JavaSE数组和Arrays工具类的使用

JavaSE之数组和Arrays工具类

一、数组

1.1一维数组

1.1.2数组和变量的关系

变量: 只能存储一个值

数组: 存储的一组相同数据类型的值, 存储个数: 由程序员在创建的数组的时候来指定(即数组的动态初始化),

数组在初始化完成后其长度固定

数组要素:

​ 1) 数组名：其实就是引用变量名

要区别好引用变量和实例变量 int[] a=new int[3]; a则为引用变量 =右边的为实例变量

​ 2) 数据类型

​ 3) 元素

​ 4) 下标: 获取指定位置的元素: 从0开始: 0 表示第一个元素, 1表示第二个元素…

​ 0=<下标<数组长度

​ 5) 数组的长度: 表示数组最大允许存多少个元素

1.1.3数组的创建

1、声明数组: 没有开辟空间

​ 语法:

​ 数据类型[] 数组名;

​ 数据类型 数组名[];

2、开辟空间, 指定数组的长度 通过new关键字, 数组开辟空间是连续

​ 数组名 = new 数据类型[长度];

​ 注意:

>   new 数组的方式: 除了开辟内存空间, 还会对数组中元素进行初始化(赋予初始值)

>  初始值根据数据类型决定:

​ int/byte/short/long: 初始值0

​ double/float: 初始值:0.0

​ char: \u000

​ boolean: false

​ String/类类型: null

3、往数组中存放元素: 通过下标

数组名[下标] = 值;

注意:

如果下标超出最大下标(数组的长度-1): 抛出一个数组越界的异常  ArrayIndexOutOfBoundsException: 5

如果一个数组没有开辟空间, 不能存放数据, 编程出错

1.1.4获取数组的元素,进行相关操作

通过下标: 数组名[下标]

如果下标超出最大下标(数组的长度-1): 抛出一个数组越界的异常 ArrayIndexOutOfBoundsException: 5

在实际开发中,可能使用循环遍历这个数组(把数组的元素一个一个拿出来), 最匹配:for

动态的获取数组的长度: 数组提供了一个属性:

  >  数组名.length  获取该数组的长度

可以把1,2,3(声明数组,开辟空间,存元素)合并成一行代码, 数组静态创建

数据类型[] 数组名 = new 数组类型[]{值1,值2,值3,…}

注意: new后面中括号不能写长度, jdk根据后面值的个数确定数组的长度

简写: 数据类型[] 数组名 ={值1,值2,…}

1.2二维数组

由多个一维数组组成, 称为二维数组

三维数组: 由多个二维数组组成

1.2.1声明一个二维数组:

//1,声明数组
数据类型[][] 数组名;
//2.开辟空间
数组名 = new 数据类型[长度1][长度2]

长度1: 表示的一维数组的个数

长度2: 表示的一维数组的元素个数

//3.赋值  通过下标
数组名[i][j] = 值;
//4.使用: 通过下标
数组名[i][j]

遍历一维数组: 一个for循环

遍历二维数组: 两个for循环

二维数组的静态初始化

//一维数组的静态初始化
int[] arr = new int[]{1,2,3,4,5};
int[] arr2 = {1,2,3,4,5};
//二维数组:
int[][] arr3 = {{1,2,3},{4,5,6},{7,8,9}};

1.2.3获取二维数组的数组长度

二维数组的一维数组长度: 数组名.length

二维数组的指定下标的一维数组元素个数: 数组名[下标].length

二维数组的元素个数: 数组名[0].length+数组名[1].length+…+数组名[数组名.length-1].length

二、Javau.util.Arrays的使用

数组的工具类: java.util.Arrays

1.Arrays.toString()方法

方法作用：快速输出数组内容

int[] a = {1,2,3,4,5};
System.out.println(Arrays.toString(a));
// 输出格式：[1,2,3,4,5]

2.Arrays.sort()方法

