Java基础——数组

最新推荐文章于 2025-06-04 20:36:48 发布

静以成学

最新推荐文章于 2025-06-04 20:36:48 发布

阅读量463

点赞数

CC 4.0 BY-SA版权

分类专栏： Java的基本程序设计结构 Java基础笔记文章标签： java

本文链接：https://blog.youkuaiyun.com/bridge_zrq/article/details/119250287

Java基础笔记同时被 2 个专栏收录

32 篇文章

订阅专栏

Java的基本程序设计结构

10 篇文章

订阅专栏

本文详细介绍了Java中的数组，包括定义、初始化、访问、默认值、内存存储、遍历、异常处理、多维数组、拷贝、排序、查找算法等内容。重点讲解了数组的动态初始化、静态初始化、遍历方法、内存分配以及如何处理数组越界和空指针异常。还涉及了二分查找算法和快速排序算法，并介绍了Java的Arrays工具类及其常用方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数组

数组的定义

数组是一种数据结构，用来存储同一类型值的集合。通过一个整型下标可以访问数组中的每一个值。

数组是相同类型数据的有序集合。
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
其中，每一个数据称作一个数组元素，每个数组元素可以通过数组的索引或者下标（角标）来访问它们。

数组声明创建

格式：
数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
数组定义格式详解：
- 数组存储的数据类型：创建的数组容器可以存储什么数据类型。
- [] : 表示数组。
- 数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
- new：关键字，创建数组使用的关键字。
- 数组存储的数据类型：创建的数组容器可以存储什么数据类型。
- [长度]：数组的长度，表示数组容器中可以存储多少个元素。
- 注意：数组有定长特性，长度一旦指定，不可更改。
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dataType[] arrayRefVar;  // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法

Java 语言使用 new 操作符来创建数组，语法如下：

ataType[] arrayRefVar = new dataType[arraySize];

数组的元素是通过索引访问的，数组索引从0开始
获取数组长度：

arrays.length

三种初始化

静态初始化

/静态初始化：创建 + 赋值
int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};

动态初始化

//动态初始化：包含默认初始化，未赋值前为0。
int[] a = new int[2];
a[0] = 1; 
a[1] = 2;

数组的默认初始化
- 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方法被隐式初始化。

数组的特点

其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
其元素必须是相同类型，不允许出现混合类型。
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

数组的访问

索引：每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引 (index)，可以通过数组的索引访问到数组中的元素。
格式：
数组名[索引]
数组的长度属性：每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为：数组名.length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数组的最大索引值为数组名.length-1
索引访问数组中的元素：
- 数组名[索引]=数值，为数组中的元素赋值
- 变量=数组名[索引]，获取出数组中的元素

数组的默认值

数组元素即使我们没有赋值每个元素都存在一个默认的值

byte shot int 默认值是 0 long类型的默认值0L

float double 默认值是0.0 char类型的默认值他是"\u0000"

boolean 类型为false String为代表的引用类型为null

数组的分类（了解）

维度：一维数组二维数组三维数组多维数组…
数据类型：基本类型的数组（整形数组浮点型数组字符型数组布尔型数组）引用类型的数组

数组在内存中的存储

内存概述

内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。 Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

Java虚拟机的内存划分

为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

JVM的内存划分：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-afdHZLOT-1627632715714)(F:\study\笔记\截图\java-performance-jvm-memory-model.jpg)]

堆区：存储对象或者数组 new出来的都在对内存中。如果申请不到空间则会抛出内存溢出异常。

虚拟机栈：栈里面是一个一个的“栈帧” 每个栈帧对应一次方法的调用。栈帧中存放了局部变量表（基本类型数据的变量和对象的引用）。操作数栈，方法出口以及其他的信息。当栈调用的深度大于jvm所允许的范围，也会发生一个异常。

一个数组内存图

public static void main(String[] args) { 
	int[] arr = new int[3]; 
	System.out.println(arr);//[I@5f150435 
}

