数组+用stream流将数组转list

数组

• 数组是相同类型数据的集合
• 数组有先后顺序
• 取数组中的值通过下标,下标从0开始
• arr.length 获取数组长度

数组的声明和创建

//数组的声明
int[] nums;  //推荐使用
int nums[];
//数组得到创建
nums = new int[10];

//合并
int[] nums = new int[10];

数组三种初始化

//静态初始化
int[] array = {1,2,3,4,5};
//动态初始化 包含默认初始化
/*
动态初始化就是后续需要手动赋值
默认初始化---->基本类型和引用类型都有默认值
*/
int[] arr = new int[10];

数组的特点

1.长度确定 超出ArrayIndexOutOfBoundsException :数组下标越界异常

2.类型一致

3.new 所以数组对象本身在堆中

二维数组

int[][] arr = {{1,2},{2,3},{3,4}};
System.out.println(arr[0][0]);    //1
System.out.println(arr[0][1]);    //2

稀疏数组

• 当一个数组中大部分元素为0,或者为同一个值的数组时,可以用稀疏数组压缩
• 记录数组一共几行几列,有多少个不同值…每个值所在位置

int[][] arr = new int[11][11];
        arr[0][2] = 1;
        arr[1][3] = 2;
       
        //稀疏数组  无外乎就是二维数组--第一行确定 多少行/多少列/几个值(n) --->int[n+1][3] n+1行:因为第一行要给行列值
        //1.取二维数组中有几个值
        int sum =0;
        for (int[] ints : arr) {
            for (int anInt : ints) {
                if (anInt != 0){
                    sum++;
                }
            }
        }
        //2定义稀疏数组
        int[][] sparse = new int[sum + 1][3];

        //3赋值
        sparse[0][0] = arr.length;
        sparse[0][1] = arr[0].length;
        sparse[0][2] = sum;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j] != 0){
                    sparse[i+1][0] = i;
                    sparse[i+1][1] = j;
                    sparse[i+1][2] = arr[i][j];
                }
            }
        }

        for (int[] ints : sparse) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();}
        /*
        11	11	2
        0	2	1
        1	3	2
         */
    }

Arrays类

//Arrays类 包含用于操作数组的各种方法(如排序搜索)-->详情API
        int[] b = {1, 3, 4, 6, 7, 5, 55, 666, 44, 88, 11};
        int[] c = {1, 3, 4, 6, 7, 5, 55, 666, 44, 88, 11};
        String[] s = {"a", "b", "c"};
        Integer[] i = {1, 3, 4, 6, 7, 5, 55, 666, 44, 88, 11};
        //打印数组
        String string = Arrays.toString(b);
        //排序 --升序
        Arrays.sort(b);
        //降序
        Arrays.sort(i, Collections.reverseOrder());  //必须是包装类
        //比较数组元素是否相等 --元素一一对应
        boolean equals = Arrays.equals(b, c);
        //数组截取  截取几位
        int[] ints = Arrays.copyOf(b, 3);
        /*数组转List  asList-->数组只能是包装类--->List要求类是包装类,不是包装类直接以数组形式存入List
                               直接生成的List是Arrays自己定义的静态内部类ArrayList 没有实现add和remove方法
                               所以,直接生成的List长度固定,不能增删,只能查改
         */
        List<int[]> ints1 = Arrays.asList(b);
        System.out.println(ints1.size());  //1
        List<String> strings = Arrays.asList(s);

Arrays.asList

Arrays.asList(T… a) —>T extends Object 基本数据类型无法泛型化 —>如果是基本数据类型的数组,他就会把一个数组当一个参数 所以转换后的列表就只包含一个int[]元素

Arrays.asList生成的ArrayList是自己定义的静态内部类,没有实现add和remove方法,所以生成的List长度固定,不能增删,只能查改

数组转List

如果是包装类或String等数组转List

String[] s = {“a”,“b”,“c”}

第一种方法: List list = Arrays.asList(s);

这种方法数组转成的listA,，不能对List增删，只能查改，否则抛异常

第二种方式: List list = new ArrayList(Arrays.asList(s));

通过ArrayList的构造器，将Arrays.asList(strArray)的返回值由java.util.Arrays.ArrayList转为java.util.ArrayList,支持增删改查的方式

第三种方式: List list = new ArrayList();

​ Collections.addAll(list,s);

通过Collections.addAll(arrayList, strArray)方式转换，通过Collections.addAll()方法，将数组中的元素转为二进制，然后添加到List中，这是最高效的方法。

使用Stream流将基本数据类型转List

核心就是**将基本数据类型数组转为包装类在转list **, JDK1.8提供了stream流的方式 基本数据类型只支持 int long double

        int[] i = {1, 2, 3};
        IntStream stream = Arrays.stream(i);//转为stream流
        //stream.forEach(System.out::println); //1 2 3
        Stream<Integer> boxed = stream.boxed(); //装箱为Integer

        List<Integer> collect = boxed.collect(Collectors.toList()); //收集

        List<Integer> list = Arrays.stream(i).boxed().collect(Collectors.toList());
        System.out.println(collect);

使用stream流 将引用类型转List

   //省去装箱的步骤        
       Student[] s = {new Student(18, "张三"), new Student(20, "李四")};
       List<Student> collect = Arrays.stream(s).collect(Collectors.toList());
       System.out.println(collect);