Java数组学习笔记Day01

数组
    一维数组
            变量 : 存储单个数据
    数组 : 存储多个数据
        是一段连续的内存空间,用来存放相同类型的多个数据,可以根据索引操作数组中的数据

    数组的特点 :
        1.引用数据类型
        2.定长,长度一旦确定不可改变
        3.存储多个相同数据类型的数据
        4.有序的,索引,根据索引操作数组中的数据

    索引 :
        从0开始每次+1
        [0,数组名.length-1]

    操作数组的数据 :
        根据索引操作
        数组名[索引]

    数组的长度 :
        数组名.length

    定义 :
        声明 :
            数据类型[] 数组名;  -->推荐
            数据类型 数组名[];

            数据类型 : 可以为任意类型

        初始化 :
            动态初始化 : 先创建后赋值
                数据类型[] 数组名 = new 数据类型[长度];
                数据类型 : 数组中存放的所有数据的类型

                数组创建成功,没有手动赋值,数组的每个空间存在默认值
                    整数0  小数0.0  字符 : 空字符  引用数据类型 : null  布尔 : false

            静态初始化 : 创建的同时赋值
                数据类型[] 数组名 = new 数据类型[]{值列表};
                数据类型[] 数组名 = {值列表}; 

    数组的遍历 :
        1.普通for
            遍历数组的索引,根据索引操作数据
        2.增强for(foreach)
            for(数据类型 变量名:数组名|集合名){
                变量中存储数据中的每一个数据
            }

/*
    练习: 定义员工类型,存储多个员工类型的数据
        1.展示输出所有员工信息
        2.找到所有员工的姓名存储起来
        3.找到所有薪资>20000的员工->裁员
        4.所有同学的年龄中,出现了几种不同的年龄
 */
public class Class004_Practice {
    public static void main(String[] args) {
        //存储所有的员工数据
        Employee[] emps = {
                new Employee("胡歌",35,20000),
                new Employee("彭于晏",33,15000),
                new Employee("吴彦祖",35,18000),
                new Employee("谢霆锋",42,25000),
        };

        // 1.展示输出所有员工信息
        for (Employee e:emps){
            System.out.println(e);
        }

        // 2.找到所有员工的姓名存储起来
        String[] names = new String[emps.length];
        for(int i=0;i<=emps.length-1;i++){
            names[i] = emps[i].getName();
        }
        System.out.println(Arrays.toString(names));

        //集合 : 存储多个数据
        //根据需求增删数据动态的修改集合的长度
        //ArrayList : 存储多个数据,可以存储任意类型数据,长度可以根据需求动态的增删,有序,可以根据索引进行操作
        //1)创建一个ArrayList集合
        ArrayList list = new ArrayList();
        //2)遍历原数组
        for(Employee employee:emps){
            //3)薪资<=20000放入集合中存储
            if(employee.getPrice()<=20000){
                list.add(employee);
            }
        }
        System.out.println(list);

        //HashSet : 存储多个数据,可以存储任意类型数据,长度可以根据需求动态的增删,会自动去重,无序
        HashSet set = new HashSet();
        for(Employee e:emps){
            set.add(e.getAge());
        }
        System.out.println(set);
        System.out.println(set.size());
    }
}

//员工类型
class Employee{
    private String name;
    private int age;
    private double price;

    public Employee(String name, int age, double price) {
        this.name = name;
        this.age = age;
        this.price = price;
    }

    public Employee() {

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", price=" + price +
                '}';
    }
}

    二维数组
            二维数组 : 了解
        数组中存放数组

    声明 :
        数据类型[][] 数组名;  -->推荐
        数据类型 数组名[][];
        数据类型[] 数组名[];

    动态初始化 : 先创建二维数组,再为其赋值(内部每一个一维数组,内部每一个一维数组中的数据)
        数据类型[][] 数组名 = new 数据类型[外层二维的长度][内层一维的长度]; --> 在创建二维数组之后直接创建内层每一个一维数组,但是内层每一个一维数组长度固定
            数组名[外层二维索引][内层一维索引]操作数组中的数据
        数据类型[][] 数组名 = new 数据类型[外层二维的长度][]; --> 创建二维数组的时候,内层每一个一维数组长度不确定没创建,根据二维数组的索引单独为每一索引位置赋值一维数组,每层的每一个一维数组长度不固定
            二维数组名[索引] = 一维数组的创建方式(动态|静态)

    静态初始化
        数据类型[][] 数组名 = new 数据类型[][]{{1,2,3},{4,5},{6}....};
        数据类型[][] 数组名 = {{1,2,3},{4,5},{6}....};

    操作数组的数据 :
        数组名[外层二维索引][内层一维索引]

    遍历 :
        循环嵌套 :
            普通for
            增强for

