程序员第三步-Java基础知识-数组及Arrays工具类

数组

数组的概述

数组是一个容器，长度在初始化时进行定义，一但定义，长度就不可以改变，数组中存放的都是相同类型的数据。

数组的定义格式

一维数组(以整型数组为例，其余类型可以直接将int替换为你想要的数据类型就可以)：
1.int []a;
2.int a[];

数组的初始化

数组初始化概述

Java中的数组必须进行初始化之后才可以使用，所谓初始化就是为定义的数组分配内存空间，并为每个元赋值

数组的初始化方式

一维数组(以整型数组为例，其余类型可以直接将int替换为你想要的数据类型就可以)：
1.动态初始化：int []a = new int[n],n表示数组长度，是大于0 的整数
2.静态初始化：int []a = new int[]{1,2,3};
int []a={1,2,3};

数组的内存分配

数组的使用

数组的元素访问

索引：数组会自动为存储进来的元素进行索引的分配，从0开始，最大的索引为数组的长度减一。
格式：数组名[索引]

import java.util.Scanner;

public class Demo {
    
    public static void main(String[] args) {
    //一维数组的定义
        int []arr = new int[]{1,2};
        int []arr2={5,6};
        //遍历通过索引输出输出数组中的元素
        for (int i = 0; i < arr.length; i++) {
            System.out.printf(arr[i]+" ");
        }
        System.out.println();
        for (int i = 0; i < arr2.length; i++) {
            System.out.printf(arr2[i]+" ");
        }



    }


}
/**
 * 输出结果
 * 1 2
 * 5 6 
 * Process finished with exit code 0
 */

import java.util.Scanner;
//动态为数组进行赋值
public class Demo {
    //break和continue案例
    public static void main(String[] args) {
        //一维数组的定义
        int []arr = new int[5];
        //创建Scanner对象进行输入操作
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入5个数：");
        for (int i = 0; i <arr.length ; i++) {
            arr[i]=sc.nextInt();
        }
        System.out.println("数组中存储的是：");
        for (int i : arr) {
            System.out.printf(i+" ");
        }
    }
}
/**
 * 输出结果
 请输入5个数：
 3 5 2 4 3
 数组中存储的是：
 3 5 2 4 3 
 * Process finished with exit code 0
 */

二维数组

二维数组概述

二维数组可以理解为存储的元素为一维数组的一维数组；

二维数组格式

以int类型为例：
1.int [][]a;
2.int [] a[];
3.int a[][]
后面两种不推荐使用哦！
二维数组的初始化方式：
1.int [][]a = new int [n][m];(动态)
2.int [][]a = new int [][]{{1,2},{2,3},{3,4}};(静态)
3.int [][]a = {{1,2},{2,3},{3,4}};(静态)

二维数组的遍历

import java.util.Scanner;

public class Demo {
    //break和continue案例
    public static void main(String[] args) {

        //二维数组的遍历
        int [][]a = {{1,2,3},{4,5,6}};
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.printf(a[i][j]+" ");
            }
            System.out.println();
        }
    }
}
/**
 1 2 3 
 4 5 6 
 * Process finished with exit code 0
 */

Arrays工具类

Arrays工具类的概述

Arrays类包含用于操作数组的各种方法（如排序和搜索）。

Arrays工具类的常用方法

1.asList

  @Test
    public void Demo1(){
        /*asList(T... a)返回由指定数组支持的固定大小的列表
        * 该方法若参数出入数组，则返回的是一个泛型为一维数组类型的List集合
        * */
        int [][]a = new int[][]{{1,2,3,4},{2,3,4,5}};
        List<int[]> ints = Arrays.asList(a);
        for (int[] anInt : ints) {
            System.out.println(Arrays.toString(anInt));
        }
        //直接传入int，char等类型的常量会返回一个对应类型作为泛型的list
        List<Integer> integers = Arrays.asList(1, 2, 3);
    }
/**
     * [1, 2, 3, 4]
     * [2, 3, 4, 5]
     */

2.binarySearch（二分查找）,返回类型为int
binarySearch的重载有很多，挑两个来说

   @Test
    public void Demo2(){
        /*
        binarySearch(byte[] a, byte key)
        第一个参数代表在哪个数组（该数组必须是有序的）中进行查找，第二个参数表示在数组中查找什么值
        使用二进制搜索算法搜索指定值的指定字节数组。
        折半查找，若找到，则返回对应的索引，否则返回一个负数
        */

        byte []b = {4,1,2,3,6};
        Arrays.sort(b);
        System.out.println(Arrays.binarySearch(b,(byte)6));//4
        System.out.println(Arrays.binarySearch(b,(byte)5));//-5，数组中存在比5大的数，将这个第一个大于5得数的坐标变成负数再减一就可以作为返回值
        System.out.println(Arrays.binarySearch(b,(byte)10));//-6,10大于数组中所有元素，所以返回的是数组长度取负数，再减一
    }

  @Test
    public void Demo3(){
        /*
        * binarySearch(byte[] a, int fromIndex, int toIndex, byte key)
        * 使用二进制搜索算法搜索指定值的指定字节数组的范围。
        * 找到就返回对应的索引
        * */

        byte []b = {3,5,28,10,19,26,24,11};//3,5,10,11,19,24,26,28
        Arrays.sort(b);
        System.out.println(Arrays.binarySearch(b,1,5,(byte)10));//2,
        System.out.println(Arrays.binarySearch(b,1,5,(byte)20));//-6
        System.out.println(Arrays.binarySearch(b,1,5,(byte)30));//-6,在给定数组索引范围内，没有这个值，就将右边的索引取反减一
    }

