Java基础知识-第4章-认识Java中的数组

标签：arr Java int System 基础知识 数组 println out

【导航】

1、数组概述

Java 中的数组可以认为是一种容器，其可以同时存放多个数据值(元素)。Java 语言中提供的数组是用来存储固定大小的同类型元素。

数组的特点：

• 数组是一种引用数据类型，但是数组元素类型不限。
• 数组当中的多个数据类型必须统一
• 数组的长度一旦确定，在程序运行期间不可修改。
• 数组是相同类型的数组元素按一定顺序排列的集合
• 通过索引(下标)获取元素，数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到array.length-1。
• 通过关键字 new 创建数组对象会在堆内存中开辟一块空间

数组的分类：

• 按照维数：一维数组和二维数组

2、一维数组的初步使用

2.1、数组的初始化

两种常见的初始化方式：

• 动态初始化（指定长度）
• 静态初始化（指定内容）

静态初始化格式

即数组的初始化和数组元素的赋值操作同时进行

标准格式：

数据类型 [] 数组名称 = new 数据类型 [ ] {元素1，元素2，···元素n} ；

说明：

• 等号左边叫声明，右边叫初始化，结合通常一起写
• 使用静态初始化数组的时候格式可以省略一下
• 省略格式：数据类型 [] 数组名称 = {元素1，元素2，····元素n }

public class shuzu {  
    public static void main(String[] args) {  
        int[] arrayC = new int[] {1,2,3,4,5};  
        String[] arrayD = new String[] {"hello","world","java"};  
    }  
}  

动态初始化数组格式

即数组的初始化和数组元素的赋值操作分开进行

标准格式：

数据类型 [] 数组名称 = new 数据类型 [数组长度] ；

eg：

public class TestArray {
   public static void main(String[] args) {
      // 数组大小
      int size = 10;
      // 定义数组
      double[] myList = new double[size];
      myList[0] = 5.6;
      myList[1] = 4.5;
      myList[2] = 3.3;
      myList[3] = 13.2;
      myList[4] = 4.0;
      myList[5] = 34.33;
      myList[6] = 34.0;
      myList[7] = 45.45;
      myList[8] = 99.993;
      myList[9] = 11123;
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < size; i++) {
         total += myList[i];
      }
      System.out.println("总和为： " + total);
   }
}

错误的写法：

1. int[] arr1 = new int[];  

2. int[5] arr2 = new int[5];  

3. int[] arr3 = new int[3]{1,2,3}; 

注意事项

静态初始化标准格式可以拆分成两个步骤，先声明再初始化，同变量一样。

public class shuzu {  
    public static void main(String[] args) {  
        int[] arrayk;//声明  
        arrayk = new int[] {1,2,3,4,5};//初始化  
    }  
}  

同样动态格式化也可以

• 虽然静态初始化没有直接告诉长度，但是根据原括号里面的据体内容，也可以自动推算出长度。
• 静态初始化一旦使用省略格式，就不能拆分成两个步骤。

2.2、一维数组的初步使用

2.2.1、访问数组中的元素

访问数组中元素是通过索引的方式调用的，索引从0开始的，到数组的长度-1结束。注意，索引不能超出数组长度范围，否则就会出现异常：ArrayIndexOutOfBoundsException

public class TestArray {
   public static void main(String[] args) {
      // 数组大小
      int size = 3;
      // 动态初始化数组
      double[] myList = new double[size];
      // 对元素赋值
      myList[0] = 5.6;
      myList[1] = 4.5;
      myList[2] = 3.3; //注意：索引不能超出数组长度范围
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < size; i++) {
         total += myList[i];
      }
      System.out.println("总和为： " + total);
   }
}

2.2.2、获取数组的长度

属性：length

System.out.println(myList.length);//5

2.2.3、遍历数组

