常量
关键字 final
类常量 static final
类常量的定义位于main方向的外部
Math类
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
Math.sqrt(x); //计算平方根 Math.pow(x); //计算幂次 Math.sin(x); //常用三角函数 Math.cos(x); Math.tan(x); Math.atan(x); Math.atan2(x); floorMod方法 //a为负数时，取模仍为整数 Math.exp //指数函数以及它的反函数 Math.log Math.log10 Math.PI //π和e的近似值 Math.E |
不必在数学方法名和常量名前添加前缀”Math”，只要在源文件的顶部加上下面这行代码：
|
1 2 3 4 |
import static java.lang.Math.*; //添加后就可使用： //System.out.println("The square root of \u03C0 is " + sqrt(PI)); |
强制类型转换
可能损失信息
如double –> int
|
1 2 3 |
double x = 9.997; int x1 = (int) x; //x1 == 9 int x2 = (int) Math.round(x); //x2 == 10（进行了四舍五入） |
字符串
子串 substring
可用 String类 的 substring方法 提取一个子串
|
1 2 |
String greeting = "Hello"; String s = greeting.substring(0, 3); //s = "Hel" |
拼接
可直接用+号拼接字符串
当将一个字符串与一个非字符串的值进行拼接时，后者会转换成字符串
|
1 2 3 |
int age = 20; String name = "xxxxx"; System.out.println(name + " 's age is " + age); |
如果要把多个字符串放在一起，用一个界定符分隔，可以使用静态join方法
|
1 2 |
String all = String.join(" / ", "S", "M", "L", "XL"); // all is the string "S / M / L / XL" |
不可变字符串
String类没有提供修改字符串中某个字符的方法，所以 String类对象称为是不可变的
如果要将”Hello”字符串变为”Help!”，可采用取字串+拼接：
|
1 2 |
String greeting = "Hello"; greeting = greeting.substring(0,3) + "p!"; |
检测字符串是否相等 equals
|
1 2 3 4 5 |
s.equals(t) //如果s, t相等则返回true; s, t不相等则返回false //以下表达式也是合法的 "Hello".equals(greeting) |
要想检测两个字符串是否相等，而不区分大小写，可以使用 equalsIgnoreCase 方法
|
1 |
"Hello".equalsIgnoreCase("hello") //true |
不要使用 == 运算符来检测两个字符串是否相等，这样只能确定两个字符串是否存放在同一个位置上
检测字符串长度 length
|
1 |
greeting.length() //获取str字符串的长度 |
空串与Null串
空串””，是长度为0的字符串，是一个Java对象
|
1 2 3 4 |
//检测字符串str是否为空串 if (str.length() == 0) //或 if (str.equals("")) |
Null串，是string变量存放着一个特殊的值，名为null，表示目前没有任何对象与该变量关联
|
1 2 3 4 5 |
//检测字符串str是否为null串 if (str == null) //检查一个字符串既不是null串也不是空串 if (str != null && str.length() != 0) //要先检查str不为null |
String API
http://docs.oracle.com/javase/9/docs/api
查询标准类库里的所有的类与方法
构建字符串 StringBuilder类
|
1 2 3 4 5 6 |
StringBuilder builder = new StringBuilder(); //创建一个空的字符串构造器 builder.append(ch); // appends a single character builder.append(str); // appends a string // 在字符串构建完成时调用toString方法，可以得到一个String对象 String completedString = builder.toString(); |
常用方法：
- StringBuilder 构造一个空的字符串构建器
- int length 返回构建器或缓冲器中的代码单元数量
- StringBuilder append(String str) 追加一个字符串并返回 this
- StringBuilder append(char C) 追加一个代码单元并返回 this
- StringBuilder appendCodePoint(int cp) 追加一个码点，并将其转换为一个或两个代码单元并返回this
- void setCharAt(int i, char c) 将第i个代码单元设置为c
- StringBuilder insert(int offset, String str) 在offset位置插入一个字符串并返回this
- StringBuilder insert(int offset, char C) 在offset位置插入一个代码单元并返回this
- StringBuilder delete(int startIndex, int endIndex) 删除偏移量从startIndex到endIndex – 1 的代码单元并返回this
- String toString() 返回一个与构建器或缓冲器内容相同的字符串
输入与输出
读取输入 Scanner
|
1 2 3 4 5 |
Scanner in = new Scanner(System.in); //构造Scanner对象 String name = in.next.line(); //读取输入的下一行内容，包含空格 String firstName = in.next(); //读取一个单词 int age = in.nextInt(); //读取一个整数 double number = in.nextDouble(); //读取一个浮点数 |
由于输入可见，所以Scanner不适用于在控制台上读取密码，要想读取密码，可以使用Console类
|
1 2 3 |
boolean hasNext() // 检测输入中是否还有其他单词 boolean hasNextInt() // 检测输入中是否还有下一个表示整数的字符序列 boolean hasNextDouble() // 检测输入中是否还有下一个表示浮点数的字符序列 |
格式化输出 printf
以下句会以一个字符宽度打印x: 包含八个字符，精度为小数点后2个字符
|
1 2 |
double x = 10000.0 / 3.0; //3333.333333333... System.out.printf("%8.2f", x); //" 3333.33" |
使用标志，常用的有：
| 标志 | 目的 | 示例 |
|---|---|---|
| + | 打印正负数的符号 | +3333.33 |
| 空格 | 在正数之前添加空格 | _3333.3 (_表示空格) |
| 0 | 数字前面补0 | 003333.33 |
| – | 左对齐 | 3333.33_ |
| ( | 将负数括在括号内 | (3333.33) |
| , | 添加分组分隔符 | 3,333.33 |
| # (对于f格式) | 包含小数点 | 3333. |
| # (对于x或0格式) | 添加前缀0x或0 | 0xcafe |
可以使用多个标志，例如
|
1 |
System.out.printf("%,(.2f", x); |
会使用分组分隔符且将负数括在括号内
可以使用静态的 String.format 方法创建一个格式化的字符串，而不打印输出
|
1 |
String message = String.format("Hello, %s. Next year, you'll be %d", name, age); |
文件输入与输出
输入文件：Scanner
输出文件：PrintWrite 如果文件不存在，创建该文件。
|
1 2 3 4 |
//读取一个文件 Scanner in = new Scanner(Path.of("C:\\mydir\\myfile.txt"), StandardCharsets.UTF_8); |//写入文件 PrintWriter out = new PrintWriter("myfile.txt", StandardCharsets.UTF_8); |
如果用一个不存在的文件构造一个scanner，或用一个无法创建的文件名构造一个PrintWriter，就会产生异常，用 throws IOException 告诉编译器可能会产生输入输出异常
|
1 2 3 4 |
public static void main(String[] args) throws IOException{ Scanner in = new Scanner(Path.of("myfile.txt", StandardCharsets.UTF_8)); ...... } |
控制流程
条件控制
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
if (condition1) { statement1; statement2; ... } else if (condition2) { statement3; statement4; ... } else { statement5; statement6; ... } |
循环控制
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
while (condition) { statements; } do { statements; } while (condition); for ( i = 1; i < 10; i++) { statements; } |
中断控制流程
普通的break：用于跳出当前循环
continue：
带标签的break语句：可用于跳出多重嵌套循环
注意：标签必须放在希望跳出的最外层循环之前，并且必须紧跟一个冒号
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
Scanner in = new Scanner(System.in); int n; read_data: while (...) { ... for(...) { System.out.print("Enter a number >= 0: "); n = in.nextInt(); if (n < 0) break read_data; ... } } |
事实上可以将标签应用到任何语句，包括if语句或者块语句，如：
|
1 2 3 4 5 6 7 |
label: { ... if (condition) break label; ... } |
只能跳出语句块，不能跳入语句块
大数 BigInteger BigDecimal
这两个类可以处理包含任意长度数字序列的数值
|
1 2 3 |
BigInteger a = BigInteger.valueOf(100); //将普通的数值转换为大数 BigInteger reallyBig = new BigInteger("2246458756454687989994554567987..."); //使用带字符串参数的构造器 |
不能使用算术运算符 + – * / 来处理大数，需要使用大数类 add subtract multiply divide方法
|
1 2 3 |
BigInteger c = a.add(b); //c = a + b BigInteger d = c.multiply(b.divide(BigInteger.valueOf(2))); //d=c * (b / 2) a.compareTo(b); //若a == b，返回0；如a > b，返回负数；若a < b，返回正数 |
数组
声明、初始化数组
|
1 2 3 4 5 6 7 8 |
int[] a; //声明 int[] a = new int[100]; //声明并初始化了一个可存储一百个整数的数组 //以下语法不需要使用new，也不需要指定长度 int[] b = {2, 3, 4, 5, 7, 11}; //最后一个值后面允许有逗号，方便为数组增加值 String[] authors = {"Bill Joy", "James Gosling", }; |
还可以声明匿名数组， 这会分配一个新数组并填入大括号中提供的值。会统计初始值个数并相应地设置数组大小。 可以使用这种语法重新初始化一个数组而无需创建新变量
|
1 2 3 4 5 |
smallPrimes = new int[] { 17, 19, 23, 29 }; //是以下语句的简写形式 int[] anonymous = {17, 19, 23, 29 }; smallPrimes = anonymous; |
允许有长度为0的数组：
|
1 2 3 |
new elementType[0] //or new elementType[]{} |
访问数组元素
创建数组时会进行默认初始化
数字数组 — 0 boolean数组 — false 对象数组 — null
|
1 2 3 |
// 将字符串数组各元素指定为空串： String[] names = String[10]; for (int i = 0; i < 0; i++ ) names[i] = ""; |
想要获得数组中的元素个数，可以使用 <array>.length
|
1 2 |
for (int i = 0, i < a.length; i++ ) System.out.println(a[i]); |
for each 循环
可以用来依次处理数组中的每一个元素，不考虑下标值，如：
|
1 2 |
for (int element : a) System.out.println(element); |
数组拷贝
允许将一个数组变量拷贝到另一个数组变量，这时两个变量将引用同一个数组
|
1 2 |
int[] luckyNumbers = smallPrimes; luckyNumbers[5] = 12; // smallPrimes[5]这时也是十二 |
如果希望将一个数组的所有值拷贝到一个新的数组中去，需要使用 Arrays类的copyOf 方法
|
1 |
int copiedLuckyNumbers = Arrays.copyOf(luckyNumbers, luckyNumbers.length); |
第二个参数是新数组的长度，常用来增加数组的大小
|
1 |
int copiedLuckyNumbers = Arrays.copyOf(luckyNumbers, 2*luckyNumbers.length); |
如果长度小于原始数组的长度，则只拷贝前面的值
数组排序
要想对数值型数组进行排序，可以使用Arrays类中的sort方法
|
1 2 3 |
int[] a = new int[10000]; ... Arrays.sort(a); |
java.util.Arrays:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
- static String toString( ElemType[] a ) 返回包含a中元素的一个字符串，这些元素用中括号包围，并用括号分隔 - static ElemType[] copyOf(ElemType[] a, int end) - static ElemType[] copyOfRange( ElemType[] a, int start, int end) 返回与a类型相同的一个数组，其长度为length或end - start。数组元素为a的值，如果end大于a.length，结果会填充0或false - static void sort(ElemType[] a) 使用优化的快速排序算法对数组进行排序 - static int binarySearch(ElemType[] a, ElemType v) - static int binarySearch(ElemType[] a, int start, int end, ElemType v ) 使用二分查找算法在有序数组a中查找值v。如果找到v，则返回相应的下标；否则，返回一个负数值r，-r-1是v应插入的位置 - static void fill(ElemType[] a, ElemType v) 将数组的所有元素设置为v - static boolean equals(ElemType[] a, ElemType[] b ) 如果两个数组大小相同，并且下标相同的元素对应都相等，返回true |
多维数组
|
1 2 3 4 5 6 7 8 9 10 11 |
double[][] balances; //声明二维数组 balances = new double[NYESRS][NRATES]; //初始化二维数组 //不调用new，直接初始化 int[][] a = { {16, 3, 2, 13}, {5, 10, 11, 8}, {9, 6, 7, 12}, {4, 15, 14, 1} }; |
for each循环语句不能自动处理二维数组的每一个元素。它会循环处理行。而这些行本身是一维数组。
|
1 2 3 4 |
// 访问二维数组a的所有元素 for (double[] row : a) for (double value : row) <do something with value> |
还可以快速地打印一个二维数组的数据元素列表
|
1 2 3 |
System.out.println(Arrays.deepToString[a]); // 输出格式为： // [[16, 3, 2, 13], [5, 10, 11, 8], [9, 6, 7, 12], [4, 15, 14, 1]] |
不规则数组
Java实际上没有多维数组，只有一维数组。多维数组被解释为“数组的数组”。
可单独访问数组的每一行，也可让两行交换
|
1 2 3 |
double[] temp = balances[i]; balances[i] = balances[i + 1]; balances[i + 1] = temp; |
可创建每行元素个数不同的不规则数组，示例：
|
1 2 3 4 |
// 第i行有i + 1个元素 int[][] odds = new int[NMAX +1][]; for (int n = 0; n <= NMAX; n++) odds[n] = new int[n + 1]; |
