数组的定义与使用（2）

---

一、数组的应用场景

1.保存数据

    public static void main(String[] args){
        int[] array={1,2,3};
        for(int i=0;i<array.length;i++){
            System.out.println(array[i]+" ");
        }
    }

2.作为函数的参数

1.参数传基本数据类型：

    public static void main(String[] args){
        int num=0;
        func(num);
        System.out.println("num="+num);
    }
    public static void func(int x){
        x=10;
        System.out.println("x="+x);
    }
}

输出结果：

我们可以发现，在方法中修改形参x的值，不影响实参的num值。
2.参数传数组类型（引用数据类型）

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

结果：

可以发现，在方法内部修改数组的内容，方法外部的数组内容也会发生改变，因为数组是引用类型，按照引用类型来进行传递，是可以修改其中存放的内容的。

func方法使用完成之后就会被销毁。

总结：所谓的“引用”本质上只是存了一个地址，Java将数组设定为引用类型，这样的话后续进行数组参数传参，其实只是将数组的地址传入到函数形参中，这样可以避免对整个数组的拷贝（数组可能比较长，那么拷贝开销就会很大）

3.作为函数的返回值

比如：获取斐波那契数列的前N项：

    public static int[] fib(int n){
        if(n<=0){
            return null;
        }
        int[] array=new int[n];
        array[0]=array[1]=1;
        for(int i=2;i<n;i++){
            array[i]=array[i-1]+array[i-2];
        }
        return array;
    }
    public static void main(String[] args){
       int[] array=fib(10);
       for(int i=0;i<array.length;i++){
           System.out.println(array[i]);
       }
    }

二、数组练习

1.数组转字符串

    import java.util.Arrays;
    public static void main(String[] args){
        int[] arr={1,2,3,4,5,6};
        String newArr=Arrays.toString(arr);
        System.out.println(newArr);
    }

结果：

使用这个方法后续打印数组就更方便一些。
java中提供了 java.util.Arrays包，其中包含了一些操作数组的常用方法。

2.数组拷贝

    import java.util.Arrays;
    public static void main(String[] args){
        //浅拷贝 -->newArr和arr引用的是同一个数组
        //因此newArr修改空间中内容之后，arr也可以看到修改的结果
        int[] arr={1,2,3,4,5,6};
        int[] newArr=arr;
        newArr[0]=10;
        System.out.println("newArr: "+Arrays.toString(arr));
        System.out.println("-----------------------------");
        //深拷贝-->copyOf方法在进行数组拷贝时，创建了一个新的数组
        //arr和newArr引用的不是同一个数组
        arr[0]=1;
        newArr=Arrays.copyOf(arr,arr.length);
        System.out.println("newArr: "+Arrays.toString(newArr));
        System.out.println("-----------------------------");
        //因为arr修改其引用数组中内容时，对newArr没有任何影响
        arr[0]=10;
        System.out.println("arr: "+Arrays.toString(arr));
        System.out.println("newArr: "+Arrays.toString(newArr));
        System.out.println("-----------------------------");
        //拷贝某个范围
        int[] newArr2=Arrays.copyOfRange(arr,2,4);
        System.out.println("newArr2: "+Arrays.toString(newArr2));
    }

运行结果：

注意：相比于newArr=arr这样的赋值，copyOf是将数组进行了深拷贝，即又创建了一个数组对象，拷贝原有数组中的所有元素到新数组中，因此，修改原数组，不会影响到新数组。
图解：




实现自己版本的拷贝数组：

import java.util.Arrays;
public class ArrayTest {
    public static int[] myCopyOf(int[] arr){
        int[] ret=new int[arr.length];
        for(int i=0;i<arr.length;i++){
            ret[i]=arr[i];
        }
        return ret;
    }
    public static void main(String[] args){
        int[] array={1,2,3,4,5,6};
        System.out.println(Arrays.toString(myCopyOf(array)));
    }
}

运行结果：

3.求数组中元素的平均值

    public static double avg(int[] arr){
        int sum=0;
        for(int x:arr){
            sum+=x;
        }
        return (double)sum/(double)arr.length;
    }
    public static void main(String[] args){
        int[] arr={1,2,3,4,5,6};
        System.out.println(avg(arr));
    }