public class TestArray {
    public static void main(String[] args) {
        double[] myList = {1.9, 2.9, 3.4, 3.5};

        // 方式1：打印所有数组元素
        for (int i = 0; i < myList.length; i++) {
            System.out.println(myList[i] + " ");
        }

        //方式2：
        for(int x=arr.length-1; x>=0; x--){ 
            System.out.println(myList[x]+ " ");  
        }
        
        // 方式3：使用增强的 for 循环
        for (double value : myList) {
            System.out.println(value + " ");
        }
        
        // 方式4：使用 Arrays.toString() 输出整个数组
		System.out.println(Arrays.toString(myList));
        
        // 方式5：使用 Stream 流式处理数组
		Arrays.stream(myList).forEach(value -> System.out.println(value + " "));
        
        // 方式6：使用 forEach 和 lambda 表达式
		Arrays.asList(myList).forEach(value -> System.out.println(value + " "));
    }
}

2.2.4、数组作为函数的参数

数组可以作为参数传递给方法。例如，下面的例子就是一个打印 int 数组中元素的方法:

public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
  }
}

下面例子调用 printArray 方法打印出 3，1，2，6，4 和 2：

printArray(new int[]{3, 1, 2, 6, 4, 2});

记住这个参数传递是值传递，只不过是传递的是引用数据类型的地址值，即入参如果是数组类型的值，对入参修改，则数组里面的内容值会发生改变

2.2.5、数组作为函数的返回值

public static int[] reverse(int[] list) {
    int[] result = new int[list.length];

    for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
        result[j] = list[i];
    }
    return result;
}

以上实例实现了将list数组中的值翻转赋给了数组result ，并将 result 数组作为函数的返回值

2.2.6、数组中的聚合操作

实例：定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。

要求：所有随机数都是两位数：[10,99]

公式：(int)(Math.random() * (99 - 10 + 1) + 10)

public class ArrayTest1 {
	public static void main(String[] args) {
		int[] arr = new int[10];
		
		for(int i = 0;i < arr.length;i++){
			arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
		}
		
		//遍历
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
		System.out.println();
		
		//求数组元素的最大值
		int maxValue = arr[0];
		for(int i = 1;i < arr.length;i++){
			if(maxValue < arr[i]){
				maxValue = arr[i];
			}
		}
		System.out.println("最大值为：" + maxValue);
		
		//求数组元素的最小值
		int minValue = arr[0];
		for(int i = 1;i < arr.length;i++){
			if(minValue > arr[i]){
				minValue = arr[i];
			}
		}
		System.out.println("最小值为：" + minValue);
        
		//求数组元素的总和
		int sum = 0;
		for(int i = 0;i < arr.length;i++){
			sum += arr[i];
		}
		System.out.println("总和为：" + sum);
        
		//求数组元素的平均数
		double avgValue = sum / arr.length;
		System.out.println("平均数为：" + avgValue);
	}
}

2.2.7、数组的赋值与复制

1、数组的赋值

public class ArrayExer2 {
    public static void main(String[] args) {  //alt + /
        int[] array1,array2;

        array1 = new int[]{2,3,5,7,11,13,17,19};

        //显示array1的内容
        for(int i = 0;i < array1.length;i++){
            System.out.print(array1[i] + "\t");
        }

        //赋值array2变量等于array1，相当于array1和array2共同指向{2,3,5,7,11,13,17,19}，修改一方的内容也会造成另外一方的改变
        //不能称作数组的复制。
        array2 = array1;

        //修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)
        for(int i = 0;i < array2.length;i++){
            if(i % 2 == 0){
                array2[i] = i;
            }

        }
        System.out.println();

        //打印出array1
        for(int i = 0;i < array1.length;i++){
            System.out.print(array1[i] + "\t");
        }

        //打印出array2
        for(int i = 0;i < array2.length;i++){
            System.out.print(array2[i] + "\t");
        }
    }
}

结果：array2修改后，array1的内容也会发生对应的改变，不是复制，相当于引用传递

