Java之数组入门

• 前言
• 一、数组
• 二、创建和初始化
• • 1、创建
  • 2、静态初始化
  • 3、动态初始化
• 三、遍历
• • 1、for循环
  • 2、for-each
• 四、拷贝
• 五、java.util.Arrays
• 六、二维数组
• • 1、静态初始化
  • 2、动态初始化
  • 3、Object数组保存表格
  • 4、使用JavaBean来存二维表格
• 七、Comparable
• 总结
• 参考文献
• 附录

Java数组入门介绍，数组、创建和初始化、遍历、拷贝、Arrays工具类、二维数组、Comparable。

相同且有序的有序集合。
1）长度确定
2）类型相同
3）数组也是对象，数组对象也是引用类型。

int[] arr;//这种便于理解，数组对象。
int arr[];

//静态初始化
        int[] arr = new int[]{1, 2, 3, 4};
        int[] sArr = {1, 2, 3};

new int[]new出的是对象，数组的变量为该对象的属性。

 for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
            System.out.println(arr[i]);
        }

不仅可以遍历，还方便修改数组元素。

		int[] arr = new int[3];
        //动态赋值，可动态初始化
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
            System.out.println(arr[i]);
        }

增强的for循环，优点简洁，缺点只能读取元素，不能修改。

		//增强的for：for-each只读取，不修改。
		int[] arr = new int[]{1, 2, 3, 4};
        for (int n : arr) {
            System.out.println(n);
        }

        //2. 数组复制
        int[] arr1 = new int[]{1, 2, 3, 4, 5};
        int[] arr2 = new int[arr1.length];
        System.arraycopy(arr1, 0, arr2, 0, arr1.length);

从arr1的第0个元素开始拷贝arr1.length个元素到arr2，从下标0开始。

一个操作数组的工具包，可排序、查找、填充、打印数组内容等。

		int[] arr1 = new int[]{1, 2, 3, 4, 5};
        int[] arr2 = new int[arr1.length];
        //3. Arrays.toString()
        System.out.println(Arrays.toString(arr1));
        //4. Arrays.sort()
        Arrays.sort(arr1);
        //5. 二分查找binarySearch,找到就返回位置，否则返回负数
        //先排序，再二分
        Arrays.sort(arr);
        System.out.println(Arrays.binarySearch(arr, 1));
        //6. 填充Arrays.fill,从0到arr.length，包头不包尾，填充value=1
        Arrays.fill(arr, 0, arr.length, 1);

一维数组是对象，二维数组也是对象，里面的元素就是一维对象。
其内存图为：

int[][] a = new int[3][3]{{1,2,3},{4,5,6},{7,8,9}};

        //7. 二维数组,二维数组也是对象
        int[][] a = new int[3][];
        a[0] = new int[1];
        a[1] = new int[2];
        a[2] = new int[3];
        a[0][0] = 1;
        a[1][0] = 2;

万物皆对象，对象又像表格一样，即万物皆表格，操作表格变得尤为重要。利用Object是所有类的祖宗类，来存所有类型的数据。

        //8。 Object[][]存表格数据。由于Object是所有类的祖宗。
        Object[][] teachers = new Object[2][];
        teachers[0] = new Object[]{"111", "李老师", "数学"};
        teachers[1] = new Object[]{"222", "王老师", "语文"};
        

        Student[] sts = new Student[2];
        sts[0] = new Student("111", "李老师", "数学");
        sts[1] = new Student("222", "王老师", "语文");

对于数字来讲，天然就有大小比较，而对于一个自定义对象，只需实现Comparable接口，实现CompareTo方法就能实现自定义比较大小。

public static class Student implements Comparable {
        String id;
        String name;
        String course;
        @Override
        public int compareTo(Object o) {
            Student s = (Student) o;
            return s.id.compareTo(id) == 1 ? -1 : 1;
        }
    }

1）数组入门。
2）数组即对象，简单数组内存分析。
3）一些常规操作。

[1] Java SE 高淇

[1] 可视化算法网站
[2] 完整代码

package com.xhu.java;

import java.util.Arrays;

public class TestArrays {
    public static void main(String[] args) {
        //1.数组遍历
        //静态初始化
        int[] arr = new int[]{1, 2, 3, 4};
        int[] sArr = {1, 2, 3};
        //可操作数组的遍历
        //动态赋值，可动态初始化
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
            System.out.println(arr[i]);
        }
        //增强的for：for-each只读取，不修改。
        for (int n : arr) {
            System.out.println(n);
        }
        //2. 数组复制
        int[] arr1 = new int[]{1, 2, 3, 4, 5};
        int[] arr2 = new int[arr1.length];
        System.arraycopy(arr1, 0, arr2, 0, arr1.length);
        //3. Arrays.toString()
        System.out.println(Arrays.toString(arr1));
        //4. Arrays.sort()
        Arrays.sort(arr1);
        //5. 二分查找binarySearch,找到就返回位置，否则返回负数
        //先排序，再二分
        Arrays.sort(arr);
        System.out.println(Arrays.binarySearch(arr, 1));
        //6. 填充Arrays.fill,从0到arr.length，包头不包尾，填充value=1
        Arrays.fill(arr, 0, arr.length, 1);
        //7. 二维数组,二维数组也是对象
        int[][] a = new int[3][];
        a[0] = new int[1];
        a[1] = new int[2];
        a[2] = new int[3];
        //8。 Object[][]存表格数据。由于Object是所有类的祖宗。
        Object[][] teachers = new Object[2][];
        teachers[0] = new Object[]{"111", "李老师", "数学"};
        teachers[1] = new Object[]{"222", "王老师", "语文"};
        System.out.println(teachers[0][0]);
        Arrays.toString(teachers[0]);
        Student[] sts = new Student[2];
        sts[0] = new Student("111", "李老师", "数学");
        sts[1] = new Student("222", "王老师", "语文");
    }

    public static class Student implements Comparable {
        String id;
        String name;
        String course;

        public Student(String id, String name, String course) {
            this.id = id;
            this.name = name;
            this.course = course;
        }

        public String getId() {
            return id;
        }

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

        public String getName() {
            return name;
        }

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

        public String getCourse() {
            return course;
        }

        public void setCourse(String course) {
            this.course = course;
        }

        @Override
        public String toString() {
            return "Student{" +
                    "id='" + id + ''' +
                    ", name='" + name + ''' +
                    ", course='" + course + ''' +
                    '}';
        }

        @Override
        public int compareTo(Object o) {
            Student s = (Student) o;
            return s.id.compareTo(id) == 1 ? -1 : 1;
        }
    }
}