《Java核心技术 卷Ⅰ》 第3章 Java 的基本程序设计结构

一些规则

• 类命名：CamelCase 驼峰命名法，以及必须是字母开头，后面跟字母和数字的任意组合；
• 源代码文件名：必须与公共类的名字相同（包括大小写）；
• Java中的函数：都是属于某个类的方法（而不是称为成员函数）；
• Java通用语法：object.method(parameters)；
• Java使用双引号分隔字符串；
• println输出后会换行，而print输出后不换行；
• 注释方法：
  • 单行：code; //comment；
  • 多行：/* comment */,不可嵌套使用；
  • 文档：使用方式如下

  /*** This is a document comment* @from Core Java Chapter 3*/
  复制代码

数据类型

• 8种基本类型(primitive type)：
  • 4种整形：byte,short,int,long；
  • 2种浮点型：float,double；
  • Unicode编码字符单元：char；
  • 真值：boolean；
  • Java没有无符号类型。
• 如果需要数值计算不含任何误差，应使用BigDecimal或BigInteger类；
• NaN不能用 == 来判断。

变量

• 声明变量：type name;
• 变量名规则：字母开头，由字母或数字构成的序列，Java中的字母包括'A'~'Z'、'a'~'z'、'_'、'$'或者某种语言中代表字母的任何Unicode字符，数字包括'0'~'9'或者某种语言中代表数字的任何Unicode字符。
• 变量名大小写敏感，长度没有限制；
• 可以在一行声明多个变量，但不提倡；
• 变量声明尽可能靠近变量第一次使用的地方；
• final关键字指示常量，表示只能被赋值一次，常量常用全大写；
• static final关键字指示类常量，一个类中的多个方法使用，const虽然是保留字，但是目前并没有使用；

运算符

• 基础运算符：+、-、*、/、%;
• 整数被0除会产生异常，浮点数被0除会得到无穷大或NaN结果；
• 自增自减：++、--，注意在其他表达式中前缀和后缀的区别，简易单独使用，以免产生困惑和问题；
• 关系（比较）运算符以及逻辑运算符：没有什么特殊的，略；
• 三元操作符： condition ? exp1(true) : exp2(false);
• 位运算符：处理整数，与(&)、或(|)、非(~)、异或(^)、左移(<<)、右移(>>)，在位模式下工作, >>>逻辑右移用0填充高位，>>>算数右移用符号位填充高位。其中需要注意的是，移位操作右边的操作数，也就是移位位数值在运算前需要进行模数据位数的计算，int类型 1 << 35 和 1 << 3 的结果相同；
• 数学函数：Math.method(x).

数值类型的转换

• 合法转换基本原则：从低字节类型向高字节类型转换；
• 特殊情况：int(4字节)、long(8字节)转float(8字节)仍有可能有精度损失，long(8字节)转double(16字节)也可能有精度损失，但int转double没有精度损失；
• 以上是自动完成的类型转换；
• 强制类型转换(cast)：(type) var，注意转换如果超出范围则会截断产生另一个合法的值;
• 舍入运算：Math.ground(x)，注意返回的是long；

运算符优先级

暂时只记录一些常用的，以下优先级递减。

除特殊说明，结合性（即在遇到相同优先级运算符时计算的顺序）默认从左向右。

• 方法调用
• 一元运算符：!,~(位非),++,--,+(正),-(负)，强转，new，从右到左
• 乘、除、求余数
• 加、减
• 移位
• 大于(等于)、小于(等于)
• 相等、不等
• 位与
• 位异或
• 位或
• 逻辑与
• 逻辑或
• 三元运算符，从右到左
• 带有赋值(=)操作的操作符，比如+=,-=,...，从右到左

当自己写代码时拿不准优先级的时候，省事点加括号就完事了。

枚举类型

enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE };
Size s = Size.MEDIUM; //赋值为null则表示没有设置任何值
复制代码

字符串

Java没有内置的字符串类型，而是在标准Java类库中提供了一个预定义类String，每个用双引号括起来的字符串都是String类的一个实例。

String emptyString = "";
String greeting = "Hello";
复制代码

子串

String s = greeting.substring(0, 3);
复制代码

substring方法的两个参数是：

1. 想要复制的第一个位置（从0开始）
2. 不想复制的第一个位置（从0开始）

