数组学习

数组的概念

数组是相同类型数据的有序集合

特点

1. 长度是确定的。一旦被创建，大小不可以改变
2. 元素的类型必须是相同类型
3. 数组类型可以是任何数据类型，基本数据类型和引用数据类型
4. 数组变量属于引用类型，数组也是对象

数组属于引用数据类型，所以在数组使用之前一定要开辟控件（实例化），如果使用了没有开辟空间的数组，则一定会出现 NullPointerException 异常信息：

数组初始化的三种方式

静态初始化

除了用new关键字产生数组以外，还可以直接在定义数组的同时就为数组元素空间并赋值

//静态初始化,两种正确写法
int[] arr = new int[]{12,23,45};
int[] arr ={12,23,45};

//！！注意
new int[3]{12,23,45};这是错误的[]不用写长度3

int[]arr;
arr ={12,23,45}; //这也是错误的不知道是数组,不能分开写

动态初始化

数组定义与数组元素分配空间并赋值的操作分开进行

int[] arr = new int[3];//也可以分开写 int[]arr;  arr=new int[3];
arr[0]=12;
arr[1]=23;
arr[2]=45;

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素也被按照实例变量通用的方式被隐藏初始化
基本数据类型（byte，short,int ，long,初始化值为0； float, double,初始化值为0.0 boolean初始化值为false char初始化值'u0000'
引用数据类型数组：null

int[]arr =new int[3];数组有默认初始化的值

数组的遍历及增强for循环

遍历指的是循环数组的所有元素
数组元素下标（索引）合法区间[0,length-1]。我们可以通过下标来遍历数组中的元素，遍历时可以读取元素的值或者修改元素的值
增强for循环，用于读取，不能修改数组中的某个元素值，不涉及有关索引的操作

public class Test01 {
    public static void main(String[] args) {

        //数组的定义和初始化
        // int[] arr1 = null;
        int[] arr1 = new int[5];//默认初始化；数组的元素相当于对象的属性，遵守对象属性默认初始化规则
        //动态初始化，根据索引直接赋值
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);

        int[] arr2 ={20,30,40};//静态初始化
        //数组遍历
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = i * 2 + 1;
        }
        for (int i = 0; i < arr1.length; i++) {//数组长度是5，索引范围【0，length-1】
            System.out.println(arr1[i]);
        }
    }
}

public class Test02 {
    public static void main(String[] args) {
        Man m =new Man(10,"高小一");

        //静态初始化需要在声明后直接初始化
        Man[] mans ={
                m,
                new Man(20,"高小二"),
                new Man(30,"高小三"),
                new Man(40,"高小四"),
                new Man(50,"高小五")};
        mans[0]=m;

            for(int i =0;i<mans.length;i++) {
                Man man=mans[i];
                System.out.println(man);
            }
            //增强for循环，用于读取，不能修改数组中的某个元素值，不涉及有关索引的操作
            for(Man man:mans){
                System.out.println(man);
            }
    }


}
class Man{
    private int id;
    private  String name;

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

    @Override//重写toString方法
    public String toString() {
        return
                "id:" + id +
                ", 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 srccpos(目标位置),int length（长度）)方法。这个方法可以把src数组里元素赋值给dest数组元素，srcpos数组的第几个元素开始赋值，length参数指定将src数组的多少个元素赋值给dest数组的元素

public class Test97 {
    public static void main(String[] args) {
        String[] s ={"阿里","腾讯","京东","网易","搜狐"};
        String[] b = new String[5];
        System.arraycopy(s,0,b,0,s.length);
        for(int i =0;i<5;i++){
            System.out.print(b[i]+"	");
        }
    }
}

java.util.Arrays类

使用Arrays类输出数组中的元素

public class Test96 {
    public static void main(String[] args) {
        int[] arr = {20,30};
        System.out.println(arr);//[I@6bdf28bb
        System.out.println(Arrays.toString(arr));//结果[20, 30]
    }
}

此处Arrays.toString()方法是Arrays类的静态方法，不是Object的toString()方法

使用Arrays类对数组元素进行排序

public class Test95 {
    public static void main(String[] args) {
        int[] a ={1,2,32,23,543,12,59};
       System.out.println(Arrays.toString(a));//进行数组的显示输出
        Arrays.sort(a);//进行排序
        System.out.println(Arrays.toString(a));//排序之后的数组通过Arrays.toString进行输出
    }
}
/**结果：
 [1, 2, 32, 23, 543, 12, 59]
 [1, 2, 12, 23, 32, 59, 543]
 */

使用Arrays类实现二分法查找法

import java.util.Arrays;

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

使用Arrays类对数组进行填充

import java.util.Arrays;

public class Test93 {
    public static void main(String[] args) {
        int[] a ={1,2,32,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,2,4,100);//将2到4的元素替换成100，但是不包含索引4。（包前不包后）
        System.out.println(Arrays.toString(a));
    }
}

多维数组-内存分析

int[][] a = new int [3][5]; //进行理解

a位于main的栈帧空间，创建的数组，属于对象位于堆中。以上为例子，int[]对象初始值为0，整个多维数组，可以理解成是一个3x5的表格，每个格子有一个地址。在进行多维数组时，可以使用Object和之前学过的类进行数组的存储

/**
 *javabeen 和数组存储表格的信息。
 * 非常重要
 */
public class Test5 {
    public static void main(String[] args) {
        Emp emp0 =new Emp(1001,"高小一",18,"程序员","2019-9-9");
        Emp emp1 =new Emp(1002,"高小二",19,"程序员","2019-3-9");
        Emp emp2 =new Emp(1003,"高小三",20,"程序员","2019-4-9");

       // Emp[] emps ={emp0,emp1,emp2};
        Emp[] emps = new Emp[3];
        emps[0]=emp0;
        emps[1]=emp1;
        emps[2]=emp2;

        //遍历数据
        for (int i=0;i<3;i++){
          //  System.out.println(emps[i].getId()+"	"+emps[i].getName()+"	"+emps[i].getAge()+"	"+emps[i].getJob()+"	"+emps[i].getHiredate());
          //利用toString；
            System.out.println(emps[i]);
        }

    }
}

class Emp{
    private int id;
    private String name;
    private int age;
    private  String job;
    private  String hiredate;

    public Emp(){
    }

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

    }

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

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

import java.util.Arrays;

/**
 * 二维数组练习
 * 使用Object[][]存储整个表隔数据
 */
public class Test04 {
    public static void main(String[] args) {

        //每一个以为数组代表一行数据
       Object[] a1 ={1001,"高淇",18,"讲师","2019-2-14"};
       Object[] a2 ={1002,"高小七",19,"助教","2019-10-10"};
       Object[] a3 ={1003,"高小琴",20,"班主任","2019-5-5"};
       Object[][]  b =new Object[3][5];
       b[0]=a1;
       b[1]=a2;
       b[2]=a3;
        System.out.println(Arrays.toString(b[0]));
        System.out.println(Arrays.toString(b[1]));
        System.out.println(Arrays.toString(b[2]));


        for(int i =0;i<b.length;i++){//竖
            for(int j =0;j<b[i].length;j++){//横
                System.out.print(b[i][j]);
            }
            System.out.println();
        }
    }
}