第3章 Java的基本成设计结构

3.1 一个简单的 Java程序

public class FirstSample{public static void main(String[] args){System.out.println("We will not user \"Hello, World\"");System.out.print("不换行输出");}
}//javac -encoding UTF-8

• Java区分大小写
• 关键字 public 称为访问修饰符 (access modifier)，用于控制程序的其他部分对代码的访问级别。
• 关键字 class 表名 Java 程序中的全部内容都包含在类中。
• class 后跟类名，类名必须以字母开头，后面可以跟字母和数字的任意组合。不能使用Java保留字。
  • 类名的标准命名规则：类名是以大写字母开头的名词。如有多个单词，每个单词首字母大写。
    • 称为 驼峰命名法
• 源代码的文件必须与公共的类名相同，并用 .java 作为扩展名。
• 运行一个以编译的程序，Java虚拟机重视从指定类中 main方法 的代码开始执行。

3.2 注释

//当行注释/*
多行注释
*//**
文档注释
*/

3.3 数据类型

​ Java是一种强类型语言。每个变量必须声明一个类型，一共有 8种 基本类型(primitve type)，4种整型 、 2种浮点型 、 1种字符型（用于表示 Unicode 编码的代码单元）和 1种用于表示真值的 boolean类型。

​ Java有一个表示任意精度的算数包，大数（big number） 是 Java对象，不是基本 Java类型。

3.3.1 整型

类型	存储需求
int	4字节
short	2字节
long	8字节
byte	1字节

​ 在Java中，整型的范围与运行Java代码的机器无关。

​ 长整型数值有一个后缀 L 或 l。十六进制数值前缀 0X 或 0x，八进制数值前缀 0、二进制数值前缀 0b 或 0B。 如果用 1_000_000（或者 0b1111_0100_0010_0100_0000）表示 100万。下划线为了易读，Java 编译器会去除这些下划线。

​ Java没有无符号形式的整型类型。

3.3.2 浮点型

类型	存储需求
float	4字节
double	8字节

​ double表示的数值精度是float类型的两倍。float类型的精度 6~7为有效数字。

​ float类型的数值加后缀 f 或F 。double类型数值后也可以加后缀 d 或 D （无伤大雅，因为默认是 double）。

​ 可以使用 16进制表示浮点数字面量。如 0.125 = $$2^{-3}$$ 可以写成 $$0X1.0p^{-3}$$。在十六进制表示法中，使用 p 表示指数，而不是 e。尾数采用十六进制，指数采用十进制。指数的基数是3，而不是10.

所有的浮点数计算都遵循 IEEE754 规范。有3个特使的浮点数值表示溢出和出错情况：

• 正无穷大：Double.POSITIVE_INFINITY
• 负无穷大：Double.NEGATIVE_ININITY
• NaN（不是一个数）：Double.NaN

如果命令 System.out.println(2.0-1.1)将打印出 0.8999999999999999，而不是 0.9。因为 浮点数值采用二进制表示，而在二进制系统中无法精确地表示分时 1/10，就像十进制无法精确地表示 1/3 一样。需要精确运算应使用 BigDecimal 类。

3.3.3 char 类型

​ char类型表示单字符。有些 Unicode字符可以用一个 char 值表述，有些则需要两个 char 值。

​ char类型的字面量要用单引号括起来，‘A’。它与 “A” 不同，"A"是包含一个字符的字符串。char类型的值可以表示为 十六进制值，其范围从 \u0000 ~ \uFFFF。

特殊字符的转移序列:

转移序列	名称	Unicode值
\b	退格	\u0008
\t	制表	\u0009
\n	换行	\u000a
\r	回车	\u000d
\f	换页	\u000c
\"	双引号	\u0022
\’	单引号	\u005c
\\	反斜杠	\u005c
\s	空格。在文本块中用来保留末尾空白符	\u0020
\newline	只在文本块中使用：连接这一行和下一行	—
—		—
—		—

3.3.3 boolean 类型

​ boolean（布尔）类型 有连个值：false 和 true，用来判定逻辑条件。整型值和布尔值之间不能进行相互转换。

3.4 变量与常量

