Java核心技术笔记语言基础

时间 2019-12-11

标签 java 核心技术笔记语言基础栏目 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；

运算符优先级

暂时只记录一些经常使用的，如下优先级递减。java

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

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

当本身写代码时拿不许优先级的时候，省事点加括号就完事了。github

枚举类型

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()）。bash

不可变字符串

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

字符串相等

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

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

若是虚拟机始终将相同字符串共享，那就可使用==，但实际上只有字符串常量是共享的，+和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

Java核心技术笔记 语言基础