两个参数相减就是子串的长度。

拼接

String name = "FirstName" + "LastName";
String age = 24 + "years old";
String person = String.join(",", name, age[, ...]);
// person is "FirstName LastName,24 years old[, ...]"
复制代码

一个字符串与一个非字符串拼接时，后者转换成字符串（任何一个Java对象都可以转换成字符串，可能指的是Class.toString()）。

不可变字符串

String类没有提供修改字符的方法，编译器可以让字符串共享以提高效率。

字符串相等

"Hello".equals(greeting) //区分大小写
"Hello".equalsIgnoreCase("hello") //不区分大小写
复制代码

一定不要使用==来解决这个问题，它只能确定字符串是否在同一位置，而不是他们具有相同的字符内容。

如果虚拟机始终将相同字符串共享，那就可以使用==，但实际上只有字符串常量是共享的，+和substring等操作产生的结果并不是共享的。

空串与Null串

""是长度为0的字符串，如果要检查字符串是否为空串：

str.length() == 0
str.equals("")
复制代码

Null串指的是String变量存放null，表示目前没有任何对象与该变量关联：

str == null
复制代码

检查字符串既不是null串也不是空串：

str != null && str.length() != 0
复制代码

String API

只列出一般常用到的

• int compareTo(String other)：按照字典顺序，字符串在other之前就返回负数，位于other之后则为正数，相等返回0。
• new String(int[] codePoints, int offset, int count：仅了解，用数组中从offset开始的count个码点构造字符串。
• boolean equals(Object other)
• boolean equalsIgnoreCase(String other)
• boolean startsWith(String prefix)：如果以prefix为开头，返回true。
• boolean endsWith(String suffix)：如果以suffix为结尾，返回true。
• int indexOf(String str)：返回与字符串str匹配的第一个子串的开始位置，如果不存在则返回-1。
• int length()
• String replace(CharSequence oldString, CharSequence newString)：用newString代替原始字符串中所有oldString，可用String或StringBuilder作为参数。
• String substring(int beginlndex, int endlndex)
• String toLowerCase()
• String toUpperCase()
• String trim()：删除原始字符串头部和尾部空格。
• String join(CharSequence delimiter, CharSequence... elements)

CharSequence类型的参数，这是一种接口类型，所有字符串都属于这个接口。

构建字符串

当需要用许多较短字符串构成字符串时，使用String的拼接方式效率会比较低，每次连接都会产生一个新的String对象，耗时也浪费空间，使用StringBuilder类可以避免这个问题。

StringBuilder builder = new StringBuilder();
builder.append(ch);
builder.append(str);
String string = builder.toString();
复制代码

StringBuilder类的前身是StringBuffer，效率稍低但是允许多线程方式添加或删除字符，如果只是在单线程中编辑，则应该用StringBuilder替代它，两个类的API相同。

• int length()
• StringBuilder appencl(String str or char c)
• void setCharAt(int i, char c)：将第i个代码单元设置为c。
• StringBuilder insert(int offset,String str or char c)：在offset位置插入一个串或单元并返回this。
• StringBuilder delete(lnt startindex,int endlndex)：删除偏移量从startIndex到endIndex-1的代码单元并返回this。
• String toString()：返回内容相同的字符串。

输入输出

读取输入

首先在程序的最开始添上：

import java.util.*
复制代码

Scanner类定义在java.util包中，当使用的类不是定义在基本java.lang包中时，一定要import指示将相应包加载。

Scanner in = new Scanner(System.in);
System.out.print("Qusetion:");
String answer = in.nextLine();
复制代码

nextLine方法获取的是一个输入行，只想读取一个单词（以空白符作为分隔符），机会调用：

String answer = in.next();
复制代码

读取一个数：

int number = in.nextInt();
double weight = in.nextDouble();
复制代码

• boolean hasNext()：检查输入中是否还有其他单词。
• boolean hasNextInt()
• boolean hasNextDouble()

如果想读取一个输入不可见的密码，使用Console类：

Console cons = System.console();
String username = cons.readLine("User name:");
char[] password = cons.readPassword("Password:");
复制代码

安全起见，在完成密码处理不再使用password后，应使用填充值覆盖数组元素。

格式化输出

double x = 10000.0/3.0;
System.out.print(x);
// 3333.3333333333335
System.out.printf("%8.2f", x);
// 8个字符宽度和小数点后两个字符的精度打印x，也就是打印一个空格和7个字符
// 3333.33
System.out.printf("Hello %s, you are %d.", name, age);
复制代码

• d：十进制整数
• x：十六进制整数
• f：定点浮点数
• e：指数浮点数
• s：字符串
• c：字符
• b：布尔
• %：百分号

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

String str = Stirng.format("Hello %s, you are %d.", name, age);
复制代码

文件输入输出

文件读取：

Scanner in = new Scanner(Paths.get("myfile.txt"), "UTF-8");
// Scanner(File f)
// static Path get(String pathname)：根据给定路径名构造一个Path
// 然后使用前面介绍的Scanner的方法进行文件读取
复制代码

如果文件名（包括其路径，比如C:\dir\)，中有反斜杠，则要在每个反斜杠前再加一个额外的反斜杠（因为反斜杠\是作为转义字符的存在，在字符串中要表示\则必须用\\）。