========array1内容========================
2	3	5	7	11	13	17	19	
========array2修改后的array1内容========================
0	3	2	7	4	13	6	19	
========array2内容========================
0	3	2	7	4	13	6	19	

结论： 赋值是数组 引用传递，引用的是地址，属于浅拷贝，不是复制

int[] array1,array2;  
array1 = new int[]{1,2,3,4};
array2 = array1; //数组引用传递

如何理解：将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体。

2、数组的复制

String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};  

//数组的复制(区别于数组变量的赋值：arr1 = arr)  
String[] arr1 = new String[arr.length];  
for(int i = 0;i < arr1.length;i++){  
    arr1[i] = arr[i];  
} 

内存解析(只要是new出来的结构，就是一个新对象，保存在堆空间里面)

如何理解：我们通过new的方式，给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。

2.3、数组元素的默认初始化值

public class ArrayTest1 {     
    public static void main(String[] args) {  
        int[] arr = new int[4];  
        for(int i = 0;i < arr.length;i++){  
            System.out.println(arr[i]);  
        }         
        //结果：0,0,0,0  

        short[] arr1 = new short[4];  
        for(int i = 0;i < arr1.length;i++){  
            System.out.println(arr1[i]);  
        }  
        //结果：0,0,0,0

        char[] arr3 = new char[4];  
        for(int i = 0;i < arr3.length;i++){  
            System.out.println("----" + arr3[i] + "");  
        }  

        //char型'0'的默认值是0，不是'0'  
        if(arr3[0] == 0){  
            System.out.println("你好！");  
        }                    

        boolean[] arr4 = new boolean[5];  
        System.out.println(arr4[0]);//false       

        String[] arr5 = new String[5];  
        System.out.println(arr5[0]);//null  
        if(arr5[0] == null){  
            System.out.println("北京天气不错！");  

        }  
    }  
}

综上

数组元素类型	元素默认初始化值
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0
char	0或写为：‘\u000’（表现为空）
boolean	false
引用类型	null

2.4、数组的内存解析

内存结构参考JVM规范，简化结构如下图

解释：

• main方法里面的都是局部变量
• 栈里面存放堆里面数组对象的地址值(栈里面存放局部变量)，通过指针和地址值指向联系起来
• String的内容其实存放在常量池中，常量池中放置一份，堆里面也放置一份(去常量池拿内容，复制)，详细后续。
• arr1由于又新new了一个数组对象，改变了指针指向，失去了原来的引用
• 引用计数算法：arr1：0x12判断是否还有地址指向它，没有了就成为了一个垃圾，就会在某个时间段被自动回收(自动垃圾回收机制)
• main方法执行完后，数组变量也就没用了，就开始相继出栈，出栈以后，指针指向没了，堆里面的数组对象也成为垃圾被自动回收(栈：先入后出)

3、二维数组的初步使用

对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。

3.1、二维数组的声明和初始化

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如：

String[][] str = new String[3][4];

现在用一段程序演示二维数组的声明和初始化

public class ArrayTest2 {  
    public static void main(String[] args) {    
        int[] arr = new int[]{1,2,3};//一维数组
        
        //二维数组静态初始化  
        int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}}; 
        
        //二维数组动态初始化1：从外层来说有3个元素，然后每个里面是由2个字符串元素构成的一维数组
        String[][] arr2 = new String[3][2];
        
        //动态初始化2：从外层来说有3个元素，然后每个里面的数组元素个数不确定的  
        String[][] arr3 = new String[3][];
        
        //错误的情况   
        // String[][] arr4 = new String[][4];  
        // String[4][3] arr5 = new String[][];  
        //[][] int arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};  


        //下面的写法也是正确的写法：  
        int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};  
        int[] arr5[] = {{1,2,3},{4,5},{6,7,8}}; //类型推断
        int arr4[][] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
    }
}

