基础必会必考点 Java数组

Java 数组

连续存储的元素集合

<font face="楷体">个人认为Java中的数据即C++、C语言相同，一定是连续分配的。笔者在C语言教材找到这样一段话可以证明：All elements of a one-dimensional array are always stored in consecutive memory locations.

数组定义

非初始化:

int [] a1;

初始化:

int [] a2 = new int[10];

自己实现的Buffer。如List中使用的扩容方法是一个叫arraycopy的方法，感兴趣的可以取看下，其底层是JVM的实现。

public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

C语言中要自己分配某长度的内存空间需要使用malloc函数。

p = (int *)malloc(len*sizeof(int));

数组遍历

方式1：

for (int item : a2){
    System.out.println(item);
}

方式2：

for (int i=0;i<a2.length;i++){
    System.out.println(a2[i]);
}

数组操作Arrays类

Java Arrays类中提供了很多便捷的方法对数组进行操作，包括排序，搜索，数组复制等操作。

如数组排序:

Arrays.sort(a2);

如数组是否相等比较:

boolean equals = Arrays.equals(a1, a2);

数组常见排序算法

选择排序

/**
 * 从第一个位置开始，依次选出最小的一个
 * @param arr
 */
public void selectionSort(int []arr){
    for(int i=0;i<arr.length;i++){
        int min = arr[i];
        int index = i;
        for (int j=i;j<arr.length;j++){
            if (arr[j]<min){
                min = arr[j];
                index = j;
            }
        }
        int temp = arr[index];
        arr[index] = arr[i];
        arr[i] = temp;
    }
}

冒泡排序

/**
 * 冒泡排序
 * @param arr
 */
public void bubbleSort(int []arr){
    for (int i=0;i<arr.length;i++){
        for (int j=0;j<arr.length-1;j++) {
            if (arr[j]>arr[j+1]){
                int temp = arr[j+1];
                arr[j+1] = arr[j];
                arr[j]   = temp;
            }
        }
    }
}

插入排序

/**
 * 插入排序
 * @param arr
 */
public void insertSort(int []arr){
    for (int i=0;i<arr.length;i++){
        for (int j=i;j>0;j--){
            if (arr[j]<arr[j-1]){
                int temp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = temp;
            }
        }
    }
}

快速排序

public void quickSort(int[] arr, int low, int high){
    if (low>=high)
        return;
    //基准值
    int base = arr[low];
    int i = low;
    int j = high;
    while (i!=j){
        //从左往右找一个大于基准值的,一定要先左右往左
        // 如 6 5 8 4 7 先右指正指向7索引为4，
        // 交换变成6 5 4 8 7,此时左指针为2，右指左指针指向8针为3
        // 先循环右指针，则最后i = j = 2
        // 先循环左指针，则最后i = j = 3 而索引为3的位置是大于base的不能和基准位置交换
        while (arr[j]>=base&&i<j){
            j--;
        }
        while (arr[i]<=base&&i<j){
            i++;
        }
        if (i<j){
            arr[j] = arr[j]^arr[i];
            arr[i] = arr[j]^arr[i];
            arr[j] = arr[j]^arr[i];
        }
    }

    {
        arr[low] = arr[low] ^ arr[i];
        arr[i] = arr[low] ^ arr[i];
        arr[low] = arr[low] ^ arr[i];
    }

    quickSort(arr,low,i-1);
    quickSort(arr,i+1,high);
}

public void quickSort(int []arr){
    quickSort(arr,0,arr.length-1);
}