尚学堂--Java数组

 

元素为基础数据类型数组：

　

　

元素为引用数据类型数组：

class Date{
      int year; int moth; int day;
      Date(int y; int m, int d){
      　　year=y ;
　　　　  month=m ;
　　　　  day=d ;
　　}  
}

 

一维数组：

声明：

int arr[];
int[] arr;
int arr[5];//错误，java语言中声明数组时不能指定其长度

创建：

arr = new int[5];

初始化：

静态初始化：定义数组的同时，就为数组元素分配空间并赋值

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

Date days[] = {
    new Date(1, 1, 2017),
    new Date(2, 1, 2017),
    new Date(3, 1, 2017)
};

动态初始化：先定义数组，再为数组元素分配空间和赋值

int a[];
a = new int[3];
a[0] = 1;
a[1] = 2;
a[2] = 3;

Date days[];
days = new Date[3];
days[0] = new Date(1, 1, 2017);
days[1] = new Date(2, 1, 2017);
days[2] = new Date(3, 1, 2017);

数组元素的默认初始化：

　　数组是引用类型（除了基础数据类型之外，java其它的类型全都是引用类型），它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化

public class Test {
    public static void main(String[] args) {
        int[] a = new int[3];
        Date[] days = new Date[3];
        System.out.println(a[1]);//输出0
        System.out.println(days[1]); //输出：null
    }
}

class Date{
    int day,month,year;
    Date(int day, int month, int year) {
        this.day = day;
        this.month = month;
        this.year = year;
    }
}

数组元素的引用

• arrayName[index]，index为数组元素的下标，可以是整型常量或整形表达式,例：a[i], a[3], a[6*i]
• 数组元素下标从0开始，取值范围为 0~n-1
• a.length的值为数组a的长度（元素个数），length是一个属性，而不是方法，后面不要加括号。（String那个类作为字符串也有length，也有长度，但那是个方法，要区别开来）

关于String[] args:

public class Test {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5, 6, 7};
        for(int i = 0; i < a.length; i ++) {
            System.out.println(a[i]);
        }
        //for中的i变量跟上面的i变量不冲突，局部变量，出了大括号就不认识了
        for(int i = 0; i < args.length; i ++) {
            System.out.println(args[i]);
        }
    }
}

深入理解String[] args:

public class Test {
    public static void main(String[] args){
        long l = 0;
        long l1 = 0;
        long l2 = 0;
        
        if(args.length != 3) {
            System.out.println("java Test " + "\"n1\" \"op\" \"n2\"");
            System.exit(-1);
        }

        try{
            l1 = Long.parseLong(args[0]);//parseLong可能会抛出NumberFormatException
            l2 = Long.parseLong(args[2]);
        }catch(NumberFormatException ex) {
            System.out.println("字符格式错误！");
            ex.printStackTrace();
        }
        
        if(args[1].equals("+")) {
            l = l1 + l2;
        }else if(args[1].equals("-")) {
            l = l1 - l2;
        }else if(args[1].equals("x")) {
            l = l1 *l2;
        }else if(args[1].equals("/")) {
            l = l1 / l2;
        }else {
            System.out.println("The message is not correct!");
            System.exit(-1);
        }
        System.out.println(l);
    }
}

练习：

要求：

1、命令行上读取多个数字，
2、构建成int类型的数组，
3、由大到小排序

public class Test {
    public static void main(String[] args) {
        //命令参数赋值给数组intArr[]
        int intArr[] = new int[args.length];
        for(int i = 0; i < args.length; i ++) {
            //String类型强制转换成int类型
            intArr[i] = Integer.parseInt(args[i]);
            //System.out.println(intArr[i] + " ");
        }

        //对args数组进行从小到大排序
        for(int i = 0; i < intArr.length - 1; i ++){
            for(int j = 0; j < intArr.length - 1 - i; j ++){
                if(intArr[j] > intArr[j + 1]) {
                    int temp = intArr[j + 1];
                    intArr[j + 1] = intArr[j];
                    intArr[j] = temp;
                }
            }
        }
        //输出数组元素
        for(int t = 0; t < intArr.length; t ++){
            System.out.print(intArr[t] + " ");
        }
    }
}

二维数组：

1、数组可以看成是以数组为元素的数组    例：int a[][] = {{1,2},{3,4,5,6},{7,8,9}};

2、java中多维数组的声明和初始化应按从高维到低维的顺序进行（从第一个中括号到第n个中括号）

int a[][] = new int[3][];
a[0] = new int[2];
a[1] = new int[4];
a[2] = new int[3];
int t[][] = new int[][3];//非法

 静态初始化：

int a[][] = {{1,2},{3,4},{5,6,7}};
int a[3][2] = {{1,2},{3,4},{5,6}};//非法，静态初始化方括号不要加数字

动态初始化：

int a[][] = new int[3][5];
int b[][] = new int[3][];
b[0] = new int[2];
b[1] = new int[3];
b[2] = new int[5];

数组拷贝：

使用java.lang.System类的静态方法

public static void arraycopy(Object src, int srcPos, Object dest,int destPos,int length)

Object src 源数组
int srcPos 源数组起始位置
Object dest 目标数组
int destPos 目标数组起始位置
int length 拷贝的长度

如果源数据数目超过目标数组边界会抛出IndexOutOfBoundsException异常

//拷贝字符串到另一个数组，拷贝一个二维数组到另一个二维数组
import java.lang.System.*;

public class Test{
    public static void main(String[] args) {
        String[] arr1 = {"hello","this","is","my","dog"};
        String[] arr2 = new String[6];
        //数组拷贝
        System.arraycopy(arr1, 0, arr2, 0, arr1.length);

        for(int i = 0; i < arr2.length; i ++) {
            System.out.print(arr2[i] + " ");
        }

        System.out.println();

        int[][] i1= {{1,2},{1,2,3},{3,4}};
        int[][] i2= new int[3][]; 
        //数组拷贝
        System.arraycopy(i1, 0, i2, 0, i1.length);
        //输出i2的全部元素
        for(int i = 0; i < i2.length; i ++) {
            for(int j = 0; j < i2[i].length; j++) {
                System.out.print(i2[i][j] + " ");
            }
        }

        System.out.println();

        int i3[][] = new int[3][];
        i3[1] = new int[2];
        //System.out.println(i3[0][]);
        System.out.println(i3[1]);
        System.out.println(i3[1][0]);

    }
}

package guolei;

public class ArrTest {
    public static void main(String[] args) {
        String[][] str1 = new String[3][];
        str1[0] = new String[2];
        str1[1] = new String[3];
        str1[2] = new String[2];
        
        for(int i = 0; i < str1.length; i ++) {
            for(int j = 0; j < str1[i].length; j ++) {
                //以下两种方法都可行，但是第二种为什么要new String?????????????/
                //str1[i][j] = "数组的位置是：i = " + i + " j = " + j;
                str1[i][j] = new String("数组的位置是：i = " + i + " j = " + j);
            }
        }
        
        for(int i = 0; i < str1.length; i ++) {
            for(int j = 0; j < str1[i].length; j ++) {
                //输出状态：数组的位置是：i = 0 j = 0。。。。。。。
                System.out.println(str1[i][j]);
            }
        }
    }
}