/*
二维数组
    动态初始化 数据类型[][]数组名=new 数据类型[二维长度][一维长度]
             数据类型[][]数组名=new 数据类型[二维长度][]
    静态初始化 数据类型[][]数组名=new 数据类型[][]{{},{},{}...}

*/
public class T04_ArrayTest {
    public static void main(String[] args) {
        int [][]arr1=new int[2][3];
        int count=0;
        for (int a=0;a<arr1.length;a++) {
            for (int b=0;b<arr1[a].length;b++) {
                count++;
                arr1[a][b]=count;
            }
        }
        for (int a=0;a<arr1.length;a++) {
            for (int b=0;b<arr1[a].length;b++) {
                System.out.print("["+arr1[a][b]+"]");
            }
        }
        //------------------------
        System.out.println();
        int [][]arr2=new int[2][3];
        for (int[]arr:arr2) {
            for (int b=0;b<arr.length;b++) {
                count++;
                arr[b]=count;
            }
        }
        for (int a=0;a<arr1.length;a++) {
            for (int b=0;b<arr1[a].length;b++) {
                System.out.print("["+arr2[a][b]+"]");
            }
        }
        //------------------------
        System.out.println();
        /*int [][]arr3=new int[2][3];
        for (int a=0;a<arr3.length;a++) {
            for (int arr:arr3[a]) {
                count++;

            }  外普通内增强 无法给数组赋值
        }*/
        for (int a=0;a<arr1.length;a++) {
            for (int arr:arr2[a]) {
                System.out.print("["+arr+"]");
            }
        }
        //------------------------
        System.out.println();
       /* int [][]arr3=new int[2][3];
        for (int arr4[]:arr3) {
            for (int arr : arr4) {
                count++;

            }  外增强内增强也无法给数组赋值
        }*/
        for (int arr3[]:arr2) {
            for (int arr:arr3) {
                System.out.print("["+arr+"]");
            }
        }
    }
}

    Arrays工具类
            Arrays : 该类包含用于操作数组的各种方法（例如排序和搜索）。
        静态工厂
          

