数组（下）

一. 命令行参数（了解）

1.在程序运行过程中，可以向应用程序传递一些参数，这些参数称为命名行参数。

列：

public class Test01{
    public static void main(String[] args){
        System.out.println(args.length);
        
        for(int i= 0;i<args.length;i++){
            System.out.println(args[i]);
        }
    }
}

运行时命令行 输入字符串 abcdjava java123（以空格形式分割），如果参数中本身包含空格，需要使用引号引起来。

D:gameprojectday06>java Te01 abcdjava java123 "jacky chan"

2
abcdjava
java123
jacky chan

二. Array

1.jdk中为了便于开发，给开发者提供了Arrays类，其中包含了很多数组的常用操作。例如快速输出、排序、查找等。

①常用的方法：

import java.util.Arrays;
public class Test02{
    public static void main(String[] args){
        
        int[] ary = {4,2,3,1};
        // 【1】数组的字符串形式
        String str = Arrays.toString(ary);
        System.out.println(str);
        
        // 【2】sort对数组排序(只能升序)-> 内部使用快速排序。
        Arrays.sort(ary);
        System.out.println(Arrays.toString(ary));
        
        // 【3】fill 填充数组
        //Arrays.fill(ary,0);
        //System.out.println(Arrays.toString(ary));
        
        // 【4】equals(ary1,ary2) 判断两个数组是否相等。
        // 数组相等的条件:a.长度相等 b.对应位置元素相等。
        int[] ary2 = {1,2,3};
        System.out.println(Arrays.equals(ary,ary2));
    }
}

2.二分法查找必须是有序的数组，如果找到返回索引；如果没有找到，返回-插入点-1。插入点就是key应该放到数组的位置。

①二分法高效动图展示：

②二分法查找：

private static int binarySearch0(long[] a, int fromIndex, int toIndex, long key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            long midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

三.数组的复制

1.copyOf(arr,len) 把arr复制len个长度的元素并返回新数组。如果len>arr.length,新数组的长度末尾用0填充。

2.copyOfRange(arr,from,to) 从arr中from(包含)位置开始复制到to(不包含)这个范围的元素到新数组中。含头不含尾。

列：

import java.util.Arrays;
public class Test04{
    public static void main(String[] args){
        
        int[] ary = {1,3,4,6,8};
        
        int[] newAry = Arrays.copyOf(arr,6);
        System.out.println(Arrays.toString(newAry));
        
        // copyOfRange(ary,from,to)
        int[] newAry2 = Arrays.copyOfRange(ary,1,3);
        System.out.println(Arrays.toString(newAry2));
    }
}

3.其中JAVA系统API方法也提供了赋值数组的方法。

　　arraycopy(srcAry,srcPos,destAry,destPos,len)

　　srcAry:要复制的源数组

　　srcPos:从srcAry的srcPos位置开始复制

　　destAry:复制到的目标数组

　　destPos:目标数组从destPos开始存放

　　len:从源数组中复制len个长度

import java.util.Arrays;
public class Test04{
    public static void main(String[] args){

            int[] ary2 = new int[ary.length];

            System.arraycopy(ary,1,ary2,0,3);

            System.out.println(Arrays.toString(ary2));
        }
}    
    

 四.二维数组

1.二维数组就是数组的数组，数组的元素也是数组。

　二维数组表示行列二维结构：

2.二维数组的声明

根据二维数组的定义：

import java.util.Arrays;
public class Test05{
    public static void main(String[] args){
        
        // 二维数组
        //int[]
        // (int[]) []
        
        
        // 【1】声明
        int[][] ary;
        // 【2】初始化一个能存3个一维数组的二维数组
        ary = new int[3][];
        
        // 【3】赋值
        int[] ary1 = {1,3,4,5};
        int[] ary2 = {1,3,4};
        int[] ary3 = {2,1,6,4};
        
        ary[0] = ary1;
        ary[1] = ary2;
        ary[2] = ary3;
        
        System.out.println(ary);
        System.out.println(Arrays.toString(ary));
    }
}

此时ary = new int[3][];只分配了二维数组的空间，一维数组没有分配空间。

 声明一个规则的二维数组

import java.util.Arrays;
public class Test06{
    public static void main(String[] args){
        
        // 声明一个规则的二维数组，3行4列
        int[][] ary;
        ary = new int[3][4];
        
        ary[0][0] = 10;
        ary[0][1] = 20;
        ary[0][2] = 30;
        ary[0][3] = 40;
        
        ary[1][0] = 100;
        ary[1][1] = 200;
        ary[1][2] = 300;
        ary[1][3] = 400;
        
        ary[2][0] = 1000;
        ary[2][1] = 2000;
        ary[2][2] = 3000;
        ary[2][3] = 4000;
        
        System.out.println(Arrays.toString(ary));
    }
}

这样二维数组已经分配好空间，同时一维也分配好空间，当已知二维数组的值数，可以考虑字面量声明；

import java.util.Arrays;
public class Test07{
    public static void main(String[] args){
        
        // 声明字面量二维数组
        int[][] ary = {
            {10,20,30,40},
            {100,200,300},
            {1000,2000,3000,4000}
        };
        System.out.println(Arrays.toString(ary));
    }
}

3.二维数组的遍历

import java.util.Arrays;
public class Test08{
    public static void main(String[] args){
        
        // 声明字面量二维数组
        int[][] ary = {
            {10,20,30,40},
            {100,200,300},
            {1000,2000,3000,4000}
        };
        // System.out.println(Arrays.toString(ary));
        
        /*
        for(int i=0;i<ary.length;i++){
            int[] t = ary[i];
            for(int j=0;j<t.length;j++){
                System.out.print(t[j]+"	");
            }
            System.out.println();
        }
        */
        
        
        for(int i=0;i<ary.length;i++){
            for(int j=0;j<ary[i].length;j++){
                System.out.print(ary[i][j]+"	");
            }
            System.out.println();
        }
    }
}

总结：

二维数组是行列结构，使用双层for循环，外层for用于控制行，内层for用于控制列

=> 行列结构

=> 双层for遍历

五.基本数据类型和引用数据类型赋值的区别

import java.util.Arrays;
public class Test09{
    public static void main(String[] args){
        
        // 基本数据类型的赋值
        int a = 10;
        int b;
        b = a;
        // a? b?
        b = 20;
        // a? b?
        
        // 引用数据类型的赋值
        int[] ary = {1,3,5};
        int[] ary2 = ary;
        ary2[0] = 100;
        
        System.out.println("ary:"+ary);
        System.out.println("ary2:"+ary2);
        
        System.out.println("ary[0]:"+ary[0]);
        
    }
}

总结:

基本数据类型赋值时，复制的是值

引用数据类型赋值时，复制的是引用