以上方法执行，输出的结果是[I@5f150435，这个是什么呢？是数组在内存中的地址。new出来的内容，都是在堆内存中存储的，而方法中的变量arr保存的是数组的地址。
输出arr[0]，就会输出arr保存的内存地址中数组中0索引上的元素

两个数组内存图

public static void main(String[] args) { 
	int[] arr = new int[3]; 
	int[] arr2 = new int[2]; 
	System.out.println(arr); 
	System.out.println(arr2); 
}

两个变量指向一个数组

public static void main(String[] args) { 
		// 定义数组，存储3个元素 
		int[] arr = new int[3]; 
		//数组索引进行赋值 
		arr[0] = 5; 
		arr[1] = 6; 
		arr[2] = 7; 
		//输出3个索引上的元素值 
		System.out.println(arr[0]); 
		System.out.println(arr[1]); 
		System.out.println(arr[2]); 
		//定义数组变量arr2，将arr的地址赋值给arr2 
		int[] arr2 = arr; 
		arr2[1] = 9; 
		System.out.println(arr[1]); 
	}

多维数组

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

二维数组

动态初始化： int[][] arr = new int[3][];
			arr[0]= new int[3];
			arr[1] = new int[5];
			arr[2]= new int[4];

静态初始化：int[][] arr = {{2,1,4},{3,1,4,2,1},{3}};
			int[][] arr =new int[][]{{2,1,4},{3,1,4,2,1},{3}};

在java中二维数组不必恃规则的矩阵形式。

        int[][] arr = new int[3][5];
        arr[0][0] = 32;
        arr[2][4] = 54;
        //遍历
        for(int i = 0 ; i < arr.length;i++){// 行
            for(int j = 0 ; j < arr[i].length; j++){// 列
                System.out.print(arr[i][j]+"    ");
            }
            System.out.println();//每一行结束  换行
        }
    }

内存结构：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JJka2QQU-1627632715717)(F:\study\笔记\截图\image-20210717142631584.png)]

面试考点：杨辉三角

1 1

1 2 1

1 3 3 1

1 4 6 4 1

第一行 1个元素第n行 n个元素

每一个的第一个和最后一个元素都是1

从第三行开始对于非第一个和最后一个的元素

yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j]

   public static void main(String[] args) {
        int[][] yh = new int[5][];
        for(int i = 0 ; i < yh.length; i++){
            yh[i] = new int[i+1];
            for(int j = 0; j < i + 1;j++){
                if(j==0 || i==j){
                    yh[i][j]= 1;
                }else{
                    yh[i][j] = yh[i-1][j-1] + yh[i-1][j];
                }
            }
        }
        for(int i = 0 ; i < yh.length;i++){
            for(int j = 0 ; j < yh[i].length; j++){
                System.out.print(yh[i][j]+"    ");
            }
            System.out.println();
        }
    }

数组的常见操作

数组越界异常

下标的合法区间：[0,length-1]，如果越界就会报错；

public static void main(String[] args){
    int[] a=new int[2];  //a长度为2，下标表示为a[0]，a[1].
    System.out.println(a[2]);//a[2]以超出设定值
}

ArraylndexOutOfBoundsException:数组下标越界异常！
小结：
- 数组是相同数据类型（数据类型可以为任意类型）的有序集合
- 数组也是对象。数组元素相当于对象的成员变量
- 数组长度的确定的，不可变的。如果越界，则报：ArrayindexOutofBounds
解决方案：

将越界的数组索引修改到正常范围即可。

数组空指针异常