​ Java使用变量来存储值，常量就是值不变的变量。

3.4.1 声名变量

​ 在Java中，每个变量都有一个类型（type）。声明变量，先指明类型，后是变量名，以分好结尾。

数据类型 变量名;
数据类型 变量名1, 变量名2, ...;

变量名：

• 由字母、数字、货币符号以及"标点连接符"组成

• 第一个字符不能是数字

• 不能为Java关键字

• 区分大小写

• 推荐使用小驼峰命名法

3.4.3 初始化变量

​ 声明一个变量后，必须用赋值语句显式地初始化变量，未初始化的变量值不能调用。

​ 对变量进行赋值，需要将变量名放在等号（=）左侧，把适当值的 Java 表达式放在等号的右侧。

​ 从 Java10 开始，对于局部变量，可以从变量的初始值推断出它的类型。只需要使用关键字 var 无须指定类型。

3.4.3 常量

​ 在Java中，可以用 final 指示常量。

final 数据类型 常量名；

​ 关键字 final 表示这个变量只能被赋值一次。一旦赋值，就不能再更改了。

​ 常量名推荐是用全大写。

3.4.4 枚举类型

​ 枚举类型包括有限个命名值

//例如
enum Size{SMALL,MEDIUM,LARGE,EXTRA_LARGE};Size s = Size.MEDIUM;
//Size 类型的变量只能存储这个类型声明中所有列的某个值，或特殊值 null，null表示这个变量没有设置任何值。

3.5 运算符

​ 运算符用于连接值。

3.5.1 算术运算符

​ 在Java中，使用通常的算术运算符 +、-、*、/、%分别表示 加、减、乘、除和取余运算。当 /运算的两个操作数都是整数时，/表示整数除法；否则，表示浮点数除法。

​ 整除被0除将产生一个异常，而浮点数被0除将会得到一个无穷大或NaN结果。

​

3.5.2 数学函数与常量

​ Math类中包含可能会用到各种数学函数。

double x =4;
double y = Math.sqrt(x);//求平方根//求密运算，表示 x的a次方。
double y = Math.pow(x,a);

​ floorMod方法是为了解决长期存在有整数余数的问题。在Java中 %不符合数学上严格的模运算定义，而floorMod方法为了解决此问题。

例如整数 x,y 来说，取模运算和取余运算的过程相同：

1. 求整数商: $$c=a/b$$

2. 计算模或者余数：$$r=a-c\ast b$$

   只是取模和取余在第一步求商的方法上有所不同：取余运算在取 $$c$$ 的值时，向 0 方向舍入（fix()函数）；取模运算在计算 $$c$$ 的值时，向负无穷方向舍入（floor()函数）。

//Math类常用的三角函数：
Math.sin;  
Math.cos;
Math.tan;
Math:atan;
Math:atan2;//提供了指数函数以及它的反函数——自然对数和以10为底的对数：
Math.exp;
Math.log;
Math.log10;//提供了连个常量来表示 π 和 e 常量最接近的近似值：
Math.PI;
Math.E;

​ Math类为了达到最佳性能，所有的方法都使用计算机浮点单元中的例程。

​ 如果得到一个完全可预测的结果比运行速度更重要的话，就应该使用 StrictMath类，它实现了 “可自由分发数据库” 的算法，确保所有平台上得到相同的结果。

3.5.3 数据类型之间的转换

​ 图中有6个实线箭头，表示无信息丢失的转换；有3个虚线箭头，表示可能会精度损失的转换。

​ 当用一个二元操作符连接两个值时，先要将两个操作数转换为同一种类型，然后再进行计算。

3.5.4 强制类型转换

​ 强制类型转换的语法格式是原圆括号中指定想要转换的目标类型，后面紧跟待转换的变量名。

//例如
double x = 10.0;
int nx = (int) x;//通过截断小数部分将浮点数转换为整型， nx = 9int nx = (int)Math.round(x);//通过舍入一个浮点数来得到最接近的整数, nx = 10

3.5.5 赋值

​ 在 Java 中赋值是一个表达式(expression)。它有一个值，可以使用这个值完成一些操作。

