七、java数组

目录

一、一维数组

声明方式

数组对象的创建

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

数组初始化

数组元素默认初始化

数组元素的引用

二、二维数组

概念

初始化

二维数组举例

三、数组的拷贝

四、练习

数组可以堪称是多个相同类型数据组合，对这些数据的统一管理

数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量

数组中的元素可以是任何数据类型，包括基本类型和引用类型

一、一维数组

1.声明方式：

type var [ ] ; 或 type [ ] var ;

例如：

int a1[];
int[] a2;
double b[];
Person [] p1;
String s1[];

java语言中声明数组时不能指定其长度（数组中的元素个数）因为java数组分配的空间是在堆上面，例如：

int a[5];    //非法

2.数组对象的创建

java中使用关键字new创建数组对象，格式为：数组名 = new 数组元素的类型 [数组元素个数]，例如：

public class Test {
    public static void main(String[] args){
        int[] s;
        s = new int[5];
        for (int i=0;i<5;i++){
            s[i] = 2 * i + 1;
        }
        
    }
}

3.元素为引用数据类型的数组

注意：元素为引用数据类型的数组中的每一个元素都需要实例化

例如：

public class Test {
    public static void main(String[] args){
        Date[] days;
        days = new Date[3];
        for (int i=0;i<3;i++){
            days[i] = new Date(2004,4,i+1);
        }
    }
}
class Date {
    int year;
    int month;
    int day;
    Date(int y,int m,int d) {
        year = y;
        month = m;
        day = d;
    }
}

4.数组初始化

1）动态初始化

数组定义与为数组元素分配空间和赋值的操作分开进行，先分配空间再赋值；例如：

public class Test {
    public static void main(String[] args){
        int a[];
        a = new int[3];
        a[0] = 3;
        a[1] = 9;
        a[2] = 8;
        
        Date days[];
        days =new Date[3];
        days[0] = new Date(1, 4, 2004);
        days[1] = new Date(2, 4, 2004);
        days[2] = new Date(3, 4, 2004);
    }
}
class Date {
    int year;
    int month;
    int day;
    Date(int y,int m,int d) {
        year = y;
        month = m;
        day = d;
    }
}

2）静态初始化

在定义数组的同时就为数组元素分配空间并赋值，例如：

public class Test {
    public static void main(String[] args){
        int a[] = {3,9,8};    
        Date days[] = {new Date(1, 4, 2004),new Date(2, 4, 2004),new Date(3, 4, 2004)};
    }
}
class Date {
    int year;
    int month;
    int day;
    Date(int y,int m,int d) {
        year = y;
        month = m;
        day = d;
    }
}

5.数组元素默认初始化

数组是引用类型，他的元素相当于类的成员变量，因此，数组分配空间后，每个元素也被按照成员变量的规则被隐式初始化，例如：

public class Test {
    public static void main(String[] args){
        int a[] = new int[3];
        Date[] days = new Date[3];
        System.out.println("a[3] = "+a[2]);
        System.out.println("days[3] = "+days[2]);
    }
}
class Date {
    int year;
    int month;
    int day;
    Date(int y,int m,int d) {
        year = y;
        month = m;
        day = d;
    }
}

输出结果：

a[3] = 0
days[3] = null

6.数组元素的引用

定义并用运算符new为数组分配空间后，才可以引用数组中的每个元素，数组元素的饮用方式为：

arrayName[index]

其中index为数组元素的下标，可以是整型常量或整型表达式。如：a[3],b[i],c[6*i]等

数组元素下表从0开始；长度为n的数组的合法下标取值范围为：0—（n-1）

每个数组都由一个属性length指明它的长度，例如：a.length的值为数组a的长度（也就是元素个数）

二、二维数组

1.概念

二维数组可以看成是以数组为元素的数组，例如：

        int a[] [] = { {1,2}, {3,4,5,6}, {7,9}};

java中多维数组的声明和初始化应从高纬到低纬的顺序进行，例如：

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

如上的示例可以参考下面的图来理解：

以二维数组为例，其实二维数组就相当于数组中包含数组，所以在声明的时候要先声明第一纬度，如上：、

a[0] = new int [2];    相当于给第一个包含在内的数组声明了两个小格的内存，

a[1] = new int [4];    相当于给第二个包含在内的数组声明了四个小格的内存，

a[2] = new int [3];    相当于给第三个包含在内的数组声明了三个小格的内存，

理解了二维数组的概念应该就能理解多维的概念

2.初始化

• 静态初始化：

int intA[][] = {{1,2},{3,4},{7,8,9}};
int intB[3][2] = {{1,2},{3,4},{7,8,}};//非法

• 动态初始化：

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];

3.二维数组举例

//测试类
public class Test {
    public static void main(String[] args){
        int a[][] = {{1,2},{3,4,5,6},{7,8,9}};
        for(int i=0;i<a.length;i++) {
            for (int j=0;j<a[i].length;j++) {
                System.out.print("a["+i+"]["+j+"]="+a[i][j]+"  ");
            }
            System.out.println();
        }        
    }    
}

//输出结果

a[0][0]=1  a[0][1]=2  
a[1][0]=3  a[1][1]=4  a[1][2]=5  a[1][3]=6  
a[2][0]=7  a[2][1]=8  a[2][2]=9