public static void main(String[] args) { 
	int[] arr = {1,2,3}; 
	arr = null; 
	System.out.println(arr[0]); 
｝

arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。

空指针异常：意味着引用类型的变量不指向任何对象（引用类型的变量没有引用到任何数据）

解决方案：给引用类型的变量一个真正的堆内存空间引用即可。

空指针异常在内存图中的表现

数组的遍历

数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。

public static void main(String[] args) { 
	int[] arr = { 1, 2, 3, 4, 5 }; 
	for (int i = 0; i < arr.length; i++) { 
		System.out.println(arr[i]); 
	} 
}

增强for循环jdk1.5新增）：专门用户读取数组或集合中所有的元素（遍历数组或集合）

 /*
         *增强for  第一部分  遍历的数组或集合中的元素的类型
         * 第二部分 a  用来存储每一次获取的元素
         * 第三部分  arr  表示要便利的数组或者集合对象
         */
        for (int a : arr){
            System.out.println(a);
        }

增强for循环在整体遍历时相对于普通for更见简洁
普通for循环可以通过索引精确控制到每一个元素而增强for 则不可以。

数组的拷贝

  public static void main(String[] args) {
        int[] arrSrc = {2,3,52,11,4,5,43,2,1};
        int[] arrDest = new int[arrSrc.length];// 新数组的长度 必须大于等于原数组
         for(int i = 0 ; i < arrDest.length;i++){
             arrDest[i] = arrSrc[i];
         }
         for(int a : arrDest){
             System.out.println(a);
         }
    }

 public static void main(String[] args) {
        int[] arrSrc = new int[5];
        int[] arrNew=null;
        int count=0;
        for(int i = 0 ; i< 100;i++ ){
            if(count < arrSrc.length){//当数组中的元素的个数小于数组的长度 则可以保存数据到数组中
                arrSrc[i]=i;//给数组添加元素
            }else{//数组中的数据的个数大于等于了数组的长度
                arrNew = new int[arrSrc.length +(int)(arrSrc.length * 0.75)];
                for (int j = 0 ; j < arrSrc.length;j++){
                    arrNew[j]= arrSrc[j];
                }
                arrSrc = arrNew;
                arrSrc[i]=i;//给数组添加元素
            }
            count++;//统计数组中数据的个数
        }
     //遍历
        for(int a : arrNew){
            System.out.println(a);
        }
    }

获取数组中的最大值

最大值获取：从数组的所有元素中找出最大值。
实现思路：
- 定义变量，保存数组0索引上的元素
- 遍历数组，获取出数组中的每个元素
- 将遍历到的元素和保存数组0索引上值的变量进行比较
- 如果数组元素的值大于了变量的值，变量记录住新的值
- 数组循环遍历结束，变量保存的就是数组中的最大值

记录元素的值

    public static void main(String[] args) {
        int[] arr = {2,52,26,22,12,3,223,22,91,81};
        // 获取数组中的最大元素
        int max = arr[0];//假设第一个元素是最大的
        for(int a : arr){
            if(a > max){
                max = a;
            }
        }
        System.out.println(max);
    }

记录元素的位置

    public static void main(String[] args) {
        int[] arr = {2,52,26,22,12,3,223,22,91,81};
        // 获取数组中的最大元素
        int maxIndex=0;
        for(int i = 0 ; i < arr.length;i++){
            if(arr[i] > arr[maxIndex]){
                maxIndex = i;
            }
        }
        System.out.println(arr[maxIndex]);
    }

数组反转

数组的反转：数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1
实现思想：数组最远端的元素互换位置。
- 实现反转，就需要将数组最远端元素位置交换
- 定义两个变量，保存数组的最小索引和最大索引
- 两个索引上的元素交换位置
- 最小索引++，最大索引–，再次交换位置
- 最小索引超过了最大索引，数组反转操作结束

数组作为方法参数和返回值

以前的方法中我们学习了方法的参数和返回值，但是使用的都是基本数据类型。那么作为引用类型的数组能否作为方法的参数进行传递呢，当然是可以的。

数组作为方法参数传递，传递的参数是数组内存的地址。

数组作为方法返回值

数组作为方法的返回值，返回的是数组的内存地址

方法的参数类型区别

方法的参数为基本类型时,传递的是数据值。方法的参数为引用类型时,传递的是地址值.

稀疏数组

需求：编写五子棋游戏中，有存盘退出或续上盘的功能。
分析问题：因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据。
解决：稀疏数组

稀疏数组介绍

当一个数组中大部分元素为0，或者为同一值得数组时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方式是：
- 记录数组一共有几行几列，有多少个不同值。
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

  public static void main(String[] args) {
        int[][] array1 = new int[11][11];//0代表空，1代表黑子，2代表白子
        array1[1][2] = 1;//给黑子定位
        array1[2][3] = 2;//给白子定位
        //输出原始数据
        System.out.println("原始数据:");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }
        System.out.println("======================");
        //转换为稀疏数组保存
        //1.求和有效值的个数
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.length; j++) {
                if (array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("稀疏数组：");
        //2.创建一个稀疏数组的数组
        int[][] array2 = new int [sum+1][3];//确定第一条稀疏数组的数据
        array2[0][0]= 11;
        array2[0][1]= 11;
        array2[0][2]= sum;
        //3.将非零的值，存放在稀疏数组中
        int count = 0;
        for (int i = 0; i <array1.length ; i++) {
            for (int j = 0; j <array1.length ; j++) {
                if (array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        System.out.println("序 "+" 行 "+" 列 "+" 值 ");//打印数组
        int xu = 0;
        for (int[] ints : array2) {
            System.out.print(xu+" ");
            for (int anInt : ints) {
                if (anInt<10){System.out.print("  "+anInt+" ");}
                else { System.out.print(" "+anInt+" ");}
            }
            xu++;
            System.out.println();
            }
        /*
        for (int i = 0; i <array2.length ; i++) {
            System.out.println(array2[i][0]+"\t"
                    +array2[i][1]+"\t"
                    +array2[i][2]+"\t");
        }*/
        System.out.println("========================");
        //转换成原始数据
        System.out.println("还原原始数组：");
        int[][] array3 = new int[array2[0][0]][array2[0][1]];//确认原始数组整体大小
        for (int i = 1; i <array2.length ; i++) {
            array3[array2[i][0]][array2[i][1]]=array2[i][2];//将数组的数据赋值
        }
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+" ");
            }
            System.out.println();
        }
    }

二分查找算法

二分检索法（折半检索）。二分检索法的基本思想是：假设数组中的元素是有序存放（排序）。首先确定我们要查找的值（key）。将key与数组中的中间位置的元素进行比较，如果key< 中间值，则说明要查找的元素位于左半部分，如果key > 中间值，则说明要查找的元素位于右半部份。如果key=中间值，则说明中间的元素就是我们要找的元素。

二分检索法是一种效率较高的检索方法。

public class SearchKey {
    public static void main(String[] args) {
        int[] arr = {12,32, 34,45, 54,65,71,82};
        boolean flag = search(arr,32);
        System.out.println(flag);
    }
    /**
     *
     * @param arr  是目标数组
     * @param key 是目标值
     * @return
     */
    public  static  boolean search(int[] arr, int key){
        int start = 0;//查找的开始位置
        int end = arr.length -1;//查找的结束为止
        while(start <= end){
            int mid = (start + end ) /2;
            if(key == arr[mid]){
                return  true;
            }else if(key < arr[mid]){
                end = mid -1;
            }else if(key > arr[mid]){
                start = mid + 1;
            }
        }
       return  false;
    }
}

    /**
     *
     * @param arr  是目标数组
     * @param key 是目标值
     * @return 表示目标元素所在的位置  如果返回-1  则表示目标元素不存在
     */
    public  static  int search(int[] arr, int key){
        int start = 0;//查找的开始位置
        int end = arr.length -1;//查找的结束为止
        int index= -1;
        while(start <= end){
            int mid = (start + end ) /2;
            if(key == arr[mid]){
                 index = mid;
                 return index;
            }else if(key < arr[mid]){
                end = mid -1;
            }else if(key > arr[mid]){
                start = mid + 1;
            }
        }
       return  index;
    }
}

