Java核心技术笔记语言基础

谁践踏了优雅 2022-10-01 07:54 206阅读 0赞

《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 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 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][]

转载于:https://juejin.im/post/5c33536df265da6174650179

[rheabubbles.github.io]: https://link.juejin.im?target=https%3A%2F%2Frheabubbles.github.io