//例
int x =4;
x += 4;//可以使用二元运算符简化 ， x = x+4;(int)(x+=4.1);//运算符得到一个值，类型与左侧操作数的类型不同，就会发生前置类型原话

3.5.6 自增与自减运算符

自增、自减运算符有两种形式：

• 前缀形式：++n/–n;
• 后缀形式： ++n/–n;
  • 前缀形式会先完成 加/减 1；而后缀形式会使用变量原来的值

3.5.7 关系和 boolean运算符

• 关系运算符

  • ==
  • !=
  • >
  • >=
  • <
  • <=
  • &&
  • ||
  • !

• boolean运算符

  • true
  • false

  3.5.8 条件运算符

  ​ Java提供了 conditional ?:运算符，可以根据一个布尔表达式选择一个值。

  //例
  conditional ? expression1 : epression2;
  //conditional: true  expression1
  //conditional: false expression2
  

  3.5.9 Switch表达式

  ​ 需要再两个以上中做出选择事，可以使用Switch表达式(Java14中引入的)

  //例
  String seasonName = switch(seasonCode){case 0 ->"Spring";case 1 ->"Summer";case 2 ->"Fall";case 3 ->"Winter";default -> "??";
  };
  //case标签还可以是 字符串 或 枚举型常量
  //如果使用 整数 或 String 操作数的 switch表达式 必须有一个 default。
  //如果操作数为 NULL，会抛出一个 NULLPointerException
  

3.5.10 位运算符

• &(“and”)
• |(“or”)
• ^(“xor”)
• ~(“not”)
• >>：有符号右移，若正数,高位补0,负数,高位补1 /
• <<:有符号左移，若正数,高位补0,负数,高位补1 *
• >>>：无符号右移

3.6 字符串

​ Java字符串就是 Unicode 字符序列。Java没有内置的字符串类型，而是标准 Java类库 中提供了一个预定一类，叫 String类。

3.6.1 子串

​ String类的substring方法可以从一个较大的字符串中提取出一个子串。

//例
String greeting = "hello";
String s = greeting/sibstromg(0,3); //左闭右开 [0,3)。Java字符串的代码单元和码点从 0 开始计数。
//s = "he"

​ substring：容易计算出子串长度，字符串s.substring(a,b) 的长度为 b-a。

3.6.2 拼接

​ Java语言允许使用 + 号连接（拼接）两个字符串。无关 +号前后与 字符串 相加 都会转换称 字符串。

//如果需要把多个字符串放在一起，用一个界定符分隔，可以使用静态 join方法
String all = String.join(" / ","S","M","L","XL");
//all = S / M / L / XL//Java11中，提供一个 repeat方法
String repeated = "java".repat(3);//repeated = javajavajava

3.6.3 字符串不可变

​ String类没有提供任何方法来修改字符串的某个字符。修改字符串，可以用字符串替换和拼接方式来实现。

​ String类的对象是不可变的（immurable).。

​ 可以修改字符串的变量的内容，让它指向另一个字符串。

​ 字符串存放在一个公共存储池中，字符串变量指向存储池中相应的位置。如果想复制一个字符串，可以直接把要共享的字符串的位置给想要复制字符串的变量中。

​ Java会自动完成垃圾回收，不会产生内存泄漏。

3.6.4 检测字符串是否相等

​ 可以使用 equals方法 判断字符串是否相等，相等为 true，否则为false；想要不区分大小写检测是否相等，可以使用 equalsIgonreCase方法。

​ 不能使用 == 运算符检测两个字符是否相等。== 只能确定两个字符串是否存放在同一个位置上。但是 ，有可能多个相等的字符串副本存放的在不同的位置上。

​ 只用字符串字面量会共享，而 + 或 substring等操作得到的字符串不共享。

3.6.5 空串与NULL串

​ 空串是一个Java对象，有子串的长度（0）和内容（空）。

​ String变量还可以存放一个特殊值 null，表示没有任何对象与该变量关联。

3.6.6 码点与代码单元

​ Java字符串是一个 char序列。char数据类型是采用 UTF-16编码表示 Unicode码点的一个代码单元。常用的Unicode字符可以用一个代码单元表示，而辅助字符需要一对代码单元表示。

