java学习笔记 --16-- 数组

容器几乎总是比数组好

对象数组保存的是对象的引用
基本类型的数组保存的是值
length是数组容量的大小，不是元素的个数
新建一个数组对象时所有的引用初始化为null
基本类型初始化值：

• 数值型：0
• char：(char)O
• boolean：false

public static void main(String [] args) {
        Integer [] integers = new Integer[]{1,2,3};
        Integer [] integers1 = {new Integer(1),new Integer(2),new Integer(3)};
        System.out.println(integers[1] + " " + integers1[1]);
    }

数组初始化方式
第二种：动态聚集初始化

public static void main(String [] args) {
        int a = 1;
        int b = a;
        b =2 ;
        System.out.println(a + " "  + b);

        Test2 test2 = new Test2();
        test2.a = 1;
        Test2 test21 = test2;
        test21.a = 2;
        System.out.println(test2.a + " " + test21.a);
    }

基本类型：堆栈中新建一个a的值给b
对象：堆中的同一个对象多了一个引用

返回一个数组

c++中不能返回数组，只能返回指向数组的指针，但java能

package com.company;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @ClassName Test
 * @Description
 * @Auther liuxiansen
 * @Date 2020/3/29 8:55 上午
 **/
public class Test{
    public static void main(String [] args) {

        for(int a : new Test2().print()){
            System.out.println(a);
        }
    }

}

interface Test1{

    int[] print();
}

class Test2 implements Test1{
    public int a[];

    public Test2(){
        a =new int[] {1,2,3};
    }

    public int[] print(){
        return a;
    }
}

print方法返回一个数组，并遍历数组

多维数组

package com.company;
import java.util.Arrays;
/**
 * @ClassName Test
 * @Description
 * @Auther liuxiansen
 * @Date 2020/3/29 8:55 上午
 **/
public class Test{
    public static void main(String [] args) {
        int [][] a = {
                {1,2,3},
                {4,5,6}
        };

        for(int[] s : a){
            for(int ss : s){
                System.out.println(ss);
            }
        }

        System.out.println(Arrays.deepToString(a));
    }

}

可以用Arrays.deepToString方法数组多维数组，将多维数组转化为多个String

粗糙数组

public static void main(String [] args) {
        Random random = new Random(1);
        int [][][] a = new int[random.nextInt(10)][][];
        for(int i=0;i<a.length;i++){
            a[i] = new int[random.nextInt(10)][];
            for(int j=0;j<a[i].length;j++){
                a[i][j] = new int[random.nextInt(10)];
            }
        }
        System.out.println(Arrays.deepToString(a));
    }

数组中构成矩阵的每个向量可以是任意的长度

Arrays.deepToString方法对基本类型数组和对象数组都起作用

数组与泛型

可以定义一个泛型数组引用，但是不能对其初始化
List [] lists;

定义一个引用没问题

List [] lists = new ArraysList[10];

但是初始化就不行了

数组是协变类型的，List[]其实就是Object[]，所以你可以把List放进数组中

public static void main(String [] args) {
        List<String> [] lists = (ArrayList<String>[]) new List[10];
        for(int i=0;i<10;i++){
            lists[i] = new ArrayList<>();
        }

    }

泛型数组定义以及初始化

public static void main(String [] args) {
        int [] a = new int[10];
        Arrays.fill(a,1);
        for(int num : a){
            System.out.println(num);
        }

    }

Arrays.fill：给数组填充一样的数据

public static void main(String [] args) {

        int[] a = {1,2,3};
        int[][] b = {
                {1, 2},
                {1, 2}
        };

        int[] a1 = a;
        int[][] b1 = b;
        System.out.println(Arrays.equals(a,a1));
        System.out.println(Arrays.deepEquals(b,b1));

        Arrays.sort(a);
        for(int num : a){
            System.out.println(num);
        }
        
        System.out.println(Arrays.binarySearch(a,1));
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.hashCode(a));

        Integer [] integers = {1,2,3};
        List<Integer> list = Arrays.asList(integers);


    }

Arrays的一些static方法：
equals：判断一维数组是否相等
deepEquals：判断多维数组是否相等
sort：排序
binarySearch：对排序后的数组查找

public static void main(String [] args) {

        int[] a = {1,2,3};

        int [] b = new int[10];

        System.arraycopy(a,0,b,0,a.length);

        System.out.println(Arrays.toString(b));

        Test2[] test2s = new Test2[10];

        for(int i=0;i<10;i++){
            test2s[i] = new Test2();
            test2s[i].a = 1;
        }

//        for(Test2 test2 : test2s){
//            test2 = new Test2();
//            test2.a = 1;
//        }

        Test2[] test2s1 = new Test2[10];

        System.arraycopy(test2s,0,test2s1,0,test2s.length);
        
        for(Test2 test2 : test2s1){
            test2.a = 3;
        }

        for(Test2 test2 : test2s){
            test2.print();
        }

    }

使用System.arraycopy方法拷贝数组，参数：源数组，起始位置，目的数组，起始位置，拷贝长度
注释的地方：使用forEach后数组中的每个元素还是null，没有新建一个对象的引用，用for循环就可以
基本类型的拷贝是拷贝值，对象的拷贝是拷贝引用（浅拷贝）

数组的比较

Arrays.eauals方法判断两个数组相等的条件：

• 元素个数一样
• 每个位置的值一样

package com.company;
import sun.rmi.rmic.iiop.Generator;

import java.util.*;
import java.util.stream.Stream;
/**
 * @ClassName Test
 * @Description
 * @Auther liuxiansen
 * @Date 2020/3/29 8:55 上午
 **/
public class Test{
    public static void main(String [] args) {
        Random random = new Random(1);

        Test2 test2 = new Test2();
        test2.a = 1;

        Test2 test21 = new Test2();
        test21.a = 2;

        System.out.println(test2.a < test21.a);

        Test2 [] test2s = new Test2[10];
        for(int i=0;i<10;i++){
            test2s[i] = new Test2();
            test2s[i].a = random.nextInt(10);
        }

        Arrays.sort(test2s);
        for(Test2 test22 : test2s){
            System.out.println(test22.a);
        }

	Arrays.sort(test2s,Collections.reverseOrder());
        for(Test2 test22 : test2s){
            System.out.println(test22.a);
        }

    }

}
class Test2 implements Comparable<Test2>{
    public int a;

    public void print(){
        System.out.println("a: " + a);
    }

    @Override
    public int compareTo(Test2 o) {
        if(this.a == o.a){
            return 0;
        } else {
            return this.a-o.a>0?1:-1;
        }
    }
}

当你的类实现了Comparable接口的compareTo方法，你的类就可以进行比较了，并且这个类构成的数组也可以排序了
Arrays.sort第二个参数可以是Collections.reverseOrder进行倒叙排序

compareTo：

• 如果返回0，表示两个数类相等
• 如果返回整数，表示当前对象大于参数对象
• 如果返回负数，表示当前对象小于参数对象

java内置排序算法：

• 基本类型：快排
• 对象：归并排序