java数组

数组的三种初始化方式

一：静态初始化

在声明的时侯就给数组赋值的方式如
int[] arr = {1,2,3};

User[] arr = {new User(),new User()};

二：默认初始化

在声明的时候只给数组指定大小，那么分配的空间就会根据类型自动初始化，如int为0，对象为null。

如： int[] arr = new int[3];

三：动态初始化

在声明的时候只给数组指定大小,随后指定每个对象具体的值

如：

//3、动态初始化
        int [ ] d= new int[10];
        for (int i=0;i<d.length;i++){
            d[i]=i*10;
			
			
	   char[][] arr = new char[3][3]{{'1','2','2'},{'2','3','4'}};

数组的拷贝方式

一维数组的拷贝

一维数组的拷贝

for循环拷贝

  //对于基本类型，深拷贝
        int[] array1 = {1,2,3,4,5};
        int[] array2 = new int[array1.length];
        for(int i = 0 ; i < array1.length;i++){
            array2[i] = array1[i];
        }

clone拷贝

   //对于一维数组基本类型，深拷贝
        int[] array1 = {1,2,3,4,5};
        int[] array2 = new int[array1.length];
        
        array2=array1.clone();
		
		
//对于引用类型来说是浅拷贝
 test[] array1 = {new test(),new test(),new test()};
       test[] array2 = new test[array1.length];

System.arrayCopy()

   //对于基本类型，深拷贝
        int[] array1 = {1,2,3,4,5};
        int[] array2 = new int[array1.length];

       System.arraycopy(array1,0,array2,0,array1.length);

Arrays.copyOf(arr,arrLength)

    //对于基本类型，深拷贝
        int[] array1 = {1,2,3,4,5};
        int[] array2 = new int[array1.length];

        array2 = Arrays.copyOf(array1, array1.length);

总结，一维数组拷贝，对于基本类型来说，上述所有的拷贝方式都是深拷贝，而对于引用型变量来说，都是浅拷贝

二维数组的拷贝

二维数组的拷贝

二维数组的拷贝方式

for循环拷贝

  //对于基本类型，深拷贝
        int[][] array1 = {{1,2,3,4,5},{2,3,4,5,6}};
        int[][] array2 = new int[2][5];
        for(int i = 0 ; i < array1.length;i++){
            for (int j = 0 ; j < array2.length; j++){
                array2[i][j] = array1[i][j];
            }
        }

clone深拷贝和浅拷贝

//对于基本类型，clone方式,深拷贝
        int[][] array1 = {{1,2,3,4,5},{2,3,4,5,6}};
        int[][] array2 = new int[2][5];
        for(int i = 0 ; i < array1.length;i++){
          array2[i] = array1[i].clone();
        }

        //下面这种是浅拷贝
        array2 = array1.clone();

System.arrayCopy(arr1,arrIndex,arr2,arr2Index,length)

 //对于基本类型，System.arrayCopy方式,深拷贝
        int[][] array1 = {{1,2,3,4,5},{2,3,4,5,6}};
        int[][] array2 = new int[2][5];
        for(int i = 0 ; i < array1.length;i++){
          System.arraycopy(array1[i],0,array2,0,array1.length);
        }

Arrays.copyOf()

//对于基本类型，System.arrayCopy方式,深拷贝
        int[][] array1 = {{1,2,3,4,5},{2,3,4,5,6}};
        int[][] array2 = new int[2][5];
        for(int i = 0 ; i < array1.length;i++){
         array2[i]=Arrays.copyOf(array1[i],array1.length);
        }

总结，对于二维数组来说，要从每个二维数组的一维部分进行复制，否则只是浅拷贝。无论是clone,System.arrayCopy(),arrays.copyOf()都是一样的。

数组的增删操作及其实质

 public static void main(String[] args) {
        String[] strings = new String[5];
        for(int i = 0 ; i<strings.length;i++){
            strings[i] = "str"+i;
        }
        System.out.println(Arrays.toString(strings));
        strings = delete(strings,2);
        System.out.println(Arrays.toString(strings));
    }

    public static String[] delete(String[] strings,int n){
        System.arraycopy(strings,n+1,strings,n,strings.length-n-1);
        strings[strings.length-1]=null;
        return strings;
    }

也就是说，数组的增删操作实质是数组的复制，而扩容操作只是重新建立一个更大的空间。

Array工具类的使用

排序 Arrays.sort();

该函数底层使用快排进行排序。

二分查找

Arrays.binarySearch()。
实现了二分查找

实现对Arrays类 自定义 排序sort的2种方法

实现Comparable接口

该排序也叫自然排序。要排序的类实现Comparable接口，就可以实现排序。

Coparable接口中只有一个compareTo方法。
定义小于返回-1，等于返回 0 ，大于返回1即可。

public interface Comparable<T> {
	public int compareTo(T o);
}

public class Employee implements Comparable<Employee> {
    private String name;
    private double salary;
	
	 public int compareTo(Employee other) {
        return Double.compare(salary, other.salary);
    }
}

public class arrays {
    public static void main(String[] args) {
        Employee[] employees = new Employee[3];
        for(int i= 0 ; i < 3 ; i++){
            employees[i] = new Employee();
            employees[i].name = "i"+i;
            employees[i].salary = Math.random();
        }
        Arrays.sort(employees);
        for(int i= 0 ; i < 3 ; i++){
            System.out.println(employees[i].name);
            System.out.println(employees[i].salary);
        }
    }
}
class Employee implements Comparable<Employee>{
    String name;
    double salary;
    @Override
    public int compareTo(Employee o) {
        return Double.compare(salary,o.salary);
    }
}

使用比较器（comparator）作为sort的参数

该排序也叫客户化排序，在外部实现 Comparator接口，就可以使用排序。

public interface Comparator<T> {
	int compare(T o1, T o2);
	
	//还有很多其他的方法
}

class salaryCompare implements Comparator<Employee> {
    @Override
    public int compare(Employee o1, Employee o2) {
        return Double.compare(o1.salary, o2.salary);
    }
}

  Arrays.sort(employees, new salaryCompare());