3.2、二维数组的初步使用

3.2.1、访问数组中的元素

对二维数组中的每个元素，引用方式为 arrayName[index1][index2]，例如：num[1][0]

public class ArrayTest2 {  
    public static void main(String[] args) {  
        int[][] arr1 = new int[][] {{1,2,3},{4,5},{6,7,8}};  
        String[][] arr2 = new String[3][2];  
        String[][] arr3 = new String[3][];  
        //调用数组的指定位置的元素  
        System.out.println(arr1[0][1]);//2  
        System.out.println(arr2[1][1]);//null  一维string数组默认初始化null
        
        //实际上这个arr3[1]是一个一维数组，是一个地址值 
        arr3[1] = new String[4];//必须要赋值，否则下面代码发生空指针异常  
        System.out.println(arr3[1][0]);//null
    }
}

3.2.2、获取数组的长度

int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}}; 
System.out.println(arr4.length);//3  
System.out.println(arr4[0].length) //3  
System.out.println(arr4[1].length);//4 

3.2.3、遍历二维数组

// 最常用：方式1：使用嵌套的 for 循环遍历二维数组
for (int i = 0; i < arr4.length; i++) {
    for (int j = 0; j < arr4[i].length; j++) {
        System.out.print(arr4[i][j] + "  ");
    }
    System.out.println();
}

// 方式2：使用增强的 for 循环遍历二维数组
for (double[] row : arr4) {
    for (double element : row) {
        System.out.print(element + "  ");
    }
    System.out.println();
}

// 方式3：使用 Arrays.deepToString() 输出整个二维数组
System.out.println(Arrays.deepToString(arr4));

// 方式4：使用 Stream 流式遍历二维数组
Arrays.stream(arr4).forEach(row -> {
    Arrays.stream(row).forEach(element -> System.out.print(element + "  "));
    System.out.println();
});

// 方式5：使用 forEach 和 lambda 表达式遍历二维数组
Arrays.asList(arr4).forEach(row -> {
    Arrays.asList(row).forEach(element -> System.out.print(element + "  "));
    System.out.println();
});

// 方式6：使用 IntStream 遍历二维数组的索引
IntStream.range(0, arr4.length).forEach(i -> {
    IntStream.range(0, arr4[i].length).forEach(j -> {
        System.out.print(arr4[i][j] + "  ");
    });
    System.out.println();
});

3.3、数组元素的默认初始化值

规定：二维数组分为外层数组的元素，内层数组的元素

• int[][] arr = new int[4][3]
• 外层元素：arr[0]，arr[1]等
• 内层元素：arr[0][0]，arr[1][2]等

针对于初始化方式一，比如：

• int[][] arr = new int[4][3]
• 外层元素的初始化值为：地址值
• 内层元素的初始化值为：与一维数组初始化情况相同

针对于初始化方式二，比如：

• int[][] arr = new int[4][]
• 外层元素的初始化值为：null，因为外层元素指向是一维数组，数组是引用类型，所以是null
• 内层元素的初始化值为：不能调用，必须赋值，否则报错。

代码演示：

public class ArrayTest3 {  
    public static void main(String[] args) {              
        int[][] arr = new int[4][3];  
        System.out.println(arr[0]); //[I@15db9742 一维数组的地址值  
        System.out.println(arr[0][0]); //0  

        System.out.println(arr);//[[I@6d06d69c，二维数组的地址值 

        System.out.println("****************************************");  

        float[][] arr1 = new float[4][3];  
        System.out.println(arr1[0]); //地址值  
        System.out.println(arr1[0][0]); //0.0  

        System.out.println("****************************************");  

        String[][] arr2 = new String[4][2];  
        System.out.println(arr2[1]);//地址值  
        System.out.println(arr2[1][1]);//null  

        System.out.println("****************************************");  
        double[][] arr3 = new double[4][];  
        //没有为内层元素赋值，因此外层指向就是一个一维数组，而数组属于引用数据类型，所以默认值为null  
        System.out.println(arr3[1]);//null       
        //System.out.println(arr3[1][0]);//没有赋值，报错空指针异常  

    }  
} 

