第二章总结

数组（一维数组为例）

1：数组的创建
JAVA中数组的类型可以是基本数据类型，也可以是引用类型。
[数据类型]数组名[]；
[数据类型][]数组名；

import java.util.Arrays;
public class MainClass {
    
    public static void main(String[] args) {
    
       int[] intArray = {
    0,1,2,3};//指定数组长度为3，分配内存。
       char charArray[] = new char[]{
    '好','好','学','习'};//使用new初始化数组，然后给数组内容赋值。
       String stringArrya[] = new String[4];//指定数组长度为4，分配内存，没有内容。
        for (int a:intArray) {
    
            System.out.println(a);
        }
        for (char c:charArray) {
    
            System.out.println(c);
        }
        for (String s:stringArrya) {
    
            System.out.println(s);
        }
    }
}

0
1
2
3
好
好
学
习
null
null
null
null

2：数组的遍历与输出
1).foreach遍历:
循环访问数组中的每个元素。

import java.util.Arrays;
public class MainClass {
    
    public static void main(String[] args) {
    
       int[] intArray = {
    0,1,2,3};//指定数组长度为3，分配内存。
        for (int a:intArray) {
    
            System.out.println(a);
        }
    }
}

0
1
2
3

2).简单的for循环遍历。

3).Arrays类中的toString静态方法:

public class MainClass {
    
    public static void main(String[] args) {
    
       int[] intArray = {
    0,1,2,3};//指定数组长度为3，分配内存。
        System.out.println(Arrays.toString(intArray));
    }
}

[0, 1, 2, 3]

对于多维数组，toString()方法并不能直接使用，需要deepToString()静态方法才能输出多维数组内的所有元素:
toString()方法返回的是每个维度的数组存储的内存地址。
deepToString()方法返回多维数组的每个维度的内容

import java.util.Arrays;
public class MainClass {
    
    public static void main(String[] args) {
    
       int intArray[][] = new int[2][2];//指定数组长度为3，分配内存。
        intArray[0] = new int[]{
    0,1};
        System.out.println(Arrays.toString(intArray));
        System.out.println(Arrays.deepToString(intArray));
    }
}

[[I@1540e19d, [I@677327b6]
[[0, 1], [0, 0]]

3.length()；取数组长度。

4.增
1):通过for循环遍历数组，对数组中的每个元素进行赋值。
2):Arrays类中提供可以给数组批量添加元素的静态方法fill()；入参为被添加元素的数组和要添加的数值；也可以指定数组要添加的索引范围（左闭右开区间）,入参为起始索引和终点索引：

import java.util.Arrays;
public class MainClass {
    
    public static void main(String[] args) {
    
       String[] string = new String[4];
       char[] char_one = new char[4];
       Arrays.fill(string,1,3,"学");
       Arrays.fill(char_one,'学');
        System.out.println(Arrays.toString(string));
        System.out.println(Arrays.toString(char_one));
    }
}

[null, 学, 学, null]
[学, 学, 学, 学]

5.删
数组长度不能被修改，但我们可以参考添加一个元素的方法，重建一个删除元素后的数组，以达到删除指定元素的目的。

import java.util.Arrays;
public class MainClass {
    
    private static char[] DeleteArray(char[] array,int index){
    
        char[] newArray = new char[array.length-1];
        for(int i = 0;i < newArray.length;i++){
    
            if(i < index){
    
                newArray[i] = array[i];
            }else{
    
                newArray[i] = array[i+1];
            }
        }
        return newArray;
    }
    public static void main(String[] args) {
    
       char[] charArray = new char[]{
    '好','好','学','学','习'};
        System.out.println(Arrays.toString(charArray));
        charArray = DeleteArray(charArray,2);
        System.out.println(Arrays.toString(charArray));
    }
}

[好, 好, 学, 学, 习]
[好, 好, 学, 习]

6.查
Arrays类中提供了binarySearch()方法，能够查找到元素在数组中的位置，若无法找到返回-1；

public static void main(String[] args) {
    
       char[] charArray = new char[]{
    '好','好','学','习'};
       int index = Arrays.binarySearch(charArray,'学');
        System.out.println(index);
    }

2

7.比较
Arrays类中提供equals()方法，用来比较两个数组的内容是否相同。

public static void main(String[] args) {
    
       char[] charArray_1 = new char[]{
    'a','b','c','d'};
       char[] charArray_2 = new char[]{
    'a','b','c','d'};
       char[] charArray_3 = new char[]{
    'a','c','d'};
       boolean bool = Arrays.equals(charArray_1,charArray_2);
       System.out.println(bool);
       bool = Arrays.equals(charArray_1,charArray_3);
        System.out.println(bool);
    }

true
false

8.数组复制
Arrays类中提供了数组复制的方法copyOf()；

 public static void main(String[] args) {
    
       char[] charArray_1 = new char[]{
    'a','b','c','d'};
       char[] charArray_2 = Arrays.copyOf(charArray_1,4);
       System.out.println(Arrays.toString(charArray_2));

    }

[a, b, c, d]