想实现一个功能，往有序数组里插入一个数，插入位置先不说，我现在就是想插入时怎么实现原数组自增一，因为数组定义时大小就已经确定了，然后我插入数后 最后一个数就没了，不想新建一个数组储存，有没有什么方法？

可以用LinkedList实现,因为你不确定插入的位置是不是末尾,所以最好先移除末尾元素,再插入新的元素
removeLast()  移除并返回此列表的最后一个元素。
add(int index, E element)  在此列表中指定的位置插入指定的元素。

你可已使用传说中的动态数组ArrayList来定义数组

public class Test110 {

        /**
         * @param args
         */
        public static void main(String[] args)
        {
                  String[] a={"a","b","c"};
         List <String> list=Arrays.asList(a);//将数组变成集合，不可以使用集合的增删方法。
                //因为数组的长度是固定。
        ArrayList<String> li=new  ArrayList<String>(list) ;//构造一个包含指定 collection 的元素的列表
                    li.add(3, "hjh");
                    li.set(2, "你好");
                   a=li.toArray(new String[li.size()]);
                   for(String b:a){
                           System.out.println(b);
                   }
                  
          }

       

}

这个是借鉴  lList  容量自增的源代码,,每增加一个 元素,才扩容一个位置的话,代码的效率会很低的.你考虑以下代码.

  private void ensureCapacityInternal(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)                                               //这里,如果长度超出,则调用增容方法
            grow(minCapacity);                                                                     
    }

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);                              //此处相当于   扩容为  原来的 1.5倍,你可以修改一下,只增加一个...
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

1. import java.util.*;
   
2. class Array
   
3. {
   
4.         public static void main(String[] arge)
   
5.         {
   
6.                 int i;
   
7.                 int[] a = {1,4,5,6};
   
8.                 int[] b = Arrays.copyOf(a,a.length+1);//这是个数组的拷贝函数，
   
9.                 b[a.length] = 7;//为刚刚增加出的空间赋个值
   
10.                 /*
    
11.                         就是将a数组拷贝给b数组但是数组的大小加了1，这个加的的1是你自己定义的你想加多大就加多大
    
12.                         但是这不是定义了一个新数组,b和a引用的是同一个数组，只是b比它大了一个.
    
13.                         通常Java用这个方法来增加数组的大小。
    
14.                 */
    
15.                 for(i=0;i<a.length;i++)
    
16.                 {
    
17.                         System.out.printf("%d,",a[i]);//输出数组a
    
18.                 }
    
19.                 System.out.println();
    
20.                 for(i=0;i<b.length;i++)
    
21.                 {
    
22.                         System.out.printf("%d,",b[i]);//输出数组b
    
23.                 }
    
24.                 System.out.println();
    
25.                
    
26.                
    
27.                
    
28.         }
    
29. }
    
30. 
    

复制代码

感谢各位  已解决