数组的排序

选择排序：直接选择排序堆排序

交换排序：冒泡排序快速排序

插入排序：直接插入折半插入排序 shell 排序

归并排序

桶式排序

基数排序

冒泡排序

[[十大经典排序算法]:(https://www.cnblogs.com/onepixel/p/7674659.html)

冒泡排序的核心就是依次比较相邻的两个数，升序排序时将小数放在前面，大数放在后面。排序算法一般都需要进行多轮比较，以下是冒泡排序的升序比较过程。

第 1 轮：首先比较第 1 个和第 2 个数，将小数放前，大数放后；然后比较第 2 个数和第 3 个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后；至此第一轮结束，将最大的数放到了最后。
第 2 轮：仍从第一对数开始比较，将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的数），第二轮结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。

总结来说，第 1 到 n-1 轮中（n 为数组长度，下文同）第 i 轮的作用是把第 i 大的数放到数组的 n-i 下标处。按此规律操作，直至最终完成排序。由于在排序过程中总是将大数往后放，类似于气泡往上升，所以称作冒泡排序。

通过上面的分析可以看出，假设需要排序的序列的个数是 n，则需要经过 n-1 轮，最终完成排序。在第一轮中，比较的次数是 n-1 次，之后每轮减少 1 次。

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr ={3,15,2,6,4,7,9,8};
        for(int j = arr.length -1;j  > 0 ; j--){//控制比较的次数
            for(int i = 0 ; i < j;i++){
                if(arr[i] > arr[i+1]){//如果前边的元素大于后边的元素 则交换连个元素的位置
                    int temp = arr[i];
                    arr[i]= arr[i +1];
                    arr[i + 1] = temp;
                }
            }
        }
        for(int a : arr){
            System.out.println(a);
        }
    }
}

