一、基本数据类型
8种基本数据类型
boolen、char、byte、short、int、long、float、double
byte：占用1个字节
short：占用2个字节
int：占用4个字节
long：占用8个字节
单精度和双精度
float:占4个字节
double：占8个字节
为啥不能用“==”比较浮点数
原因：存储和转换的过程中浮点数容易引起一些较小的舍入误差，正是这个原因，导致在比较浮点数的时候，不能使用“==”操作符
解决：
第一种方案就是使用 Math.abs() 方法来计算两个浮点数之间的差异，如果这个差异在阈值范围之内，我们就认为两个浮点数是相等。Math.abs() 方法用来返回 double 的绝对值，如果 double 小于 0，则返回 double 的正值，否则返回 double。也就是说，abs() 后的结果绝对大于 0，如果结果小于阈值（THRESHOLD），我们就认为 d1 和 d2 相等。
第二种解决方案就是使用 BigDecimal 类，可以指定要舍入的模式和精度，这样就可以解决舍入的误差。 可以使用 BigDecimal 类的 compareTo() 方法对两个数进行比较，该方法将会忽略小数点后的位数，怎么理解这句话呢？比如说 2.0 和 2.00 的位数不同，但它俩的值是相等的。
包装类型和基本类型
Java 的每个基本类型都对应了一个包装类型，比如说 int 的包装类型为 Integer，double 的包装类型为 Double。基本类型和包装类型的区别主要有以下 4 点。
1、包装类型可以为 null，而基本类型不可以
2、包装类型可用于泛型，而基本类型不可以：
List list = new ArrayList<>(); // 提示 Syntax error, insert "Dimensions" to complete ReferenceType
List list = new ArrayList<>();
3、基本类型比包装类型更高效：基本类型在栈中直接存储的具体数值，而包装类型则存储的是堆中的引用
4、两个包装类型的值可以相同，但却不相等：两个包装类型在使用“==”进行判断的时候，判断的是其指向的地址是否相等。
自动拆箱与装箱
既然有了基本类型和包装类型，肯定有些时候要在它们之间进行转换。把基本类型转换成包装类型的过程叫做装箱（boxing）。反之，把包装类型转换成基本类型的过程叫做拆箱（unboxing）
Integer 的缓存机制
Integer A=-128;
Integer AA=-128;
System.out.printf("A=AA? %s
",A==AA) //ture
Integer A=127;
Integer AA=127;
System.out.printf("A=AA? %s
",A==AA) //ture
Integer B=128;
Integer BB=128;
System.out.printf("B=BB? %s
",B==BB) //false
这是因为Integer类在负128至127(默认)区间的Integer实例缓存到cache数组中,Integer是对小数据（-128~127）是有缓存的，jvm初始化的时候，数据-128~127之间的数字便被缓存到了本地内存中，这样，如果初始化-128~127之间的数字，便会直接从内存中取出，而不需要再新建一个对象
二、操作符
算术运算符：+、-、*、/、%、++，--
逻辑运算符：&&、||、！
关系运算符：==、！=、>、<、>=、<=
位运算符：
＆ ：如果相对应位都是1，则结果为1，否则为0 （A＆B），得到12，即0000 1100
|： 如果相对应位都是 0，则结果为 0，否则为 1 （A | B）得到61，即 0011 1101
^ ：如果相对应位值相同，则结果为0，否则为1 （A ^ B）得到49，即 0011 0001
〜： 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 （〜A）得到-61，即1100 0011
<< ：按位左移运算符。左操作数按位左移右操作数指定的位数。 A << 2得到240，即 1111 0000
>> ：按位右移运算符。左操作数按位右移右操作数指定的位数。 A >> 2得到15即 1111
>>> ：按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。
赋值运算符：=、+=，-=，*=，/=、(%)=、<<=、>>=、&=、^=、|=
条件运算符：(?:)三元运算符
三、流程控制语句
条件分支（if/else/else if、三元运算符、switch）
循环或者遍历（for、while、do-while）
break 和 continue
四、main 方法详解
public关键字
关键字是可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。可以在其他任何类或包中引用 public 类、方法或字段。 所有类成员的默认访问范围都是 package 访问，也就是说，除非存在特定的访问控制修饰符，否则，可以从同一个包中的任何类访问类成员
static关键字：
static 关键字可用于变量、方法、代码块和内部类，表示某个特定的成员只属于某个类本身，而不是该类的某个对象。
1、静态变量
静态变量也叫类变量，它属于一个类，而不是这个类的对象。静态变量和成员变量有着很大的不同，成员变量的值属于某个对象，不同的对象之间，值是不共享的；但静态变量不是的，它可以用来统计对象的数量，因为它是共享的
2、静态方法也叫类方法，它和静态变量类似，属于一个类，而不是这个类的对象。
1）Java 中的静态方法在编译时解析，因为静态方法不能被重写（方法重写发生在运行时阶段，为了多态）。
2）抽象方法不能是静态的。
3）静态方法不能使用 this 和 super 关键字。
4）成员方法可以直接访问其他成员方法和成员变量。
5）成员方法也可以直接方法静态方法和静态变量。
6）静态方法可以访问所有其他静态方法和静态变量。
7）静态方法无法直接访问成员方法和成员变量。
3、静态代码块可以用来初始化静态变量，尽管静态方法也可以在声明的时候直接初始化，但有些时候，我们需要多行代码来完成初始化。一个类可以有多个静态代码块。
4、静态内部类：常见的内部类有四种，成员内部类、局部内部类、匿名内部类和静态内部类
1）静态内部类不可访问外部类的所有成员变量。
2）静态内部类可以访问外部类的所有成员变量，包括私有变量。
3）外部类不能声明为 static。
void关键字
可以用作方法的返回类型，以指示该方法不返回值。
main关键字
一个程序执行的入口， jvm执行时会去以main方法作为入口
字符串数组参数(string [] args)
专门用来接收命令行参数的
五、JAVA数组
注：Java 获取数组长度的时候用 length，获取字符串长度的时候用的是 length()
创建数组：
arrayRefVar = new dataType[arraySize];
dataType[] arrayRefVar = new dataType[arraySize];
dataType[] arrayRefVar = {value0, value1, ..., valuek};
访问数组、遍历数组
double[] myList = {1.9, 2.9, 3.4, 3.5}; // 打印所有数组元素
for (int i = 0; i < myList.length; i++) {
System.out.println(myList[i] + " ");
}
double[] myList = {1.9, 2.9, 3.4, 3.5}; // 打印所有数组元素
for (double element: myList) {
System.out.println(element);
}
打印数组：
1、使用Stream
String [] A = {"周一","周二","周三"};
1）、Arrays.asList(A).stream().forEach(s -> System.out.println(s));
2）、Stream.of(A).forEach(System.out::println);
3）、Arrays.stream(A).forEach(System.out::println);
2、使用for循环
1）、for(int i = 0; i < A.length; i++){ System.out.println(A[i]); }
2）、for (String s : A) { System.out.println(s); }
3、使用 Arrays.toString()
System.out.println(Arrays.toString(A));
打印结果：[周一, 周二, 周三]
4、使用 Arrays.deepToString()
如果需要打印多维码数组的话，Arrays.toString() 就无能为力了。
String[][] deepArray = new String[][] {{"周四", "周五"}, {"明天放假二天"}};
System.out.println(Arrays.deepToString(deepArray));
打印结果：[[周四, 周五], [明天放假二天]]
数组排序
处理排序后的数组比没有排序的快
数组转成Stream
在 java8 中，您可以使用 Arrays.Stream 或 Stream.of 将 Array 转换为 Stream。
String[] array = {"a", "b", "c", "d", "e"}; //Arrays.stream
Stream stream = Arrays.stream(array);
stream.forEach(x-> System.out.println(x));
System.out.println("======"); //Stream.of
Stream stream1 = Stream.of(array);
stream1.forEach(x-> System.out.println(x));
数组转成List：
1、String[] strArray = new String[2];
List list = Arrays.asList(strArray);
2、String[] strArray = new String[2];
ArrayList list = new ArrayList(Arrays.asList(strArray)) ;
3、String[] strArray = new String[2];
ArrayList< String> arrayList = new ArrayList(strArray.length);
Collections.addAll(arrayList, strArray);
数组搜索：
1、使用 List
public static boolean useList(String[] arr, String targetValue) {
return Arrays.asList(arr).contains(targetValue);
}
contains() 方法调用了 indexOf() 方法，如果返回 -1 则表示 ArrayList 中不包含指定的元素，否则就包含。其中 indexOf() 方法用来获取元素在 ArrayList 中的下标，如果元素为 null，则使用“==”操作符进行判断，否则使用 equals() 方法进行判断。
2、使用 Set
public static boolean useSet(String[] arr, String targetValue) {
Set set = new HashSet(Arrays.asList(arr));
return set.contains(targetValue);
}
contains() 方法调用了 HashMap 的 containsKey() 方法，如果指定的元素在 HashMap 的键中，则返回 true；否则返回 false。
3、使用一个简单的循环
public static boolean useLoop(String[] arr, String targetValue) {
for (String s : arr) {
if (s.equals(targetValue))
return true;
}
return false;
}
for-each 循环中使用了 equals() 方法进行判断
4、使用 Arrays.binarySearch()
public static boolean useArraysBinarySearch(String[] arr, String targetValue) {
int a = Arrays.binarySearch(arr, targetValue);
if (a > 0) return true;
else return false;
}
不过，binarySearch() 只适合查找已经排序过的数组。
java.util.Arrays
1、创建数组
1）、copyOf，复制指定的数组，截取或用 null 填充
String[] intro = new String[] { "这", "是", "什", "么" };
String[] revised = Arrays.copyOf(intro, 3);
String[] expanded = Arrays.copyOf(intro, 5);
System.out.println(Arrays.toString(revised));
System.out.println(Arrays.toString(expanded));
输出结果： [这, 是, 什]
[这, 是, 什, 么, null]
2）、pyOfRange，复制指定范围内的数组到一个新的数组
String[] intro = new String[] { "就", "很", "神", "奇" };
String[] abridgement = Arrays.copyOfRange(intro, 0, 3);
System.out.println(Arrays.toString(abridgement));
copyOfRange() 方法需要三个参数，第一个是指定的数组，第二个是起始位置（包含），第三个是截止位置（不包含）
输出结果： [就, 很, 神]
3）、fill，对数组进行填充
String[] stutter = new String[3];
Arrays.fill(stutter, "简直了");
System.out.println(Arrays.toString(stutter))
使用 new 关键字创建了一个长度为 3 的数组，然后使用 fill() 方法将 3 个位置填充为“简直了”，来看一下输出结果
输出结果： [简直了, 简直了, 简直了]
2、比较数组
Arrays 类的 equals() 方法用来判断两个数组是否相等
3、数组排序
Arrays 类的 sort() 方法用来判断两个数组是否相等
4、数组检索
数组排序后就可以使用 Arrays 类的 binarySearch() 方法进行二分查找了。否则的话，只能线性检索，效率就会低很多。
String[] intro1 = new String[] { "jiu", "hen", "li", "pu" };
String[] sorted = Arrays.copyOf(intro1, 4);
Arrays.sort(sorted);
int exact = Arrays.binarySearch(sorted, "li");
System.out.println(exact);
int caseInsensitive = Arrays.binarySearch(sorted, "li", String::compareToIgnoreCase);
System.out.println(caseInsensitive);
输出结果： 3
3
5、数组转流
Arrays 类的 stream() 方法可以将数组转换成流：
6、打印数组
上面谈了很多种数组打印的方式
7、数组转 List
上面谈了很多种数组转List的方式
8、setAll
它提供了一个函数式编程的入口，可以对数组的元素进行填充
int[] array = new int[10];
Arrays.setAll(array, i -> i * 10);
System.out.println(Arrays.toString(array));
这段代码什么意思呢？i 就相当于是数组的下标，值从 0 开始，到 9 结束，那么 i * 10 就意味着 0 * 10 开始，到 9 * 10 结束
输出结果：[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
9、parallelPrefix
Java 8 之后提供的，提供了一个函数式编程的入口，通过遍历数组中的元素，将当前下标位置上的元素与它之前下标的元素进行操作，然后将操作后的结果覆盖当前下标位置上的元素。
int[] arr = new int[] { 1, 2, 3, 4};
Arrays.parallelPrefix(arr, (left, right) -> left + right);
System.out.println(Arrays.toString(arr));
输出结果： 1，2
3，3
6，4
[1, 3, 6, 10]
第一次是 1 和 2 相加，结果是 3，替换下标为 1 的位置
第二次是 3 和 3 相加，结果是 6，也就是第一次的结果和下标为 2 的元素相加的结果
第三次是 6 和 4 相加，结果是 10，也就是第二次的结果和下标为 3 的元素相加的结果
数组越界：为了摆脱ArrayIndexOutOfBoundsException,我们可以使用增强的 for 循环，当我们确定不需要使用下标的时候。
六、注释
单行注释：//
多行注释 ：/*.......*/
文档注释：/**......
注释真的不会被执行嘛？是的，但别在在注释//后面加u000d。u000d代表一个换行符。所以如果加了u000d，后面的内容就没有被注释掉
七、字符串
未完待续......