​ String.length方法返回采用 UTF-16编码表示给定字符串所需要的代码单元个数。

​ String.codePointCount(0,String.length())表示码点个数。

​ 调用String.charAt(n)将返回n的代码单元。n介于 0~String.length()-1之间。

3.6.7 String API

常用的方法（类名后是版本号）：

• char charAt(int index)：返回给定位置的代码单元。
• int codePointAt(int index) 5：返回从给定位置开始的码点。
• int offsetByCodePoints(int startIndex, int cpCount) 5 ：返回从 startIndex 码点开始，cpCount 个码点后的码点索引。
• int compareTo(String other) ：按照字典顺序，如果字符串位于 other 之前，返回一个负数；如果字符串位于 other 之后，返回一个正数；如果两个字符串相同，返回 0。
• IntStream codePoints() 8 ：将这个字符串的码点作为一个流返回。调用 toArray 将它们放在一个数组中。
• new String（int[] codePoints,int offset, int count) 5：用数组中从 offset 开始的 count 个码点构造一个字符串。
• boolean isEmpty()
• boolean isBlank() 11 : 如果字符串为空或者有空白字符组成，返回为 true。
• boolean equals(Object other)：如果字符串与 other相等，返回 true。
• boolean equalsIgnoreCase(String other)：如果字符串与other相等（忽略大小写），返回true。
• boolean starsWith(String prefix)
• boolean endsWith(String suffix)：如果字符以 prefix 开头 或 以 suffix结尾，则返回true。
• int indexOf(String srt)
• int indexOf(String str,int fromIndex)
• int indexOf(int cp)
• int indexOf(int cp,int fromINdex)：返回与字符串str或码点cp相等的第一个子串的位置开始。从索引 0 或fromIndex开始匹配。如果 str 或 cp 不在字符串中，则返回-1。
• int lastIndexOf(String str)
• int lastIndexOf(String str,int fromIndex)
• int lastIndexOf(int cp)
• int lastIndexOf(int cp,int fromINdex)：返回与字符串str或码点cp相等的最后一个子串的位置开始。从索引 0 或fromIndex开始匹配。如果 str 或 cp 不在字符串中，则返回-1。
• int length()：返回字符串代码单元的个数。
• int codePointCount(int startIndex, int endIndex) 5：返回 startIndex 到 endIndex-1之间的码点数。
• String replace(CharSequence oldString, CharSequence newString)：返回一个新字符串，这是用 newString 替换原始字符串与 oldString匹配的所有子串得到的。可以用String或StringBuilder对象作为 CharSequence 参数。
• String substring(int beginIndex)
• String substring(int beginIndex, int endIndex)：返回一个新字符串，这个字符串包含原始字符串中从 beginIndex 到字符串末尾或者 endIndex-1 的所有代码单元。
• String toLowerCase()
• String toUpperCase()：返回一个新字符串，这个字符串包含原始字符串中的所有字符，不过将原始字符串中的大写字母改为小写，或者将原始字符串中的小写字母改成大写。
• String strip() 11
• String stripLeading() 11
• String stripTrailing() 11：返回一个新字符串，这个字符串删除原始字符串头部和尾部只是头部或尾部的空白符。
• String join(CharSequence delimiter, CharSequence… elements) 8：返回一个新字符串，用给定的定界符连接所有元素。
• String repeat(int count) 11：返回一个字符串，将当前字符串重复 count次。

3.6.8构建字符串

​ 字符串拼接是，都会构成一个新的String对象，即耗时，又浪费空间。使用StringBuilder类可以避免，

• 首先构建一个空的字符串构建器

  • StringBuilder builder = new StringBuilder();
  • 每次添加另外一部分时，调用append方法。
  • 构建完成时，调用 toString方法，就会得到一个String对象，包含了构建器中的字符序列。

• StringBuffer 类 的效率不如StringBuilder类，但是它允许采用多线程方式添加或删除字符。两个类的API一样。

• StringBuilder()：构建一个空的字符串构建器。