3.4、内存解析

4、数组相关的常见数据结构算法

4.1、数组中涉及的常见算法

4.1.1、数组的反转

//方法三：通过中间数组，再遍历给他赋值(首位相互赋值)，达到反转，再把新数组赋值给arr
public static int[] reverse(int[] list) {
    int[] result = new int[list.length];

    for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
        result[j] = list[i];
    }
    return result;
}

//方法一： 针对一个数组，首尾交换 
for(int i = 0;i < arr.length / 2;i++){  
    String temp = arr[i];  
    arr[i] = arr[arr.length - i -1];  
    arr[arr.length - i -1] = temp;  
}  



//方法二：针对一个数组，双指针遍历  
for(int i = 0,j = arr.length - 1;i < j;i++,j--){  
    String temp = arr[i];  
    arr[i] = arr[j];  
    arr[j] = temp;  
}  

4.1.2、数组的线性查找

实现思路：通过遍历的方式，一个一个的数据进行比较、查找。下面实例演示了通过线性查找找出目标元素出现的第一个位置

public class Demo2 {
    public static void main(String[] args) {  
        
        String[] arr=new String[]{"AA","BB","CC","DD","EE","FF"};

        //线性查找：
        String dest = "BB";
        boolean isFlag = true;
        for(int i = 0;i < arr.length;i++){
            if(dest.equals(arr[i])){
                System.out.println("找到了指定的元素，位置为：" + i);
                isFlag = false;
                break;
            }
        }
        if(isFlag){
            System.out.println("很遗憾，没有找到的啦！");
        }   
    }
}

4.1.3、数组的二分法查找：

实现思路：每次比较中间值，折半的方式检索。适用性：（前提：数组必须有序）。下面实例演示了没有使用递归的情况。

public class Demo2 {
    public static void main(String[] args) {        

        //二分法查找：(熟悉)
        //前提：所要查找的数组必须有序。
        int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};

        int dest1 = -34; //查找目标元素

        int head = 0;//初始的首索引
        int end = arr2.length - 1;//初始的末索引
        
        boolean isFlag1 = true;
        //开始查找
        while(head <= end){

            int middle = (head + end)/2;

            if(dest1 == arr2[middle]){
                System.out.println("找到了指定的元素，位置为：" + middle);
                isFlag1 = false;
                break;
            }else if(arr2[middle] > dest1){
                end = middle - 1;
            }else{   //arr2[middle] < dest1
                head = middle + 1;
            }


        }
        if(isFlag1){
            System.out.println("很遗憾，没有找到的啦！");
        }
    }
}

4.2、数组的排序算法

4.2.1、排序算法概述

衡量排序算法的优劣：

• 时间复杂度 ：分析关键字的比较次数和记录的移动次数
• 空间复杂度：分析排序算法中需要多少辅助内存
• 稳定性： 若两个记录 A 和 B 的关键字值相等，但排序后 A 、 B 的先后次序保持不变，则称这种排序算法是稳定的。

排序算法分类：

• 内部排序和外部排序 。
• 内部排序 ：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。
• 外部排序 ：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。

十大内部排序

• 选择排序：直接选择排序、堆排序
• 交换排序：冒泡排序、快速排序
• 插入排序：直接插入排序、折半插入排序、 Shell 排序
• 归并排序，桶式排序，基数排序

不同排序算法的时间复杂度

