一、数组类型

数组是存储多个变量(元素)的东西(容器)，这多个变量的数据类型要一致。

定义一个数组类型的变量，使用数组类型“类型[]”，例如，int[]。和单个基本类型变量不同，数组变量初始化必须使用new int[5]表示创建一个可容纳5个int元素的数组。

Java的数组有几个特点：

• 数组所有元素初始化为默认值，整型都是0，浮点型是0.0，布尔型是false；
• 数组一旦创建后，大小就不可改变。

要访问数组中的某一个元素，需要使用索引。数组索引从0开始，例如，5个元素的数组，索引范围是0~4。

可以修改数组中的某一个元素，使用赋值语句，例如，ns[1] = 79;。

可以用数组变量.length获取数组大小。

数组是引用类型，在使用索引访问数组元素时，如果索引超出范围，运行时将报错。

//数组的定义和初始化
//所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
int[] ns = new int[5];
        ns[0] = 68;  
        ns[1] = 79;
        ns[2] = 91;
        ns[3] = 85;
        ns[4] = 62;
//数组的初始化方式
//动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
//静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。


//也可以在定义数组时直接指定初始化的元素，这样就不必写出数组大小，而是由编译器自动推算数组大小。
 int[] ns = new int[] { 68, 79, 91, 85, 62 };
//还可以进一步简写为：
int[] ns = { 68, 79, 91, 85, 62 };

//注意数组是引用类型，并且数组大小不可变。
public class Main {
    public static void main(String[] args) {
        String[] names = {"ABC", "XYZ", "zoo"};
        String s = names[1];
        names[1] = "cat";
        System.out.println(s); // s是"XYZ"
    }
}

数组是同一数据类型的集合，数组一旦创建后，大小就不可变；

可以通过索引访问数组元素，但索引超出范围将报错；

数组元素可以是值类型（如int）或引用类型（如String），但数组本身是引用类型；

注意：1. 数组无论是定义为实例变量还是局部变量，若没有初始化都会被自动初始化

2. string数组默认值为null，char型数组默认值为空格，boolean型数组默认值为false

 Java中的内存分配

 二、遍历数组

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int i=0; i<ns.length; i++) {
            int n = ns[i];
            System.out.println(n);
        }
        //增强型foreach
        for (int n : ns) {
            System.out.println(n);
        }
        //或是
        System.out.println(Arrays.toString(ns));  //[1, 4, 9, 16, 25]
    }
}

三、数组排序

如冒泡排序：

public class Main {
    public static void main(String[] args) {
        int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
//冒泡排序的特点是，每一轮循环后，最大的一个数被交换到末尾，
//因此，下一轮循环就可以“刨除”最后的数，每一轮循环都比上一轮循环的结束位置靠前一位。
        for(int i = 0; i< ns.length-1;i++)
        {
            for(int j = 0; j< ns.length - i-1;j++ )
            {
                if(ns[j] > ns[j+1] ){
                    int tmp = ns[j];
                    ns[j] = ns[j+1];
                    ns[j+1] = tmp;
                }
            }
        }
        System.out.println(Arrays.toString(ns));  //[8, 12, 18, 28, 36, 50, 65, 73, 89, 96]
        //Java的标准库已经内置了排序功能
        int[] ns2 = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
        Arrays.sort(ns2);
        System.out.println(Arrays.toString(ns2)); //[8, 12, 18, 28, 36, 50, 65, 73, 89, 96]
    }
}

四、多维数组

二维数组：

public class Main {
    public static void main(String[] args) {
        int[][] ns = {
                { 1, 2, 3, 4 },
                { 5, 6, 7, 8 },
                { 9, 10, 11, 12 }
        };
        System.out.println(ns.length); // 3

        System.out.println(ns[1][2]);//访问二维数组的某个元素

        //二维数组的每个数组元素的长度并不要求相同
        int[][] ns2 = {
                { 1, 2, 3, 4 },
                { 5, 6 },
                { 7, 8, 9 }
        };

        //打印二维数组
        for (int[] arr : ns) {
            for (int n : arr) {
                System.out.print(n);
                System.out.print(',');
            }
            System.out.println();
        }
        //或者使用Java标准库的Arrays.deepToString()：
        System.out.println(Arrays.deepToString(ns)); //[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
    }
}

三维数组：

public class Main {
    public static void main(String[] args) {
        int[][][] ns = {
                {
                        {1, 2, 3},
                        {4, 5, 6},
                        {7, 8, 9}
                },
                {
                        {10, 11},
                        {12, 13}
                },
                {
                        {14, 15, 16},
                        {17, 18}
                }
        };
        System.out.println(Arrays.deepToString(ns));
        //[[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[10, 11], [12, 13]], [[14, 15, 16], [17, 18]]]
    }
}

五、数组常用方法

public class Main {
    public static void main(String[] args) {
        int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };

        //返回数组长度
        System.out.println(ns.length);
        //数组转字符串
        System.out.println(Arrays.toString(ns));  //[28, 12, 89, 73, 65, 18, 96, 50, 8, 36]
        //数组升序
        Arrays.sort(ns);
        System.out.println(Arrays.toString(ns)); //[8, 12, 18, 28, 36, 50, 65, 73, 89, 96]

        //在已排序的数组中进行二分查找指定元素的索引
        int index = Arrays.binarySearch(ns,28);
        System.out.println(index);//3

        //复制数组
        int[] copy = Arrays.copyOf(ns,ns.length);  //ns.length 新数组长度
        int[] copy2 = Arrays.copyOfRange(ns,0,3); // fromindex包括 toindex不包括
        System.out.println(Arrays.toString(copy));
        System.out.println(Arrays.toString(copy2)); //[8, 12, 18]

        //比较两个数组元素内容是否相同
        int[] numbers1 = {1, 2, 3};
        int[] numbers2 = {1, 2, 3};
        boolean isEqual = Arrays.equals(numbers1, numbers2);
        System.out.println(isEqual); // 输出 true

        //多维数组转字符串
        int[][] matrix = {{1, 2}, {3, 4}};
        System.out.println(Arrays.deepToString(matrix)); // 输出 "[[1, 2], [3, 4]]"

        String[] strArr = {"a","b","c"};
        //转成ArrayList
        ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(strArr));
        //转成Set
        Set<String> set = new HashSet<String>(Arrays.asList(strArr));
        //转成List
        List<String> list = new ArrayList<String>(Arrays.asList(strArr));

        //数组中是否包含某个值
        if(Arrays.asList(strArr).contains("a")){
            System.out.println("包含");
        }

        //数组全部填充为10
        int[] arr = new int[5];
        Arrays.fill(arr,10);

        //去重，利用Set特性
        Set<Integer> set2 = new HashSet<>();
        for (int i:ns){
            set2.add(i);
        }
        int[] ns2 = new int[set2.size()];
        int j = 0;
        for(Integer i:set2){
            ns2[j++] = i;
        }
        System.out.println(Arrays.toString(ns2));
    }