• int length()：返回构建器或缓冲器中的代码单元个数。

• StringBuilder append(String srt)：追加一个字符串并返回 this。

• StringBuilder appendCodePoint(int cp)：追加一个码点，将它转换为一个或两个代码单元并返回 this。

• void setCharAt(int i,char c)：将第 i 个代码单元设置为 c。

• StringBuilder insert(int offset,String set)：在 offset 位置插入一个字符串并返回 this。

• String toString()：返回一个字符串，其数据与构建器或缓冲器相同。

3.6.9 文本块

​ Java15新增的文本块(text block) 特性，可以容易提供多行的字符串字面量。文本以 “”" 开头(开始）,后面是一个换行符"""结尾；

//例
String Str = """""";

​ 注意转义符、开始和结束的字符 要匹配。

3.7 输入与输出

​ 使用基本对的控制台来实现输入和输出。

3.1 读取输入

​ 读取“标准输入流” System.in

• 首先构造一个与 “标准输入流” System.in 关联的 Scanner 对象
  • Scanner in = new Scanner(System.in);
• 使用 Scanner 类的各种方法
  • 进行导包，import java.util.*;
  • Scanner 类在java.util包中定义。

如果想读取密码可以使用 Conslole类

• Console cons = System.console()

java.util.Scanner 5

• Scanner(InputStream int)：用给定的输入流构造一个 Scanner 对象。
• String nextLine()：读取下一行输入。
• String next()：读取输入的下一个单词（以空白字符为分隔符）。
• int nextInt()
• double extDouble()：读取并转换下一个表示整数或浮点数的字符序列。
• boolean hasNext()：检测输入中是否还有其他单词。
• boolean hasNextInt()
• boolean hasNextDouble()：检测下一个字符序列是否表示一个整数或浮点数。

java.lang.System 10

• staticConsole console() 6：如果可能进行交互操作，通过控制台为交互的用户返回一个 Console对象，否则返回 null。对于任何一个在控制台启动的程序，都可使用 Console对象。否则，是否可用取决于所使用的系统。

java.io.Console 6

