《Java核心技术卷1：基础知识》CH3-Java的基本程序设计结构
文章目录
- 3.1 一个简单的Java程序
- 3.2 注释
- 3.3 数据类型
- 3.3.1 整型
- 3.3.2 浮点类型
- 3.3.3 char类型
- 3.3.4 Unicode和char类型
- 3.3.5 boolean类型
- 3.4 变量
- 3.4.1 变量初始化
- 3.4.2 常量
- 3.5 运算符
- 3.5.1 数学函数与常量
- 3.5.2 数值类型之间的转换
- 3.5.3 强制类型转换
- 3.5.4 结合赋值和运算符
- 3.5.5 自增与自减运算符
- 3.5.6 关系和boolean运算符
- 3.5.7 位运算符
- 3.5.8 括号与运算符级别
- 3.5.9 枚举类型
- 3.6 字符串
- 3.6.1 子串
- 3.6.2 拼接
- 3.6.3 不可变字符串
- 3.6.4 检测字符串是否相等
- 3.6.5 空串与null串
- 3.6.6 码点与代码单元
- 3.6.7 String API
- 3.6.8 联机阅读API文档
- 3.6.9 构建字符串
- 3.7 输入输出
- 3.7.1 读取输入
- 3.7.2 格式化输出
- 3.7.3 文件输入与输出
- 3.8 控制流
- 3.8.1 块作用域
- 3.8.2 条件语句
- 3.8.3 循环语句
- 3.8.4 确定循环
- 3.8.5 多重选择：switch语句
- 3.8.6 中断控制流程语句
- 3.9 大数值
- 3.10 数组
- 3.10.1 foreach循环
- 3.10.2 数组初始化以及匿名数组
- 3.10.3 数组拷贝
- 3.10.4 命令行参数
- 3.10.5 数组排序
- 3.10.6 多维数组
- 3.10.7 不规则数组
- Java过时的技术栈
3.1 一个简单的Java程序
public class FirstSample
{
public static void main(String[] args)
{
System.out.println("We will not use 'Hello, World!'"); // 在cmd中输出文本We will not use 'Hello, World!'
System.out.println("println方法，输出文本后会换行");
System.out.print("print方法，输出文本后不会换行");
}
}
- Java区分大小写，
main不能写成Main； public是访问修饰符，用于控制程序的其他部分是否能对这段代码进行访问；class后面紧跟类名，类名的命名遵循驼峰命名法，例如MyFirstClassName；- 源代码的文件名必须与类名一致，例如本例的源代码文件名必须为
FirstSample.java； - 每个Java程序都必须要有一个
main方法； - 一般来说，
main方法的访问修饰符，一定是public；
3.2 注释
- Java的注释不会被编译，不会出现在可执行程序中，因此可以在源代码中添加任意多的注释，而不必担心代码膨胀；
// 以下是Java的三种注释方法
public class FirstSample
{
public static void main(String[] args)
{
System.out.println("demo"); // 注释的第一种方法：单行注释
/*
注释的第二种方法：多行注释，而且不能嵌套
*/
}
}
/**
* 注释的第三种方法
* 可用于自动的生成文档
* 一般作为java源代码的头部注释
* /
3.3 数据类型
- Java是强类型语言，即是说，要对每一个变量声明一种类型；
- Java的8种基本数据类型：
- 4种整型：
int，4字节；short，2字节；long，8字节；byte，1字节； - 2种浮点类型：
float，4字节；double，8字节； - 1种用于表示Unicode编码的字符单元：
char - 1种逻辑值：
boolean
- 4种整型：
- 常用的
String/BigDecimal/BigInteger等，不是基本数据类型，而是Java自定义的对象；
3.3.1 整型
- 整型包含四种：
int，4字节，范围为[-2^31, 231)；`short`，2字节，范围为[-215, 215)；`long`，8字节，范围为[-264, 264)；`byte`，1字节，范围为[-27, 2^7)； - 数字的字面值可以加上下划线，增加易读性；例如，1_000_000表示一百万，Java编译器会自动去除下划线；
3.3.2 浮点类型
float，单精度浮点数，4字节；数值后有一个F或f后缀表示，例如3.14F；double，双精度浮点数，8字节；数值后有D或d后缀表示，也可以不用后缀，例如3.14D/3.14；- 特殊浮点数：
Double.POSITIVE_INFINITY表示正无穷大；Double.NEGATIVE_INFINITY表示负无穷大；Double.NaN表示NaN，即不是一个数字；Double.isNaN(3.14)，用于判断3.14是否为数字；
3.3.3 char类型
- char类型常量要用单引号表示，例如，
'A'表示编码值65所对应的字符常量；而"A"则是字符串；
# 转义字符
\b 退格
\t 制表
\n 换行
\r 回车
\" 文本形式的双引号
\' 文本形式的单引号
\\ 反斜杠
3.3.4 Unicode和char类型
- Java中，char类型描述了UTF-16编码的一个代码单元；
- 但是强烈建议，在程序中不要使用char类型，最好将字符串作为抽象数据类型处理；
3.3.5 boolean类型
boolean，布尔值只有两种，true/false；- Java中，布尔值不能与0/ 1互相替代；
3.4 变量
- Java的变量名，是由字母开头、且由字母或数字构成的序列；
- 尽管
$是一个合法的Java字符，但在个人编码中不要使用；它只用于Java编译器或其他工具生成的名字中； - 不能使用Java保留字作为变量名；
- 尽量不要在一行中声明多个变量，逐一声明每个变量可以提高程序的可读性；
3.4.1 变量初始化
- 声明一个变量之后，必须进行显式的初始化，否则无法使用；
- 在Java中，变量的声明最好靠近第一次使用的地方，这是一种良好的编程习惯；
3.4.2 常量
- 常量，用
final修饰；一旦被赋值之后，就不能再修改了；习惯上，常量名使用全大写，例如final double CM_INCH = 2.54； - 类常量：在Java中，经常希望某个常量可以在一个类中的多个方法中使用，通常将这些常量称之为类常量。使用
static final声明类常量；如果用public static final修饰，那么该类常量也可以被其他类所使用；
3.5 运算符
int a = 1;
int b = 3;
int result1 = a + b; // 加
int result2 = a - b; // 减
int result3 = a * b; // 乘
int result4 = a / b; // 除。两整数相除，输出整数；否则，输出浮点数
System.out.println(15 / 2); // 输出7
System.out.println(15.0 / 2); // 输出7.5
int result5 = a % b; // 求余，或成为取模
3.5.1 数学函数与常量
在java.lang.Math类中，Java自带了很多数据函数，使用起来很广泛、很方便。
// 常用数学计算类：Math类
Math.sqrt(4); // 4的平方根
Math.pow(2, 5); // 2的5次方
Math.floorMod(); //
Math.sin(); // 三角函数
Math.cos();
Math.tan();
Math.atan();
Math.atan2();
Math.exp(); // 指数函数
Math.log();
Math.log10();
Math.PI; // π
Math.E; // 自然常量e
Math.round(9.99); // 对9.99进行四舍五入，输出10，且为long类型
// 也可以通过静态导入Math类，就不必再方法名和常量名前面添加前缀"Math"
import static java.lang.Math.*;
System.out.println(Math.sqrt(PI)); // 不使用静态导入
System.out.println(sqrt(PI)); // 使用静态导入
3.5.2 数值类型之间的转换
Java的8种数据类型之间的转换，可能存在数据精度缺失的情况。
3.5.3 强制类型转换
// 类型转换demo
double x = 9.997;
int nx = (int)x; // 将float类型的x，强制转换为int类型；截断了小数点后的数字，因此输出为9
int nx2 = (int)(Math.round(x)); // 输出为10
3.5.4 结合赋值和运算符
x += 4;
x = x + 4; // 二者等价，但我更喜欢第二种写法，理解清晰
3.5.5 自增与自减运算符
int x = 10;
x++; // 自增
x--; // 自减。一般这两种写法用于指针计算
3.5.6 关系和boolean运算符
int a = 3;
int b = 5;
System.out.print(a == b ? 1 : 0); // 相等运算符
System.out.print(a != b ? 1 : 0); // 不等运算符
System.out.print(a < b ? 1 : 0); // 小于运算符
System.out.print(a > b ? 1 : 0); // 大于运算符
System.out.print(a <= b ? 1 : 0);
System.out.print(a >= b ? 1 : 0);
System.out.print(a > 0 && b > 0 ? 1 : 0); // 逻辑与
System.out.print(a > 0 || b > 0 ? 1 : 0); // 逻辑或
3.5.7 位运算符
& // and
| // or
^ // xor
~ // not
<< // 右移
>> // 左移
>>> // 左移，且用0填充高位
3.5.8 括号与运算符级别
3.5.9 枚举类型
有时候，变量的取值仅在一个范围之内，例如，衣服的尺寸只有S/ M/ L；这种情况下，可以自定义枚举类型。枚举包括有限个命名的值。枚举一般用大写表示；
enum Size {SMALL, MEDIUM, LARGE};
System.out.println(Size.SMALL);
// Java不同数据类型的变量相互转换的方法，以下是伪代码展示
[String] = String.valueOf([int]); // int -> String，方法一
[String] = Integer.toString([int]); // int -> String，方法二
[String] = [int] + ""; // int -> String，方法三
[byte] = Byte.parseByte([String]); // String -> byte
[short] = Short.parseShort([String]); // String -> short
[int] = Integer.parseInt([String]); // String -> int
[long] = Long.parseLong([String]); // String -> long
[float] = Float.parseFloat([String]); // String -> float
[double] = Double.parseDouble([String]); // String -> double
[String] = "" + [double]; // double -> String
[String] = String.valueOf([double]); // double -> String
String str = String.format("%.2f", [double]); // 保留两位有效数字
String str = String.format("%02d", [int]); // 保留至少两位十进制整数
System.out.println(String.format("%02d", 5)); // 输出05
// 输出给定长度的字符串
System.out.println(String.format("%-10s", "test")); // 输出"test "，在右侧补足10位
System.out.println(String.format("%10s", "test")); // 输出" test"，在左侧补足10位
// int变量的进制转换
int n = 100;
String str = Integer.toBinaryString(n); // 十进制转换为二进制字符串
String str = Integer.toOctalString(n); // 十进制转换为八进制字符串
String str = Integer.toHexString(n); // 十进制转换为十六进制字符串
String str = Integer.toString(n, [r]); // 十进制转换为r进制字符串
String str = Long.parseLong([String], [r]); // 将字符串代表的数字，从r进制转化为十进制
// 四舍五入
long round1 = Math.round(1.499);
long round2 = Math.round(1.5);
int a = (int)Math.ceil(1.1); // 向上取整，返回2
int b = (int)Math.floor(1.1); // 向下取整，返回1
3.6 字符串
从概念上说，Java字符串就是unicode字符序列。Java没有内置的字符串类型，而是在标准Java库中提供了一个预定义类，String类，定义在java.lang.String中。每个用双引号括起来的字符串，都是String类的一个实例；
3.6.1 子串
str.substring(a, b)函数截取str字符串，从而生成一个子串。其中，a是开始截取的位置，b是结束截取的位置，且为左闭右开；子串的长度为b-a；
String str1 = "Hello";
String str2 = "H.e.l.l.o";
String str3 = str.substring(0, 3); // str3 = "Hel"
String[] arr1 = str2.split("\\."); // 将str2按.分割，生成数组；注意，.是正则表达式，因此这里要对.进行转义
String[] arr2 = str.split("[\\+\\-\\*\\/]"); // 将str2按+-*/分隔，生成数组；同样这里也要使用\\进行转义
3.6.2 拼接
Java允许使用+拼接多个字符串，甚至可以将字符串和非字符串拼接起来，从而转换为字符串对象；
str1 = "a" + "b" // 拼接两个字符串，生成一个新字符串"ab"
str2 = "a" + 1 // 拼接字符串与int，生成一个新字符串"a1"
str3 = String.join(" / ", "a", "b", "c"); // 用定界符/，将abc串联在一起，生成一个新字符串"a / b / s"
3.6.3 不可变字符串
java.lang.String类中没有提供修改字符串的方法，因此String类的对象被称为不可变字符串；- 在复制字符串变量的时候，新变量和旧变量指向相同的内存地址，共享相同的字符；
3.6.4 检测字符串是否相等
比较两个字符串对象是否相等，只能用str1.equals(str2)函数，决不能用==符号；
str1 = "hello";
str2 = "HELLO";
boolean bool1 = str1.equals(str2); // 字符串不相等，返回false
boolean bool2 = str1.equals("hello"); // 字符串变量与字符串字面值对比，返回true
boolean bool3 = str1.equalsIgnoreCase(str2); // 不区分大小写的条件下，判断两字符串是否相等，返回true
3.6.5 空串与null串
- 空串
""是长度为0的字符串； - String变量可以存放一个特殊的值
null；
if (str.length() == 0) // 判断str是否为空串
if (str.equals("")) // 判断str是否为空串
if (str == null) // 判断str是否为null串
3.6.6 码点与代码单元
Java的字符串由char值序列组成；
str = "Hello";
char first = str.charAt(0); // 返回str的位置0的代码单元
char last = str.charAt(4); // 返回str的位置4的代码单元
3.6.7 String API
char charAt(int index)
int codePointAt(int index)
int offsetByCodePoints(int startIndex, int cpCount)
int compareTo(String other)
IntStream codePoints()
new String(int[] codePoints, int offset, int count)
boolean equals(Object other)
boolean equalsIgnoreCase(String other)
boolean startsWith(String prefix)
boolean endsWith(String suffix)
int indexOf(String str)
int indexOf(String str, int fromIndex)
int indexOf(int cp)
int indexOf(int cp, int fromIndex)
int lastIndexOf(String str)
int lastIndexOf(String str, int fromIndex)
int lastIndexOf(int cp)
int lastIndexOf(int cp, int fromIndex)
int length()
int codePointCount(int startIndex, int endIndex)
String str2 = str1.replace([oldString], [newString]); // 替换字符串对象str1中的某些字符，将[a]替换为[b]
String substring(int beginIndex)
String substring(int beginIndex, int endIndex)
String str2 = str1.toLowerCase(); // 将字符转换为小写
String str2 = str1.toUpperCase(); // 将字符转换为大写
String trim()
String join(CharSequence delimiter, CharSequence... elements)
String str = String.valueOf([char]); // 将char转化为String对象
boolean str.matches([reg]); // 判断str是否满足[reg]，可使用正则表达式
boolean str.matches("[\u4e00-\u9fa5]"); // 判断str是否只由汉字组成
boolean str.matches("[A-Z][a-z]"); // 判断str中是否只由大写字母、或只由小写字母组成
boolean str.matches("[A-Za-z]"); // 判断str中是否由大写字母、及小写字母组成
boolean str.matches(".*[A-Za-z]+.*"); // 判断str是否包含字母
boolean str.contains([str1]); // 判断str是否包含str1
3.6.8 联机阅读API文档
String类中常用的有50多个方法，而Java标准库中有上千各类，上万种方法。想要记住所有的类和方法是不可能的，因此要善于使用API文档。
3.6.9 构建字符串
- 在每次截取、拼接字符串的时候，都会构建一个新的String对象，既耗时又浪费空间，而使用字符串构造器，
StringBuilder类可以有效规避这一问题； - 字符串缓冲器
StringBuffer类，与字符串构造器StringBuilder类的API完全相同；前者效率稍低，但适用于多线程；后者则适用于单线程；
ch = 'A';
str = "Hello";
StringBuilder builder = new StringBuilder();
builder.append(ch); // 插入字节
builder.append(str); // 插入字符串
String result = builder.toString(); // 将StringBuilder对象转化为String对象
// ----------------------------------------------------------
// StringBuilder类的常用API
StringBuilder()
int length()
StringBuilder append(String str)
StringBuilder append(char ch)
StringBuilder appendCodePoint(int cp)
void setCharAt(int i, char c)
StringBuilder insert(int offset, String str)
StringBuilder insert(int offset, Char c)
StringBuilder delete(int startIndex, int endIndex)
String toString()
3.7 输入输出
Java程序可以从GUI等操作界面获取输入，也可以从控制台接受键盘的输入。
3.7.1 读取输入
import java.util.Scanner; // 输入控制流相关类
import java.util.Console; // 用于读取不可见的控制台输入，例如输入密码；但使用不如Scanner类方便
public class Demo
{
public static void main(String[] args)
{
Scanner scanner = new Scanner(System.in); // 从控制台获取数据，例如键盘
scanner.hasNext(); // 返回布尔值；若有输入数据，则返回true；反之则返回false
scanner.hasNextInt(); // 检测是否还有int数值输入
scanner.hasNextDouble(); // 检测是否还有double数值输入
String str1 = scanner.nextLine(); // 读取键盘输入的每一行字符串
int a = scanner.nextInt(); // 读取键盘输入的整数
double b = scanner.nextDouble(); // 读取键盘输入的浮点数
String str2 = scanner.next(); // 以空白符、回车符作为分隔符，读取第一个单词
Console console = new Console();
String str3 = console.readLine("User name: ");
char[] str4 = console.readPassword("Password: "); // 为安全起见，将输入的密码存放在char中
}
}
3.7.2 格式化输出
System.out.print("Hello World"); // 简单输出，输出文本后不换行
System.out.println("Hello World"); // 简单输出，输出文本后换行
System.out.printf("Hello World"); // 简单输出
System.out.printf("Hello World %s Hello %d", "ABC", 100); // %是格式说明符，%s表示"ABC"，%d表示100
。。。。待补充
3.7.3 文件输入与输出
// 读取文件
import java.util.Scanner; // 输入流的类
import java.nio.file.Paths; // 文件路径相关的类
import java.io.PrintWriter; // 输出流的类
Scanner scanner1 = new Scanner(Paths.get("file.txt"), "UTF-8");
Scanner scanner2 = new Scanner(Paths.get("C:\\MyDirectory\\file.txt"), "UTF-8"); // Windows系统文件路径的反斜杠前面，要再加个反斜杠
Scanner scanner2 = new Scanner(Paths.get("home/MyDirectory/file.txt"), "UTF-8"); // Linux系统文件路径
// 写入文件
PrintWriter printWriter = new PrintWriter("file.txt", "UTF-8"); // 若文件不存在，则直接创建
3.8 控制流
条件语句、循环语句、笨重的switch、foreach循环
3.8.1 块作用域
- 块block，是由一对大括号括起来的若干条简单的Java语句；
- 块，决定了变量的作用域；
- 互相嵌套的两个块中，不能有同名的两个变量；
3.8.2 条件语句
if (yourSales > target)
{
System.out.println("result1");
} else if (yourSales = target)
{
System.out.println("result2");
} else (yourSales < target)
{
System.out.println("result3");
}
3.8.3 循环语句
while (yourSales > target) // 简单while循环
{
System.out.println("result1");
target = target + 1; // 计数器
}
// --------------------------
do // do-while循环，至少执行一次
{
System.out.println("result1");
target = target + 1; // 计数器
}
while (yourSales > target)
3.8.4 确定循环
for循环是while循环的简化形式
for (int i = 0; i <= 10; i++)
{
System.out.println("result1");
}
3.8.5 多重选择：switch语句
- 适用于处理多个选项的场景下，替代if-else语句；
- 实际开发中并不推荐，因为忘记写break会导致程序无限制的执行下去；
- case标签可以是char/ byte/ short/ int的常量表达式、枚举值、字符串字面值；
switch (choice)
{
case 1:
System.out.println("result1");
break; // 语句块的中止
case 2:
System.out.println("result2");
break;
case 3:
System.out.println("result3");
break;
case 4:
System.out.println("result4");
break;
default: // 默认值
System.out.println("result_detault");
break;
}
3.8.6 中断控制流程语句
break，用于退出循环语句；- 带标签的
break，跳转到带标签的语句块末尾； continue，用于将控制转移到最内层循环的首部；- 即便不适用
break和continue也可以表达相同的逻辑含义，因此可以不适用；
3.9 大数值
Java的基本数据类型，int和decimal是有范围限制的。int变量无法描述太大的数值，decimal变量无法描述小数位太多的数值，因此需要使用BigInteger BigDecimal两个类实现任意精度的整数运算、浮点数运算
import java.Math.BigInteger;
import java.Math.BigDecimal;
int a = 100;
int b = 200;
BigInteger a1 = BigInteger.valueOf(a); // 将int变量a转化为BigInteger对象a1
BigInteger b1 = BigInteger.valueOf(b);
BigInteger c1 = a1.add(b1); // BigInteger对象相加
BigInteger c2 = a1.substract(b1); // BigInteger对象相减
BigInteger c3 = a1.multiply(b1); // BigInteger对象相乘
BigInteger c4 = a1.divide(b1); // BigInteger对象相除
BigInteger c5 = a1.mod(b1); // 返回BigInteger的和、差、积、商、余
int c6 = a1.compareTo(b1); // 若a1b1，则返回正数
// --------------------------------------------------------------------------
double x = 5.56;
double y = 8.12;
BigDecimal x1 = BigDecimal.valueOf(x); // 将long或double类型变量，转化为BigDecimal对象
BigDecimal y1 = BigDecimal.valueOf(y);
BigDecimal z1 = x1.add(y1); // 求和
BigDecimal z2 = x1.substract(y1); // 求差
BigDecimal z3 = x1.multiply(y1); // 求积
BigDecimal z4 = x1.divide(y1, RoundingMode.HALF_UP); // 以四舍五入方式返回商
int z5 = x1.compareTo(y1); // 若a1b1，则返回正数
BigDecimal z6 = x1.valueOf(x, [scale]); // 返回x/10^scale的BigDecimal对象
3.10 数组
- 数组可以分为：一维数组、多维数组、不规则数组；
- 数组是一种数据结构，用于存储同一类型值的集合；通过一个整型下标可以访问数值中的每一个值；
- 数组的下标从0开始；
- 一旦创建了数组，就不能再改变其长度，但可以改变每一个元素的值；另一种数据结构，数组列表
ArrayList却可以改变其长度； - 数组的长度不要求是常量，可以是变量；
3.10.1 foreach循环
foreach循环用于依次处理数组中的每个元素，而不必为指定下标值而分心，是一种强力的循环结构，也是for循环的简化
int[] a = {1, 2, 3, 4, 5};
for (i : a)
{
System.out.println(i);
}
3.10.2 数组初始化以及匿名数组
Array类，是Java中一种基本的数据结构，用于声明数组类，由于定义在java.lang.Array中，属于Java的基础类，因此不需要import也可以使用；Arrays类，是静态类，用于对数组进行排序、搜索、转化等操作，需要import才能使用；
import java.util.Arrays;
public class FirstSample
{
public static void main(String[] args)
{
int[] a; // 声明了一个整型数组a，常用
int b[]; // 声明了一个整型数组b，不常用
int[] c = new int[100]; // 创建一个可存储100个int的整型数组c
int[] d = {1, 2, 3, 4, 5}; // 创建数组对象
d = new int[] {1, 2, 3, 4}; // 使用匿名数组，重新初始化数组d
int[] e = d; // 数组拷贝，d、e两个变量引用同一个数组
int[] f = Arrays.copyOf(e, e.length); // 将数组e中的所有元素拷贝到数组f中，一般用于扩充数组或截断数组
int[] copyOfRange_e = Arrays.copyOfRange(e, 0, 10); // 返回一个与e类型相同的数组，起始下标为0，终止下标为10
Arrays.sort(d); // 对数组c进行排序，sort()方法使用的是优化后的快速排序算法
String str_d = Arrays.toString(d); // 将数组d转化为字符串
int x = Arrays.binarySearch(e, 1); // 在数组中查找元素1
Arrays.fill(e, 10); // 将数组e中所有元素值设置为10
boolean bool_x = Arrays.equals(a, b); // 比较两个数组，若相同，则返回true
float g = Math.random(); // 返回一个[0, 1)之间的随机浮点数
int h = (int) (Math.random() * 100); // 返回一个[0, 100)之间的随机整数
for (int i = 0; i < 100; i++) // 给数组赋值
{
a[i] = i;
}
for (int i : a) // foreach循环，更加简洁，且不需要关注数组的元素个数，从而避免了超出数组边界的问题，因此适用于数组、集合
{
System.out.println(i);
}
// 向数组中增加元素，方法一
List<Integer> list = new ArrayList<Integer>(); // 使用动态数组
list.add(1); // 增加元素
list.add(2, 0); // 在下标为2的位置增加元素
System.out.println(list);
// 向数组中增加元素，方法二
int[] f = Arrays.copyOf(e, e.length + 1); // 新建数组并扩充数组长度
f[e.length] = 10;
System.out.println(a.length); // 输出数组的元素个数。注意，这里的length不是方法，是数组的属性
System.out.println(Arrays.toString(a)); // 将数组转化为字符串，打印出来
ArrayList<Integer> arrayList = new ArrayList<Integer>;
arrayList = Arrays.asList(a); // 数组转化为动态数组
int[] a1 = arrayList.toArray(); // 动态数组转化为数组
}
}
3.10.3 数组拷贝
3.10.4 命令行参数
java程序的命令行参数public static void main(String[] args)，其实接收的也是一个字符串数组
3.10.5 数组排序
3.10.6 多维数组
二维数组用于描述表格类的数据，也成为矩阵。
double[][] a; // 声明一个二维数组，元素类型为double
int[][] b =
{
{1, 2, 3}
, {4, 5, 6}
, {7, 8, 9}
}; // 初始化二维数组
int c = b[2][1]; // 访问二维数组中的元素，下标为[2][1]
for (int[] x : a) // 遍历二维数组的每一个元素
for (int i : x)
{
System.out.println(i);
}
System.out.println(Arrays.deepToString(b)); // 快速打印二维数组
boolean x = Arrays.deepEquals(a, b); // 判断两个多维数组是否相等
3.10.7 不规则数组
Java实际上是没有多维数组的，只有一维数组；多维数组被解释为“数组的数组”；
Java过时的技术栈
- Applet：在网页中运行的Java程序，被称为Applet。Applet原本是将Java嵌入html中，作为前端页面的一种功能的扩展；开发的时候需要jdk环境，运行的时候需要jre环境。目前HTML5已经放弃对Applet的支持，Applet被JavaScript取代，可以说它是完全被淘汰了；
- Java Swing：用于开发桌面应用的Java原生类；由于目前程序多基于Web浏览器展示，客户如果使用Swing程序，那么还需要安装jre运行环境，但开发者不可能要求成千上万的用户都去安装jre。因此Java Swing在2010年之前就被淘汰了；
- JSP：jsp和HTML耦合在一起开发，前者负责动态，后者负责静态；后来流行前后分离的架构思想，于是jsp也就没落了；
- Java ME：用于开发手机等移动设备、嵌入式设备的Java语言平台，随着塞班的死亡而死亡；