Java学习（4）—— 数组_java string[] array

数组（Array）：是多个相同类型的数据按一定顺序排列的集合。

特点：（1）数组是有序排列的；（2）数组属于引用数据类型的变量。数组中的元素可以是基本数据类型，也可以是引用数据类型；（3）数组对象在内存中占一整块连续的空间；（4）数组的长度一旦确定就不能修改。

一.   一维数组

public class Test{
    public static void main(String[] args) {
        //1. 数组的初始化
        //生成一个int型的数组
        int[] age = new int[]{18,19,20,21,22}; //静态初始化：数组的初始化和数组元素的赋值同时进行
 
        //生成一个String型的数组
        String[] name = new String[5];  //动态初始化：数组的初始化和数组元素的赋值分开进行
 
        //2. 调用数组指定位置的元素(数组的索引是从0开始)
        name[0] = "王";
        name[1] = "杨";
        name[2] = "刘";
        name[3] = "张";
        name[4] = "赵";
 
        System.out.println(age[0]); //18
        System.out.println(name[1]); //杨
 
        //3. 获取数组的长度
        System.out.println(name.length); //5
        System.out.println(age.length);  //5
 
        //4. 遍历数组元素
        for(int i = 0; i < name.length; i++){
            System.out.println(name[i]);
        }
 
        //5. 数组元素的默认初始化值
        int[] array1 = new int[4];
        System.out.println(array1);        //结果是指向数组array1的地址
        System.out.println(array1[0]);     //数组是整型：0
 
        double[] array2 = new double[4];
        System.out.println(array2);        //结果是指向数组array2的地址
        System.out.println(array2[0]);     //数组是浮点型：0.0
        boolean[] array3 = new boolean[4];
        System.out.println(array3[0]);     //数组是布尔型：false
 
        String[] array4 = new String[4];
        System.out.println(array4[0]);     //数组是字符串类型：null
 
    }
}

二.   二维数组

public class Test{
    public static void main(String[] args) {
        //1. 二维数组的初始化
        //生成一个int型的数组
        int[][] age = new int[][]{{5,6,7,8},{18,19,20},{40,41}}; //静态初始化：数组的初始化和数组元素的赋值同时进行
 
        //生成一个String型的数组
        String[][] name1 = new String[3][2];  //动态初始化1：内层元素的个数固定为2，name1 = [[2个元素],[2个元素],[2个元素]]
        String[][] name2 = new String[3][];  //动态初始化2：内层元素的数量不固定
 
        //2. 调用数组指定位置的元素(数组的索引是从0开始)
        System.out.println(age[1][2]); //20
 
        name1[0][0] = "王";
        name1[0][1] = "杨";
        name1[1][0] = "刘";
        name1[1][1] = "张";
        name1[2][0] = "金";
        name1[2][1] = "朱";
        System.out.println(name1[1][0]); //刘
 
        name2[0] = new String[3];
        name2[1] = new String[4];
        name2[2] = new String[2];
        //以上的形式相当于name2 = [[3个元素],[4个元素],[2个元素]]
        name2[1][1] = "杨";
        System.out.println(name2[1][1]); //杨
 
        //3. 获取数组的长度
        System.out.println(age.length); //3
        System.out.println(age[0].length);  //4
        System.out.println(age[2].length);  //2
 
        //4. 遍历数组元素
        for(int i = 0; i < age.length; i++){
            for(int j = 0; j < age[i].length; j++){
                System.out.print(age[i][j] + " ");
            }
            System.out.println();
        }
 
        //5. 数组元素的默认初始化值：(1)动态初始化1：外层元素为地址，内层元素与一维数组相同；(2)动态初始化2：外层元素为null，内层元素会报错
        int[][] array1 = new int[4][3];
        System.out.println(array1);           //结果是指向二维数组array1的地址
        System.out.println(array1[0]);        //结果是指向一维数组array1[0]的地址
        System.out.println(array1[0][0]);     //数组是整型：0
 
        double[][] array2 = new double[4][3];
        System.out.println(array2);           //结果是指向二维数组array2的地址
        System.out.println(array2[0]);        //结果是指向一维数组array2[0]的地址
        System.out.println(array2[0][0]);     //数组是浮点型：0.0
 
        boolean[][] array3 = new boolean[4][3];
        System.out.println(array3[0][0]);     //数组是布尔型：false
 
        String[][] array4 = new String[4][3];
        System.out.println(array4[0][0]);     //数组是字符串类型：null
 
        double[][] array5 = new double[4][];
        System.out.println(array5[0]);        //null，不管声明为什么类型的数组，都为null
        //System.out.println(array5[0][0]);    //报错
    }
}