//测试类
public class Test {
    public static void main(String[] args){
        String[][] s;
        s = new String[3][];
        s[0] = new String[2];
        s[1] = new String[3];
        s[2] = new String[2];
        
        for(int i=0;i<s.length;i++) {
            for(int j=0;j<s[i].length;j++) {
                s[i][j] =new String("我的位置是： "+i+","+j);
                System.out.print(s[i][j]+"    ");
            }
            System.out.println();
        }
    }
}

//输出结果：

我的位置是： 0,0    我的位置是： 0,1    
我的位置是： 1,0    我的位置是： 1,1    我的位置是： 1,2    
我的位置是： 2,0    我的位置是： 2,1

三、数组的拷贝

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

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

• 可以同于数组src从第srcPos项元素开始的lenth个元素拷贝到目标数组从destPos项开始的length个位置
• 如果源数据数目超过目标数组边界会抛出IndexOutOfBpundsException异常
• 需要注意的是，修改拷贝后的数组，源数组的值也会跟着改变，因为copy后的数组和源数组在内存空间指向的是同一地址，可以参考后面的例子来理解这句话

看一个例子：

//测试类
public class Test {
    public static void main(String[] args){
        //一维数组的拷贝
        String[] s = {"Mircosoft","IBM","Sun","Oracle","Apple"};
        String[] sBak = new String[6];
        System.arraycopy(s, 0, sBak, 0, s.length);
    
        for(int i=0;i<sBak.length;i++){
            System.out.print(sBak[i]+" ");
        }
        System.out.println();
        for(int i=0;i<s.length;i++){
            System.out.print(s[i]+" ");
        }
        System.out.println();
        //二维数组的拷贝
        int [][] intArray = {{1,2},{1,2,3},{3,4}};
        int [][] intArrayBak = new int[3][];
        System.arraycopy(intArray, 0, intArrayBak, 0, intArray.length);
        intArrayBak[2][1] = 100;
        for(int i = 0;i<intArray.length;i++) {
            for(int j=0;j<intArray[i].length;j++) {
                System.out.print(intArray[i][j]+"     ");
            }
            System.out.println();
        }
    }
}

 再看一个例子：

public class Test {
	public static void main(String[] args) {		
		int a[] = {1,2,3,4};
		int b[] = {4,2,3,5,6};
		int c[];
		int c1[];
		//相当于数组扩充,观察c1和c2的输出来参考这个函数的使用方式
		c = Arrays.copyOf(b, a.length + b.length);
		c1 = Arrays.copyOf(a, a.length + b.length);
		System.out.println("c = " + Arrays.toString(c));
		System.out.println("c1 = " + Arrays.toString(c1));
		//数组拷贝
		System.arraycopy(b, 0, c, a.length, b.length);
		System.out.println("c = " + Arrays.toString(c));		
		System.out.println("a = " + Arrays.toString(a));
		System.out.println("b = " + Arrays.toString(b));	
	}
}

四、练习

1.练习1

public class Test {
    public static void main(String[] args){
        int a[] = {1,3,5,7,9,11,13,15,17};
        //打印数组中所有元素
        for(int i=0;i<a.length;i++) {
            System.out.print(a[i]+" ");
        }
    }
}

输出结果

1 3 5 7 9 11 13 15 17

这里要说一下main主方法中有一个（String[] args），main()方法是Java应用程序的入口方法，也就是说main()方法是程序运行的时候第一个执行方法，这个方法体是被固定的，比如方法名字必须是main，类型必须是public static void的，方法必须接受一个字符串数组的参数，这个参数主要是为程序使用者在命令行状态下与程序交互提供的一种手段

再简单点，其实main方法中的数组就是为了让使用者通过命令行传参来使用的一个数组。你也可以在自己的程序中利用for循环将main方法中的数组打印出来，但是在不传参的情况下打印出来的内容为空，但是如果在命令行下运行你的测试类，并在命令行传入参数，就会进行输出了，比如：

2.练习2

使用命令行传参的方式写了一个小的计算器，计算加减乘除

public class Test {
    public static void main(String[] args){
        if(args.length<3){
            //使用了转义符
            System.out.println("Usage: java Test "n1" "op" "n2"");
        } else if(args.length==3) {
            //写了一个小计算
              //将参数的字符串转换为基础类型

            double d1 = Double.parseDouble(args[0]);
            double d2 = Double.parseDouble(args[2]);
            double d = Double.parseDouble(args[1]);
            if(args[1].equals("+")) {
                d = d1 + d2;
            }else if(args[1].equals("-")) {
                d = d1 - d2;
            }else if(args[1].equals("x")) {
                d = d1 * d2;
            }else {
                d = d1 / d2;
            }
            System.out.println(d);
        } else {
            System.out.println("Usage: java Test "n1" "op" "n2"");
        }
    }
}

3.练习3

这是一段对命令行传参进行排序并输出的小程序，可以试着写一下调试一下，当然这不一定是最优算法，只是拿来测试用一下

public class Test {
    public static void main(String[] args){
        int[] a = new int[args.length];
        for(int i=0;i<args.length;i++) {
            a[i] = Integer.parseInt(args[i]) ;
        }
        print(a);
        sort(a);
        print(a);
        
    }
    
    private static void sort(int[] a) {
        for(int i=0;i<a.length;i++) {
            for(int k=i+1;k<a.length;k++){
                if(a[k] < a[i]) {
                    int temp =a[i];
                    a[i] = a[k];
                    a[k] = temp;
                }
            }
        }
    }

    private static void print(int[] a) {
        for(int i=0;i<a.length;i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }
}