liujijiang

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

2020.04.02

容器几乎总是比数组好

对象数组保存的是对象的引用
基本类型的数组保存的是值
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内置排序算法:

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