Java核心技术笔记 语言基础

摘要：变量声明变量变量名规则字母开头，由字母或数字构成的序列，中的字母包括或者某种语言中代表字母的任何字符，数字包括或者某种语言中代表数字的任何字符。删除原始字符串头部和尾部空格。中断控制流程，使用在和循环中，用于提前中断循环。

《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方法的两个参数是：

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

不想复制的第一个位置（从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等操作产生的结果并不是共享的。

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

str.length() == 0
str.equals("")

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

str == null

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

str != null && str.length() != 0

只列出一般常用到的

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循环。

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

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

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

{ // block 1
  int i;
  {
    // block 2
    int 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(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）的随机浮点数

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]

基本命名规则：驼峰法

三种注释方式

8种基本数据类型

变量声明以及命名规则

基本运算符

数值类型的自动与强制转换

各运算符优先级

枚举类型

String API

StringBuilder

命令行输入输出

文件输入输出

控制流程

中断控制流程

大数值

数组以及相关操作

个人静态博客：

气泡的前端日记： https://rheabubbles.github.io