05.JAVA String等常用方法（java输入Scanner类+输出Print类+根类Object+字符串String类常用方法API列表总结+代码示例）
Day03.13 API+String
常用API
API(Application Programming Interface)：应用程序编程接口。Java API是一本程序员的字典 ，是JDK中提供给我们使用的类的说明文档，后期建议以文档为主，API文档已上传1.8版本。
概述：Java 标准输出流的方法，用于将数据打印到控制台，属于本地方法。println 为换行打印，print 为不换行打印。
int a = 1;
int a = 2;
System.out.println(a)
System.out.println(b)
/*
1
2
*/
System.out.print(a)
System.out.print(b)
// 12Scanner
概述：用于读取输入数据的类，可以从各种数据源（如控制台、文件等）获取输入。
| 方法 |
描述 |
| scanner.next( ) |
迭代，读取并返回输入中的下一个元素（以空格分隔） |
| scanner.nextInt( ) |
读取并返回输入中的下一个整数 |
| scanner.nextLine( ) |
返回字符串，读取并返回输入中的下一行内容 |
| scanner.nextDouble( ) |
读取并返回输入中的下一个双精度浮点数 |
| scanner.hasNext( ) |
返回布尔值，检查输入中是否还有下一个元素 |
| scanner.hasNextInt( ) |
返回布尔值，检查输入中是否还有下一个整数 |
| scanner.hasNextLine( ) |
返回布尔值，检查输入中是否还有下一行内容 |
| scanner.hasNextDouble( ) |
返回布尔值，检查输入中是否还有下一个双精度浮点数 |
import java.util.Scanner;
public class ScannerExample {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 使用next()方法读取下一个字符串
System.out.print("请输入一个字符串：");
String str = scanner.next();
System.out.println("您输入的字符串是：" + str);
// 使用nextInt()方法读取下一个整数
System.out.print("请输入一个整数：");
int num = scanner.nextInt();
System.out.println("您输入的整数是：" + num);
// 使用nextLine()方法读取一行文本
System.out.print("请输入一行文本：");
scanner.nextLine(); // 清除输入缓冲区中的换行符
String line = scanner.nextLine();
System.out.println("您输入的文本是：" + line);
// 使用hasNext()方法检查是否还有下一个元素
System.out.print("是否还有下一个元素？");
boolean hasNext = scanner.hasNext();
System.out.println("结果：" + hasNext);
// 使用hasNextInt()方法检查是否还有下一个整数
System.out.print("是否还有下一个整数？");
boolean hasNextInt = scanner.hasNextInt();
System.out.println("结果：" + hasNextInt);
// 使用hasNextLine()方法检查是否还有下一行文本
System.out.print("是否还有下一行文本？");
boolean hasNextLine = scanner.hasNextLine();
System.out.println("结果：" + hasNextLine);
// 关闭Scanner对象
scanner.close();
}
}
Object类
概述：是Java语言中的根类，位于 java.lang 包中。每个类在声明时都隐式地继承了 Object 类，以下是常用的 Object 类方法，多用于实体类，
| 方法 |
描述 |
| object.toString( ) |
返回该对象的字符串表示，默认对象的类型+@+内存地址值 |
| object.equals( obj ) |
默认进行“==”运算符的对象地址比较，若比较内容需重写 |
| object.hashCode( ) |
返回对象的哈希码值，用于位置标识等方面 |
| object.getClass( ) |
获取对象的类 Class 对象，常用于反射 |
代码示例：1、定义一个 Person 实体类；
public class Person {
private String name;
private int age;
// 有参构造器
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 重写 equals(Object obj) 方法，比较内容
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {
return false;
}
Person other = (Person) obj;
return age == other.age && Objects.equals(name, other.name);
}
// 重写 toString() 方法，自定义返回字符串内容，默认为内存地址
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + "}";
}
}2、功能测试（也可以直接写在实体类中）
class MyTest{
Person person = new Person("John", 25);
Person person1 = new Person("John", 25);
public static void main(String[] args) {
System.out.println(person1.equals(person2)); // true
// 若不重写 equals(Object obj) 方法，上行结果为 false
// 使用 hashCode() 方法
int hashCode = person.hashCode();
System.out.println("HashCode: " + hashCode);
// 使用 getClass() 方法，获取 Person 类
Class cls = person.getClass();
System.out.println("Class: " + cls.getName());
// 使用 notify() 和 wait() 方法
synchronized (person) {
try {
System.out.println("Before waiting");
person.wait(); // 线程进入等待状态，直到其他线程调用 notify() 或 notifyAll() 方法唤醒它
System.out.println("After waiting");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}String类
概述：即字符串，Java 程序中所有的字符串文字都可以被看作是实现此类的实例。字符串的值在创建后不能被更改，因此在多线程环境下是安全的。
PS：JDK8之前是通过 char[ ] 数组实现，JDK8 之后是 byte[ ] 数组实现。
常用判断
概述：即方法的返回值都是布尔类型。
| 方法 |
描述 |
| string.equals( obj ) |
比较字符串的内容是否相同，区分大小写 |
| string.equalsIgnoreCase( str ) |
比较字符串的内容是否相同，忽略大小写 |
| string.contains( str ) |
判断 string 中是否包含 str |
| string.startsWith( str ) |
判断 string 是否以某个指定的 str 开头 |
| string.endsWith( str ) |
判断 string 是否以某个指定的 str 结尾 |
| string.isEmpty( ) |
判断字符串是否为空 |
PS：空内容【 String = "" 】与空对象【 String = null 】的区别
【 String = "" 】已进行初始化，是一个有效地字符串，有内存指向，可以进行相关方法的访问；
【 String = null 】没有经过初始化，无内存指向，是一个无效的变量，访问会出现 NullPointerException 空指针异常。
public class StringExample {
public static void main(String[] args) {
String str = "Hello World";
// 使用equals()方法比较字符串是否相等
boolean isEqual = str.equals("Hello World");
System.out.println("字符串是否相等：" + isEqual);
// 使用equalsIgnoreCase()方法比较字符串是否相等（忽略大小写）
boolean isIgnoreCaseEqual = str.equalsIgnoreCase("hello world");
System.out.println("字符串是否相等（忽略大小写）：" + isIgnoreCaseEqual);
// 使用contains()方法检查字符串是否包含指定的子字符串
boolean containsStr = str.contains("World");
System.out.println("字符串是否包含指定的子字符串：" + containsStr);
// 使用startsWith()方法检查字符串是否以指定的前缀开始
boolean startsWithStr = str.startsWith("Hello");
System.out.println("字符串是否以指定的前缀开始：" + startsWithStr);
// 使用endsWith()方法检查字符串是否以指定的后缀结束
boolean endsWithStr = str.endsWith("World");
System.out.println("字符串是否以指定的后缀结束：" + endsWithStr);
// 使用isEmpty()方法检查字符串是否为空
boolean isEmptyStr = str.isEmpty();
System.out.println("字符串是否为空：" + isEmptyStr);
}
}
常用查询
概述：查询即获取对象的某部分属性或者内容，都有返回值，返回值根据查询内容不同而不同。
| 方法 |
描述 |
| string.charAt(int index) |
返回char，获取 string 的 index 位置的字符 char |
| string.length( ) |
返回int，获取 string 字符串的长度 |
| string.indexOf( str ) |
返回int，返回 obj 第一次出现时索引，未找到为-1 |
| string.indexOf( str, start ) |
返回int，返回 obj 从 start 开始第一次出现时索引，包括start |
| string.concat(String str) |
返回 String，将 str 拼接到 string 的末尾 |
| string.substring( start ) |
返回 String，截取 string 从 start 之后的所有字符串，包括 start |
| string.substring( start, end ) |
返回 String，截取 string 从 start 到 end 位置的字符串，前包后不包 |
PS：因为 String 不可修改，因此返回值为 String 的，需要新创建一个 String 对象接收返回值。
String str = "Hello, World!";
// 获取字符串的长度，结果为 13
int length = str.length();
// 拼接字符串，结果为 "Hello, World! Welcome!"
String concatStr = str.concat(" Welcome!");
// 获取指定索引位置的字符，结果为 'W'
char ch = str.charAt(7);
// 查找字符第一次出现的位置
int indexOfO = str.indexOf('o');
// 从指定索引位置开始查找字符第一次出现的位置，结果为 -1
int indexOfOFromIndex = str.indexOf('o', 5);
// 截取字符串，从指定索引位置开始到末尾，结果为 "World!"
String substring1 = str.substring(7); //
// 截取字符串，从指定索引位置开始到结束索引之前，结果为 "World"
String substring2 = str.substring(7, 12); 常用转换
| 方法 |
描述 |
| string.getBytes( ) |
返回 byte[ ]，将字符串转换为字节数组 |
| string.toCharArray( ) |
返回 char[ ]，将字符串转换为字符数组 |
| string.valueOf( char[ ] ) |
返回 String，将字符数组转换为字符串 |
| string.valueOf( int ) |
返回 String，将整数转换为字符串，不改变数字本身 |
| string.toLowerCase( ) |
返回 String，将字符串内所有字母转换为小写 |
| string.toUpperCase( ): |
返回 String，将字符串内所有字母转换为大写 |
| string.replace( oldStr, newStr ) |
返回 String，将 string 内所有 newStr 替换为 oldStr |
| string.trim( ) |
返回 String，将该字符串两端的空格去除并返回 |
String str = "Hello, World!";
// 将字符串转换为字节数组
byte[] bytes = str.getBytes();
// 结果为 [72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33]
// 将字符串转换为字符数组
char[] chars = str.toCharArray();
// 结果为 ['H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!']
// 将字符数组转换为字符串，结果为 "Hello, World!"
String valueOfChars = String.valueOf(chars);
// 将整数转换为字符串，不改变数字大小，结果为 "123"
String valueOfInt = String.valueOf(123);
// 将字符串转换为小写，结果为 "hello, world!"
String lowerCase = str.toLowerCase();
// 将字符串转换为大写，结果为 "HELLO, WORLD!"
String upperCase = str.toUpperCase();
// 字符串替换，后替换前，结果为：Hi, World!
String replaceStr = str.replace("Hello","Hi")正则组合
概述：字符串常可以与正则表达式搭配使用，正则表达式是通过一系列字符和特殊符号组成的模式来定义一个搜索规则（此处不详细讲）。
| 方法 |
描述 |
| string.split( regex ) |
返回 String[ ]，将此字符串按照 regex 拆分为字符串数组 |
| string.replaceAll( regex, str ) |
返回 String，将匹配 regex 的所有部分替换为新字符串 str |
| string.replaceFirst( regex, str ) |
返回 String，将匹配 regex 的第一部分替换为新字符串 str |
String str = "Hello, World! Hello, Java!";
// 使用 split(String regex) 方法进行字符串分割
String[] parts = str.split(", ");
// 结果为 ["Hello", "World! Hello", "Java!"]
// 使用 replaceAll方法进行替换
String replaced1 = str.replaceAll("H[a-z]+", "Goodbye");
// 结果为 "Goodbye, World! Goodbye, Java!"
// 使用 replaceFirst方法进行替换
String replaced2 = str.replaceFirst("[a-zA-Z]+,", "Hey,");
// 结果为 "Hey, World! Hello, Java!"