运行结果：

注意事项：结果要用double来表示

4.查找数组中指定元素（顺序查找）

    public static int toFind(int x,int[] arr){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==x){
                return i;
            }
        }
        return -1;
    }
    //已找到返回下标，返回-1表示没找到
    public static void main(String[] args){
       int[] array={1,2,3,4,5,6};
       System.out.println(toFind(3,array));
    }

我们会发现，这种方式查找的次数非常多，那有没有什么更加优化的方法呢？

5.查找数组中指定元素（二分查找）

针对有序数组，可以使用更高效的二分查找。
有序数组分为升序和降序。二分查找的思路 是先取中间位置的元素，看要找的值比中间元素大还是小，如果小就去左边找，否则就去右边找。
注意：这个代码非常要注意的是left和right的取值，一不小心就会发生数组下标越界，这里有两种书写方式：
方式一：

    public static int binarySearch(int[] arr,int toFind){
        int left=0;
        int right=arr.length;
        while(left<right){
            int mid=(left+right)/2;
            if(toFind==arr[mid]){
                return mid;
            }else if(toFind<arr[mid]){
                //在左侧找
                right=mid;
            }else{
                //在右侧找
                left=mid;
            }
        }
        return -1;
    }
    public static void main(String[] args){
        int[] array={1,2,3,4,5,6};
        System.out.println(binarySearch(array,6));
    }
}

方式二：

   public static int binarySearch2(int[] arr,int toFind){
        int left=0;
        int right=arr.length-1;
        while(left<=right){
            int mid=(left+right)/2;
            if(arr[mid]==toFind){
                return mid;
            }else if(toFind<arr[mid]){
                right=mid-1;
            }else{
                left=mid+1;
            }
        }
        return -1;
    }
    public static void main(String[] args){
        int[] array={1,2,3,4,5,6};
        System.out.println(binarySearch2(array,6));
    }

运行结果：

随着数组元素个数越多，二分的优势就越大。
错误示例：
假如方式一的right=arr.length-1，那么就会出现如下图这样的错误：

6.数组排序

假设排升序：
1.将数组中相邻元素从左往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素就在数组的末尾。
2.依次重复上述过程，直到数组中所有的元素都排列好。

import java.util.Arrays;
public class BubbleSort {
    public static void bubbleSort(int[] arr){
        for(int count=1;count<arr.length;count++){
            for(int i=0;i<arr.length-count;i++){
                if(arr[i]>arr[i+1]){
                    int temp=arr[i];
                    arr[i]=arr[i+1];
                    arr[i+1]=temp;
                }
            }
        }
    }
    public static void main(String[] args){
        int[] arr={7,4,0,5,2,6};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

运行结果：

冒泡排序性能较低，Java中内置了更高效的排序方法。

    public static void main(String[] args){
        int[] arr={7,4,0,5,2,6};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

7.数组逆序

思路：设定一个下标，分别指向第一个元素和最后一个元素，交换两个位置的元素，然后让前一个下标自增，后一个下标自减，循环继续即可。

    public static void reverse(int[] arr){
        int left=0;
        int right=arr.length-1;
        while(left<right){
           int temp=arr[left];
           arr[left]=arr[right];
           arr[right]=temp;
           left++;
           right--;
        }
    }
    public static void main(String[] args){
        int[] arr={1,2,3,4,5,6};
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }

运行结果：

三、二维数组

二维数组本质上也就是一维数组，只不过每个元素又是一个一维数组。
基本语法：
数据类型[ ][ ] 数组名称 = new 数据类型 [行数][列数]{初始化数据}；
代码如下（示例）：

    public static void main(String[] args){
        int[][] arr={
                {1,2,3,4},
                {5,6,7,8},
                {9,10,11,12}
        };
        for(int row=0;row<arr.length;row++){
            for(int col=0;col<arr[row].length;col++){
                System.out.printf("%d\t",arr[row][col]);
            }
            System.out.println();
        }
    }

运行结果：