百无聊赖之JavaEE从入门到放弃（十二）数组

目录

一.基础知识

1.数组的定义

2.建议

3.注意

4.数组的默认初始化

 二.基操示例代码

三.拷贝

四.Arrays类

五.多维数组

六.Object数组存储表格数据

七.Comparable 接口（对象排序）

---

一.基础知识

1.数组的定义

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

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

2.建议

数组变量属于引用类型，数组也是对象，数组中的每个元素相当于该对象的成员变量。

数组本身就是对象，Java 中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。

3.注意

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

4.数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量,因此数组一经分配空间，其中的每个
元素也被按照实例变量同样的方式被隐式初始化。默认的值之前讲到过的默认值,如下：

整性：0

浮点型：0.0

字符型：'\u0000'

布尔型：false

所有引用类型：null

可以阅读这篇博客中的六.运算符

基本类型数组内存分配图：

 二.基操示例代码

代码1：

public class Test1 {

    public static void main(String[] args) {
        //数组的定义和初始化
        //数组是引用类型，所以当声明后没分配内存时，默认值是null
        //int[] arr1=null;
        //默认初始化，数组元素相当于对象的属性，遵守对象属性默认初始化的规则
        int[] arr1=new int[5];
        //动态初始化，根据索引直接
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);//此时还未赋值，int型默认是0

        int arr2[]={20,30,40};//静态初始化
        System.out.println(arr2);//默认调用toString()方法

        //数组的遍历
        for(int i=0;i<arr1.length;i++){
            arr1[i]=i+1;
            System.out.print(arr1[i]+" ");
        }
    }
}

输出：

0
0
[I@5cad8086
1 2 3 4 5 

代码2：

增强for循环for-each是JDK1.5新增加的功能,专门用于读取数组或集合中所有的元素，即对数组进行遍历。

public class Test2 {
    public static void main(String[] args) {
        //静态初始化需要在声明后直接初始化
        Man m=new Man(1,"小明");
        Man[] mans={
                m,
                new Man(2,"小狗"),
                new Man(3,"小猪"),
                new Man(4,"小羊"),
                new Man(5,"小高")
        };
        /*
        for(int i=0;i<mans.length;i++){
            System.out.println(mans[i].getName());
        }
         */
        //foreach循环
        for (Man man:mans){
            System.out.println(man.getName());
        }
    }

}
//就按大的一个javaBean
class Man{
    private int id;
    private String name;

    public Man(int id, String name) {
        this.id = id;
        this.name = name;
    }

    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;
    }
}

输出：

小明
小狗
小猪
小羊
小高

三.拷贝

System类里也包含了一个static void arraycopy (object src, int srcpos, object dest，int destpos, int length)方法，

该方法可以将src数组里的元素值赋给dest数组的元素，其中srcpos指定从src数组的第几个元素开始赋值, length 参数指定将src数组的多少个元素赋给dest数组的元素。

public class Test3 {
    public static void main(String[] args) {
        String[] s={"阿里","京东","百度","腾讯","字节跳动"};
        String[] sBak=new String[6];
        //参数不懂就看看源码
        System.arraycopy(s,0,sBak,0,s.length);
        for (int i=0;i<sBak.length;i++){
            System.out.println(sBak[i]+"\t");
        }
    }
}

输出：

阿里	
京东	
百度	
腾讯	
字节跳动	
null	

四.Arrays类

这个类是java提供给我们操作数组的工具类。
提供了常见的:排序、查找、填充、打印数组内容的相关的方法。

public class Test {
    public static void main(String[] args) {
        int[] a={1,2};
        System.out.println(a);
//        输出整个数组
        System.out.println(Arrays.toString(a));
        //排序
        int[] b = {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(b));
        Arrays.sort(b);
        System.out.println(Arrays.toString(b));
        //使用二分法返回排序后新的索引位置，若未找到返回负数
        System.out.println("该元素的索引："+Arrays.binarySearch(b,12));
        //填充数组
        int[] c = {10,20,30,40,50};
//        [2,4)区间的元素填充为100
        Arrays.fill(c,2,4,100);
        System.out.println(Arrays.toString(c));

        int[] d = new int[5];
        System.out.println(Arrays.toString(d));
    }
}

