一：标识符、修饰符和注释

（1）标识符

标识符规则

• 包名、类名、方法名、参数名、变量名等，这些符号被称为标识符
• 标识符可以由字母、数字、下划线_和美元符号$组成
• 标识符不能以数字开头，不能是java中的关键字和保留字
• Java 区分大小写，因此 myvar 和 MyVar 是两个不同的标识符
• 标识符不能包含空格
• 标识符不能是常量表达式 false true null等

（2）修饰符

两个重要的修饰符

• static修饰符
  • static 关键字用来声明独立于对象的静态变量。局部变量不能被声明为 static 变量
  • 静态方法只能调用静态方法和静态变量，非静态方法可以调用静态方法
  • static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量
• final修饰符
  • final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值
  • 被 final 修饰的实例变量必须显式指定初始值
  • final 修饰符通常和 static 修饰符一起使用来创建类常量

（3）注释

Java中注释主要分为以下三种

• 单行注释：//注释内容；用的最多
• 多行注释：/*注释内容*/；不推荐使用
• 文档注释：/**注释内容*/；一般用在函数或者类上边

需要注意

• 多行注释不能嵌套使用
• 无论是单行还是多行注释，都不参与编译，也即.class文件中是不包含注释信息的

/**文档注释@version v1.0.1@deprecated  2024/02/19@author  fa第一个HelloWorld，以供练习
*/
public class HelloWorld {/*1.main方法是Java程序的入口方法2. main函数的格式是固定的，必须为public static void main(String[] args)*/public static void main(String[] args) { System.out.println是Java中标准输出，会将内容输出到控制台System.out.println(10);}
}

二：数据类型

（1）分类

数据类型：数据类型是用来定义变量的，它规定了一个变量占用的空间大小，Java中的数据类型分为以下两类

• 基本数据类型
• 引用数据类型

（1）基本数据类型

基本数据类型见下表，需要注意

• 每个基本数据类型都会对应一个类类型，也即包装类

• 无论是16位还是32位系统，int都占用4个字节，long都占用8个字节

• 整型和浮点型都是有符号的（意思就是肯定有正负）

• 整型默认为int，浮点型默认为double

• 计算机使用 二进制(bit) 表示数据

• 字节（Byte）是计算机中表示空间大小的基本单位，1B=8bit

（2）引用数据类型

在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如Employoyee、Puppy等。变量一旦声明后，类型就不能被改变了

三：变量

变量及赋值：除常量外，生活中更多见的是变量（比如人的年龄就处在不断变化之中）；可以把变量想象成一个箱子，这个箱子可以装特定的东西（例如苹果箱子规定只能装苹果），而箱子的大小则由数据类型决定，箱子的名字就叫做变量名，即数据类型 变量名=数值，在赋值时需要注意

• 变量在使用前必须初始化，否则无法运行（Java对数据类型的检查非常严格）
• 给变量赋的值不能超过该类型变量所规定的的范围，否则溢出
• 在方法内部定义的变量叫做局部变量、外部定义的是成员变量

（1）整型变量

A：int

需要注意

• 无论在何种系统下，int都是4个字节
• int的包装类型为integer
• int范围为：-2³¹~ 2³¹-1
• case1：建议使用这种方式
• case3：通过integer的MAX_VALUE和MIN_VALUE可以得到整型的最大和最小值
• case4：定义时未初始化或超出int范围，Java会直接报错

