【JAVA】【集合2】Java中数组的使用

【集合】Java中的数组

一、一维数组

数组长度一旦声明，不可改变不可追加。

1. 数组引用声明

如：声明一个int类型的数组

int[] arr; 
或
int arr[]；

2. 数组分配空间

样例：

arr = new int[5];

注：java中如下定义是允许的，定义这么一个数组，除了可以看到a.length为0外，a[0]都会报错。通过Arrays.toString()转换后，打印结果是[]。

int[] a = new int[0]

3. 数组单元赋值

样例：

arr[0] = 1;      //0代表的是数组的第1个元素 ,元素下标为0
arr[1] = 1;      //1代表的是数组的第2个元素 ,元素下标为1   

4. 声明数组引用+分配空间+赋值

样例：

int[] arr1 = {12,3,4,8,5,6,6,7,8,8,9,8};
int[] arr2 = new int[]{12,3,4,8,5,6,6,4};

注：如果new int[]同时进行了赋值，则new int[]一定不能指定数组大小。

5. 获取数组长度（arr.length）

样例：

int[] arr1 = {12,3,4,8,5,6,6,7,8,8,9,8};
for (int i = 0; i < arr.length; i++) {
    ....
}

6. 循环读取数组元素

样例：

 int[] arr = new int[]{12,3,4,8,5,6,6,7,8,8,9,8};
 for (int i = 0; i < arr.length; i++) {
     System.out.println("数组第" + (i+1) + "个值为" + arr[i]);
 }

7.数组排序

public static void sort(char[] a)
public static <T> void sort(T[] a, Comparator<? super T> c)

指定排序逻辑使用样例：

  Arrays.sort(a,new Comparator<Integer>(){
            public int compare(Integer x,Integer y){
                return y-x;
            }
     });

Arrays.sort(nums,new Comparator<int[]>(){
             public int compare(int[] a, int[] b){
                 return a[0]-b[0];
             }
         });

二、二维数组

一维数组是个存储相同数据类型的容器，其存储的数据类型可以是基本数据类型和引用数据类型。

二维数组就是用来存储一维数组的数组，二维数组的存储数据类型是引用类型（即：存储一维数组的引用）。

1. 二维数组引用声明

支持如下多种格式：

• 数据类型 数组名[][]
• 数据类型[][] 数组名
• 数据类型[] 数组名[]

样例：

int[][] intB;

2. 二维数组分配存储空间

（1）通过new仅为第二维分配空间

样例：

//声明一一个二维数组，用于存储3个一维数组，每一个一维数据存多少个数组。
int[][] intB = new int[3][];

注意：如上，仅分配3个空间，用于存放一维数组的索引。一维数组本质上是没有分配空间的。

如果需要赋值，需要为一维分配空间。样例：

//声明一一个二维数组，用于存储3个一维数组，每一个一维数据存多少个数组，不知道 ，null
int[][] intB = new int[3][];

intB[0]=new int[3];      //3个单元
intB[1]=new int[]{1,2,3,4};  //4个单元
intB[2]=new int[2];  //2个单元

System.out.println(intB);

（2）通过new同时为第二维 + 第一维分配空间

样例：

//声明一个二维数组。同时创建出一维数组，每个一维数组的长度均相同，长度为4
int[][] intC = new int[3][4];

3. 声明数组引用+分配空间+赋值

（1）new分配空间 + 数组初始化赋值

样例：

int[][] arr = new int[][]{{4,5,6,8},{2,3},{1,6,9}};
或
int[][] arr = {{4,5,6,8},{2,3},{1,6,9}};

4. 获取数组长度（arr.length）

样例：

        int[][] arr3 = {{4,5,6,8},{2,3},{1,6,9}};
        System.out.println(arr3.length);    //长度是3
        for (int i = 0; i < arr3.length; i++) {
            System.out.println(arr3[i].length);   //每个一维数组的长度不同，分别是4/2/3
            for (int j = 0; j < arr3[i].length; j++) {
                System.out.println("数组[" + i  + "][" + j + "]的值：" + arr3[i][j]);
            }
        }

5. 二维数组遍历

方式1：

        int[][] arr3 = {{4,5,6,8},{2,3},{1,6,9}};

        for (int i = 0; i < arr3.length; i++) {
            for (int j = 0; j < arr3[i].length; j++) {
                System.out.println("数组[" + i  + "][" + j + "]的值：" + arr3[i][j]);
            }
        }

方式2：

        int[][] arr3 = {{4,5,6,8},{2,3},{1,6,9}};

        for(int[] arr : arr3){  //int[]二维数组中元素的类型, arr迭代变量, arr3二维组的名称
            for(int element : arr){ //int一维数组中元素的类型，element迭代变量, arr一维数组的名称
                System.out.println(element);
            }
        }        

方式3：（方式1和方式2的混合使用）

    int[][] arr3 = {{4,5,6,8},{2,3},{1,6,9}};

    for (int i = 0; i < arr3.length; i++) {
        for(int element : arr3[i]){ //int一维数组中元素的类型，element迭代变量, arr3[i]一维数组的名称
            System.out.println(element);
        }
    } 
    
    for(int[] arr : arr3){  //int[]二维数组中元素的类型, arr迭代变量, arr3二维组的名称
        for (int j = 0; j < arr.length; j++) {
            System.out.println(arr[j]);
        }
    }

​

三、数组实现常用的排序算法

1. 冒泡排序

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

样例：学生成绩降序排列

int[] arr = {78, 89, 67, 98, 90, 56, 88};

for(int i = 0; i < arr.length; i++){//每次循环，arr[i]的元素就确定是i~数组末尾中最小的。
    for(int j = i; j < arr.length; j++){
       if(arr[i] > arr[j]){
           int temp = arr[j];
           arr[j]  = arr[i];
           arr[i] = temp;
        }
    }
}

2. 二分查找

二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储，而且表中元素按关键字 有序 排列。

首先，假设表中元素是按升序排列，将表中间位置内容与查找内容比较，如果两者相等，则查找成功；否则利用中间位置将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到查找完毕。

样例：

public static void main(String[] args) {
  int[] arr = {30, 50, 56, 67, 78, 88, 89, 90, 98, 99};
  System.out.println(findNum(arr, 56));
}

public int findNum(arr, num) {
    int start = 0;                         　　　　 // 默认起始坐标
    int end = arr.length-1;           　　　　// 默认结尾坐标
    int index = -1;                      　　　　 // 找不到默认index为-1
　　
    while(start <= end){
        int middleIndex = (start + end)/2; 　　　　// 计算中间下标
        if(num == arr[middleIndex]){
             index = middleIndex;
             break;
        }
        else if(num > arr[middleIndex]){
            start = middleIndex + 1;
        }
        else if(num < arr[middleIndex]){
            end = middleIndex - 1;
        }
　　} 
}