代码的重构：

1 让代码的结构更加清晰便于阅读和维护

2 让代码能够复用减少代码的冗余

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr ={3,15,2,6,4,7,9,8};
        sort(arr);
        print(arr);
    }
// 使用冒泡算法 对整数数组进行排序
    public  static void  sort(int[] arr){
        for(int j = arr.length -1;j  > 0 ; j--){//控制比较的次数
            for(int i = 0 ; i < j;i++){
                if(arr[i] > arr[i+1]){//如果前边的元素大于后边的元素 则交换连个元素的位置
                    swap(arr,i,i+1);
                }
            }
        }
    }
    // 交换数组中两个的位置
    public static void swap(int[] arr, int index1, int index2){
        int temp = arr[index1];
        arr[index1]= arr[index2];
        arr[index2] = temp;
    }
    //数组的遍历
    public  static  void print(int[] arr){
        for(int a : arr){
            System.out.println(a);
        }
    }
}

快速排序

快速排序采用的是一种分治思想快速排序可以看作是冒泡排序的升级版

思想：

1 从数组中挑出一个元素称为”基准元素“

2 重新排序数组，所有元素比基准元素小的放在基准元素的前面，所有比基准元素大的放在基准的后面。在这个分区结束之后，该基准元素就处于数组的中间位置。称为分区操作。

3 递归的把小于基准元素的子数组和大于基准元素的子数列排序

4 递归的最底部的情形是数列的大小是零或 1 也就是永远都已经被排序好了虽然这样一直递归下去，但是这个算法总会要结束，因为在每次的迭代中，他至少会把一个元素摆在他最后的位置。

public class QuciSort {
    public static void main(String[] args) {
        int[] arr ={3,15,2,6,4,7,9,8};
        quickSort(arr);
        print(arr);
    }
    public  static  void quickSort(int[] arr){
        if(arr == null || arr.length == 0 ){
            return;
        }
        sort(arr,0,arr.length - 1);
    }
    // 核心算法
    public static  void sort(int[] arr,int left,int right){
        if(left > right){//递归的结束条件
            return;
        }
        // 选择基准元素
        int base = arr[left];
        int i = left;
        int j = right;
        while( i != j){
            while(arr[j] >= base && i < j){//从右边开始寻找比基准元素大的元素  如果比基准元素大 则继续向前寻找
                j--;
            }
            // 从左往右找  找比基准元素小的  如果比基准元素小 则继续往后找
            while(arr[i] <= base && i < j){
                i++;
            }
            if(i < j ){// 如果从右往左找打比基准元素小的    从左往右找到比基准元素大的  则交换两个元素的位置 让大区右边  让小的  去左边
                int temp  = arr[i];
                arr[i] =arr[j];
                arr[j] = temp;
            }
        }
        // 将基准元素放到中间位置（基准归位）
        arr[left] = arr[i];
        arr[i]= base;
        // 递归 继续进行左右两边的快速排序
        sort(arr,left,i -1);
        sort(arr,i+1,right);
    }
    //数组的遍历
    public  static  void print(int[] arr){
        for(int a : arr){
            System.out.println(a);
        }
    }
}

