变量与常量
1、变量的声明、赋值与输出
@Test
public void test05() {
int a = 10; //变量的赋值：数据类型 变量名 赋值符号 变量值分号
//变量就是在内存中凯尼一个空间，名就是空间的名字，查找用，值就是空间中所存放的东旭
System.out.println(a); //变量的输出 输出变量时不能加””，若增加，则只输出变量名
//八种基本的数据类型
byte z = 10; //数值型-整数型-byte变量，占用1B空间
short y = 10; //数值型-整数型-short变量，占用2B空间
int x = 10; //数值型-整数型-int变量，占用4B空间
long w = 10L; //数值型-整数型-long变量，占用8B空间，变量赋值时需要加L
double v = 10.0d; //数值型-浮点型-double变量，占用8B空间，变量赋值时需要加d
float u = 10.0f; //数值型-浮点型-float变量，占用4B空间，变量赋值时需要加f
char t = ‘t’; //字符型-char变量，占用2B空间，在java中采用unicode编码，所以占用2B
boolean s = true; //布尔型-boolean变量，占用1B空间，只有true或false
boolean r = false;
}
2、数据类型的修改
小转大自动转，大转小强制转
int a = 10; long b = a; // √
long a = 10; int b = a; // ×
注意：强制转换可以但会造成数据失真
3、常量，不可修改
final int a = 1;
此后a不可修改
字符串
1、字符串声明、赋值与读取
@Test
public void test01() {
String a = “忽如一夜春风来，”;
String b = “千树万树梨花开。”;
System.out.println(a); // 输出字符串时不能加””，若增加，则只输出变量名
System.out.println(b);
}
2、字符串拼接
@Test
public void test03() {
String a = “忽如一夜春风来，”;
String b = “千树万树梨花开。”;
System.out.print(“北风卷地白草折，胡天八月即飞雪。” + “\n”);
System.out.println(a + b); //+左右有一端为字符串即表示拼接，左右均需要有空格
System.out.println(“散入珠帘湿罗幕，狐裘不暖锦衾薄。”);
String c = “将军角弓不得控，”;
System.out.println(c.concat(“都护铁衣冷难着。”)); //.concat 用的极少，比较麻烦
}
转义字符
System.out.print(“aaaaa\””); // \” 输出”
System.out.print(“bbbbb\n”); // \n 换行
System.out.print(“ccccc\r”); // \r 回车
System.out.print(“ddddd\t”); // \t tab位
System.out.print(“eeeee\\” + “\n”); // \\ 转义输出\
预定义格式
@Test
public void test04() {
System.out.println(“””
我爱你中国，
亲爱的母亲。
我为你骄傲，
我为你自豪。
“””);
//使用”””xxx”””输出xxx，内部格式可直接输出
}
运算符
1、数学运算符
@Test
public void test05() {
int a = 1;
int b = 2;
int c = a % b; // % 取模运算，只取余数
double e = (a + 0.0f) / b;
double f = (a + 0.0f) / 4; //java中除法为地板除
System.out.println(c);
System.out.println(e);
System.out.println(f); //Java中浮点型计算能但不精确
}
@Test
public void test06() {
int a = 10;
System.out.println(a++); //自增运算，此时输出a原值，因为先取a值输出才进行自增
System.out.println(++a); //自增运算，此时输出a++的值，因为先进行自增才取a值输出
System.out.println(a);
int b = a++; //b输出a原值，因为先取了a值赋给b才进行a的自增运算，之后并没有第二次给b赋值
// int b = a;
// a = a + 1;
System.out.println(b);
System.out.println(a);
}
2、比较运算符
@Test
public void test13() {
System.out.print(“10 == 10 >>>” + (10 == 10) + “\t”); // == 等于，比较对象是否相等
System.out.println(“10 == 20 >>>” + (10 == 20));
System.out.print(“10 != 10 >>>” + (10 != 10) + “\t”); // != 不等于，比较对象是否不等
System.out.println(“10 != 20 >>>” + (10 != 20));
System.out.print(“10 > 20 >>>” + (10 > 20) + “\t”); // > 大于，返回x大于y的结果
System.out.println(“10 < 20 >>>” + (10 < 20)); // < 小于，返回x小于y的结果
System.out.print(“10 <= 10 >>>” + (10 <= 10) + “\t”); // <= 小于等于，返回x小于等于y的结果
System.out.print(“10 <= 11 >>>” + (10 <= 11) + “\t”);
System.out.println(“10 <= 9 >>>” + (10 <= 9));
System.out.print(“10 >= 10 >>>” + (10 >= 10) + “\t”); // >= 大于等于，返回x大于等于y的结果
System.out.print(“10 >= 11 >>>” + (10 >= 11) + “\t”);
System.out.println(“10 >= 9 >>>” + (10 >= 9));
// 输出值为True或False
}
3、逻辑运算符
（1）、
逻辑与&
短路与&&
@Test
public void test01() {
int a = 10;
int b = 20;
int c = 30;
// 逻辑与 &
// （逻辑）短路与 &&
System.out.println(“a < b && a < c >>> ” + (a < b && a < c));
// &&符号两端表达式返回结果同时为true的时候则整体返回值为true
System.out.println(“a > b && a > c >>> ” + (a > b && a > c));
// &&符号两端表达式返回有一个为false则整体返回值为false 当第一个表达式返回结果为false的时候则第二个表达式不再计算 直接整体返回false
System.out.println(“a < b & a < c >>> ” + (a < b & a < c));
// &符号两端表达式返回结果同时为true的时候则整体返回值为true
System.out.println(“a > b & a > c >>> ” + (a > b & a > c));
// &符号两端表达式返回有一个为false则整体返回值为false，当第一个表达式返回结果为false的时候第二个表达式仍然需要计算
}
（2）
逻辑或|
短路或||
@Test
public void test02() {
int a = 10;
int b = 20;
int c = 30;
// 逻辑或 |
// （逻辑）短路或 ||
System.out.println(“a < b || a < c >>> ” + (a < b || a < c));
// ||符号两端表达式返回结果有一个为true的时候则整体返回值为true 当第一个表达式返回结果为true的时候则第二个表达式不再计算 直接整体返回true
System.out.println(“a > b || a > c >>> ” + (a > b || a > c));
// ||符号两端表达式返回均为为false则整体返回值为false
System.out.println(“a < b | a < c >>> ” + (a < b | a < c));
// |符号两端表达式返回结果有一个为true的时候则整体返回值为true 当第一个表达式返回结果为true的时候第二个表达式仍然要做计算
System.out.println(“a > b | a > c >>> ” + (a > b | a > c));
// |符号两端表达式返回均为为false则整体返回值为false
}
（3）
逻辑非！
@Test
public void test03() {
// 逻辑非 ！输出相反的结果
System.out.println(“!true => ” + !true);
System.out.println(“!false => ” + !false);
System.out.println(“!!true => ” + !!true);
System.out.println(“!!false => ” + !!false);
}
4、位运算符
@Test
public void test04() {
// &按位与运算
System.out.println(5 & 3);
// |按位或运算
System.out.println(5 | 3);
// ^按位异或运算 二进制，相同输出0，不同输出1
// 原数据根据参考数据得到一个新数据，再次异或该参考数据会得到原数据 可以用来加密
System.out.println(5 ^ 3);
System.out.println(6 ^ 3);
// ~按位取反 二进制中最高位为符号位，0正1负
System.out.println(~ 3);
}
5、左移与右移
@Test
public void test05() {
//右移相当于除以2的n次幂
//无符号右移 >>> 也叫逻辑右移若该数为正，则最高位补0，负数同样补0 无符号右移一般正数运算时使用
System.out.println(8 >>> 2);
//右移 >> 若该数为正，则最高位补0，负数补1
System.out.println(8 >> 2);
System.out.println(-4 >> 2);
System.out.println(4 >> 3);
System.out.println(-4 >> 1);
//左移相当于乘以2的n次幂
//最低位补0
System.out.println(2 << 2);
System.out.println(-2 << 2);
}
判断与循环
1、判断
（1）if语句
if(判断内容){判断内容为true时需要执行的内容}
@Test
public void test01() {
boolean rain = true;
if (rain) {
System.out.println(“不上课”);
}
System.out.println(“结束”);
}
（2）if-else语句
if(判断内容){判断内容为true时需要执行的内容}
else{判断结果为false时需要执行的内容}
@Test
public void test02() {
boolean rain = true;
if (rain) {
System.out.println(“今天不上课”);
} else {
System.out.println(“上课”);
}
System.out.println(“结束”);
}
（3）if-else-if语句
if(判断的内容){判断内容为true时需要执行的内容}
else if(判断的内容){判断内容为true时需要执行的内容}
else if(判断的内容){判断内容为true时需要执行的内容}
@Test
public void test07() {
Random random = new Random();
int i = random.nextInt(7);
System.out.println(i);
if (i == 1) {
System.out.println(“今天是星期一”);
} else if (i == 2) {
System.out.println(“今天是星期二”);
} else if (i == 3) {
System.out.println(“今天是星期三”);
} else if (i == 4) {
System.out.println(“今天是星期四”);
} else if (i == 5) {
System.out.println(“今天是星期五”);
} else if (i == 6) {
System.out.println(“今天是星期六”);
} else if (i == 0) {
System.out.println(“今天是星期日”);
}
}
（4）if语句的简写
判断 ? “判断结果为true时需要执行的内容”:”判断结果为false时需要执行的内容”
@Test
public void test04() {
boolean rain = true;
String weather = rain ? “不上课” : “上课”;
System.out.println(“今天” + weather);
System.out.println(“结束”);
}
（5）switch-case语句
@Test
public void test08() {
Random random = new Random();
int i = random.nextInt(7);
System.out.println(i);
switch (i) {
case 1:
System.out.println(“今天是星期一”);
break;
case 2:
System.out.println(“今天是星期二”);
break;
case 3:
System.out.println(“今天是星期三”);
break;
case 4:
System.out.println(“今天是星期四”);
break;
case 5:
System.out.println(“今天是星期五”);
break;
case 6:
System.out.println(“今天是星期六”);
break;
default:
System.out.println(“今天是星期日”);
break;
}
}
2、循环
（1）while循环
@Test
public void test01() {
int i = 0;
while (i < 10) {
if (i % 2 == 0) {
System.out.println(i);
}
}
i++;
}
continue为跳过但继续循环
@Test
public void test04() {
int i = 0;
while (i < 10) {
if (i % 2 != 0) {
i++;
continue;
}
System.out.println(i++);
}
}
break为打断循环
@Test
public void test05() {
int i = 1;
while (i <= 5) {
System.out.println(“输出第” + i++ + “次”);
if (i == 3) {
System.out.println(“技能被打断”);
break;
}
}
}
（2）for循环
@Test
public void test07() {
for (int i = 0; i < 10; i++) {
if (i == 5) {
break;
}
System.out.println(“第” + (i + 1) + “次”);
}
}
（3）双层for循环
@Test
public void test12() {
for (int i = 0; i < 9; i++) {
for (int j = 0; j < i + 1; j++) {
System.out.print((j + 1) + “*” + (i + 1) + “=” + (j + 1) * (i + 1) + “\t”);
}
System.out.print(“\n”);
}
}
数组
1、数组的声明、赋值与读取
相同类型的元素组成的集合称为数组
三种声明方法:（1）
声明一个整数数组为a，并赋值给它三个值
int[] arr = { 10, 20, 30 };
读取数组下标为0位置上元素的值
System.out.println(arr[0]);
（2）
声明一个整数数组啊，并给他一个长度为6（这样声明时候必须带上长度）
int[] a = new int[6];
//给数组下标为2位置上的元素赋值
arr[2] = 20;
//读取数组下标为2位置上元素的值
System.out.println(arr[2]);
（3）
//{}中的为数组中元素的值 不是数组的长度
int[] arr = new int[] { 1, 2, 3 };
//读取数组下标为2位置上元素的值
System.out.println(arr[2]);
数组读取时，注意下标从0开始，而不是从1开始
读取的位置没有赋值时会读取到该数组数据类型的默认值
.length属性获取数组长度
读取
（1）利用for循环遍历数组输出
@Test
public void test05() {
String[] a0 = new String[4];
a0[0] = “北风卷地白草折”;
a0[1] = “胡天八月即飞雪”;
a0[2] = “忽如一夜春风来”;
a0[3] = “千树万树梨花开”;
for (int i = 0; i < a0.length; i++) {
System.out.println(a0[i]);
}
}
（2）利用toString将数组转化成字符串输出
@Test
public void test06() {
String[] a0 = new String[4];
a0[0] = “北风卷地白草折”;
a0[1] = “胡天八月即飞雪”;
a0[2] = “忽如一夜春风来”;
a0[3] = “千树万树梨花开”;
System.out.println(Arrays.toString(a0));
}
（3）利用for循环输出指定的元素
@Test
public void test07() {
int[] arr0 = new int[] { 1, 6, 7, 65, 45, 78, 34 };
System.out.print(“偶数:”);
for (int i = 0; i < arr0.length;) {
if (arr0[i] % 2 == 0) {
System.out.print(arr0[i] + “\0”);
}
i++;
}
System.out.print(“\n奇数:”);
for (int j = 0; j < arr0.length;) {
if (arr0[j] % 2 == 1) {
System.out.print(arr0[j] + “\0”);
}
j++;
}
}
（4）增强for循环
@Test
public void test14() {
String[] array = {“我”, “爱”, “你”};
for (String string : array) {
System.out.println(string);
}
}
2、数组的合并
（1）数组的简单合并
@Test
public void test02() {
int[] arr0 = { 1, 3, 5, 7, 9 }; // 数组一
int[] arr1 = { 0, 2, 4, 6, 8 }; // 数组二
int z = arr0.length + arr1.length; // 新数组长度为两数组长度之和
int[] arr2 = new int[z]; // 定义新数组
for (int i = 0; i < arr0.length; i++) { // 将数组一的元素按下标赋值给新数组的同样下标
arr2[i] = arr0[i];
}
for (int j = arr0.length; j < z; j++) { // 新数组的前几个下标（数组一长度）已占用，所以从后便开始
arr2[j] = arr1[j – arr0.length]; // 新数组的后几个下标（j）等于数组二的（j-长度）下标，赋值
}
/**
* 第二遍for循环可以
* for(int j = 0;j < arr1.length;j++){
* arr2[j + arr0.length] =arr1[j];
* }
*/
System.out.println(Arrays.toString(arr2));
}
（2）隔位组合数组
数组长度一致
@Test
public void test03() {
int[] arr0 = { 0, 2, 4, 6, 8 };// 数组一
int[] arr1 = { 1, 3, 5, 7, 9 };// 数组二
int z = arr0.length + arr1.length;// 新数组长度为两数组长度之和
int[] arr2 = new int[z];// 定义新数组
for (int i = 0; i < arr0.length; i++) {
arr2[2 * i] = arr0[i];
arr2[2 * i + 1] = arr1[i];
}
System.out.println(Arrays.toString(arr2));
}
3、数组排序
（1）数组排序时需要用到元素值的交互
三种交互方法
1.引入中间变量
int a = 10 , b = 20;
// 虽然多使用了变量但是容易理解
int c = a;
a = b;
b = c;
2.利用数学运算符
int a = 10 , b = 20;
//借助数学公式 但不推荐 有数据失真的风险
a = a + b;
b = a – b;
a = a – b;
3.利用位运算符
int a = 10 , b = 20;
//利用按位异或运算 虽然效率高但不好理解
a = a ^ b;
b = a ^ b;
a = a ^ b;
（2）数组排序可能需要用到寻找数组最大最小值
获取最大值
@Test
public void test01() {
// 需求: 获取数组中的最大值
int[] arr = { 23, 32, 12, 21, 19, 91 };
// 思路: 找一个和中间变量 将数组中的最后一个位置上的元素存储在该中间比哪里中 然后依次比较数组中所有元素的值
// 获取数组中最后一个元素的值
int max = arr[arr.length – 1];
for (int i = 0; i < arr.length – 1; i++) {
// 获取元素的值
int j = arr[i];
// 和中间变量比较 将最大值赋值给中间变量
max = max > j ? max : j;
}
System.out.println(“数组中最大值 >>> ” + max);
}
获取最小值
@Test
public void test02() {
// 需求: 获取数组中的最小值
int[] arr = { 23, 32, 12, 21, 19, 91 };
// 思路: 找一个和中间变量 将数组中的最后一个位置上的元素存储在该中间比哪里中 然后依次比较数组中所有元素的值
// 获取数组中最后一个元素的值
int min = arr[arr.length – 1];
for (int i = 0; i < arr.length – 1; i++) {
// 获取元素的值
int j = arr[i];
// 和中间变量比较 将最小值赋值给中间变量
min = min < j ? min : j;
}
System.out.println(“数组中最值 >>> ” + min);
}
（3）数组的排序方法
冒泡排序、插入排序、选择排序、希尔排序、快速排序、Arrays.sort排序、归并排序、堆排序、计数排序、桶排序、基数排序等
1.Arrays.sort排序
@Test
public void test01() {
int[] arr0 = { 23, 32, 12, 21, 19, 91 };
// 调用java自带的指令排序
System.out.println(“排序前：” + Arrays.toString(arr0));
Arrays.sort(arr0);
System.out.println(“排序后：” + Arrays.toString(arr0));
}
2.插入排序
@Test
public void test02() {
int[] arr0 = { 23, 32, 12, 21, 19, 91 };
// 插入排序
System.out.println(“排序前：” + Arrays.toString(arr0));
for (int i = 1; i < arr0.length; i++) {
int a = arr0[i];
int j;
for (j = i; j > 0 && arr0[j – 1] > a; j–) {
arr0[j] = arr0[j – 1];
}
arr0[j] = a;
}
System.out.println(“排序后：” + Arrays.toString(arr0));
}
3.冒泡排序
@Test
public void test03() {
int[] arr0 = { 23, 32, 12, 21, 19, 91 };
// 冒泡排序
System.out.println(“排序前：” + Arrays.toString(arr0));
for (int i = 0; i < arr0.length – 1 ; i++) {
for (int j = 1; j < arr0.length – i; j++) {
if (arr0[j – 1] > arr0[j]) {
int a = arr0[j];
arr0[j] = arr0[j – 1];
arr0[j – 1] = a;
}
}
}
System.out.println(“排序后：” + Arrays.toString(arr0));
}
4、数组的一些工具类
（1）Copyof拷贝数组
copyOf（原数组，新数组长度） = 数组的拷贝
生成新数组，按下标对应，多的丢掉 少的默认值
@Test
public void test01() {
// copyOf(原数组,新数组长度) = 数组的拷贝
String[] arr0 = {“我”, “爱”, “你”};
System.out.println(Arrays.toString(arr0));
String[] arr1 = Arrays.copyOf(arr0, 5);
System.out.println(Arrays.toString(arr1));
String[] arr2 = Arrays.copyOf(arr0, 2);
System.out.println(Arrays.toString(arr2));
}
（2）数组的插入覆盖
将数组0的1下标开始截取，从2下标替换数组1，截取三个长度
不生成新数组
注意截取数组0长度时不能溢出，存的时候也不能溢出
@Test
public void test02() {
int[] arr0 = {0, 1, 2, 3, 4};
int[] arr1 = {5, 6, 7, 8, 9};
System.arraycopy(arr0, 1, arr1, 2, 3);
System.out.println(Arrays.toString(arr1));
}