方法运用:给数组排序，默认升序

int[] a = new int[5]{5，4，3，2，1};
Arrays.sort(a); // 1 2 3 4 5
System.out.println(Arrays.toString(a));
// [1,2,3,4,5]

int []a = new int[]{7,2,8,3,1,2,90,23};
//  fromndex 起始地址     排序到toindex的前一位； 
Arrays.sort(a,3,6);
System.out.println(Arrays.toString(a));
// [7, 2, 8, 1, 2, 3, 90, 23]
//           3  4  5

Arrays.sort()降序排列

不能作用于基本数据类型！

Integer[] a = {1,2,3,4,5}
Arrays.sort(a,Collections.reverseOrder())
// 输出数组的内容即为：5 4 3 2 1

关于对象数组的排序则需要 自定义排序规则：实现Comparator<> 接口

   Integer []a = new Integer[]{2,45,34,70,0,1};
        Arrays.sort(a, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //升序
//                return o1.intValue()-o2.intValue();
                //逆序
                return o2.intValue()-o1.intValue();
            }
        });
        System.out.println(Arrays.toString(a));
        //[70, 45, 34, 2, 1, 0]


//lambda 表达式
 Integer []a = new Integer[]{2,45,34,70,0,1};
        Arrays.sort(a, (e1,e2)-> e2-e1);
        System.out.println(Arrays.toString(a));
        //[70, 45, 34, 2, 1, 0]

3.Arrays.equals()方法

方法作用：比较两个数组内容是否相等

int[] a = {1,2,3};
int[] b = {1,2,3};
boolean isSame = Arrays.equals(a,b);
//true

注意：Arrays.equals()是比较数组内容，而没有重写equals的对象的a.equals(b) （继承Object）这样的方法是比较地址值

4.Arrays.binarySearch()

方法作用：通过二分查找在数组中查找元素

再数组中查找指定值，若找到，则返回此值的下标，

若没找到，返回 -插入点-1；

int[] a = {1,5,6,7};
Arrays.binarySearch(a,2)  //没找到，插入点为1，则返回 -2
Arrays.binarySearch(a,4)  //没找到，插入点为1，则返回 -2
Arrays,binarySearch(a,8)  //没找到，插入点为4，则返回 -5
Arrays.binarySearch(a,5)  //找到了！返回下标 1
只要返回值 ≥ 0 ，就代表找到了。

5.Arrays.copyOf()

方法作用：拷贝数组

   int []a = new int[]{1,2,3,4,5};
//      第二个参数为拷贝的数组元素个数
        int []b= Arrays.copyOf(a, 5);
        int []c= Arrays.copyOf(a, 3);
        System.out.println(Arrays.toString(a)); //[1, 2, 3, 4, 5]
        System.out.println(Arrays.toString(b)); //[1, 2, 3, 4, 5]
        System.out.println(Arrays.toString(c)); //[1, 2, 3]

返回值是一个新数组，会改变接收这个新数组的引用的一些属性

eg:

      int[] arr1 = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
            int[] arr2 = new int[5];
            arr2 = Arrays.copyOf(arr1, 10);
            System.out.println(Arrays.toString(arr2));  //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Arrays.copyOf()的拷贝是从下标0开始的，如果你想从其他下表开始，可以使用Arrays.copyOfRange()方法

   int[] arr1 = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
            int[] arr2 = new int[5];
            //from起始下标 ， to 复制到下标前一位  前闭后开
            arr2 = Arrays.copyOfRange(arr1, 2,6);
            System.out.println(Arrays.toString(arr2));  //[3, 4, 5, 6]

Range()方法

   int[] arr1 = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
            int[] arr2 = new int[5];
            //from起始下标 ， to 复制到下标前一位  前闭后开
            arr2 = Arrays.copyOfRange(arr1, 2,6);
            System.out.println(Arrays.toString(arr2));  //[3, 4, 5, 6]