选择排序

选择排序是一种简单直观的排序算法。原理：在没有排序的数组中找出最小的（最大的）与第一个位置的元素进行交换

选择排序和冒泡排序的区别：

冒泡排序通过一次交换相邻两个元素的位置，从而将当前最大的元素放置到最后的位置。选择排序，每遍历一次都记住当前最小的元素的位置，最后仅需交换一次即可将元素放到合适的位置。

思想：

1 数组排序，数组是无序的

2 第一次排序：从n-1个元素中找出最大的元素与第一个元素进行交换

3 后边就以此类推

public class SelectSort {
    public static void main(String[] args) {
        int[] arr ={3,15,2,6,4,7,9,8};
        for(int i = 0 ; i < arr.length;i++){
            int minIndex= i;// 假设第一个元素是最小  同时使用minIndex记录最小元素所在的位置
            for(int j = i + 1; j < arr.length;j++){
                if(arr[j] < arr[minIndex]){//找到比假设的最小元素小的的元素
                    minIndex = j;// 记录最小元素的位置
                }
            }
           // 找到其中的最小的元素  将最小的元素和第一个元素交换位置
            if(minIndex != i){
                int temp = arr[i];
                arr[i]= arr[minIndex];
                arr[minIndex] = temp;
            }
        }
        // 遍历数组
        for(int a : arr){
            System.out.println(a);
        }
    }
}

Arrays 工具类

数组的工具类java.uti.Arrays

由于数组对象本身并没有什么方法可以供我们调用，但是 API 中提供了一个工具类 Arrays 供我们使用，从而可以对数据对象进行一些基本的操作。

查看 JDK 帮助文档

Arrays 类中的方法都是 static 修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是“不用”而不是“不能”）

具有以下常用功能：

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

public static void main(String[] args) {
        int[] arr ={2,24,4,43,222,456,64,32,211,2,3};
        //使用Arrays提供的方法  对数组进行排序
        Arrays.sort(arr);
        //遍历数组
        for(int a : arr){
            System.out.println(a);
        }
    }

public static void main(String[] args) {
        int[] arr ={2,24,4,43,222,456,64,32,211,2,3};
        //使用Arrays提供的方法  对数组进行排序
        Arrays.sort(arr);//必须先排序
       int res =  Arrays.binarySearch(arr,2);
        System.out.println(res);

import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr ={2,24,4,43,222,456,64,32,211,2,3};
        //填充数组
        /*
        public static void fill(int[] a,
                        int fromIndex,
                        int toIndex,
                        int val)
         */
        Arrays.fill(arr,3,6,100);

        //遍历数组
//        for(int a : arr){
//            System.out.println(a);
//        }
        System.out.println(Arrays.toString(arr));
    }
}

m.out.println(a);
}
}


```java
public static void main(String[] args) {
        int[] arr ={2,24,4,43,222,456,64,32,211,2,3};
        //使用Arrays提供的方法  对数组进行排序
        Arrays.sort(arr);//必须先排序
       int res =  Arrays.binarySearch(arr,2);
        System.out.println(res);

import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr ={2,24,4,43,222,456,64,32,211,2,3};
        //填充数组
        /*
        public static void fill(int[] a,
                        int fromIndex,
                        int toIndex,
                        int val)
         */
        Arrays.fill(arr,3,6,100);

        //遍历数组
//        for(int a : arr){
//            System.out.println(a);
//        }
        System.out.println(Arrays.toString(arr));
    }
}