这里指定了UTF-8字符编码，要读取一个文本时要知道它的字符编码，如果省略字符编码将会使用运行这个Java程序的机器的“默认编码”，不同机器可能会有不同的“默认编码”。

文件写入：

PrintWriter out = new PrintWriter("myfile.txt", "UTF-8");
// PrintWriter(String fileName)
复制代码

如果文件不存在，将创建该文件，使用print,printf,println等方法写入数据。

注意，如果直接给Scanner一个字符串参数，Scanner会把字符串解释为数据而不是文件名。

Scanner in = new Scanner("myfile.txt");
// Scanner会包含10个字符的数据，而不是文件数据
复制代码

另外，如果使用一个不存在的文件构造Scanner或者用一个不能被创建的文件名构造一个PrintWriter将会发生异常，Java编译器认为这些异常比“被0除”异常更严重。

控制流程

Java的控制流程结构与C和C++的一样，只有很少的例外，Java没有goto语句，但break语句可以带标签，可以实现从内层循环跳出的目的。另外还有一种变形的for循环，类似C#的foreach循环。

块(block)作用域

块，即复合语句，一对大括号括起来的若干Java语句，块确定了变量的作用域。

{ // block 1int i;{// block 2 这是一个嵌套块int j;}
}
复制代码

但不能在嵌套的两个块中声明同名变量：

{ // block 1int i;{// block 2int i; // Error}
}
复制代码

虽然C++中，允许这样做，内层定义的变量会覆盖外层定义的变量，有可能导致程序设计出错，所以Java中不允许这样做。

条件语句

if(condition1) { statement1 }
else if(condition2) { statement2 }
else { statement3 }
复制代码

循环

while(condition) { statement }
复制代码

如果希望循环体至少被执行一次，则使用：

do { statement }
while(condition);
复制代码

确定循环

for(declare; condition; refresh) { statement }
// for语句内部声明的变量无法在循环体外部使用
复制代码

多重选择

switch(condition)
{case 1:...break;case 2:...break;...default:// no case match...break;
}
复制代码

case标签可以是：

• 类型为char、byte、short或int的常量表达式；

  switch(grade)
  {...case 100:...
  }
  复制代码

• 枚举常量（当使用枚举常量时，不必在标签中指明枚举名）；

  Size size = ....;
  switch(size)
  {...case SMALL: //no need to use Size.SMALL...
  }
  复制代码

• JAVA SE 7 开始可以用字符串字面量。

  switch(str)
  {...case "yes":...
  }
  复制代码

中断控制流程

break，使用在while和for循环中，用于提前中断循环。

Java提供一个种带标签的break语句，用于跳出多重嵌套的循环语句。

tag:
while(...)
{...for(...){...if(...){break tag;}}
}
// 在break后会跳出绑定tag的循环体（在这里也就是while）
// 而不是像普通break只是跳出for
复制代码

continue，用于跳过本次循环，进行下一次循环体的执行。

大数值

基本的整数和浮点数精度不能够满足需求，可以使用java.math包中的两个很有用的类：

• BigInteger：任意精度的整数运算
• BigDecimal：任意精度的浮点数运算

使用valueOf方法可以将普通的数值转换为大数值：

