6.数组

int[] array 和int array[]的区别

对于int[10] array来讲，是先为array分配一个内存地址空间，然后在里面进行内存地址的分配

对于int array[]来讲，是为每一个数组变量分配一个内存地址，

也就是说，对于int[10] array来说，就是先分配一个整的内存地址，然后再里面进行分配，对于int array[10]来说，就是一个变量分配一个内存地址，也就是one to one

数组定义

对于一维数组的定义

int[] array=new int[];

对于数组的赋值

int[] array=new int[]{1,3,6,7};
int[] array1={2,4,6,8}

对于二维数组的定义

int[][] array=new int[][];

对于数组的赋值

int[][] array=new int[][]{{1,4,6},{3,6,8}};

数组的基本操作

1.遍历

用foreach语句进行遍历

int[][] array1=new int[][]{{1,3,4},{2,8,6},{3,6,4}};
        for (int i = 0; i <array1.length ; i++) {
            for (int j = 0; j <array1[i].length ; j++) {
                System.out.print(array1[i][j]);
            }
            System.out.println();

   int[][] array2=new int[][]{{1,3,6,5},{4,6,7,9},{3,5,3,2},{4,2,6,8}};
        int i=0;
        for (int x[]:array2          //先遍历外层数组，就相当于遍历一位数组
             ) {
            i++;
            int j=0;
            for (int e:x               //遍历内层数组，遍历每一个数组元素
                 ) {
                j++;
                if (i==array2.length&&j==x.length){
                    System.out.print(e);
                }else {
                    System.out.print(e+"、");
                }
            }
        }

2.填充替换数组元素

fill(int[] a,int value)方法，该方法可将指定的int值分配给int型数组的每个元素
fill(int[] a,int fromIndex,int toIndex,int value)方法，该方法将指定的int值分配给int型数组 指定范围中的每个元素。

 int[] array3=new int[6];
        Arrays.fill(array3,8);
        System.out.println();
        for (int j = 0; j <array3.length ; j++) {
            System.out.print(array3[j]);
        }

 int[] array4=new int [6];
        Arrays.fill(array4,1,2,3);
        System.out.println();
        for (int j = 0; j < array4.length; j++) {
            System.out.print(array4[j]);
        }

3.对数组进行排序

sort(object)方法可对任意类型的数组进行升序排序

 int[] array5=new int[]{4,4,3,2,5};
        Arrays.sort(array5);
        System.out.println();
        for (int j = 0; j <array5.length ; j++) {
            System.out.print(array5[j]);
        }

4. 复制数组

copyOf(arr,int newlength)方法，满足不同类型数组的复制
copyOfRange(arr,int formIndex,int toIndex)方法，可以将指定范围内的数组复制出来

 int[] array6=new int[]{4,2,9};
        int[]  array7=Arrays.copyOf(array6,6);
        System.out.println();
        for (int j = 0; j <array7.length ; j++) {
            System.out.print(array7[j]);
        }

 int[] array8=new int[]{2,4,5,7,1};
        int[] array9=Arrays.copyOfRange(array8,2,4);
        System.out.println();
        for (int j = 0; j <array9.length ; j++) {
            System.out.print(array9[j]);
        }

5.数组查询

binarySearch(Object[],Object key)方法，此方法采用二分搜索法来搜索指定数组，来获得指定对象，该方法返回的是要搜索元素的索引值。
binarySearch(Object[],int fromIndex,int toIndex,Object key)此方法在指定的范围内检索某一元素。

 int[] array0=new int[]{1,6,93};
        Arrays.sort(array0);
        int index=Arrays.binarySearch(array0,6);
        System.out.println("6的索引是"+index);

 int[] zhang=new int[]{8,4,5,3,5};
        Arrays.sort(zhang);
        int index1=Arrays.binarySearch(zhang,2,4,5);
        System.out.println("索引为"+index1);

数组排序算法

1.冒泡算法

public class Bubblesort {
    public static void main(String[] args) {
        int[] array=new int[]{42,43,64,15,93,53};
        Arrays.sort(array);
        for (int i = 1; i <array.length ; i++) {
            for (int j = 0; j <array.length-i ; j++) {
                if (array[j]>array[j+1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
            }
        }
        }
        for (int m:array){
            System.out.print(">"+m);
        }
    }
}

2.直接排序算法