JAVA - 学习记录第九天-CSDN博客

本文链接：https://blog.csdn.net/xz2366/article/details/125550266

一、数组的概念（掌握）

（一）数组的定义

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

（二）四个基本特点

长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
其元素的类型必须是相同类型，不允许出现混合类型。
数组类型可以是任何数据类型，包括基本类型和引用类型。
数组变量属于引用类型，数组也是对象。

（三）数组的声明方式(以一维数组为例)

type[ ] arr_name; //方式一（推荐使用这种方式）

type arr_name[ ];

注意事项

声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM 才分配空间，这时才与长度有关。
声明一个数组的时候并没有数组真正被创建。
构造一个数组，必须指定长度。

（四）初始化

静态初始化：除了用 new 关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行。
默认初始化：数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

测试：

public class Test3 {
    public static void main(String[] args) {
        //静态初始化
        chengji[] chj = {
                new chengji(60,"java"),
                new chengji(70,"pychon"),
                new chengji(80,"大数据"),
                new chengji(90,"人工智能")
        };

        //动态初始化
        chengji m = new chengji(60,"java") ;
        chengji n = new chengji(70,"pychon") ;
        chengji b = new chengji(80,"大数据") ;
        chengji v = new chengji(90,"人工智能") ;
        chengji[] chj = new chengji[4];
        chj[0] = m;
        chj[1] = n;
        chj[2] = b;
        chj[3] = v;

        //默认初始化
        chengji chj[] = new chengji[4];
        chengji m = new chengji(60,"java");
        chengji n = new chengji(70,"pychon") ;
        chengji b = new chengji(80,"大数据") ;
        chengji v = new chengji(90,"人工智能") ;
        chj[0]=m;
        chj[1]=n;
        chj[2] = b;
        chj[3] = v;
        //输出数组
        for (int i=0;i<chj.length;i++){
            chengji KEMU = chj[i];
            System.out.println(KEMU);
        }
        //增强for循环，读取元素的值
        for (chengji KEMU:chj){
            System.out.println(KEMU);
        }
    }
}

class chengji {
    private int cj;
    private String kemu;

    public chengji(int cj,String kemu){
        this.cj=cj;
        this.kemu=kemu;
    }

    @Override
    public String toString() {
        return "成绩:"+cj+"，科目:"+this.kemu;
    }

    public int getCj() {
        return cj;
    }

    public void setCj(int cj) {
        this.cj = cj;
    }

    public String getKemu() {
        return kemu;
    }

    public void setKemu(String kemu) {
        this.kemu = kemu;
    }
}

二、数组常见操作（遍历、拷贝）

遍历指的就是“通过循环遍历数组的所有元素”。
拷贝指的是将某个数组的内容拷贝到另一个数组中。实质上，后面学到的容器，容器的扩容本质上就是“数组的拷贝”。

（一）数组的遍历

数组元素下标的合法区间：[0, length-1]。可以通过下标来遍历数组中的元素，遍历时可以读取元素的值或者修改元素的值。

测试：

public class Test5 {
    public static void main(String[] args) {
        int[] a = new int[4];
        //初始化数组元素的值
        System.out.println("使用循环初始化和遍历数组");
        for (int i = 0; i < a.length; i++) {
            a[i] = 100*i;
        }
        //读取元素的值
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }

        System.out.println("使用增强for循环遍历数组");
        String[] ss = {"aa","bbb","ccc","ddd"};
        for(String temp:ss){
            System.out.println(temp);
        }

        //数组的拷贝
        String[] s = {"数学","语文","英文","政治"};
        String[] sBak = new String[4];
        System.arraycopy(s,0,sBak,0,s.length);
        for (int i=0;i<sBak.length;i++){
            System.out.print(sBak[i]+"\t");
        }

    }
}

（二）数组的拷贝

static void arraycopy

测试：

String[ ] s = {"手机","电脑","鞋子","袜子","衣服"};//数组s
        String[ ] sBak = new String[6];//定义新的数组sBak，长度6
        //s数组的第0位开始复制到sBak数组的第0位，即全部复制copy
        System.arraycopy(s,0,sBak,0,s.length);
        //遍历数组
        for (int i = 0; i < sBak.length; i++) {
            System.out.print(sBak[i]+ "\t");
        }

（三）java.util.Arrays 类

JDK 提供的 java.util.Arrays 类，包含了常用的数组操作，方便我们日常开发。Arrays 类包含了：排序、查找、填充、打印内容等常见的操作。

测试1：

public static void main(String args[]) {
        int[] a = {1,2};
        System.out.println(a); // 打印数组引用的值；
        //此处的 Arrays.toString()方法是 Arrays 类的静态方法，
        //不是 Object 的 toString()方法。
        System.out.println(Arrays.toString(a)); // 打印数组元素的值；
    }

测试2：

public static void main(String args[ ]) {
        int[] a = {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);//使用二分法查找，必须先对数组进行排序
        System.out.println(Arrays.toString(a));
        //返回排序后新的索引位置,若未找到返回负数
        System.out.println("该元素的索引："+Arrays.binarySearch(a, 12));
        Arrays.fill(a, 2, 4, 100); //将2到4索引的元素替换为100;
        System.out.println(Arrays.toString(a));
    }

三、多维数组（掌握）

多维数组可以看成以数组为元素的数组。

（一）数组存储表格数据

测试1：

public class Test6 {
    public static void main(String[] args) {
        //定义数组各元素的内容
        Emp emp0 = new Emp(1001,"一",12,"程序","2018-2-1");
        Emp emp1 = new Emp(1002,"二",11,"骄傲","2015-5-1");
        Emp emp2 = new Emp(1003,"三",51,"便宜","2019-1-1");
        //定义数组长度
        Emp[] emps = new  Emp[3];
        emps[0] = emp0;
        emps[1] = emp1;
        emps[2] = emp2;
        //遍历数据
        for (int i=0;i<emps.length;i++){
            System.out.println(emps[i]);
        }
    }
}
class Emp{
    private int id;
    private String name;
    private int age;
    private String job;
    private String hiredate;

    public Emp(int id, String name, int age, String job, String hiredate) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.job = job;
        this.hiredate = hiredate;
    }

    @Override
    public String toString() {
        return getId()+"\t"+getName()+"\t"+getAge()+"\t"+getJob()+"\t"+getHiredate();
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age +"岁";
    }

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

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public String getHiredate() {
        return hiredate;
    }

    public void setHiredate(String hiredate) {
        this.hiredate = hiredate;
    }
}

测试运行图：