到头来还是逃不过Java - Java13数组操作

数组操作

没有特殊说明，我的这个系列的Java13的学习笔记都是从廖老师那里摘抄、总结过来的，侵删。

引言

兜兜转转到了大四，学过了C，C++，C#，Java，Python，学一门丢一门，到了最后还是要把Java捡起来。所以奉劝大家，面向对象还是要掌握一门，虽然Python好写舒服，但是毕竟不能完全面向对象，也没有那么多的应用场景，所以，奉劝看到本文的各位，还是提前学好C#或者Java，话不多说，直接开干！

遍历数组

• 在for each循环中for (int n : ns)，变量n直接拿到ns数组的元素，而不是索引。
• 显然for each循环更加简洁。但是，for each循环无法拿到数组的索引，因此，到底用哪一种for循环，取决于我们的需要。

打印数组内容

• 直接打印数组变量，得到的是数组在jvm中的引用地址（数组的首元素的地址）。

• 使用for each循环打印也很麻烦。幸好Java标准库提供了Arrays.toString()，可以快速打印数组内容

   import java.util.Arrays;//注意引入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));//为什么引用方法toString()的时候需要添加Arrays呢？因为要和默认的包作用域区分开来（自圆其说型=_=）
       }
   }

数组排序

• 常用的有冒泡排序，快速排序，插入排序

   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++) {
           // n个数字只需要调换n-1轮
               for (int j = 0; j < ns.length - i - 1; j++) {
               // 在对第i个数字只需要调换length-i-1轮次
                   if (ns[j] > ns[j+1]) {
                       // 交换ns[j]和ns[j+1]:
                       int tmp = ns[j];
                       // 注意这里借助了临时变量 tmp
                       ns[j] = ns[j+1];
                       ns[j+1] = tmp;
                   }
               }
           }
           // 排序后:
           System.out.println(Arrays.toString(ns));
       }
   }

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

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

  • 即变量ns本身的数组内容被改变，不是新创建了一个变量，也没有改变ns的指向，但是改变了数组内部的指向。

   	                   ┌──────────────────────────────────┐
   	               ┌───┼──────────────────────┐           │
   	               │   │                      ▼           ▼
   	         ┌───┬─┴─┬─┴─┬───┬────────┬───┬───────┬───┬──────┬───┐
   	ns ─────>│░░░│░░░│░░░│   │"banana"│   │"apple"│   │"pear"│   │
   	         └─┬─┴───┴───┴───┴────────┴───┴───────┴───┴──────┴───┘
   	           │                 ▲
   	           └─────────────────┘

• 调用Arrays.sort(ns);排序后，这个数组在内存中表示如下：

   	                   ┌──────────────────────────────────┐
   	               ┌───┼──────────┐                       │
   	               │   │          ▼                       ▼
   	         ┌───┬─┴─┬─┴─┬───┬────────┬───┬───────┬───┬──────┬───┐
   	ns ─────>│░░░│░░░│░░░│   │"banana"│   │"apple"│   │"pear"│   │
   	         └─┬─┴───┴───┴───┴────────┴───┴───────┴───┴──────┴───┘
   	           │                              ▲
   	           └──────────────────────────────┘

• 原来的3个字符串在内存中均没有任何变化，但是ns数组的每个元素指向变化了。

多维数组

• 二维数组

   // 定义一个二维数组
   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(ns.length); // 3
       }
   }

• 因为ns包含3个数组，因此，ns.length为3。实际上ns在内存中的结构如下：

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

• 如果我们定义一个普通数组arr0，然后把ns[0]赋值给它，实际上arr0就获取了ns数组的第0个元素。因为ns数组的每个元素也是一个数组，因此，arr0指向的数组就是{ 1, 2, 3, 4 }。在内存中，结构如下：

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

• 二维数组的每个数组元素的长度并不要求相同

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

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

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

• 三维数组

  三维数组就是二维数组的数组。可以这么定义一个三维数组：

   int[][][] ns = {
       {
           {1, 2, 3},
           {4, 5, 6},
           {7, 8, 9}
       },
       {
           {10, 11},
           {12, 13}
       },
       {
           {14, 15, 16},
           {17, 18}
       }
   };

• 它在内存中的结构如下：

                                 ┌───┬───┬───┐
                      ┌───┐  ┌──>│ 1 │ 2 │ 3 │
                  ┌──>│░░░│──┘   └───┴───┴───┘
                  │   ├───┤      ┌───┬───┬───┐
                  │   │░░░│─────>│ 4 │ 5 │ 6 │
                  │   ├───┤      └───┴───┴───┘
                  │   │░░░│──┐   ┌───┬───┬───┐
           ┌───┐  │   └───┘  └──>│ 7 │ 8 │ 9 │
   ns ────>│░░░│──┘              └───┴───┴───┘
           ├───┤      ┌───┐      ┌───┬───┐
           │░░░│─────>│░░░│─────>│10 │11 │
           ├───┤      ├───┤      └───┴───┘
           │░░░│──┐   │░░░│──┐   ┌───┬───┐
           └───┘  │   └───┘  └──>│12 │13 │
                  │              └───┴───┘
                  │   ┌───┐      ┌───┬───┬───┐
                  └──>│░░░│─────>│14 │15 │16 │
                      ├───┤      └───┴───┴───┘
                      │░░░│──┐   ┌───┬───┐
                      └───┘  └──>│17 │18 │
                                 └───┴───┘

• 如果我们要访问三维数组的某个元素，例如，ns[2][0][1]，只需要顺着定位找到对应的最终元素15即可。

• 理论上，我们可以定义任意的N维数组。但在实际应用中，除了二维数组在某些时候还能用得上，更高维度的数组很少使用。

命令行参数

• Java程序的入口是main方法，而main方法可以接受一个命令行参数，它是一个String[]数组。这个命令行参数由JVM接收用户输入并传给main方法：

   public class Main {
       public static void main(String[] args) {
           for (String arg : args) {
               System.out.println(arg);
           }
       }
   }

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

   public class Main {
       public static void main(String[] args) {
           for (String arg : args) {
               if ("-version".equals(arg)) {
                   System.out.println("v 1.0");
                   break;
               }
           }
       }
   }

• 上面这个程序必须在命令行执行，我们先编译它：

   $ javac Main.java

• 然后，执行的时候，给它传递一个-version参数：

   $ java Main -version
   v 1.0

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