public class TestDemo {public static void main(String[] args) {//case1：在定义时给出初值int a = 10;System.out.println(a);System.out.println("---------------------------------------------");//case2：先定义后赋值int b;b = 20;System.out.println(b);System.out.println("---------------------------------------------");//case3：输出最大和最小值System.out.println("最大值"+Integer.MAX_VALUE);System.out.println("最小值"+Integer.MIN_VALUE);//case4：定义时未初始化或者超过范围，Java将直接报错，非常安全/*int c = 9999999999999999999999999999999999;//errorint d;System.out.println(d);//error

B：long

需要注意

• 无论在何种系统下，long都是4个字节
• long的包装类型为Long
• long范围为：-2⁶³~ 2⁶³-1
• case2：建议使用这种方式初始化，以区分int
• case3：通过Long的MAX_VALUE和MIN_VALUE可以得到长整型的最大和最小值

public class TestDemo {public static void main(String[] args) {//case1long a = 100;System.out.println(a);System.out.println("--------------");//case2：初始化时为了进行区分，建议在后面加Llong b = 100L;System.out.println(a);System.out.println("--------------");//case3：输出最大和最小值System.out.println("最大值"+Long.MAX_VALUE);System.out.println("最小值"+Long.MIN_VALUE);}
}

C：short

需要注意

• 无论在何种系统下，short都是2个字节
• short的包装类型为Short
• short范围为：-2¹⁵~ 2¹⁵-1
• case2：通过Short的MAX_VALUE和MIN_VALUE可以得到短整型的最大和最小值

public class TestDemo{public static void main(String[] args) {//cas1:short a = 10;System.out.println(a);//case2:System.out.println("最大值"+Short.MAX_VALUE);System.out.println("最小值"+Short.MIN_VALUE);}
}

D：byte

需要注意

• 无论在何种系统下，byte都是1个字节
• byte的包装类型为Byte
• byte范围为：-128~127
• case2：通过Byte的MAX_VALUE和MIN_VALUE可以得到byte的最大和最小值

public class TestDemo{public static void main(String[] args) {//cas1:byte a = 10;System.out.println(a);//case2:System.out.println("最大值"+Byte.MAX_VALUE);System.out.println("最小值"+Byte.MIN_VALUE);}
}

这里再补充一点，如下代码看似是没有错误的，因为变量b的结果是11，并没有超过byte的范围，但编译器却报出了错误

这是因为变量a的确是byte型的，但在Java中整型字面常量默认为int，整型提升后变量a+1自然就变为了int型，类型不正确。正确写法如下

（2）浮点型变量

A：float

需要注意

• 无论在何种系统下，float都是4个字节
• float存储遵守IEEE 754标准，更多可点击了解：(计算机组成原理)第二章数据的表示和运算-第三节2：IEEE754标准
• 不推荐使用float，因为其范围较小，常用的还是double
• float包装类型为Float
• case1：由于浮点型字面常量默认为double，所以在定义时后面必须加f或F，否则无法编译通过

public class TestDemo{public static void main(String[] args) {//cas1:float a = 3.14F;System.out.println(a);}
}

B：double

• 无论在何种系统下，double都是8个字节
• double存储遵守IEEE 754标准，更多可点击了解：[(计算机组成原理)第二章数据的表示和运算-第三节2：IEEE754标准]
• double包装类型为Double
• case2：Java中，int与int相除是不会得到double的，除非两个都是double（或者让其中一个暂时变为小数）
• case3：在计算机中某些小数是无法用二进制精确表示的，所以很多时候计算的结果会和我们想象的存在误差（具体见：(计算机组成原理)第二章数据的表示和运算-第一节1：一文总结进制转换，妈妈再也不用担心我不会进制转换了）

public class TestDemo{public static void main(String[] args) {//case1:double  a = 3.14;System.out.println(a);//case2:int b1 = 1;int c1= 2;System.out.println(b1/c1);//不等于0.5，等于0double b2 = 1;double c2 = 2;System.out.println(b2/c2);//等于0.5System.out.println(b1*1.0/c1);//这样也是0.5//case3:double d = 1.1;System.out.printf("%.20f", d*d);}
}

（3）字符型变量

需要注意

• char的包装类型为Character

• char范围为：0~65535

• case1：计算机中的字符本质上是一个整数。在C语言中使用ASCII表示字符，而Java中使用Unicode表示字符。因此一个字符占用两个字节,表示的字符种类更多,包括中文（具体见（(计算机组成原理)第二章数据的表示和运算-第一节3：字符与字符串在计算机中的表示详解））

• case2：字符可以存放整数（显示时会显示为整数对应的字符；不能是负数）

public class TestDemo{public static void main(String[] args) {//case1char a = 'a';char b ='6';System.out.println(a);System.out.println(b);//case2char c = 97;System.out.println(c);}
}

（4）布尔型变量

需要注意

• 在Java中 boolean类型只有两种取值：ture和false（没有所谓的0是假非0是真的说法）
• boolean的包装类型为Boolean
• boolean并没有规定它的大小

public class TestDemo{public static void main(String[] args) {//case1boolean flg = true;System.out.println(flg);}
}

四：类型转换

类型转换：Java是一门强类型编程语言，在进行变量赋值时会有严格的类型检查，检查不通过编译也会失败，如下

• 在C/C++中顶多会给你一个warning，很不安全

public class TestDemo{public static void main(String[] args) {int a = 10;long b = 100L;b = a;//编译通过a = b;//编译失败，4字节存不了8字节的}
}

如果编译可以通过，那么当数据类型不一致时就会进行类型转换，分为两类

• 自动类型转换（隐式）
• 强制类型转换（显式）

（1）自动类型转换（隐式）

自动类型转换（隐式）：即代码不需要经过任何处理，在编译时编译器自动进行转换；典型特征就是数据范围小的转数据范围大的

public class TestDemo{public static void main(String[] args) {//case1:int a = 10;long b = 100L;b = a;//编译通过；4字节转向8字节a = b;//编译失败；8字节转向4字节会丢失//case2:float f = 3.14F;double d =5.12;d = f;//编译通过；4字节转向8字节f = d;//编译失败；8字节转向4字节会丢失//case3：byte b1 = 100;//编译通过；未超过byte范围，会将int下的100转化为bytebyte b2 = 257;编译失败；超出范围，数据丢失}
}

（2）强制类型转换（显式）

强制类型转换（显式）：操作时，代码需要一定的格式处理，一旦强转意味着程序员需要为此次转换负责；典型特征就是数据范围大的转数据范围小的

• 注意：强转不一定成功，两个不相干的类型不能强转

public class TestDemo{public static void main(String[] args) {//case1:int a = 10;long b = 100L;b = a;//编译通过；4字节转向8字节a = b;//编译失败；8字节转向4字节会丢失a = (int)b;//强转//case2:float f = 3.14F;double d =5.12;d = f;//编译通过；4字节转向8字节f = d;//编译失败；8字节转向4字节会丢失f = (float)d;//强转//case3：byte b1 = 100;//编译通过；未超过byte范围，会将int下的100转化为bytebyte b2 = 257;编译失败；超出范围，数据丢失byte b3 = (byte)257;//强转}
}

五：逻辑控制

（1）分支结构

if语句

public class TestDemo {public static void main(String[] args) {//格式1int a = 10;if(a > 1){System.out.println("不知道写啥");}System.out.println("---------------------------------");//格式2int b = 3;int c = 5;if(b > c){System.out.println("b比c要大");}else{System.out.println("b比c要小");}System.out.println("---------------------------------");//格式3int score = 77;if(score >= 90){System.out.println("优秀");}else if(score >= 80 && score < 90){System.out.println("良好");}else if(score >= 70 && score < 80){System.out.println("中等");}else if(score >= 60 && score < 70){System.out.println("及格");}else if(score >= 0 && score < 60){System.out.println("不及格");}else{System.out.println("错误数据");}}
}

Switch语句

• 多个case后的常量值不可以重复
• switch括号内不能是以下数据类型
  • long、float、double、boolean
• 不要遗漏break，否则switch将失去“多分支选择”的效果

public class TestDemo {public static void main(String[] args) {int day = 2;switch(day){case 1:System.out.println("周一");break;case 2:System.out.println("周二");break;case 3:System.out.println("周三");break;default:System.out.println("休息");break;}}
}

（2）循环结构

while循环

• break：结束循环
• continue：跳过本次循环直接进入下一次循环

public class TestDemo {public static void main(String[] args) {int i = 1;while(i <= 10){System.out.println(i++);}}
}

for循环

public class TestDemo {public static void main(String[] args) {for(int i = 1; i <= 10; i++){System.out.println(i);}}
}

增强for循环

public class TestDemo{public static void main(String[] args){int[] a = new int[10];for (int x : a) {System.out.println(x);}}
}

do while循环

int num = 1;
do {
System.out.println(num);
num++;
} while (num <= 10);

六：方法

（1）概述

Java中的方法是用来执行特定任务的一段代码块。方法可以接受参数，执行操作，并返回结果。在Java中，方法通常定义在类中，并且可以被该类的对象调用。以下是Java方法的一些基本特征和语法：

• 方法声明：方法声明包括方法的访问修饰符（如public、private、protected或默认修饰符），返回类型，方法名，参数列表以及方法体
• 访问修饰符：控制方法的访问级别，例如public表示公共方法，可以从任何地方访问；private表示私有方法，只能在同一类中访问；protected表示受保护方法，可以在同一包或子类中访问；默认修饰符表示包私有方法，只能在同一包中访问
• 返回类型：方法可以返回一个值，其类型由返回类型指定。如果方法不返回任何内容，则返回类型为void
• 方法名：方法的名称，用来在程序中调用方法
• 参数列表：方法可以接受零个或多个参数。参数列表是方法名称后的括号内部声明的变量列表，每个参数由参数类型和参数名组成
• 方法体：包含方法执行的代码块

下面是一个简单的Java方法示例： add方法接受两个整数作为参数，并返回它们的和。main方法是Java程序的入口点，在其中调用了add方法，并输出了结果

public class Example {// 方法声明public static int add(int num1, int num2) {// 方法体int sum = num1 + num2;return sum; // 返回结果}public static void main(String[] args) {// 调用方法int result = add(3, 5);System.out.println("Result: " + result);}
}

（2）重载

方法的重载（Overloading）是指在同一个类中可以定义多个同名的方法，但它们的参数列表必须不同（参数类型、参数个数或参数顺序不同）。在调用方法时，编译器会根据提供的参数类型和数量来确定调用哪个重载方法

• 方法名相同：重载的方法必须有相同的方法名
• 参数列表不同：重载的方法的参数列表必须不同，至少有以下一点不同：
  • 参数个数不同
  • 参数类型不同
  • 参数顺序不同
• 返回类型可以相同也可以不同：即使两个重载方法的返回类型不同，只要它们的参数列表不同，它们仍然被认为是重载方法
• 访问修饰符、返回类型、抛出的异常等都可以不同：重载的方法可以具有不同的访问修饰符，返回类型以及抛出的异常类型

下面是一个方法重载的示例： Calculator类中定义了四个重载方法add，分别用于执行整数相加、双精度浮点数相加、字符串连接等操作。在main方法中，演示了如何调用这些重载方法

public class Calculator {// 重载方法1：两个整数相加public int add(int a, int b) {return a + b;}// 重载方法2：三个整数相加public int add(int a, int b, int c) {return a + b + c;}// 重载方法3：两个双精度浮点数相加public double add(double a, double b) {return a + b;}// 重载方法4：两个字符串连接public String add(String a, String b) {return a + b;}public static void main(String[] args) {Calculator calc = new Calculator();// 调用重载方法1System.out.println("Result 1: " + calc.add(3, 5));// 调用重载方法2System.out.println("Result 2: " + calc.add(3, 5, 7));// 调用重载方法3System.out.println("Result 3: " + calc.add(3.5, 2.5));// 调用重载方法4System.out.println("Result 4: " + calc.add("Hello, ", "world!"));}
}

七：类与对象

在Java中，类（Class）是一种用来描述对象的模板或蓝图，它定义了对象的属性和方法。而对象（Object）则是类的实例化，是类的具体实体，可以执行类中定义的方法，访问类中定义的属性。以下是关于Java类和对象的一些基本概念：

• 类（Class）：类是一种用户自定义的数据类型，用来描述具有相似特征和行为的对象集合。类定义了对象的属性（成员变量）和行为（成员方法）
• 对象（Object）：对象是类的实例，它是类的具体实体，具有类中定义的属性和行为。可以通过new关键字来创建对象
• 属性（成员变量）：类的属性是描述对象状态的变量，也称为成员变量或实例变量。每个对象都有自己的一组属性
• 方法（成员方法）：类的方法是描述对象行为的函数，也称为成员方法或实例方法。通过调用对象的方法，可以执行特定的操作
• 封装（Encapsulation）：封装是面向对象编程的基本概念之一，它指的是将数据和方法封装在类的内部，并对外部提供访问接口。通过封装，可以隐藏对象的内部实现细节，提高代码的安全性和可维护性
• 继承（Inheritance）：继承是面向对象编程中的另一个重要概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以扩展或修改父类的行为，从而实现代码的重用和扩展
• 多态（Polymorphism）：多态是指同一个方法调用可以在不同的对象上具有不同的行为。Java中的多态性通过方法重写（Override）和方法重载（Overload）来实现

下面是一个简单的Java类和对象的示例：Car类描述了汽车的属性（品牌、型号、年份）和行为（显示汽车信息）。在main方法中，通过new关键字创建了一个Car对象myCar，并调用了它的displayInfo方法来显示汽车信息

// 定义一个类
public class Car {// 成员变量String brand;String model;int year;// 构造方法public Car(String brand, String model, int year) {this.brand = brand;this.model = model;this.year = year;}// 成员方法public void displayInfo() {System.out.println("Brand: " + brand);System.out.println("Model: " + model);System.out.println("Year: " + year);}public static void main(String[] args) {// 创建对象Car myCar = new Car("Toyota", "Camry", 2022);// 调用对象的方法myCar.displayInfo();}
}

八：接口

在Java中，接口（Interface）是一种抽象类型，它定义了一组抽象方法（没有方法体）以及常量（变量值不可改变）。接口提供了一种定义行为的方式，而不涉及具体的实现。类可以实现一个或多个接口，从而具备接口定义的方法和属性。以下是Java接口的一些基本特征和规则

①定义接口：使用interface关键字来定义接口。接口中可以包含抽象方法、常量、默认方法和静态方法

public interface MyInterface {// 抽象方法void abstractMethod();// 常量int CONSTANT_VALUE = 10;// 默认方法default void defaultMethod() {System.out.println("Default method implementation");}// 静态方法static void staticMethod() {System.out.println("Static method implementation");}
}

②实现接口：使用implements关键字来让一个类实现一个或多个接口。一个类可以同时实现多个接口

public class MyClass implements MyInterface {// 实现接口中的抽象方法@Overridepublic void abstractMethod() {System.out.println("Implementation of abstractMethod");}// MyClass可以选择重写默认方法
}

③多继承：Java中允许类实现多个接口，这提供了一种弥补Java单继承限制的方式

public class MyOtherClass implements MyInterface, AnotherInterface {// 实现接口中的抽象方法@Overridepublic void abstractMethod() {System.out.println("Implementation of abstractMethod");}// 实现AnotherInterface中的抽象方法@Overridepublic void anotherMethod() {System.out.println("Implementation of anotherMethod");}
}

其他

• 接口继承：接口可以继承其他接口，通过extends关键字
• 默认方法：接口中的默认方法是具有方法体的方法，实现类可以选择重写或者直接继承
• 静态方法：接口中的静态方法是使用static关键字修饰的方法，可以通过接口名直接调用

九：输出和输入

（1）输出

Java中向控制台输出信息主要有三种方式

System.out.println(msg);
//输出一一个字符串,带换行
System.out.print(msg);
//输出一个字符串,不带换行
System.out.printf(format, msg); // 格式化输出

其中格式化字符串如下

（2）输入

Java中需要输入信息时需要导入util包

import java.util.Scanner;

导入之后，可以new出一个Scanner对象用于接收信息

Scanner sc = new Scanner(System.in);

接着可以调用该Scanner对象的各种方法去接收各种类型的值（注意输入的值的类型一定要匹配）

如果最后不需要输入，记得关闭Scanner

Scanner.close()

---

这里举一些常见的例子

①：Scanner.nextLine()：接收一行信息，使用String接收按下回车时结束输入

• Scanner.nextLine()：接收一行信息，碰到空格时结束输入

public class TestDemo {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入您的姓名：");String name =sc.nextLine();System.out.println(name);}
}

②：Scanner.nextInt()：接收整型

• Scanner.nextFloat()/Scanner.nextDouble()：接收浮点型

public class TestDemo {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入您的姓名：");String name = sc.nextLine();System.out.println(name);System.out.println("请输入您的年龄：");int age = sc.nextInt();System.out.println(age);}
}

③：使用如下方式处理循环输入

• 如下例子用于循环读取10个数字并求它们的和
• 结束输入时按下ctrl+D

public class TestDemo {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int sum = 0;int num = 0;while(sc.hasNextInt()){int temp = sc.nextInt();sum += temp;num++;if(num == 10) {break;}}System.out.println(sum);}
}

④：Scanner.next：接收不带空格的字符串

十：String和StringBuilder

（1）字符串构造

A：常用构造方法

字符串构造：构造一个字符串方法有很多，常用的有以下三种

• 使用常量字符串构造
• 直接newString对象
• 使用字符数组构造

public class TestDemo {public static void main(String[] args){//使用常量字符串构造String str1 = "Hello World1";//直接newString对象String str2 = new String("Hello World2");//使用字符数组进行构造char[] arr = {'H','e','l','l','o','W','o','r','l','d','3'};String str3 = new String(arr);System.out.println(str1);System.out.println(str2);System.out.println(str3);}
}

B：注意

String是引用类型，但是其内部并不存储字符串本身，实际回报存在一个char类型的数组中

完整的关系应该是下面这样

public static void main(String[] args){//s1和s2引用的不是同一个对象//s1和s3引用的是同一个对象String s1 = new String("hello");String s2 = new String("world");String s3 = s1;
}

（2）字符串比较

①：==用于比较是否引用的是同一个对象

• 内置类型：比较的是变量的值
• 引用类型：比较的是地址

public class TestDemo {public static void main(String[] args) {int a = 10;int b = 20;int c = 10;//对于基本类型，比较的是值System.out.println(a == b);System.out.println(a == c);System.out.println("----------------------------------------------");//对于引用类型，比较是否引用的是同一个对象String s1 = new String("hello");String s2 = new String("hello");String s3 = new String("world");String s4 = s1;System.out.println(s1 == s2);System.out.println(s2 == s3);System.out.println(s1 == s4);}
}

②：boolean equals(Object anObject)方法会按照字典序进行比较。如下，String类中重写了父类Object中的equals方法

public class TestDemo {public static void main(String[] args) {String s1 = new String("hello");String s2 = new String("hello");String s3 = new String("hello");System.out.println(s1 == s2);System.out.println(s1.equals(s2));}
}

③：int compareTo(String s)方法也会按照字典序进行比较，但与equals有所不同的是，它返回的是int。具体比较规则如下

• 先按照字典序进行比较，如果出现不等的字符，直接返回这两个字符的大小差值
• 如果前k个字符相等（k为两个字符长度最小值），则返回两个字符串长度差值

public class TestDemo {public static void main(String[] args) {String s1 = new String("abc");String s2 = new String("ac");String s3 = new String("abc");String s4 = new String("abcdef");System.out.println(s1.compareTo(s2));//不同输出字符差值 -1System.out.println(s1.compareTo(s3)); //相同为零System.out.println(s1.compareTo(s4)); //前k个字符完全相同，输出长度差值 -3}
}

④：int compareTolgnoreCase(String str)方法：与compareTo方法相同，但是忽略大小写

public class TestDemo {public static void main(String[] args) {String s1 = new String("abc");String s2 = new String("ac");String s3 = new String("ABc");String s4 = new String("abcdef");System.out.println(s1.compareToIgnoreCase(s2));System.out.println(s1.compareToIgnoreCase(s3));//相同System.out.println(s1.compareToIgnoreCase(s4));}
}

（3）字符串查找

①：char charAt(inde index)：返回index位置上字符

• 如果index为负数或者越界，抛出"indexOutofBoundsException"异常

public class TestDemo {public static void main(String[] args) {String s1 = new String("Hello");String s2 = new String("World");char c1 = s1.charAt(2);System.out.println(c1);System.out.println("-----------------------------------");for(int i = 0; i < s2.length(); i++){System.out.println(s2.charAt(i));}}
}

②：int indexOf(int ch)：返回字符ch第一次出现的位置

• 如果没有ch这个字符则会返回-1

public class TestDemo {public static void main(String[] args) {String s1 = new String("Hello");String s2 = new String("World");System.out.println(s1.indexOf('e'));System.out.println(s2.indexOf('c'));}
}

③：int indexOf(int ch, int fromIndex)：从“fromIndex”位置开始寻找字符“ch”第一次出现的位置

• 如果没有ch这个字符则会返回-1

public class TestDemo {public static void main(String[] args) {String s1 = new String("Hello World!");System.out.println(s1.indexOf('e', 1));System.out.println(s1.indexOf('o', 5));System.out.println(s1.indexOf('e', 5));}
}

④：int indexOf(String str)：返回字符串str第一次出现的位置

• 如果没有str这个字符串则会返回-1

public class TestDemo {public static void main(String[] args) {String s1 = new String("Hello World!");System.out.println(s1.indexOf("World"));System.out.println(s1.indexOf("Worls"));}
}

⑤：int indexOf(String str, int fromIndex)：从“fromIndex”位置开始寻找字符串“str”第一次出现的位置

• 如果没有str这个字符串则会返回-1

public class TestDemo {public static void main(String[] args) {String s1 = new String("one two three one four nine");System.out.println(s1.indexOf("one", 4));System.out.println(s1.indexOf("one", 15));}
}

⑥：int lastIndexOf(int ch)、int lastIndexOf(int ch, int fromIndex)、int lastIndexOf(String str)、int lastIndexOf(String str, int fromIndex)：和前面类似，只不过是从后向前找

（4）字符串转化

A：数值和字符串的转换

数字转换为字符串可以使用String.valueOf()

public class TestDemo {public static void main(String[] args) {String s1 = String.valueOf(123);String s2 = String.valueOf(3.14);String s3 = String.valueOf(true);System.out.println(s1);System.out.println(s2);System.out.println(s3);}
}

字符串转化为数字常用方法如下

public class TestDemo {public static void main(String[] args) {int num1 = Integer.parseInt("1234");int num2 = Integer.parseInt("64", 8);//8表示八进制，八进制下的64对应十进制下的52double num3 = Double.parseDouble("3.14");System.out.println(num1);System.out.println(num2);System.out.println(num3);}
}

B：大小写转换

字母大小写转换可以使用toUpperCase()和toLowerCase()。需要注意是，转换完成后，原来字符串的值并不会改变

public class TestDemo {public static void main(String[] args) {String s1 = "hello";String s2 = "HELLO";//小写转换为大写System.out.println(s1 + "->" + s1.toUpperCase());//大写转换为小写System.out.println(s2 + "->" + s2.toLowerCase());}
}

C：字符串转数组

可以使用String.toCharArray()将一个字符串转为一个字符数组

public class TestDemo {public static void main(String[] args) {String str = "Hello!";char[] ch = str.toCharArray();for(int i = 0; i < ch.length; i++){System.out.println(ch[i]);}}
}

D：格式化

使用String.format()可以将一个字符串格式化为目标字符串

public class TestDemo {public static void main(String[] args) {String str = String.format("%d-%d-%d", 2000, 10, 12);System.out.println(str);}
}

（5）字符串替换

①：String replaceAll(String regex, String replacement)：将原字符串中regex替换为replacement

public class TestDemo{public static void main(String[] args) {String s1 = "HelloWorld,Hello You";String s2 = s1.replaceAll("Hello", "Bye"); //将Hello替换为ByeString s3 = s1.replace('H', 'S'); //将H替换为SSystem.out.println(s2);System.out.println(s3);}
}

②：String replaceFirst(String regex, String replacement)：仅替换首次出现的regex

public class TestDemo{public static void main(String[] args) {String s1 = "HelloWorld,Hello You";String s2 = s1.replaceFirst("Hello", "Bye"); //将第一个Hello替换为ByeSystem.out.println(s2);}
}

（6）字符串拆分

①：String[] split(String regex)：以regex为分割标志，将原字符串拆分为多个字符串

public class TestDemo{public static void main(String[] args) {String str = "中国-北京市-东城区-长安街-天安门广场";String[] ret = str.split("-");for(String s : ret){System.out.println(s);}}
}

②：String[] split(String regex, int limit)：以regex为分割标志，将原字符串拆分为limit字符串

public class TestDemo{public static void main(String[] args) {String str = "中国-北京市-东城区-长安街-天安门广场";String[] ret = str.split("-", 3);for(String s : ret){System.out.println(s);}}
}

③：一旦以"|“、”*“、”+“等作为分割标志时，前面都得加上”\\“，而且如果是”\“，那么就得写上”\\\\"

public class TestDemo{public static void main(String[] args) {String str = "www.baidu.com";String[] ret = str.split("\\.");for(String s : ret){System.out.println(s);}}
}

④：如果第一次拆分出来的字符串中还需要进行拆分，那么就要使用下面这种多次拆分的写法

• 首先以&为分割标志拆分出name=zhangsan和age=18
• 然后再以=为分割标志拆分出name、zhangsan、age和18

public class TestDemo{public static void main(String[] args) {String str = "name=zhangsan&age=18";String[] result = str.split("&");for(int i = 0; i < result.length;i++){String[] temp = result[i].split("=");System.out.println(temp[1]);}}
}

（7）字符串截取

使用String substring(int beginIndex, int endIndex)可以截取[beginIndex, endIndex)区间内的字符串

• 如果不写endIndex，那么表示从beginIndex开始一直截取到末尾

public class TestDemo{public static void main(String[] args) {String str = "-Hello_World";String str1 = str.substring(7);String str2 = str.substring(1,6);System.out.println(str1);System.out.println(str2);}
}

（8）StringBuilder

String和StringBuilder都是用于处理字符串的类，但它们之间有几个重要的区别：

• 不可变性：

