Java语言ch03 数组

字数统计: 920字 | 阅读时长: 4分

2019-06-04

本文主要内容为数组遍历与排序。

数组遍历

for循环遍历数组

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int i=0; i<ns.length; i++) {
            int n = ns[i];
            System.out.println(n);
        }
    }
}

for each循环遍历数组

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int n : ns) {
            System.out.println(n);
        }
    }
}

变量n直接拿到ns数组的元素，而不是索引。

打印数组内容

直接打印数组变量，得到的是数组在JVM中的引用地址：

1 2	int[] ns = { 1, 1, 2, 3, 5, 8 }; System.out.println(ns); // 类似 [I@7852e922

使用for each循环来打印数组内容：

int[] ns = { 1, 1, 2, 3, 5, 8 };
for (int n : ns) {
    System.out.print(n + ", ");
}

Java标准库提供了Arrays.toString()，可以快速打印数组内容：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 1, 2, 3, 5, 8 };
        System.out.println(Arrays.toString(ns));
    }
}

数组排序

冒泡排序

使用冒泡排序算法对一个整型数组从小到大进行排序：

import java.util.Arrays;

public class Main {
	public static void main(String[] args) {
		int[] ns = {28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
		//排序前：
		System.out.println(Arrays.toString(ns));
		for (int i = 0; i < ns.length-1; i++) {
			for (int j = 0; j < ns.length - i - 1; j++) {
				if (ns[j] > ns[j+1]) {
					int temp = 0;
					temp = ns[j];
					ns[j] = ns[j+1];
					ns[j+1] = temp;
				}
			}
		}
		//排序后：
		System.out.println(Arrays.toString(ns));	
	}
}

内置排序

Java的标准库已经内置了排序功能，我们只需要调用JDK提供的Arrays.sort()就可以排序：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
        Arrays.sort(ns);
        System.out.println(Arrays.toString(ns));
    }
}

注意

对数组排序实际上修改了数组本身

多维数组

二维数组

定义

二维数组就是数组的数组。

public class Main {
    public static void main(String[] args) {
        int[][] ns = {
            { 1, 2, 3, 4 },
            { 5, 6, 7, 8 },
            { 9, 10, 11, 12 }
        };
        int[] arr0 = ns[0];
        System.out.println(arr0.length); // 4
    }
}

            arr0 ─────┐
                      ▼
                    ┌───┬───┬───┬───┐
         ┌───┐  ┌──>│ 1 │ 2 │ 3 │ 4 │
ns ─────>│░░░│──┘   └───┴───┴───┴───┘
         ├───┤      ┌───┬───┬───┬───┐
         │░░░│─────>│ 5 │ 6 │ 7 │ 8 │
         ├───┤      └───┴───┴───┴───┘
         │░░░│──┐   ┌───┬───┬───┬───┐
         └───┘  └──>│ 9 │10 │11 │12 │
                    └───┴───┴───┴───┘

二维数组的每个数组元素的长度并不要求相同，例如，可以这么定义ns数组：

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

打印

要打印一个二维数组，可以使用两层嵌套的for循环：

for (int[] arr : ns) {
    for (int n : arr) {
        System.out.print(n);
        System.out.print(', ');
    }
    System.out.println();
}

或者使用Java标准库的Arrays.deepToString()：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[][] ns = {
            { 1, 2, 3, 4 },
            { 5, 6, 7, 8 },
            { 9, 10, 11, 12 }
        };
        System.out.println(Arrays.deepToString(ns));
    }
}

命令行参数

命令行参数类型是String[]数组；
命令行参数由JVM接收用户输入并传给main方法；

可以利用接收到的命令行参数，根据不同的参数执行不同的代码。例如，实现一个-version参数，打印程序版本号：

public class Main {
    public static void main(String[] args) {
        for (String arg : args) {
            if ("-version".equals(arg)) {
            //将“--version”放前面是为了防止arg字符串为空时调用equals方法出错
                System.out.println("v 1.0");
                break;
            }
        }
    }
}

上面程序必须在命令行执行，先编译：

1	$ javac Main.java

然后，执行的时候，给它传递一个参数-version，则输出v 1.0：

1 2	$ java Main -version v 1.0

这样，程序就可以根据传入的命令行参数，作出不同的响应。