三.   数组复制

public class Test{
    public static void main(String[] args) {
        int[] array1 = new int[]{5,6,7,8};
        int[] array2;
        array2 = array1;     //不能实现数组的复制
        array2[0] = 13;
        System.out.println(array1[0]); // array1[0] = 13，堆中只有一个数组，array2 = array1是将array1的地址赋值给array2
 
        //数组的复制
        int[] array3 = new int[]{5,6,7,8};
        int[] array4 = new int[array3.length];
        for(int i = 0; i < array3.length; i++){
            array4[i] = array3[i];
        }
    }
}

四.   查找

1. 线性查找

public class Test{
    public static void main(String[] args) {
        String[] array = new String[]{"A","B","C","D","E","F"};
        String index = "B";
        for(int i = 0; i < array.length; i++){
            if(index.equals(array[i])){
                System.out.println(i);
                break;
            }
        }
    }
}

2. 二分法查找

public class Test{
    public static void main(String[] args) {
        int[] array = new int[]{5,12,13,18,22,24,28,32};
        int index = 22;
        int head = 0;
        int end = array.length;
        while(head <= end){
            int middle = (head + end)/2;
            if(array[middle] == index){
                System.out.println(middle);
                break;
            }else if(array[middle] > index){
                end = middle - 1;
            }else if(array[middle] < index){
                head = middle + 1;
            }
        }
    }
}

五.   排序

  冒泡排序

public class Test{
    public static void main(String[] args) {
        int[] array = new int[]{97,15,85,64,22,53,46,25,18,32};
        for(int i = 0; i < array.length - 1; i++){
            for(int j = 0; j < array.length - 1 - i; j++){
                if(array[j] > array[j + 1]){
                    int temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                }
            }
        }
        for(int i = 0; i < array.length; i++){
            System.out.print(array[i] + " ");
        }
    }
}

六.   Arrays类

举例：以下的数据类型可以是任意的

1. 判断两个数组是否相等：Arrays.equals(int[] a, int[] b)

import java.util.Arrays;
public class Test{
    public static void main(String[] args) {
        int[] array1 = new int[]{18,19,20,21,22};
        int[] array2 = new int[]{18,19,20,21,22};
        int[] array3 = new int[]{19,18,20,21,22};
        System.out.println(Arrays.equals(array1,array2));  //true
        System.out.println(Arrays.equals(array1,array3));  //false
    }
}

2. 输出数组信息：Arrays.toString(int[] a)

import java.util.Arrays;
public class Test{
    public static void main(String[] args) {
        int[] array = new int[]{18,19,20,21,22};
        System.out.println(Arrays.toString(array)); //[18, 19, 20, 21, 22]
    }
}

3. 对数组进行排序：Arrays.sort(int[] a)

import java.util.Arrays;
public class Test{
    public static void main(String[] args) {
        int[] array = new int[]{97,15,85,64,22,53,46,25,18,32};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array)); //[15, 18, 22, 25, 32, 46, 53, 64, 85, 97]
    }
}

4. 二分查找：Arrays.binarySearch(int[] a, int key)

import java.util.Arrays;
public class Test{
    public static void main(String[] args) {
        int[] array = new int[]{15, 18, 22, 25, 32, 46, 53, 64, 85, 97};
        int index = Arrays.binarySearch(array, 22);
        System.out.println(index); //2
    }
}