• 从平均时间而言 快速排序最佳。 但在最坏情况下时间性能不如堆排序和归并排序。
• 从算法简单性看 ：由于直接选择排序、直接插入排序和冒泡排序的算法比较简单，将其认为是 简单 算法。 对于 Shell 排序、堆排序、快速排序和归并排序算法，其算法比较复杂，认为是复杂排序。
• 从稳定性看 ：直接插入排序、冒泡排序和归并排序时稳定的；而直接选择排序、快速排序、 Shell 排序和堆排序是不稳定排序
• 从待排序的记录数 n 的大小看 n 较小时，宜采用简单排序；而 n 较大时宜采用改进排序。

算法的5大特征

说明：满足确定性的算法也称为：确定性算法。 现在人们也关注更广泛的概念 例如考虑各种非确定性的算法 如并行算法 、 概率算法等 。 另外 人们也关注并不要求终止的计算描述 这种描述有时被称为过程 (procedure)

4.2.2、十大排序算法

1、冒泡排序

冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。 排序思想

1. 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要

package com.atguigu.java;  
public class BubbleSortTest {  
    public static void main(String[] args) {
        
        int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};

        //冒泡排序，外层交换比较lenth-1次
        for(int i = 0;i < arr.length - 1;i++){
            //内层比较 arr.length - 1 - i次 
            for(int j = 0;j < arr.length - 1 - i;j++){
                if(arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }	
    }
}

2、快速排序

快速排序通常明显比同为O(nlogn) 的其他算法更快，因此常被采用，而且快排采用了分治法的思想，所以在很多笔试面试中能经常看到快排的影子。可见掌握快排的重要性 。 快速排序（Quick Sort ）由图灵奖获得者 Tony Hoare 发明，被列为 20 世纪十大算法之一 ，是迄今为止所有内排序算法中速度最快的一种。冒泡排序的升级版，交换排序的一种。快速排序的时间复杂度为 O(nlog(n))

代码实现：

略

5、Arrays工具类

java.util.Arrays 类能方便地操作数组，包含了用来操作数组比如排序和搜索的各种方法，并且它提供的所有方法都是静态的。

具有以下功能：

• 给数组赋值：通过 fill 方法。
• 对数组排序：通过 sort 方法，按 升序。
• 比较数组：通过 equals 方法比较数组中元素值是否相等。
• 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
• 通过 toString 方法可以打印出数组的信息

具体说明请查看下表：

序号	方法和说明
1	public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
2	public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
3	public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
4	public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）

使用：具体方法使用可以查看源码

//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
int[] arr1 = new int[]{1,2,3,4};
int[] arr2 = new int[]{1,3,2,4};
boolean isEquals = Arrays.equals(arr1, arr2);
System.out.println(isEquals);

//2.String toString(int[] a):输出数组信息。
System.out.println(Arrays.toString(arr1));

//3.void fill(int[] a,int val):将指定值填充到数组之中。
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));

//4.void sort(int[] a):对数组进行排序。
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));

//5.int binarySearch(int[] a,int key)
int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int index = Arrays.binarySearch(arr3, 210);
if(index >= 0){
    System.out.println(index);
}else{
    System.out.println("未找到");
}

6、数组中的常见异常

数组角标越界的异常：ArrayIndexOutOfBoundsExcetion

int[] arr = new int[]{1,2,3,4,5};
//	for(int i = 0;i <= arr.length;i++){
//			System.out.println(arr[i]);
//		}

//		System.out.println(arr[-2]);
//		System.out.println("hello");//程序出现异常，未处理时，就终止执行，所以hello不会打印

空指针异常：NullPointerException

//情况一：
int[] arr1 = new int[]{1,2,3};
arr1 = null;
System.out.println(arr1[0]);

//情况二：
int[][] arr2 = new int[4][];
System.out.println(arr2[0][0]);

//情况三：
String[] arr3 = new String[]{"AA","BB","CC"};
arr3[0] = null;
System.out.println(arr3[0].toString());

一旦程序出现异常，未处理时，就终止执行。

标签：arr,Java,int,System,基础知识,数组,println,out
From： https://blog.csdn.net/weixin_50281626/article/details/144169648