• char[] readPassword(String fmt, Object … args
• String readLine(String fmt, Object … args)：显示提示符（prompt）并读取用户输入，直到输入行结束。可选的 args 参数用来提供格式参数。

3.2 格式化输出

​ 使用 System.out.print()x 语句将数值x输入到控制台。

​ Java printf沿用了 C语言函数库中的约定

//例
System.out.printf("%8.2f",x);

​ 每一个以%字符开头的格式说明（formation specifers）都替换为响应的参数。

用于 printf 的转换字符（conversion character）

转换字符	类型	转换字符	类型
d	十进制整数	s 或S	字符串
x或X	十六进制整数	c或C	字符
o	八进制整数	b或B	布尔
f或F	定点浮点数	tx或Tx	遗留的日期时间格式化
g或G	通用浮点数	%	百分号
a或A	十六进制浮点数	n	与平台有关的行分隔符

可以使用s转换字符格式化任意的对象。如果一个任意对象实现了 Formattble接口，会调用这个对象的 formatTO方法。否则，会调用 toString方法将这个对象转换为一个字符串。

用于 printf 的标志

标志	作用
+	打正数和负数的符号
空格	在正数前面增加一个空格
0	增加前导 0
-	字段左对齐
(	将负数包围在括号内
,	增加分组分隔符
#（对于 f 格式)	总是包含一个小数点
#（对于 x 或 0 格式）	增添前缀 0X 或 0
$	指定要格式化的参数索引
<	格式化前面的指定的同一个值

可以使用静态的String.format 方法创建一个格式化的字符串，而不打印输出。

String str = String.format(内容,格式化内容)；

在 Java15中，可以使用 formatted方法

String str = “内容”.formatted(格式化的内容);

3.7.3 文件输入与输出

java.util.Scanner 5

• Scanner(Path p ,String encoding)：构造一个Scanner使用给定字符编码从给定路径读取数据。
• Scanner(String data)：构建一个Scnner从给定字符串读取数据

java.io.PrintWriter 1.1

• PrintWriter(String fileName)：构建一个 PrintWriter 将数据写入指定文件

java.nio.file.Path

• static Path of(String pathname)1 11 ：由给定的路径构造一个Path

3.8 控制流程

​ Java支持使用条件语句和循环结构来确定控制流程。

3.8.1 块的作用域

​ 块(block，即复合语句)：由若干条Java语句组成，并用一对大括号起来。块确定了变量的作用域。但是，不能在嵌套的两个块中声明同名的变量。

3.8.2 条件语句

​ 在Java中，条件语句的形式为：if(condition) statement；希望在某个条件为真时执行多条语句，可以使用块语句(block statement)。

​ 在Java中，更一般的条件语句：if(condition) statement1 else statement2；else部分总是可选地，else字句与最邻近的if构成一组。

3.8.3 循环

​ while循环会在条件为true时执行一个语句（也可以是一个块语句）。一般形式如下：while(condition) statement

![

​

​ do/while循环，循环体至少执行一次。一般形式：do statement while (condition)

3.8.4 确定性循环

​ for循环语句是支持迭代的一种通用结构，它由一个计数器或类似的变量控制迭代次数，每次迭代后和这个变量将会更新。

​ for语句的第一部分通常是对计数器初始化；第二部分给出每次新一轮执行前要检测的循环条件；第三部分指定如何更新计数器。

3.8.5 多重选择：switch语句

switch(){case ->;default ->;
}

• case 标签可以是：
  • 类型为char、byte、short 或int的常量表达式
  • 枚举常量
  • 字符串字面量
  • 多个字符串，用逗号分隔

​ switch语句从与选项相匹配的 case 标签开始执行，直到遇到下一个 break语句，或者执行到 switch语句结束。如果没有匹配的case标签，则执行default子句（如果有default子句）。

​ 如果忘记在一个分支末尾增添 break语句，就会接着执行下一个分支。

​ Java14引入一个有直通行为的Switch表示，有4中不同形式的switch。

​ 直通行为的形式：每个 case以一个结束。如果case以箭头 -> 结束，则没有直通行为。

​ switch表示中的 yield 关键字，与break类似，yield会终止行为。但与break不同的是，yield会生成一个值，这个就是表达式的值。

3.8.6 中断控制流程语句

​ Java的设计者将 goto 作为一个保留字，但实际上并不打算在语言中包含 goto。

​ 无限制地使用 goto语句的确容易导致错误，但在有些情况下，偶尔使用 goto 跳出循环是有益的。Java设计者也同意这种用看法，甚至在Java语言中增加了一条新语句：带标签的break。

​ 标签可以应用到任何语句中。

​ continue语句与break语句一样，它将中断正常的控制流程。continue语句将控制转移到最内层外围循环的首部。还有一种带标签的continue语句，将跳转到有匹配标签的循环的首部。

3.9 大数

​ 在 java.math包中两个很有用的类：BigInteger 和 BigDecimal。这个两个类可以处理任意长度数字序列的数值。BigInteger类实现任意精度的整数运算，BigDecimal实现任意精度的浮点数运算。

​ 使用静态的 valueOf 方法可以将一个普通的数转为大数。

​ 常量：BigInteger.ZERO、BigInteger.ONE 和 BigInteger.TEN，在java9之后还增加了 BigInteger.TWO。

java.math.BigInteger 1.1

• BigInteger add(BigInteger other)
• BigInteger subtract(BigInteger other)
• BigInteger multiply(BigInteger other)
• BigInteger divde(BigInteger other)
• BigInteger mod(BigInteger ohter)：返回这个大整数和另一个大整数 other 的 和、差、积、商和余数。
• BigInteger sqrt() 9：得到这个BigInteger的平方根
• int compareTo(BigInteger other)：如果这个大整数另一个大整数 other相等，返回 0；小于 ，返回负数；大于，返回正数。
• static BigInteger valueOf(long x)：返回值等于 x 的大整数。

java.math.BigDecimal 1.1

• BigDecimal(String digiths)：给定数位构建一个大实数。
• BigDecimal add(BigDecimal other)
• BigDecimal subtract(BigDecimal other)
• BigDecimal multiply(BigDecimal other)
• BigDecimal divde(BigDecimal other)
• BigDecimal divide(BigDecimal ohter，RoundingMode mode)：返回这个大实数和另一个大实数 other 的 和、差、积和商。如果商是一个无限小数，第一个 divide方法会抛出一个异常。要得到一个舍入的结果，就使用第二法方法 .RoundingMode.HALF_UP就是四舍五入。
• int compareTo(BigDecimal other)：如果这个大实数另一个大实数 other相等，返回 0；小于 ，返回负数；大于，返回正数。

3.10 数组

​ 数组存储相同类型值的序列。

3.10.1 声明数组

​ 数组是一种数据结构，用来存储同一类型值的集合。通过一个整型索引（index，或称下标）可以访问数组中的每一个值。一旦创建了数组，就不能改变它的长度。

//声明数组
int[] a = new int[10];
int[] a= {1,2,3,4,5,6,7,8,9,0};
int[] a = new int[]{};
int[] a ={};
new int[10];

3.10.2 访问数组

​ 数组元素从0 开始编号。最后一个合法的索引为数组长度减-1.

​ array.length获取数组的长度

3.10.3 for each循环

​ Java的增强for循环，可以用来以此处理数组（或者任何其他元素记恨）中的每个元素，而不必考虑指定的索引值。

形式为：for (varible : collection) statement。

​ 给定变量（variable）设置为集合中的每一个元素，然后执行语句（statement）。collection表达式必须是一个数组或者是一个实现了 Iterable 接口的类独享。

​ “for each” 循环的循环变量将会遍历数组中的每个元素，而不是索引值。

​ Arrays类的toString方法，会返回一个包含数组元素的字符串，这些元素包围在中括号后内，用逗号分隔。

3.10.4 数组拷贝

​ 在Java中，允许将一个数组变量拷贝到另一个数组变量。这时，两个变量将引用同一个数组。

例如：int[] luckyNumbers = smallPrimes;

​ luckyNumbers[4] = 12;

​ 将一个数组所有的值拷贝到一个新的数组中，可以使用 Arrays类的 copyof 方法。

static <T> T[] copyOf(T[] original, int newLength);//第二个参数是新数组的长度。
//	数组元素是数值型：那么新增元素将填入0；如果是布尔型，则填入false。如果长度小于原数组长度，则只拷贝前面的值。

​

​ Java中 [] 运算符预定义为完成越界检查（bounds checking）。Java没有指针运算，不能通过 a+1得到数组中的下一个元素。

3.10.5 命令行参数

​ main方法中的参数 String arg[],表名 main方法将接受一个字符串数组，也就是命令行上指定的参数。

3.10.6 数组排序

​ 对数值型数组进行排序，可以使用 Arrays类中的sort方法。这个方法是使用优化的快速排序（QuickSort） 算法。

java.util.Arrays 1.2

• static String toString(xxx[] a)：返回一个字符串，其中包含a中的元素，用中括号包围，用逗号分隔。xxx的数组元素类型可以是：int、long、short、byte、char、boolen、float或 double。
• static xxx[] copyOf(xxx[] a, int end)
• static xxx[] copyOf(xxx[] a, int start, int end)：返回相同类型的数组，长度为 end 或者 end-start，并填入a的值。
• static void sort(xxx[] a)：优化的快速排序（QuickSort） 算法对数组进行排序。
• static int binarySearch(xxx[] a,xxx y)
• static int binarySearch(xxx[] a,int start, int end,xxx y)：使用个二分查找算法在有序数组 a中查找值v。如果找到v，则返回相应的索引；否则，返回一个负数值r。-r -1是 v应插入的位置。
• static boolean equals(xxx[] a, xxx[] b)：如果两个数组长度相同，并且相同索引对应的元素都相同，则返回true。

3.10.7 多维数组

​ 多维数组使用多个索引访问数组元素，它适用于表格或其他更复杂的排列形式。

​ “for each”循环语句不会自动循环处理多维数组。它会循环处理行。

3.10.8 不规则数组

​ Java实际上没有多维数组，只用一维数组。多维数组被解释为 “数组中的数组”。