数组的相关方法

数组的魅力

数组本质上就是让我们可以批量创建相同类型的变量

数组可分为：一维数组，二维数组以及多维数组，今天我们着重看一下一维数组，二维数组也用的比较少，常用的就是一维数组了。

1:创建一维数组有以下方法：

    int[]a={1,2,3,4};   //静态初始化
    int[]b=new int[]{1,2,3,4,5};  //动态初始化，new出来的对象在堆上
    int[]c=new int[10];     //动态初始化，初值都是0

2:如何使用数组

        int[]b=new int[]{1,2,3,4,5};
        System.out.println(b[0]);
        System.out.println(b[1]);
        System.out.println(b.length);

从这我们可以看出0号下标输出的是数组的第一位元素，下标长度为
[0,b.length-1],数组的length是属性，不是一个方法。如果超出数组的长度，下标取多了，会出现以下数组越界异常。

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException:

遍历数组可以使用for循环和for-each循环

      int[]b=new int[]{1,2,3,4,5};
       for(int i=0;i<b.length;i++){
           System.out.println(b[i]);
       }

      int[]b=new int[]{1,2,3,4,5};
      for(int i:b){
          System.out.println(i);

二者的区别：for-each循环不用下标，减少出错
3：关于数组做方法的参数
这是我举出的一个例子感受数组做方法的参数

 public static void print(int[]b){
        b[0]=10;
    }
    public static void main(String[] args) {
        int[]a={1,2,3};
        System.out.println(a[0]);
        print(a);
        System.out.println(a[0]);
      }

下面是结果

1
10

这个说明了数组做参数其实是按引用传递，也就是传的是地址，那么实参和形参都指向了同一个地址里面对象，在方法里面把对象的值改变了，自然在main函数里面再输出a[0],还是同一个地址，输出的自然就是改变后的值。

这是我对这个的理解，按值传递就不会影响原来的值；

public static void print(int n){
       n=20;
       System.out.println(n);
    }
    public static void main(String[] args) {
           int a=10;
           print(a);
        System.out.println(a);
      }

结果

20
10

由此可见按值传递不会影响实参的值
4：数组也可以作为函数的返回值

 public static int[] def(int[]a){
        int[]ret=new int[a.length];
        for(int i=0;i<a.length;i++){
            ret[i]=a[i]*2;
        }
        return ret;
    }
    public static void print(int[]c){
        for(int j=0;j<c.length;j++){
            System.out.println(c[j]);
        }
    }
    public static void main(String[] args) {
        int[]b={1,2,3,4,5};
        int[]s=def(b);
        print(s);
    }

其实创建的数组接受的是传来的地址，这点一定要清楚，然后再把这个数组作为参数传入打印函数里面去遍历里面的内容。
5：数组的一些方法
数组的copy
System.arraycopy() 是一个本地方法
Array.copyOf(); 方法内部调用了 System.arraycopy()方法
数组名.clone();
很明显System.arraycopy()比较快速，因为是本地方法
数组的排序：一般用一个循环就可以搞定，但是现在有Aaarys.sort(数组名)可供使用就方便多了。
还有冒泡排序其实也就是循环，比大小，然后交换位置；
数组的查找
有顺序查找，也就是循环遍历，效率比较低，不建议使用
查找就不得不题二分查找了，效率贼高。
下面是一个二分查找的代码

public static int print(int[]b,int n){
        int left=0;
        int right=b.length-1;
        while(left<=right){
            int middle=(left+right)/2;
            if(n<b[middle]){
                right=middle-1;
            }
            else if(n>b[middle]){
                left=middle+1;
            }
            else{
                return middle;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        int[]a=new int[]{1,4,6,7,15,67,56,34};
        Arrays.sort(a);
        int s= print(a,15);
        System.out.println(s);
    }

关于数组我就先说到这里了，脑阔疼，其实二维数组也一样，也就是特殊的一维数组，里面的每一个元素就是一个一维数组。