系统整理了 Java 核心基础知识点，包括访问修饰符（public/protected/private/default）与作用范围、行为修饰符（final/static/abstract/synchronized/volatile）的特性、面向对象编程四大特性（封装、继承、重写、重载、多态）、异常处理体系（Error/Exception/try-catch-finally）、运算符（位移/按位赋值）、数据类型默认值、Math 数学工具类、Scanner 输入流处理以及字符串转换与切割方法。文中提供代码示例辅助理解，适合 Java 开发者复习参考。
所有类（无论是否在同一个包或是否子类）都可以访问。用于类、方法、变量、构造函数。
//定义公开的类 public class text1 {
//定义公开的变量 public String name="aaa";
//定义公开的方法 public void printname(){ System.out.println("bbb"); }
//定义构造函数（方法） public text1() { }
}
同一个包内的类可以直接访问，不同包中的子类可以通过继承（extends）访问，不同包中的非子类无法访问。用于方法、变量（不能用于类和外部接口）。
//定义公开的类（protected 不能定义类） public class text1 {
//定义变量 protected String a = "A";
//定义方法 protected void rename(){ System.out.println("rename"); }
}
//不同包下的子类 text2 通过继承 text1 来访问 text1 中的变量和方法
class text2 extends text1{
protected void rname2(){ System.out.println(a); rename(); }
}
仅限声明它的类内部访问。方法、变量（不能用于类和外部接口），外部要使用getter/setter来访问。
//定义公开的类（private 不能定义类） public class text1 {
//定义私有变量 private String name="Alice";
//定义私有方法 private void rename(String name){ this.name=name; System.out.println(name); }
//定义公有方法来调用私有方法 public String getName() { return name; }
//setter public void setName(String name) { this.name = name; }
//getter public void name(String name){ rename(name); }
}
同一个包内的类可以直接访问，不同包中的类（无论是否子类）无法访问。用于类、方法、变量、构造函数。
//无修饰符的 default 类 class text1 {
//无修饰符的 default 变量 String name = "Alice";
//无修饰符的 default 方法 void rename(String name){ name=name; }
//无修饰符的 default 构造函数（无参） text1(){}
}
类中不能被继承，方法中不能被重写，变量中只能赋值一次（不可变）。
//final 类不能被扩展（继承) final class text1 {
//final 变量不可修改，只能赋值一次 final String name = "Alice";
//final 方法不能被重写 final void rename(String name){ name=name;//这是无效代码，因为 name 不能修改。 }
}
定义变量是属于类而不是对象，在对象中可以使用是因为实例共享，定义方法是属于类而不是对象，在对象中可以直接通过类名调用，**代码块（static{...代码...}）**在类第一次加载时才执行（自动）。
public class text1 {
//静态变量 static String name ="Alice";
//静态方法 public static void printname(){ System.out.println(name); }
//代码块 static { name=name+"Liu"; }
}
public class text {
public static void main(String[] args) {
//不需要 new 一个 text1 类的实例对象，而是可以直接使用类名来调用类中的静态变量和静态方法
System.out.println(text1.name);//类第一次加载时执行了代码块，使得原本的 name="Alice"改成了"AliceLiu"
text1.name="jack";//修改 name 的值，
text1.printname();//再次加载类时不会执行代码块，所以 name="jack"不会改为"jackLiu"
}
}
//AliceLiu
//jack
定义的类不能被实例化，只能被继承，定义的方法只有声明，没有实现，必须由子类重写。
//定义抽象类，只能继承 abstract class text1 {
//定义抽象方法，只能声明，子类才能重写 public abstract void print();
}
保证多线程环境下同步访问。
确保多线程环境下变量的可见性。
继承是面向对象编程（OOP）的三大核心特性之一（封装、继承、多态），允许一个类（子类/派生类）继承另一个类（父类/基类）的字段（成员变量）和方法，从而实现代码复用。子类可以扩展或修改父类的功能（重写），但无法直接访问父类的 private 成员（除非通过 getter/setter）。
单继承：Java 类只能直接继承一个父类（但可以实现多个接口）。
构造方法调用：子类构造方法必须调用父类构造方法（显式或隐式通过 super()）。
访问权限：子类可以访问父类的 public 和 protected 成员，但无法直接访问 private 成员。
public class text1 {
String name;
public text1() { }
public text1(String name) { this.name = name; }
public void rename(){ System.out.println(name+"***"); }
}
public class text extends text1{
//调用父类的构造方法 public text(String name) { super(name); }
public void rename(){ System.out.println(name+"..."); }
}
重写是子类重新定义父类中已有的方法，以提供不同的实现逻辑。
重写的方法必须与父类方法具有相同的名称、参数列表和返回类型（或子类返回类型是父类返回类型的子类，即协变返回类型）。
重写的方法访问权限不能比父类方法更严格（例如父类方法是 public，子类不能改为 private）。
运行时多态：通过父类引用调用重写方法时，实际执行的是子类的实现（动态绑定）。
@Override 注解：建议使用，帮助编译器检查是否正确重写。
不能重写：
final 方法（禁止重写）。static 方法（静态方法属于类，不属于对象，重写会隐藏父类方法）。private 方法（子类无法访问，谈不上重写）。//text1 是父类，提供了一个方法 public class text1 {
public void show(){ System.out.println("hello"); }
}
//text2 继承了 text1，可以重写父类的方法 public class text2 extends text1{
@Override//注解，用于显示表明重写 public void show(){ System.out.println("helloWorld"); }
}
public class text{
public static void main(String[] args) {
//父类引用指向子类对象 (demo1 的引用类型是 text1，但是实际类型是 text2）
//注意：demo1 只能调用子类中重写父类的方法（即只能调用父类中的方法，而不能调用子类独有的方法）
text1 demo = new text1();
text1 demo1 = new text2();
demo.show();
demo1.show();
}
}
//hello
//helloWorld
重载是在同一个类中定义多个同名方法，但参数列表不同（参数类型、数量或顺序不同）。形参列表不同指的是：形参的个数、类型、顺序不同，不关心形参的名称。（子类中的两个方法是继承了父类的方法来重写的话，即使两个方法在子类中满足重载的定义，也不是重载，因为是重写父类的方法）
编译时多态：根据调用时传入的参数类型和数量决定调用哪个方法（静态绑定）。
常见用途：提供多个便利方法（如 System.out.println() 的多种重载版本）。
public class text1 {
//show() 和 show(String) 两个方法是重载 public void show(){ System.out.println("hello"); }
public String show(String name){ return "hello"+name; }
}
多态是面向对象编程（OOP）的三大核心特性之一（封装、继承、多态），它允许同一方法调用在不同对象上表现出不同的行为。
Animal animal = new Cat();）①同一接口，不同实现：父类定义一个方法，子类可以重写该方法，提供自己的实现逻辑。
②运行时动态绑定：程序在运行时根据对象的实际类型决定调用哪个方法，而不是根据引用变量的声明类型。（如 Animal animal = new Cat();）
//text1 是父类，提供了一个方法 public class text1 {
public void show(){ System.out.println("hello"); }
}
//text2 继承了 text1，可以重写父类的方法 public class text2 extends text1{
@Override//注解，用于显示表明重写 public void show(){ System.out.println("helloWorld"); }
}
//text3 继承了 text1，可以重写父类的方法 public class text3 extends text1{
@Override public void show(){ System.out.println("hello world!"); }
}
public class text{
public static void main(String[] args) {
//父类引用指向子类对象 (demo1 的引用类型是 text1，但是实际类型是 text2）
//注意：demo1 只能调用子类中重写父类的方法（即只能调用父类中的方法，而不能调用子类独有的方法）
text1 demo = new text1();
text1 demo1 = new text2();
text1 demo2 = new text3();
demo.show();
demo1.show();
demo2.show();
}
}
//hello
//helloWorld
//hello world!
封装是将数据和方法包装在一起，限制对对象的直接访问，通常通过私有属性和公共 getter/setter 方法实现。
用于调试，在开发和测试阶段验证某些条件是否为真。如果条件为假，则抛出 AssertionError。
①assert true/false : 在抛出的异常里显示的内容;
②开启断言（IntelliJ IDEA 中）
public class text{
public static void main(String[] args) {
int x = 5;
assert x==10 : "x 不等于 10";
System.out.println("x 是"+x);
}
}
//开启断言
//Exception in thread "main" java.lang.AssertionError: x 不等于 10
// at dome.text.main(text.java:6)
//不开启断言
//x 是 5
Error 是 Java 中的严重错误，通常由 JVM 抛出，表示系统级错误，如 OutOfMemoryError、StackOverflowError 等。程序通常无法恢复或处理这些错误。
程序会崩溃。
Exception 是可以通过 try-catch 块程序可以捕获和处理的异常，通常由外部因素（如用户输入、文件读取等）引起，不会导致程序崩溃。Exception 分为 检查型异常（Checked Exception） 和 非检查型异常（Unchecked Exception，即 RuntimeException）。
程序捕获了异常后会打印错误信息并继续执行。不会导致程序崩溃（除非未捕获）。
用于执行必要的清理操作（如关闭文件、释放资源等），无论是否发生异常都会执行。
无论 try 块是否抛出异常，无论是否执行了 catch 块，甚至在 try 或 catch 块中使用了 return，finally 仍会执行。
try 块可以没有 catch，但如果有 finally，它必须与 try 配对。（即一个 try 块可以有多个 catch 块，只能有一个 finally 块）import java.util.Scanner;
public class text{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
try{
int a = input.nextInt();
}finally {
System.out.println("finally 运行...");
}
}
}
//hello
//finally 运行...
//Exception in thread "main" java.util.InputMismatchException
// at java.base/java.util.Scanner.throwFor(Scanner.java:943)
// at java.base/java.util.Scanner.next(Scanner.java:1598)
// at java.base/java.util.Scanner.nextInt(Scanner.java:2263)
// at java.base/java.util.Scanner.nextInt(Scanner.java:2217)
// at dome.text.main(text.java:10)
大部分运算符内容在《Java 的基础二》这篇文章中讲解了。
用于对二进制位进行操作。它们的主要作用是对数字的二进制表示进行移位，常用于底层编程、性能优化或特定算法（如哈希计算、加密等）。
将一个数的二进制表示向左移动指定的位数，右侧用 0 填充。效果：相当于对该数乘以 2^n（n 是移位的位数）。
public class text{
public static void main(String[] args) {
int a =5;//二进制位：00000101
int b = a<<3;//左移 2 位：00101000（即 40）
System.out.println(b);//输出 40（5*2^3=40)
}
}
//40
将一个数的二进制表示向右移动指定的位数，左侧用 符号位（正数补 0，负数补 1）填充。效果：相当于对该数除以 2^n（向下取整）。
public class text{
public static void main(String[] args) {
int a = 20;//二进制：00010100
int b = a>>2;//右移 2 位：00000101(即 5）
System.out.println(b);//输出 5（20/2^2=5)
int c=-20;//二进制（补码）：11101100
int d = c>>2;//右移 2 位：11111011（即 -5）
System.out.println(d);//输出 -5
}
}
//5
//-5
将一个数的二进制表示向右移动指定的位数，左侧 始终用 0 填充，无论该数是正数还是负数。效果：适用于无符号数（Java 的 int/long 是有符号的，但 >>> 可以模拟无符号行为）。
public class text{
public static void main(String[] args) {
int c=-20;//二进制（补码）：11101100
int d = c>>>2;//右移 2 位：00111011（即 1073741819）
System.out.println(d);
}
}
//1073741819
①作用&= 是二进制位运算，它对两个数的每一位进行 与操作。，相当于 x = x & y。它先对两个数进行 按位与（&）运算，然后将结果赋值给左侧变量。
&）规则：public class text{
public static void main(String[] args) {
int num1=5;//二进制：0101
int num2=3;//二进制：0011
num1&=num2;//即 num1=num1&num2
System.out.println(num1);
}
}
//1(0001)
^= 是按位异或赋值运算符，相当于 x = x ^ y。
^）规则：0。1。public class text{
public static void main(String[] args) {
int num1=5;//二进制：0101
int num2=3;//二进制：0011
num1^=num2;//即 num1=num1^num2
System.out.println(num1);
}
}
//6(0110)
|= 是按位或赋值运算符，相当于 x = x | y。
|）规则：1，结果为 1。0。public class text{
public static void main(String[] args) {
int num1=5;//二进制：0101
int num2=3;//二进制：0011
num1|=num2;//即 num1=num1 | num2
System.out.println(num1);
}
}
//7(0111)
| 数据类型 | 默认值 |
|---|---|
| byte | 0 |
| short | 0 |
| int | 0 |
| long | 0L |
| float | 0.0f |
| double | 0.0d |
| char | '\u0000' 或 '\0' |
| boolean | false |
| 类（Class） | null |
| 接口（Interface） | null |
| 数组（Array） | null |
Math 库是一个位于 java.lang 包中的工具类，提供了丰富的数学运算方法，且所有方法均为静态方法，可直接通过类名调用，无需调包。
参数类型：
int、long、float、double
public class Main{
public static void main(String [] args){
System.out.println(Math.abs(-10.3));
}
}
//10.3
参数类型：
int、long、float、double
public class Main{
public static void main(String [] args){
System.out.println(Math.max(10,8.9));
}
}
//10.0
a 的 b 次方参数类型：
double
public class Main{
public static void main(String [] args){
System.out.println(Math.pow(2,3));
}
}
//8.0
参数类型：
double
public class Main{
public static void main(String [] args){
System.out.println(Math.sqrt(16));
}
}
//4.0
参数类型：
double
public class Main{
public static void main(String [] args){
System.out.println(Math.ceil(-4.2));
}
}
//-4.0
参数类型：
public class Main{
public static void main(String [] args){
System.out.println(Math.round(4.5));
}
}
//5
参数类型：
double
public class Main{
public static void main(String [] args){
System.out.println(Math.rint(4.5));
System.out.println(Math.rint(5.5));
}
}
//4.0
//6.0
[0.0, 1.0) 之间的随机 double 值public class Main{
public static void main(String [] args){
int r = (int) (Math.random()*10);
System.out.println(r);
}
}
//7
public class Main{
public static void main(String [] args){
System.out.println(Math.PI);
}
}
//3.141592653589793
返回值类型：int
好处：直接读取整数，不会读取多余的空格或换行符，适合解析以空格分隔的多个整数。
import java.util.Scanner;
public class text4 {
public static void main(String[] arges) {
Scanner input=new Scanner(System.in);
int num=input.nextInt();
}
}
返回值：double
好处：直接读取浮点数，不会读取多余的空格或换行符，适合解析以空格分隔的多个浮点数。
import java.util.Scanner;
public class text4 {
public static void main(String[] arges) {
Scanner input=new Scanner(System.in);
double num=input.nextDouble();
}
}
返回值：String
好处：直接读取字符串，不会读取多余的空格或换行符，适合解析以空格分隔的多个字符串。
import java.util.Scanner;
public class text4 {
public static void main(String[] arges) {
Scanner input=new Scanner(System.in);
String num=input.next();
}
}
返回值：String
好处：会读取整行（包括空格和换行符），适合解析以空格分隔得整行数据（数组、列表等）
注意：如果要分割读取整行字符串，代码如下
String line = scanner.nextLine(); // 读取 "10 5"
String[] parts = line.split(" "); // 按空格分割，并存入数组中
import java.util.Scanner;
public class text4 {
public static void main(String[] arges) {
Scanner input=new Scanner(System.in);
String line = input.nextLine(); // 读取 "10 5"
String[] parts = line.split(" "); // 按空格分割
System.out.println(parts);
}
}
返回值：boolean
import java.util.Scanner;
public class text4 {
public static void main(String[] arges) {
Scanner input=new Scanner(System.in);
if (input.hasNextInt()) {
int N = input.nextInt();
}else {
System.out.println("请输入整数。");
}
}
}
返回值：boolean
import java.util.Scanner;
public class text4 {
public static void main(String[] arges) {
Scanner input=new Scanner(System.in);
while (input.hasNext()) { // 检查下一个输入是否有数
int num = input.nextInt(); // 读取整数
System.out.println("读取到：" + num);
}
}
}
利用数字字符的 Unicode 编码连续性（'0'-'9'对应 48-57）
public class text4 {
public static void main(String[] arges) {
String nums = "12345";
for (int i=0;i<nums.length();i++){
//如果直接让 char 类型直接转为 int 类型，会输出的是 Unicode 编码
char n1 = nums.charAt(i);
int n2 = n1;
int n3 = n1-'0';
System.out.println(n1+"的 Unicode 编码："+n2+",实际 int 值为："+n3);
}
}
}
//结果
//1 的 Unicode 编码：49，实际 int 值为：1
//2 的 Unicode 编码：50，实际 int 值为：2
//3 的 Unicode 编码：51，实际 int 值为：3
//4 的 Unicode 编码：52，实际 int 值为：4
//5 的 Unicode 编码：53，实际 int 值为：5
返回字符的 Unicode 数值-'0'==char-'0'（支持数字、字母、罗马数字等）
public class text4 {
public static void main(String[] arges) {
String nums = "12345";
for (int i=0;i<nums.length();i++){
//如果直接让 char 类型直接转为 int 类型，会输出的是 Unicode 编码
char n1 = nums.charAt(i);
//对数字字符（'0'~'9'）：它会自动处理为数字值（等价于 char - '0'）
int n2 = Character.getNumericValue(n1);
System.out.println(n1+"的实际 int 值为："+n2);
}
}
}
//结果
//1 的实际 int 值为：1
//2 的实际 int 值为：2
//3 的实际 int 值为：3
//4 的实际 int 值为：4
//5 的实际 int 值为：5
解析字符串并返回 int，支持正负号
public class text4 {
public static void main(String[] arges) {
String nums = "12345";
int num = Integer.parseInt(nums);
System.out.println(num);
}
}
//结果
//12345
从输入流中读取下一个整数（处理用户输入或文件中的数字）
import java.util.Scanner;
public class text4 {
public static void main(String[] arges) {
Scanner input = new Scanner(System.in);
while (input.hasNext()){
int num = input.nextInt();
System.out.print(num);
}
input.close();
}
}
//输入
//123 456
//结果
//123456
遍历字符串，逐字符转数字并累加（处理超大数字 [超出 int 范围]）
public class text4 {
public static void main(String[] arges) {
String s = "789ca";
int ans=0;//用于存储读出来的整数
for (int i=0;i<s.length();i++){
char a =s.charAt(i);
//判断 a 是否是数字字符
if(a>='0'&&a<='9'){
//是的话就累加，*10 是因为要给（a-'0'）空出位置，
//例如：ans=78;那要实现 ans=789 就得 ans*10=780，然后加上 9
ans=ans*10+(a-'0');
}else {
System.out.println("非数字字符："+a);
}
}
System.out.println(ans);
}
}
//结果
//非数字字符：c
//非数字字符：a
//789
Java 的 Scanner 类用于解析基本类型和字符串的输入（来自文件、字符串、控制台等），默认使用空格、制表符、换行符作为分隔符
new Scanner(字符串)
import java.util.Scanner;
public class text4 {
public static void main(String[] arges) {
Scanner input = new Scanner("234 567");
while (input.hasNext()){
int num = input.nextInt();
System.out.print(num);
}
input.close();
}
}
//结果
//234567
new Scanner(System.in)
import java.util.Scanner;
public class text4 {
public static void main(String[] arges) {
Scanner input = new Scanner(System.in);
while (input.hasNext()){
int num = input.nextInt();
System.out.print(num);
}
input.close();
}
}
//输入
//123 456
//结果
//123456
new Scanner(new File("文件名"))
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class text4 {
public static void main(String[] arges) {
try {
// 从文件读取
Scanner scanner = new Scanner(new File("input.txt"));
// 逐行或逐个标记读取
while (scanner.hasNext()) {
if (scanner.hasNextInt()) {
int num = scanner.nextInt();
System.out.println("数字：" + num);
} else {
String text = scanner.next();
System.out.println("文本：" + text);
}
}
scanner.close();
} catch (FileNotFoundException e) {
System.err.println("文件未找到：" + e.getMessage());
}
}
}
//结果
//数字：123
//数字：456
//文本：Hello
//文本：World
增强 for 循环（也称为 for-each 循环）是 Java5 引入的一种简化集合和数组遍历的语法结构。
for(元素类型 变量名 : 集合或数组){
//循环体
}
import java.util.ArrayList;
public class text4 {
public static void main(String[] arges) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(55);
list.add(23);
list.add(95);
for(int num : list){
System.out.println(num);
}
}
}
//结果
//55
//23
//95
import java.util.ArrayList;
import java.util.Iterator;
public class text4 {
public static void main(String[] arges) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(23);
list.add(29);
list.add(26);
for (Integer number : list) {
System.out.println(number);
}
// 等价于： Iterator<Integer> it = list.iterator();
// while (it.hasNext()) {
// Integer number = it.next();
// System.out.println(number);
// }
}
}
//结果
//23
//29
//26
在代码编译阶段（将源代码转换为机器码或字节码时）被发现的错误。
①语法错误：如缺少分号、括号不匹配、拼写错误等
②类型错误：如变量类型不匹配
③引用错误：如使用了未定义的变量或方法
④编译错误：程序无法生成可执行文件，直接终止编译
编译器直接报错，程序无法运行
public class Test {
public static void main(String[] args) {
System.out.println("Hello"); // 正确
int x = "abc"; // 编译时错误：类型不匹配（String 无法赋值给 int）
}
}
程序通过编译，但在执行过程中（运行时）发生的错误。
①逻辑错误：如空指针访问、数组越界、除零操作等。
②资源问题：如文件未找到、网络连接失败。
③编译通过：代码语法正确，但执行到特定逻辑时崩溃。
编译成功，生成可执行文件。运行到错误语句时抛出异常，程序终止。
public class Test {
public static void main(String[] args) {
String str = null;
System.out.println(str.length()); // 运行时错误：空指针异常（NullPointerException）
}
}
使用正则表达式拆分字符串，返回 String[] 数组。
import java.util.*;
public class text4 {
public static void main(String[] arges) {
Scanner input = new Scanner(System.in);
String s = input.next();
String[] list = s.split(",");
System.out.println(Arrays.toString(list));
}
}
//输入
//1，2，，，3
//结果
//[1，2，，，3]
①规则
import java.util.*;
public class text4 {
public static void main(String[] arges) {
Scanner input = new Scanner(System.in);
String s = input.next();
//忽略尾部空字符
String[] list = s.split(",",0);
//控制分割次数
String[] list2 = s.split(",",3);
//保留空字符串
String[] list3 = s.split(",",-9);
System.out.println(s+"忽略尾部空字符:"+(Arrays.toString(list)));
System.out.println(s+"控制分割次数:"+(Arrays.toString(list2)));
System.out.println(s+"保留空字符串:"+(Arrays.toString(list3)));
}
}
//输入
//1,2,,,,3,4,,,,,,
//结果
//1,2,,,,3,4,,,,,,忽略尾部空字符:[1, 2, , , , 3, 4]
//1,2,,,,3,4,,,,,,控制分割次数:[1, 2, ,,,3,4,,,,,,]
//1,2,,,,3,4,,,,,,保留空字符串:[1, 2, , , , 3, 4, , , , , , ]
①使用 Java8 的 StreamAPI 拆分字符串，适用于流式处理拆分后的数据
②格式
import java.util.regex.Pattern;//导包
String s = "1,2,3";
Pattern pattern = Pattern.compile(",");//定义分隔符
pattern.splitAsStream(s);//返回 Stream<String>，可以直接用 Stream API 处理。
String str = "1,2,3,4,5";
Pattern pattern = Pattern.compile(",");
pattern.splitAsStream(str)
.map(Integer::parseInt) // 转换为整数
.forEach(System.out::println);
①适用于固定格式，通过 substring() 和 indexOf() 手动拆分
String str = "apple,banana,orange";
int index1 = str.indexOf(",");
int index2 = str.indexOf(",", index1 + 1);
String part1 = str.substring(0, index1); // apple
String part2 = str.substring(index1 + 1, index2); // banana
String part3 = str.substring(index2 + 1); // orange
Java API 是一个统称，包含所有 Java 标准库提供的类、接口、方法等，例如：
基础类：Object、String、Math
数值处理：Integer、BigDecimal
集合框架：List、Map
函数式编程：Stream API
工具类：Arrays、Collections
异常处理：Exception 类
函数式数据处理工具，提供了丰富的操作符（方法）来处理集合、数组等数据源。其中中间操作会返回一个新的 Stream，而终止操作会触发计算并返回结果或副作用
介绍
中间操作是惰性的（Lazy），不会立即执行，只有遇到终止操作时才会触发整个流水线的计算。
①filter(Predicate predicate)——过滤与筛选
返回值
根据条件筛选元素，返回满足条件的元素组成的 Stream
举例
Integer.parseInt(String s)int 基本类型。"abc"），会抛出 NumberFormatException。" 123 " 会抛出异常，需先调用 trim()）。null，否则抛出 NullPointerException。Integer.valueOf(String s)Integer 包装类对象（但可自动拆箱为 int）。Integer.parseInt()，但返回的是 Integer 对象。Integer 对象的场景（如泛型集合）。Scanner.nextInt()Scanner 从字符串中读取下一个整数。InputMismatchException 如果下一个标记不是整数。String s = "123";
int num = 0;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c < '0' || c > '9') throw new NumberFormatException();
num = num * 10 + (c - '0');
}
Float.parseFloat() 或 Double.parseDouble()Float.parseFloat(String s)float 基本类型。Double.parseDouble(String s)double 基本类型。Float.valueOf() 或 Double.valueOf()Float 或 Double 包装类对象（而非基本类型），可以使用 valueOf() 方法。Float 或 Double 对象，但可以通过自动拆箱转为基本类型。"abc"、"12.34.56" 或 null），会抛出 NumberFormatException。try-catch 处理异常：String invalidStr = "12.34.56";
try {
double value = Double.parseDouble(invalidStr);
} catch (NumberFormatException e) {
System.out.println("错误：" + invalidStr + " 不是有效的浮点数");
}
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online