2.copyOf（拷贝）,返回类型为数组

  @Test
    public void Demo6(){
        /*copyOf(int[] original, int newLength)
        使用 false （如有必要）复制指定的数组，截断或填充，以使副本具有指定的长度。
        original：原数组，即用于被copy的数组
        newLength:新数组的长度
        将已有数组的元素拷贝到一个新的数组，拷贝的长度自己定义，若超过现有长度，则补位数据类型的默认值
        */
        int []a={2,3,4,5,6,7,8,910};
        int[] ints = Arrays.copyOf(a, 8);
        for (int anInt : ints) {
            System.out.println(anInt);
        }
        System.out.println("a==ints:"+(ints==a));//双等于号是比较地址
        System.out.println("Arrays.equals():"+(Arrays.equals(a,ints)));//这里比较数值

        char []c = {'c','r','f','g','h','j','i'};
        char[] chars = Arrays.copyOf(c, 10);
        for (char aChar : chars) {
            System.out.print(aChar+",");//c,r,f,g,h,j,i, , , ,123
        }
        System.out.println("123");
    }


  @Test
    public void Demo8() {
        /*copyOfRange(int[] original, int from, int to)
        将指定数组的指定范围复制到新数组中。
        original:被拷贝的数组，
        from：拷贝开始的索引
        to：to-1为拷贝的最后一个元素的索引，实际操作是无法拷贝到to的
		*/
        int []a = {1,2,3,4,5,6,7,8,9};
        int[] ints = Arrays.copyOfRange(a, 1, 5);//实际是将1-4索引对应的元素拷贝到新的数组中
        for (int anInt : ints) {
            System.out.println(anInt);
        }
    }

**3deepEquals(Object[] a1, Object[] a2)

 @Test
    public void Demo9() {
       /* deepEquals(Object[] a1, Object[] a2)
        如果两个指定的数组彼此 深度相等 ，则返回 true*/
       String[] s1 = {"123","456","789"};
       String[] s2 = {"123","456","789"};
       String[] s3 = {"123","456"};
        System.out.println(Arrays.deepEquals(s1,s2));
        System.out.println(Arrays.deepEquals(s1,s3));


        String [][]s4={{"123","456","789"},{"123","456","789"},{"123","456","789"}};
        String [][]s6={{"123","456","111"},{"123","456","789"},{"123","456","789"}};
        String [][]s7={{"123","456","111"},{"123","456","789"},{"123","456","789"}};
        String [][]s5 = {{"123","456","789"}};
        System.out.println(Arrays.deepEquals(s4,s5));
        System.out.println(Arrays.deepEquals(s4,s6));//false,并且两个数组中所有对应的元素对都相等，则两个数组引用被认为是相当相等的。

        System.out.println(Arrays.deepEquals(s7,s6));//比较值，多维数组展开后进行比较，有一个不同，则为false
    }

4.deepToString

@Test
    public void Demo11() {
       /* deepToString(Object[] a)
        返回指定数组的“深度内容”的字符串表示形式。*/

        String[] s1 = {"123","456","789"};
        String [][]s5 = {{"123","456","789"},{"123","456","7"}};
        System.out.println(Arrays.toString(s1));//[123, 456, 789]
        System.out.println(Arrays.toString(s5));//[[Ljava.lang.String;@30946e09, [Ljava.lang.String;@5cb0d902]

        //上述运行结果可知，toString可以返回一维数组的字符串表示形式，对于多维的，只是返回第一维展开的地址
        //deepToString可以将多维数组展开
        System.out.println(Arrays.deepToString(s5));//[[123, 456, 789], [123, 456, 7]]

    }

4.fill

 @Test
    public void Demo12() {
        /*
        fill(int[] a, int val)
        将指定的int值分配给指定的int数组的每个元素,原数组中若有值，则进行替换

        fill(int[] a, int fromIndex, int toIndex, int val)
        将指定的int值分配给指定的int数组的指定范围的每个元素。
        */


        int []a = {1,2,3,4,5};
        Arrays.fill(a,8);
        for (int i : a) {
            System.out.print(i+" ");
        }
        System.out.println();
        Arrays.fill(a,0,3,77);//值赋值给索引是0-2的
        for (int i : a) {
            System.out.print(i+" ");
        }
    }

    /**
     * 8 8 8 8 8 
     * 77 77 77 8 8 
     */

5.sort(底层为快排)

/*
sort(int[] a) 
按照数字顺序排列指定的数组。
sort方法可以对各种类型的数据进行排序，只要实现Comparable接口即可进行比较
*/


  @Test
    public void Demo15() {
        int []a = {7,5,6,8,9,2};
        Arrays.sort(a);
        System.out.println("排序后的结果为：");
        for (int i : a) {
            System.out.printf(i+" ");
        }
        /**
         * 排序后的结果为：
         * 2 5 6 7 8 9
         */
    }