public class Class001_Arrays {
    public static void main(String[] args) {
        int[] arr1 = new int[]{1,3,5,2,6};
        int[] arr2 = new int[]{3,1,5,2,4};

        char[][] arr3 = new char[][]{{'a','b','c'},{'中','国'}};
        char[][] arr4 = new char[][]{{'a','b','c'},{'中','国'}};

        //static String toString(int[] a) 返回指定数组内容的字符串表示形式。
        System.out.println(Arrays.toString(arr1));

        //static boolean equals(int[] a, int[] a2) 如果两个指定的int数组彼此 相等 ，则返回 true 。
        //static boolean equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex) 如果指定范围内的两个指定的int数组彼此 相等 ，则返回true。
        //注意 : 参数中如果有指定结束索引,一般结束索引位置都不不包含
        System.out.println(arr1==arr2); //false
        System.out.println(Arrays.equals(arr1,1,4,arr2,1,4)); //true
        System.out.println(Arrays.equals(arr1,arr2)); //false

        //只对于多维数组
        //static String deepToString(Object[] a) 返回指定数组的“深层内容”的字符串表示形式。
        System.out.println(Arrays.toString(arr3));
        System.out.println(Arrays.toString(arr4));
        System.out.println(Arrays.deepToString(arr3));

        //static boolean deepEquals(Object[] a1, Object[] a2) 如果两个指定的数组彼此 深度相等 ，则返回 true 。
        System.out.println(Arrays.equals(arr3,arr4));
        System.out.println(Arrays.deepEquals(arr3,arr4));

        //static void fill(int[] a, int val) 将指定的int值分配给指定的int数组的每个元素。
        //Arrays.fill(arr1,1000);
        //static void fill(int[] a, int fromIndex, int toIndex, int val) 将指定的int值分配给指定的int数组的指定范围的每个元素。
        //Arrays.fill(arr1,1,3,1000);
        System.out.println(Arrays.toString(arr1));

        //static void sort(int[] a) 将指定的数组按升序排序。
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));

        //static void sort(int[] a, int fromIndex, int toIndex) 按升序对数组的指定范围进行排序。

        //static int binarySearch(int[] a, int key) 使用二进制搜索算法在指定的int数组中搜索指定的值。,如果不存在返回 -插入点-1
        //二分搜索法 : 要求查询之前先升序排序
        System.out.println(Arrays.binarySearch(arr1,7));
    }
}

            Arrays :与数组拷贝相关的方法 ****
                        static int[] copyOf(int[] original, int newLength) 使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。
                创建新数组+数据拷贝
                参数 :
                    int[] original 要拷贝的原数组
                    int newLength  新数组的长度
                        新数组长度 == 原数组长度   拷贝
                        新数组长度 < 原数组长度   截取   默认从原数组索引为0的位置开始拷贝,拷贝newLength个
                        新数组长度 > 原数组长度   填充   默认从原数组索引为0的位置开始拷贝,拷贝原数组的所有数据,使用默认值填充剩余的位置
                返回值 :
                    新数组

               特点 : 1)方法内部创建新数组  2)默认从索引为0的位置考试拷贝原数组中的数据
                        static int[] copyOfRange(int[] original, int from, int to) 将指定数组的指定范围复制到新数组中。
                一般结束索引不包含
            特点 : 1)方法内部创建新数组  2)可以实现拷贝原数组指定索引范围内的数据
                        static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 将指定源数组中的数组从指定位置开始复制到目标数组的指定位置。
            参数 :
                Object src 原数组
                int srcPos 原数组的起始索引
                Object dest 新数组|目标数组
                int destPos 新数组起始索引
                int length 拷贝数据个数

public class Class002_Array {
    public static void main(String[] args) {
        int[] arr= {1,2,3,4,5,6,7,8};
        int[] newArr= new int[10];
        /*
            static int[] copyOf(int[] original, int newLength) 使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。
                创建新数组+数据拷贝
                参数 :
                    int[] original 要拷贝的原数组
                    int newLength  新数组的长度
                        新数组长度 == 原数组长度   拷贝
                        新数组长度 < 原数组长度   截取   默认从原数组索引为0的位置开始拷贝,拷贝newLength个
                        新数组长度 > 原数组长度   填充   默认从原数组索引为0的位置开始拷贝,拷贝原数组的所有数据,使用默认值填充剩余的位置
                返回值 :
                    新数组

               特点 : 1)方法内部创建新数组  2)默认从索引为0的位置考试拷贝原数组中的数据
         */
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(Arrays.copyOf(arr,5)));
        System.out.println(Arrays.toString(Arrays.copyOf(arr,8)));
        System.out.println(Arrays.toString(Arrays.copyOf(arr,10)));
        System.out.println("--------------------------------------------------");

        /*
            static int[] copyOfRange(int[] original, int from, int to) 将指定数组的指定范围复制到新数组中。
                一般结束索引不包含
            特点 : 1)方法内部创建新数组  2)可以实现拷贝原数组指定索引范围内的数据
         */
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(Arrays.copyOfRange(arr,1,4)));

        /*
            static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 将指定源数组中的数组从指定位置开始复制到目标数组的指定位置。
            参数 :
                Object src 原数组
                int srcPos 原数组的起始索引
                Object dest 新数组|目标数组
                int destPos 新数组起始索引
                int length 拷贝数据个数
         */
        System.out.println(Arrays.toString(newArr));
        System.arraycopy(arr,2,newArr,4,3);
        System.out.println(Arrays.toString(newArr));
    }
}