学习Java的一些笔记
注意事项
- Java对大小写很敏感
- 类名必须以字母开头，后面可以跟字母和数字,也可以用 _和$ 两种符号。不能使用Java保留字。（标准类名：以大写字母开头，如果类名由多个单词组成，每个单词首字母应该要大写
- 源代码文件名必须与公共类的名字相同
- 为了代码能够你执行，必须包含一个main方法
Java中的三种注释
- 单行注释( // )
- 多行注释( /* */)
- 多行注释 可以自动生成文档( /** */)
数据类型
| 类型 | 储存需求 | 取值范围 | |
|---|---|---|---|
| boolean | 1字节 (8 bit) | true, false | |
| char | 2字节(16 bit) | 0 ~ 216-1 | |
| byte | 整型 | 1字节 (8 bit) | -128 ~ 127 |
| short | 整型 | 2字节 (16 bit) | -32 768 ~ 32 767 (-215 ~ 215-1) |
| int | 整型 | 4字节 (32 bit) | -2 147 483 648 ~ 2 147 483 647 (-231 ~ 231-1) |
| long | 整型 | 8字节 (64 bit) | -9 223 372 036 854 776 808 ~ 9 223 372 036 854 775 807 (-263 ~ 263-1) |
| float | 浮点类型 | 4字节 (32 bit) | 大约±3.402 823 47E + 38F(有效位数为6~7位) |
| double | 浮点类型 | 8字节 (64 bit) | 大约±1.797 693 134 862 315 70E + 308(有效位数为15位) |
- 长整数型有一个后缀L (如4000000000L)
- 十六进制数值有一个后缀0x (如0xCAFE)
- 八进制有一个前缀 0 (如010)
- 二进制有一个前缀 0b (如0b1001)
- Float类型的数值有一个后缀F (如 3.14F)
final 关键字
final关键字表示变量只能被赋值一次，一旦被赋值后，就不能被更改。
例如：
Final double CMCC = 2.54
如果希望某个常量可以在一个类中的多个方法中使用，称这个常量为类常量。可以使用关键字static final 设置一个类常量，定义的位置在main方法外部。因此，同一个类的其他方法中也可以使用这个常量。如果一个常量被声明为public，那么其他类的方法也可以使用这个常量。
运算符
在java中，算术运算符可以用+ - * / 来代表加减乘除。
当参与除(/)运算的两个操作数为整数时，表示整数除法，答案为整数。否则，表示浮点除法。
求余数可以用%
例如 10%3等于1，10%3.0等于1.0
注意：整数除以0将会产生一个异常，而浮点数除以0将会得到无穷大或NaN结果。
i++ 和 ++i 的 区别
- 如果只是看i++和++i，这两个是等价的，都等同于i=i+1，都是变量自身加1。
- 在一般情况下，它们都是跟赋值联系在一起。
比如：
int a;
a=i++; //将i的值赋值给a，即a=i；然后再执行i=i+1；
也就是【a=i++;】与【a=i; i=i+1;】等价。
a=++i;//将i+1的值赋给a,即a=i+1;然后再执行i=i+1；
也就是【a=++i;】与【a=i+1;i=i+1;】等价。
总结一下
- 前置++是将自身加1的值赋值给新变量，同时自身也加1；
- 后置++是将自身的值赋给新变量，然后才自身加1.
关系运算符
三元操作符
Condition? expression1: expression2
当Condition为true时，计算或返回第一个表达式expression1，如果为false,则计算第二个表达式expression2.
如 x
数值类型之间的转换
整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。转换过程中可能导致溢出或损失精度
低----------------------------------------------------------高
byte, short, char—> int —> long—> float —> double
自动类型转换
必须满足转换前的数据类型的位数要低于转换后的数据类型。
自动转换由低到高的顺序转换
int n = 123456789;
float f = n;//f值为1.234567892E8
当使用上面两个数值进行二元操作时（例如 n+f , n是整数，f是浮点数），先要将两个操作数转换为同一种类型，然后再进行计算。
如果两个操作数中有一个是double类型，另一个操作数就会转换为double类型；
否则，如果其中一个操作数是float类型，另一个操作数将会转换为float类型；
否则，如果其中一个操作数是long类型，另一个操作数将会转换为long类型。
否则，两个操作数都将被转换为int类型。
强制类型转换
高的向低的顺序转换
double x = 3.94;
int y = (int) x;
x的结果为3，强制类型转换通过截断小数部分将浮点值转为整型。
如果想要四舍五入，得到最接近的整数。可以使用Math.round方法
double x = 3.14;
int y = (int) Math.round(x);
结果为 4，当调用round时，仍然需要使用强制类型转换(int).其原理是因为round方法返回的结果为long类型。由于存在信息丢失的可能性，所以只有使用显式的强制类型转换才能够将long类型转换成int类型。
不要在boolean类型与任何类型之间进行强制类型转换，这样可以防止发生错误。
运算符优先级
| 优先级 | 运算符 | 简介 | 结合性 |
|---|---|---|---|
| 1 | [ ]、 .、 ( ) | 方法调用，属性获取 | 从左向右 |
| 2 | !、~、 ++、 -- | 一元运算符 | 从右向左 |
| 3 | * 、/ 、% | 乘、除、取模（余数） | 从左向右 |
| 4 | + 、 - | 加减法 | 从左向右 |
| 5 | <<、 >>、 >>> | 左位移、右位移、无符号右移 | 从左向右 |
| 6 | < 、<= 、>、 >=、 instanceof | 小于、小于等于、大于、大于等于，对象类型判断是否属于同类型 | 从左向右 |
| 7 | == 、!= | 2个值是否相等，2个值是否不等于。 下面有详细的解释 | 从左向右 |
| 8 | & | 按位与 | 从左向右 |
| 9 | ^ | 按位异或 | 从左向右 |
| 10 | | | 按位或 | 从左向右 |
| 11 | && | 短路与 | 从左向右 |
| 12 | || | 短路或 | 从左向右 |
| 13 | ?: | 条件运算符 | 从右向左 |
| 14 | =、 += 、-= 、*= 、/=、 %=、 &=、 |=、 ^=、 <、<= 、>、>= 、>>= | 混合赋值运算符 | 从右向左 |
字符串
子串substring
String类的substring方法可以从一个较大的字符串提取出一个子串。
substring(a,b)
- a 表示开始的位置（从0开始计数）
- b表示不想复制的第一个位置
例如
String greeting = "hello";
String s = greeting.substring(0,3);
// s = hel
//从0开始计数，直到3位置，但是不包括3，所以返回 hel
substring的一个优点：容易计算子串的长度，长度为b-a。
例如 hel的长度为 3-0=3
检测字符串是否相等
可以使用equals来检测两个字符串是否相等。
s.equals(t)
如何相等，会返回true,否则，返回false. s和t可以是字符串变量，也可以是字符串常量。
eg: "hello".equals(greeting)
检测是否相等，而且不区分大小写，可以使用equalsIgnoreCase方法。
eg: "hello".equalsIgnoreCase("HeLLO)
不能使用==运算符来检测两个字符串是否相同，这个运算符只能够确定两个字符串是否放置在同一个位置。
空串和Null串
空串是一个Java对象，有自己的串长度(0)和内容(空)。可以通过调用以下代码检查字符串是否为空。
if(str.length()==0)
或
if (str.equals(""))
null表示目前没有任何对象与该变量关联。可以通过调用以下代码检查字符串是否为null
if (str == null)
要检测一个字符串既不是null也不是空串：
if (str != null && str.length()!=0)
length() 与 charAt()
length方法会返回采用UTF-16编码表示的给定字符串所需的代码单元数量。
想要得到实际的长度，即代码点数量，可以调用
xxx.codePointCount(0,xxx.length())
调用s.chatAt(n)将返回位置n的代码单元，n介于0~ s.length()-1 之间。
eg:
String greeting = "Hello"
char first = greeting.charAt(0); // first is H
char last = greeting.charAt(4); // last is o
想得到i个的代码点，可以使用
int index= greeting.offsetByCodePoints(0,i);
int cp = greeting.codePonintAt(index);
输入输出
读取输入
为了能够读取用户在控制台的输入，首先需要创建一个Scanner对象，并与“标准输入流”System.in关联。
Scanner in = new Scanner (System.in)
- next()
读取到输入有效的字符才会结束输入，对于输入有效的字符之前的空白会自动去掉，输入有效的字符之后的空白作为分隔符或者结束符。next() 不能得到带有空格的字符串。 - nextLine()
以enter为结束符，nextLine()可以得到带有空格的字符串，不会去掉空白，会全盘输出。 - nextInt()
得到int类型的数据。nextDouble(),nextFloat()以此类推。 - boolean hasNext()
检测输入中是否有还有其他单词。
记得要import java.util.*;
import java.util.*;
public class Input_and_Output {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
System.out.print("what is your name :");
String name = in.nextLine();
System.out.print("age :");
int age = in.nextInt();
System.out.println("the name is " + name + ",the age is "+age);
}
//输入结果：
//what is your name :jerry
//age :24
//the name is jerry,the age is 24
格式化输出
System.out.print(X)会将以x对应的数据类型所允许的最大非0数字位数打印输出x
double x = 10000.0/3.0;
System.out.print(x); // x = 3333.3333333333335
为了能够方便格式输出结果，可以使用printf()。
double x = 10000.0/3.0;
System.out.printf("8.2f",x);
// x = 3333.33 使用8个字符的宽度和小数点后两位字符的精度打印x
// 因为小数点后2位，为3333.33。但是指定要8个字符的宽度，所以左边会补一个空格
// x结果为（1个空格）3333.33
用于printf的转换符
| 转换符 | 类型 | 举例 |
|---|---|---|
| %s | 字符串类型 | "Hello" |
| %c | 字符类型 | 'H' |
| %b | 布尔类型 | true OR false |
| %d | 整数类型（十进制） | 10 |
| %x | 整数类型（十六进制） | 9f |
| %o | 整数类型（八进制） | 237 |
| %f | 浮点类型 | 15.9 |
| %a | 十六进制浮点类型 | 0x1.fccdp3 |
| %e | 指数类型 | 6.23e+24 |
| %g | 通用浮点类型（f和e类型中较短的） | 42.5000 |
| %h | 散列码 | 42628b2 |
| %% | 百分比类型 | ％ |
| %n | 换行符 | 相当于"\n"换行作用 |
| %tx | 日期与时间类型（x代表不同的日期与时间转换符） | 见博文下表 |
大数值
如果基本的整数和浮点数精度不够满足需求，那么可以使用java.math包中的两个很有用的类：BigInteger和BigDecimal。这两个类可以处理包含任意长度数字序列的数值。
- BigInteger 实现任意精度的整数运算
- BigDecimal 实现任意精度的浮点数运算
把普通的数值转换成大数值，可以使用静态的function valueOf() { [native code] }方法
BigInteger a = BigInteger.function valueOf() { [native code] }(100)
大数值的运算不能使用常用的算术运算符（如+，*）处理，而是要使用大数值类中的add和multiply
BigInteger c = a.add(b); // c=a+b
BigInteger d = c.multiply(b.add(BigInteger.function valueOf() { [native code] }(2))); // d = c*(b+2)
其他的运算包括有 subtract(减)，divide(除)和mod（余数）
数组
数组声明
数组是一种数据结构，用来存储同一类型值的集合
数组声明方式：
int[] array 或者int array[]
数组初始化
int[] array = new int[100];
int[] arry = new int[]{1,2,3,4,5}
int[] array = {1,2,3,4,5}
创建一个数字数组时，所有的元素都初始化为0。
boolean数组的元素会初始化为false
对象数组的元素会初始化为一个特殊值null
public class Array {
public static void main(String[] args) {
int[] test = new int[5];
for(int i =0;i输出的结果会是： 0 0 0 0 0
重要：
一旦创据数组，就不能再改变数组的大小。如果需要在运行中扩展数组的大小，则需要使用另一种数据结构——数组列表（array list)
for each循环
Java有一种很强的循环结构，可以用来依次处理数组中的每个元素而不必为指定下标值而分心。
格式：
for(variable:collection) statement
定义一个变量用于暂存集合中的每一个元素，并执行相应的语句。
collection这一集合表达式必须必须是一个数组或者是一个实现了Iterable接口的类对象（例如Arraylist)。
eg:
for(int element ：a)
System.out.println(element)
//打印数组a的每一个元素，一个元素占一行
// for each element in a
数组拷贝
在java中，允许将一个数组变量拷贝到给另一个数组变量。这时，两个变量将引用同一个数组
int[] a = {2,3,5,7,11,12};
int[] b = a;
a[5] = 12 // b[2] = 12
如果想将一个数组的所有值拷贝到一个新的数组去，使用Arrays类的copyTo方法。
int[] copieda = Arrays.copyTo(a,a.length);
第二个参数是新数组的长度，可以通过这个方法来增加数组的大小。
eg: Arrays.copyTo(a,2*a.length); 增加到2倍大
如果数组元素是数字数组时，多余的元素都赋值为0。
如果数组元素是boolean数组，多余的元素会赋值为false
如果数组元素是对象数组的元素，多余的元素赋值为特殊值null
如果长度小于原始数组的长度，则只拷贝前面的数据元素