BigInteger a = BigInteger.valueOf(100);
复制代码

算术运算符是add、subtract、divide、multiply，BigInteger还有mod运算：

BigInteger c = a.add(b);
// c = a + b
BigInteger d = c.multiply(b.add(BigInteger.valueOf(2)));
// d = c * (b + 2)
复制代码

以及两个大数的比较compareTo，相等返回0，小于返回负，大于返回正。

数组

声明数组变量：

int[] a;
int[] b = new int[100];
复制代码

当然Java中也可以int a[]的声明方式，看个人喜好吧。

数组创建时的初始化：

• int数组：所有元素初始化为0
• boolean数组：所有元素初始化为alse
• 对象数组：所有元素初始化为null

获取数组中的元素个数使用array.length。

for each 循环

for each 循环语句的循环变量将会遍历数组中的每个元素，而不需要使用下标值。

for(variable:collection) { statement }

• variable：用于暂存集合中的每一个元素，并执行相应块
• collection：必须是一个数组或者实现了Iterable接口的类对象（比如ArrayList）。

for(int element : a)
{System.out.println(element);
}
复制代码

数组初始化以及匿名数组

Java中，可以创建数组对象的同时赋予初始值的写法：

// 不需要调用new
int[] a = { 2, 3, 5, 7, 11, 13 };
// 初始化一个匿名的数组
a = new int[] { 17, 19, 23, 31, 37 };
// 这是以下语句的简写方式
int[] anonymous = { 17, 19, 23, 31, 37 };
a = anonymous;
复制代码

Java中允许数组长度为0，但这与null不同。

数组拷贝

数组变量拷贝：

int[] b = a;
b[0] = 1;
复制代码

此时a中的第一个元素a[0]的值也会被修改为1。

数组值拷贝：

int[] c = Arrays.copyOf(a, a.length);
// 第2个参数是新数组长度，通常用于增加数组大小
int[] c = Arrays.copyOf(c, c.length * 2);
// 如果长度小于原始数组，则只拷贝前面的数据元素
复制代码

命令行参数

如果使用下面这种形式运行一个Java程序：

java Message -g cruel world
复制代码

则程序中获取命令行参数的方法是：

public class Message
{public static void main(String[] args){// args就是参数数组System.out.printlf(Arrays.toString(args));// [-g, cruel, world]}
}
复制代码

数组排序

int[] a = new int[1000];
...
Arrays.sort(a);
复制代码

sort方法使用了优化的快速排序算法。

插播一个生成0到n-1之间随机数的办法：

int r = (int) (Math.random() * n);
// Math.random返回一个0-1（不包括1）的随机浮点数
复制代码

java.util.Arrays

• static String toString(type[] a)：a为基本数据类型数组（不包括字符串数组），返回字符串，元素放在中括号内，并用逗号分隔。
• static type copyOf(type[] a, int length)
• static type copyOfRange(type[] a, int start, int end)
  • 返回与a类型相同的一个数组，长度为length或end-start
  • start：起始下标（包含这个值）
  • end：终止下标（不包含这个值）
• static int binarySearch(type[] a, type v)
• static int binarySearch(type[] a, int start, int end, type v)
  • 采用二分法查找值v，查找成功则返回相应下标值，否则返回一个负数值r，-r-1是保持a有序的v应该插入的位置。
• static void fi11(type[] a, type v)：将数组的所有元素设置为v。
• static boolean equals(type[] a, type[] b)：数组大小相同，并且所有对应下标的元素都相等，则返回true。

多维数组

int[][] magicSquare =
{{ 16, 3, 2, 13 },{ 5, 10, 11, 8 },{ 9, 6, 7, 12 },{ 4, 15, 14, 1 }
};
// 访问元素使用 magicSquare[i][j]
复制代码

Java语言基础总结

• 基本命名规则：驼峰法
• 三种注释方式
• 8种基本数据类型
• 变量声明以及命名规则
• 基本运算符
• 数值类型的自动与强制转换
• 各运算符优先级
• 枚举类型
• String API
• StringBuilder
• 命令行输入输出
• 文件输入输出
• 控制流程
• 中断控制流程
• 大数值
• 数组以及相关操作

---

个人静态博客：

• 气泡的前端日记： rheabubbles.github.io