说明：本文很多引用子尚硅谷
开发环境
JDK = JRE开发工具集（例如javac编译工具）
JRE = JVM + Java SE 标准类库** **
变量的分类
1. 整型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
① byte范围：-128 ~ 127
② 声明long型变量，必须以"l"或"L"结尾
③ 通常，定义整型变量时，使用int型。
④整型的常量，默认类型是：int型
2. 浮点型：float(4字节) \ double(8字节)
① 浮点型，表示带小数点的数值
② float表示数值的范围比long还大
③ 定义float类型变量时，变量要以"f"或"F"结尾
④ 通常，定义浮点型变量时，使用double型。
⑤ 浮点型的常量，默认类型为：double
3. 字符型：char (1字符=2字节)
① 定义char型变量，通常使用一对'',内部只能写一个字符
② 表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
4.布尔型：boolean
① 只能取两个值之一：true 、 false
② 常常在条件判断、循环结构中使用
自动类型转换(只涉及7种基本数据类型
- 当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
- byte 、char 、short --> int --> long --> float --> double
- 特别的：当byte、char、short三种类型的变量做运算时，结果为int型
- 整型的默认类型是int,浮点型默认的类型是double
运算符
面试题型：char+char = int 这种运算会改变结果的数据类型
赋值运算符：= += -= *= /= %=
运算的结果不会改变变量本身的数据类型
方式一：num = num + 2;
方式二：num += 2; (推荐)
方式一：num = num + 1;
方式二：num += 1;
方式三：num++; (推荐)
逻辑运算符：& && | || ! ^
- 区分& 与 &&
- 相同点1：& 与 && 的运算结果相同
- 相同点2：当符号左边是true时，二者都会执行符号右边的运算
- 不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
- 开发中，推荐使用&&
逻辑运算符操作的都是boolean类型的变量。而且结果也是boolean类型
位运算符：<< >> >>> & | ^ ~
你能否写出最高效的2 * 8的实现方式？
答案：2 << 3 或 8 << 1
【特别说明的】
- 位运算符操作的都是整型的数据
-
<< ：在一定范围内，每向左移1位，相当于 * 2
>> :在一定范围内，每向右移1位，相当于 / 2
switch-case选择结构
switch结构中的表达式，只能是如下的6种数据类型之一：
byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)
排序算法
- 衡量排序算法的优劣：
- 时间复杂度、空间复杂度、稳定性
- 排序的分类：内部排序 与 外部排序（需要借助于磁盘）
- 不同排序算法的时间复杂度
冒泡排序
int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
for(int i = 0;i < arr.length - 1;i++){
for(int j = 0;j < arr.length - 1 - i;j++){
if(arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
快速排序
public class QuickSort {
private static void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
private static void subSort(int[] data, int start, int end) {
if (start < end) {
int base = data[start];
int low = start;
int high = end + 1;
while (true) {
while (low < end && data[++low] - base <= 0)
;
while (high > start && data[--high] - base >= 0)
;
if (low < high) {
swap(data, low, high);
} else {
break;
}
}
swap(data, start, high);
subSort(data, start, high - 1);//递归调用
subSort(data, high + 1, end);
}
}
public static void quickSort(int[] data){
subSort(data,0,data.length-1);
}
public static void main(String[] args) {
int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
quickSort(data);
System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
}
}
数组
数组一旦初始化，其长度就是确定的。arr.length
数组长度一旦确定，就不可修改。
** 数组初始化 **
> 数组元素是整型：0> 数组元素是浮点型：0.0> 数组元素是char型：0或'\u0000'，而非'0'> 数组元素是boolean型：false> 数组元素是引用数据类型：null
二维数组中，每个维度的长度可以不一样
int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
System.out.println(arr1[0].length); //3
System.out.println(arr1[1].length); //2
System.out.println(arr1[2].length); //3
数组的初始化
正确的方式：
int[] arr = new int[]{1,2,3};//一维数组
//静态初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
//动态初始化1
String[][] arr2 = new String[3][2];
//动态初始化2
String[][] arr3 = new String[3][];
//也是正确的写法：
int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};//类型推断
错误的方式：
// String[][] arr4 = new String[][4];
// String[4][3] arr5 = new String[][];
// int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};
- ⑤ 数组元素的默认初始化值
- 针对于初始化方式一：比如：int[][] arr = new int[4][3];
外层元素的初始化值为：地址值内层元素的初始化值为：与一维数组初始化情况相同- 针对于初始化方式二：比如：int[][] arr = new int[4][];
外层元素的初始化值为：null内层元素的初始化值为：不能调用，否则报错。