  • String是不可变的，即一旦创建了String对象，就不能修改其内容。对String对象进行任何操作（如拼接、替换等）都会创建一个新的String对象。
  • StringBuilder是可变的，它允许对字符串进行动态修改，而不会创建新的对象。因此，对于频繁修改字符串内容的情况，使用StringBuilder会更高效

• 线程安全性：

  • String是线程安全的，因为它的不可变性保证了多个线程同时访问一个String对象时不会出现竞态条件
  • StringBuilder是非线程安全的，如果多个线程同时访问一个StringBuilder对象并进行修改，可能会导致数据不一致或其他并发问题。如果需要在多线程环境下使用可变字符串，应该使用StringBuffer，它和StringBuilder功能类似但是线程安全的

基于上述区别，我们可以得出以下结论：

• 如果字符串内容不需要经常修改，或者只需进行少量的字符串拼接、替换操作，那么使用String是合适的，因为它的不可变性可以带来线程安全性和更简单的代码。
• 如果字符串需要频繁修改，例如在循环中进行大量的拼接操作，或者需要动态构建较大的字符串，那么使用StringBuilder会更加高效

常用方法如下

• append(): 用于在字符串末尾添加字符、字符串、基本类型数据或其他 StringBuilder 对象的内容
• insert(): 用于在指定位置插入字符、字符串、基本类型数据或其他 StringBuilder 对象的内容
• delete(): 用于删除从指定起始位置到指定结束位置的字
• deleteCharAt(): 用于删除指定位置的字符
• replace(): 用于将指定范围内的字符替换为新的字符或字符
• reverse(): 用于颠倒字符串中字符的顺序
• charAt(): 用于获取指定位置的字符
• length(): 用于获取字符串的长度
• toString(): 用于将 StringBuilder 对象转换为 String 对象
• indexOf() 和 lastIndexOf(): 用于查找指定字符或字符串在 StringBuilder 中第一次和最后一次出现的位置

StringBuilder sb = new StringBuilder();// append() 示例
sb.append("Hello");
sb.append(" ").append("world");
sb.append(2024);// insert() 示例
sb.insert(5, ", ");
sb.insert(0, "Greetings, ");// delete() 示例
sb.delete(6, 11);// deleteCharAt() 示例
sb.deleteCharAt(7);// replace() 示例
sb.replace(5, 11, "Java");// reverse() 示例
sb.reverse();// charAt() 示例
char c = sb.charAt(1);// length() 示例
int len = sb.length();// toString() 示例
String str = sb.toString();// indexOf() 和 lastIndexOf() 示例
int firstIndex = sb.indexOf("o");
int lastIndex = sb.lastIndexOf("o");

十一：常见数学方法

Java中的Math类是一个包含了许多用于执行数学运算的工具方法的内置类。它提供了一系列静态方法来执行常见的数学运算，如取绝对值、取最大值、取最小值、求平方根、求幂运算等等。以下是Math类中一些常用方法的介绍：

• abs(double a)：返回参数的绝对值。
• ceil(double a)：返回大于等于参数的最小整数。
• floor(double a)：返回小于等于参数的最大整数。
• round(float a)：将参数四舍五入为最接近的整数。
• max(int a, int b)：返回两个参数中的较大值。
• min(int a, int b)：返回两个参数中的较小值。
• sqrt(double a)：返回参数的平方根。
• pow(double a, double b)：返回第一个参数的第二个参数次方。
• sin(double a)：返回参数的正弦值（参数是以弧度表示的角度）。
• cos(double a)：返回参数的余弦值（参数是以弧度表示的角度）。
• tan(double a)：返回参数的正切值（参数是以弧度表示的角度）。
• random()：返回一个介于0.0（包含）和1.0（不包含）之间的随机浮点数。