读取输入
打印输出到“ 标准输出流”（即控制台窗口）是一件非常容易的事情，只要 调用System.out.println 即可。然而，读取“ 标准输人流” System.in就没有那么简单了。要想通 过控制台进行输人，首先需要构造一个Scanner对象，并与“ 标准输人流” System.in关联。nextLine() 和 nextInt() 是 Scanner 类的常用方法，用于读取用户输入。
nextInt()
读取下一个整数，但不会读取整数后的换行符。
Scanner in=new Scanner(System.in);
int a =in.nextInt();
int b=in.nextInt();
int c =in.nextInt();
nextLine()
读取整行输入（包括空格和换行符），会消耗当前行的所有剩余字符。
String a=in.nextLine();
String b=in.nextLine();
String c=in.nextLine();
// System.out.println(d);
System.out.println(a);
System.out.println(b);
System.out.println(c);
常见问题：输入被跳过
当连续使用 nextInt() 和 nextLine() 时，可能出现 nextLine() 直接读取空字符串的情况。
原因：nextInt() 读取整数后，换行符 \n 仍留在输入缓冲区中，nextLine() 会直接读取这个换行符作为输入。
int d=in.nextInt();
nexLine 前边有其他输入，会多吃一空格，如果前面需要有其他输入，就在中间多吃一次，即in。nextLine
// in.nextLine();
String a=in.nextLine();
String b=in.nextLine();
String c=in.nextLine();
System.out.println(d);
System.out.println(a);
System.out.println(b);
System.out.println(c);
解决方案
方案一：在 nextInt() 后手动读取换行符
int d=in.nextInt();
nexLine 前边有其他输入，会多吃一空格，如果前面需要有其他输入，就在中间多吃一次，即in。nextLine
in.nextLine();
String a=in.nextLine();
String b=in.nextLine();
String c=in.nextLine();
System.out.println(d);
System.out.println(a);
System.out.println(b);
System.out.println(c);方案二：统一使用 nextLine() 读取输入
循环
for-each
for-each 循环也被叫做增强型 for 循环，它为遍历数组或集合提供了一种更为简洁的方式
int[] arr= {1,5,7,10};
for(int x:arr) {
System.out.println(x);
}
String[] arr2= {"aa","bb","cc"};
for(String x:arr2) {
System.out.println(x);
}
int[][] arr3= {{1,2},{3,4}};
for(int[] x:arr3) {
for(int z:x){
System.out.println(z);
}
}
switch
switch 语句是许多编程语言中常用的一种条件控制结构，它允许根据一个表达式的值来选择执行多个代码块中的某一个。在 Java 中，switch 语句可以接受 byte、short、char、int、enum 类型以及 String 类型的表达式。
int day = 3;
switch (day) {
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;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("无效的日期");
}switch击穿
“switch 击穿” 一般指的是在 switch 语句里，没有使用 break 语句来终止 case 块的执行，从而使得程序继续执行下一个 case 块的情况。
在多数编程语言中，switch 语句依据表达式的值来匹配对应的 case 标签。当找到匹配的 case 后，就会开始执行该 case 块中的代码。要是这个 case 块里没有 break 语句，程序不会跳出 switch 语句，而是会接着执行下一个 case 块中的代码，这就是 “击穿” 现象。
public class SwitchFallthroughExample {
public static void main(String[] args) {
int num = 2;
switch (num) {
case 1:
System.out.println("数字是 1");
case 2:
System.out.println("数字是 2");
case 3:
System.out.println("数字是 3");
default:
System.out.println("不是 1、2、3");
}
}
}
BigInteger
java.math.BigInteger 类能够处理任意大小的整数。它提供了丰富的方法来进行大整数的算术、逻辑和比较运算。
// 创建 BigInteger 对象
BigInteger num1 = new BigInteger("12345678901234567890");
BigInteger num2 = new BigInteger("98765432109876543210");
// 加法运算
BigInteger sum = num1.add(num2);
System.out.println("两数之和: " + sum);
// 乘法运算
BigInteger product = num1.multiply(num2);
System.out.println("两数之积: " + product);
// 比较大小
int compareResult = num1.compareTo(num2);
if (compareResult < 0) {
System.out.println(num1 + " 小于 " + num2);
} else if (compareResult > 0) {
System.out.println(num1 + " 大于 " + num2);
} else {
System.out.println(num1 + " 等于 " + num2);
}
拷贝
依据复制方式的不同，可分为浅拷贝和深拷贝。
浅拷贝
浅拷贝仅复制对象的一层属性。要是对象的属性是引用类型，那么浅拷贝只会复制引用，而不会复制对象本身，这就导致原对象和拷贝对象可能会共享一部分数据。
// 浅
int[] arr2= {4,7,8,9};
int[] arr4=arr2;
System.out.println(Arrays.toString(arr2));
System.out.println(Arrays.toString(arr4));
深拷贝
深拷贝会递归地复制对象的所有属性，包含引用类型的属性。这样原对象和拷贝对象就不会共享任何数据，对一方的修改不会影响到另一方
int[] arr2= {4,7,8,9};
int[] arr5 =new int[arr2.length];
for(int i=0;i<arr5.length;i++) {
arr5[i]=arr2[i];
}
arr5[0]=100;
System.out.println(Arrays.toString(arr2));
System.out.println(Arrays.toString(arr5));
排序
public class ArraySorting {
public static void main(String[] args) {
// 整数排序
Integer[] arr7 = {10, 1, 7, 2, 4};
// 使用 Lambda 表达式实现降序排序
Arrays.sort(arr7, (a, b) -> b - a);
// 或者使用 Collections.reverseOrder() 实现降序排序
// Arrays.sort(arr7, Collections.reverseOrder());
System.out.println(Arrays.toString(arr7));
// 字符串排序
String[] arr8 = {"aaa", "vvv", "ccc", "azz", "azc"};
Arrays.sort(arr8);
System.out.println(Arrays.toString(arr8));
Person x1 = new Person(20, 168, "李华");
Person x2 = new Person(19, 185, "赵雨");
Person x3 = new Person(24, 178, "周H");
Person[] arr10 = {x1, x2, x3};
// 按年龄升序排序
Arrays.sort(arr10, (a, b) -> a.age - b.age);
System.out.println(Arrays.toString(arr10));
}
}package com.qcby.基础类型;
public class Person {
int age;
int height;
String name;
public Person(int age, int height, String name) {
super();
this.age = age;
this.height = height;
this.name = name;
}
@Override
public String toString() {
return "Node [age=" +age + ", height=" + height + ", name=" + name + "]";
}
}
整数数组排序：
创建了一个 Integer 类型的数组 arr7。
使用 Arrays.sort 方法进行排序。Arrays.sort 方法有多个重载版本，这里使用的是接收一个数组和一个 Comparator 比较器的版本。(a, b) -> b - a 是一个 Lambda 表达式，它定义了一个比较器，实现了降序排序。如果 b - a 大于 0，则 b 应该排在 a 前面。也可以使用 Collections.reverseOrder() 来实现降序排序。
最后使用 Arrays.toString 方法将排序后的数组转换为字符串并打印。
字符串数组排序：
创建了一个 String 类型的数组 arr8。
直接调用 Arrays.sort 方法对数组进行排序。由于 String 类实现了 Comparable 接口，所以 Arrays.sort 方法会按照 String 的自然顺序（字典序）进行排序。
同样使用 Arrays.toString 方法打印排序后的数组。
自定义类对象数组排序：
创建了三个 Person 对象 x1、x2、x3，并将它们存储在数组 arr10 中。
使用 Arrays.sort 方法和 Lambda 表达式 (a, b) -> a.age - b.age 对数组进行排序。这个 Lambda 表达式定义了一个比较器，按照 Person 对象的 age 属性进行升序排序。如果 a.age - b.age 小于 0，则 a 应该排在 b 前面。
最后打印排序后的数组。
![[Lc5_dfs+floodfill] 简介 | 图像渲染 | 岛屿数量](https://i-blog.csdnimg.cn/img_convert/e1fc2ab6cdb0515915d880f275fb51cd.png)