五.多维数组

多维数组可以看成以数组为元素的数组。
可以有二维、三维、甚至更多维数组，但是实际开发中用的非常少。
最多到二维数组（学习容器后，我们一般使用容器，二维数组用的都很少)

在内存里的定义：

public class 多维数组 {
    public static void main(String[] args) {
        //Java中多维数组的声明和初始化应按从低维到高维的顺序进行
        int[][] a = new int[3][];
        a[0] = new int[2];
        a[1] = new int[4];
        a[2] = new int[3];
        //非法
        //int[][] a= new int[][4];
        a[0][0] = 100;
        a[2][1] = 200;
        System.out.println(Arrays.toString(a));

        int[][] b = {{1,2,3},{3,4},{3,5,6,7}};
        System.out.println(Arrays.toString(a));
        System.out.println(b[1][0]);

        //动态初始化
        int[][] c = new int[3][];
        //c[0] = {1,2,55};//错误，没有声明就初始化
        c[0] = new int[]{1,2};
        c[1] = new int[]{2,2};
        c[2] = new int[]{22,2,3,4};
        System.out.println(c[2][3]);
        System.out.println(Arrays.toString(c[1]));
    }
}

六.Object数组存储表格数据

表格是计算机世界最普遍的模型。大家在互联网上看到的所有数据本质上都是“表格”。

此处基本数据类型”1001”，本质不是 Object 对象。JAVA 编译器会自动把基本数据

类型“自动装箱”成包装类对象。

这样我们只需要再定义一个二维数组，将上面 3 个数组放入即可：

public class Test {
public static void main(String[ ] args) {
    Object[ ] a1 = {1001,"高淇",18,"讲师","2-14"};
    Object[ ] a2 = {1002,"高小七",19,"助教","10-10"};
    Object[ ] a3 = {1003,"高小琴",20,"班主任","5-5"};
    Object[ ][ ] emps = new Object[3][ ];
    emps[0] = a1;
    emps[1] = a2;
    emps[2] = a3;
    System.out.println(Arrays.toString(emps[0]));
    System.out.println(Arrays.toString(emps[1]));
    System.out.println(Arrays.toString(emps[2]));
    }
}

使用 javabean 和一维数组保存表格信息：

javabean类：

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 "["+id+","+name+","+age+","+job+","+hiredate+"]";
     }
     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 int 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;
     }
}

public class Test {
     public static void main(String[ ] args) {
         Emp[] emps = {
             new Emp(1001,"高淇",18,"讲师","2-14"),
             new Emp(1002,"高小七",19,"助教","10-10"),
             new Emp(1003,"高小八",20,"班主任","5-5")
         };
         for (Emp e:emps){
             System.out.println(e);
         }
     }
}

七.Comparable 接口（对象排序）

多个对象做比较，就要有“比较规则”，然后实现排序。

事实上，java 中排序算法的底层也依赖 Comparable 接口。

Comparable 接口中只有一个方法：

public int compareTo(Object obj) obj 为要比较的对象

方法中，将当前对象和 obj 这个对象进行比较，如果大于返回 1，等于返回 0，小于返回-1. (此

处的 1 也可以是正整数，-1 也可以是负整数)。 compareTo 方法的代码也比较固定：

class Man implements Comparable {
    int age;
    int id;
    String name;
    public Man(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    public String toString() {
        return this.name;
    }
    public int compareTo(Object o) {
        Man man = (Man) o;
        if (this.age < man.age) {
            return -1;
        }
        if (this.age > man.age) {
            return 1;
        }
        return 0;
    }
}

public class Test {
    public static void main(String[ ] args) {
        Man[ ] msMans = { new Man(3, "a"), new Man(60, "b"), new Man(2, "c") };
        //此时的被排序对象数组的类必须实现Comparable接口，才能实现对象之间的比较
        Arrays.sort(msMans);
        System.out.println(Arrays.toString(msMans));
    }
}