- java.security - 提供了安全性和加密功能，包括安全的随机数生成、加密、摘要、签名等。主要类有
KeyStore、Cipher、MessageDigest、Signature等。 - java.math - 包含了
BigDecimal类，用于任意精度的整数和定点数的数学运算。 - java.concurrent - 包含了并发编程的工具类，如线程池、同步器、并发集合等。关键类有
ExecutorService、Future、Callable、CountDownLatch、CyclicBarrier、ConcurrentHashMap等。 - java.time - Java 8引入的新的日期和时间API，提供了更加易用和更加灵活的日期时间处理类，如
LocalDate、LocalTime、LocalDateTime、ZonedDateTime、Duration、Period等。
这些包构成了Java标准库的基础，是开发Java应用程序时不可或缺的部分。
二、java.lang包
2.1关于java.lang包
2.1.1简介
java.lang 包是 Java 程序中最基本和最核心的包。它包含了 Java 编程语言的基础类，这些类是每个 Java 程序的构建块。由于其重要性，java.lang 包中的类被自动导入到所有的 Java 程序中，无需显式地使用 import 语句。
java.lang包是java语言的核心，它提供了java中的基础类。包括基本Object类、Class类、String类、基本类型的包装类、基本的数学类等等最基本的类。
2.1.2常用类和接口
- Object - 所有类的根类，提供了一些基本的方法，如
toString()、equals(Object)、hashCode() 和getClass()。 - String - 表示不可变的字符串。
String 类提供了创建和操作字符串的方法，如length()、charAt(int)、substring(int, int)、indexOf(String) 等。 - Math - 提供了基本的数学运算功能，如
abs()、sqrt()、random()、pow(double, double) 等。 - System - 提供了与系统相关的方法，如
out（PrintStream 类型的System.out）、err（PrintStream 类型的System.err）、exit(int)、gc() 等。 - Thread - 用于创建和控制线程的类。
Thread 类提供了线程的创建、启动、等待、同步和通信的方法。 - Runnable - 一个标记接口，其实现类的对象可以作为线程执行。通常与
Thread 类一起使用，以定义线程的任务。 - Throwable - 所有错误和异常的超类。
Exception 和Error 是Throwable 的两个主要子类。 - Exception - 程序可以处理的异常的基类。
RuntimeException 和IOException 是Exception 的常见子类。 - RuntimeException - 非检查性异常的超类，表示那些可能在Java虚拟机正常运行期间抛出的异常，如
NullPointerException、IllegalArgumentException 等。 - ClassLoader - 用于动态加载 Java 类的类。Java 虚拟机会使用
ClassLoader 来加载.class 文件。 - StringBuilder 和 StringBuffer - 可变字符串类，提供了可修改字符串的方法。
StringBuffer 是线程安全的，而StringBuilder 不是。 - Long、Integer、Double、Float 等 - 提供了基本数值类型的包装类，以及一系列静态方法来操作这些数值类型。
2.2Object类
2.2.1简介
java.lang.Object 是 Java 语言中所有类的根类。这个类提供了一些基本的方法和行为，这些方法和行为在所有的 Java 类中都是可用的，因为它们最终都是从 Object 类继承而来的。
Java Object 类是所有类的父类，也就是说 Java 的所有类都继承了 Object，子类可以使用 Object 的所有方法。
Object 类可以显式继承，也可以隐式继承，以下两种方式是一样的：
1.显式继承:
public class Runoob extends Object{
}
2.隐式继承:
public class Runoob {
}
2.2.2构造方法
Object 类是所有类的根类，它包含了一些所有类都具有的通用方法，比如 toString、equals、hashCode 等。由于 Object 类是所有类的祖先，因此它并没有显式定义构造方法。换句话说，Object 类的构造方法是由 Java 虚拟机隐式提供的，它没有任何参数，也没有任何操作，因为它并不需要进行实例化。
2.2.3方法
- toString() - 返回对象的字符串表示，通常返回类的名称和对象的哈希码的无符号十六进制表示。可以通过重写此方法来提供对象的自定义字符串表示。
- equals(Object obj) - 用于比较两个对象是否相等。默认实现是比较对象的引用，即只有当两个对象是同一个实例时才返回
true。可以通过重写此方法来提供自定义的相等性比较逻辑。 - hashCode() - 返回对象的哈希码，这是一个用于哈希表的整数值。默认实现依赖于对象的内部状态。通常，当你重写
equals 方法时，也应该重写hashCode 方法，以确保equals 方法的相等性与hashCode 方法的一致性。 - getClass() - 获取运行时对象的类信息，返回一个
Class 对象，表示对象的类型。 - clone() - 创建并返回对象的一个副本。默认实现是浅拷贝，即复制对象的引用，而不是对象本身。可以通过实现
Cloneable 接口并重写clone 方法来提供深拷贝或其他自定义的克隆行为。 - wait() - 使当前线程等待，直到另一个线程调用此对象的
notify() 或notifyAll() 方法，或者直到超过指定的超时时间。 - notify() 和 notifyAll() - 用于唤醒在此对象监视器上等待的单个线程（
notify()）或所有线程（notifyAll()）。 - finalize() - 在垃圾收集器决定回收对象之前，由垃圾收集器调用此方法。这个方法可以用于执行清理操作，比如释放资源。然而，由于
finalize() 方法的调用时机不确定，以及可能对性能的影响，通常建议使用 try-with-resources 语句和自动资源管理器来管理资源，而不是依赖finalize() 方法。
2.2.4示例
toString方法
Object 类中的 toString() 方法是 Java 中一个非常重要的方法，它被用来返回对象的字符串表示。这个字符串表示通常包含了对象的类名和它的哈希码值的无符号十六进制表示。
/\*\*
\* Returns a string representation of the object. In general, the
\* {@code toString} method returns a string that
\* "textually represents" this object. The result should
\* be a concise but informative representation that is easy for a
\* person to read.
\* It is recommended that all subclasses override this method.
\* <p>
\* The {@code toString} method for class {@code Object}
\* returns a string consisting of the name of the class of which the
\* object is an instance, the at-sign character `{@code @}', and
\* the unsigned hexadecimal representation of the hash code of the
\* object. In other words, this method returns a string equal to the
\* value of:
\* <blockquote>
\* <pre>
\* getClass().getName() + '@' + Integer.toHexString(hashCode())
\* </pre></blockquote>
\*
\* @return a string representation of the object.
\*/
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
默认实现
在 Object 类中，toString() 方法的默认实现返回一个字符串，格式通常如下：
"[类名@哈希码]"
其中，类名是对象所属的类的名称，哈希码是对象的哈希值的无符号十六进制表示。哈希码是基于对象的内部状态计算得来的，通常是对象的内存地址的某种变换。
重写 **toString()** 方法
由于 toString() 方法在 Object 类中的实现并不具有太多的描述性，因此在实际编程中，通常会根据需要重写这个方法，以提供更有意义的信息。例如，一个 Person 类可能会重写 toString() 方法来返回包含人名和年龄的字符串。
下面是一个重写 toString() 方法的例子：
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + '}';
}
}
在这个例子中，toString() 方法返回了一个包含 Person 对象 name 和 age 属性的字符串。
使用 **toString()** 方法
toString() 方法在 Java 中的使用非常广泛，它被用于打印对象信息、显示在用户界面上、记录日志等场景。例如，可以使用 System.out.println() 方法打印对象的字符串表示：
Person person = new Person("Alice", 30);
System.out.println(person); // 输出：Person{name='Alice', age=30}
在上述代码中，由于 Person 类重写了 toString() 方法，所以 System.out.println() 方法能够打印出自定义的字符串表示。
在IDEA中高效使用toString
- 第一步：alt +insert
- 第二步：选中toString（）
- 第三步：将所需参数选中，点击OK!
生成你所需的方法，也可在此基础上进行修改达到最佳效果！
equals方法
Object类的equals()方法用于比较两个对象是否相等。默认情况下，equals()方法实现的是比较两个对象的引用是否相同，即它检查两个对象的内存地址是否一致。如果两个对象的引用指向同一个内存位置，equals()方法返回true；否则返回false。
public boolean equals(Object obj) {
return (this == obj);
}
重写**equals()** 方法
在实际应用中，通常需要根据对象的内容而不是它们的引用来比较它们是否相等。因此，经常需要重写equals()方法来提供自定义的相等性比较逻辑。重写equals()方法时，通常也需要重写hashCode()方法，以确保相等的对象具有相同的哈希码，这是hashCode()方法的一般约定。
以下是一个重写equals()方法的示例：
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 重写equals方法
@Override
public boolean equals(Object obj) {
// 如果对象引用相同，或者obj是null，或者类型不匹配，则不平等
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {
return false;
}
// 转换为Person类型以安全地访问属性
Person person = (Person) obj;
// 比较name和age属性
return this.name.equals(person.name) && this.age == person.age;
}
// 重写hashCode方法以保持与equals的一致性
@Override
public int hashCode() {
int result = 17;
result = 31 \* result + name.hashCode();
result = 31 \* result + age;
return result;
}
}
在这个示例中，Person类重写了equals()方法，以比较两个Person对象的name和age属性是否相同。同时，也重写了hashCode()方法，以确保具有相同属性的Person对象具有相同的哈希码。
使用**equals()** 方法
当你创建了自定义的equals()方法后，可以使用它来比较两个对象是否具有相同的数据：
Person person1 = new Person("Alice", 30);
Person person2 = new Person("Alice", 30);
Person person3 = new Person("Bob", 30);
boolean areEqual1 = person1.equals(person2); // 返回true，因为他们具有相同的属性
boolean areEqual2 = person1.equals(person3); // 返回false，因为他们的name不同
在这个例子中，person1和person2具有相同的name和age，所以equals()方法返回true。而person1和person3的name不同，所以equals()方法返回false。
hashCode()方法
简介
Object类的hashCode()方法用于为对象生成一个哈希码值，这个值通常用于确定对象在哈希表中的位置。哈希码是一个32位的整数，它通过对象的内部数据计算得到，可以用来快速比较对象的相等性。
public int hashCode();
hash值
哈希值是根据地址值换算出来的一个值，并不是实际的地址值，常用于哈希表中，如HashMap、HashTable、HashSet。关于哈希值，不同的JDK算法其实是不一样的：
● Java 6、7 中会默认返回一个随机数；
● Java 8 中默认通过和当前线程有关的一个随机数 + 三个确定值，运用Marsaglia’s xorshift scheme的随机数算法得到的一个随机数。
默认行为
Object类的默认hashCode()实现依赖于对象的内存地址，因此不同的Java虚拟机实现可能会有不同的hashCode()行为。通常情况下，如果你不重写这个方法，那么只有完全相同的对象（即指向同一内存地址的引用）才会返回相同的哈希码。
重写**hashCode()** 方法
当重写了equals()方法来提供自定义的相等性比较逻辑时，也应该重写hashCode()方法，以确保相等的对象具有相同的哈希码。这是非常重要的，因为很多Java集合类（如HashSet、HashMap和Hashtable）都依赖于hashCode()方法来快速查找和存储对象。
一个好的hashCode()实现应该满足以下条件：
- 如果两个对象根据
equals()方法被认为是相等的，那么它们的hashCode()返回值也必须相等。 hashCode()方法的返回值应该在对象的生命周期内保持不变。- 应该尽量生成一个分布均匀的哈希码，以减少哈希冲突。
以下是一个重写hashCode()方法的示例：
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 重写hashCode方法
@Override
public int hashCode() {
int result = 17; // 常数种子
result = 31 \* result + name.hashCode(); // 将name的哈希码混合进去
result = 31 \* result + age; // 将age的值混合进去
return result;
}
// 重写equals方法，以保持与hashCode的一致性
@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 && name.equals(other.name);
}
}
在这个例子中，Person类的hashCode()方法使用了一个常数种子（17）和一个乘数（31），将name的哈希码和age的值混合在一起，生成了一个哈希码。这样做可以确保即使name或age的值改变，hashCode()方法返回的哈希码也会相应地改变。
使用**hashCode()** 方法
当你使用哈希表相关的集合类时，hashCode()方法会被自动调用，以确定对象的存储位置：
HashSet<Person> people = new HashSet<>();
Person person1 = new Person("Alice", 30);
Person person2 = new Person("Bob", 35);
people.add(person1);
people.add(person2);
Person person3 = new Person("Alice", 30);
boolean contains = people.contains(person3); // 返回true，因为person3与person1相等
在这个例子中，HashSet使用hashCode()方法来确定person1和person2的存储位置。当我们尝试添加person3时，由于它与person1相等，HashSet会认为它们是同一个对象，因此contains方法返回true。
2.3字符串类
2.3.1关于字符串类
简介
在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。String 类是不可变类，即一旦一个 String 对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁。
Java 提供了两个可变字符串类 StringBuffer 和 StringBuilder，中文翻译为“字符串缓冲区”。
StringBuilder 类是 JDK 1.5 新增的类，它也代表可变字符串对象。实际上，StringBuilder 和 StringBuffer 功能基本相似，方法也差不多。不同的是，StringBuffer 是线程安全的，而 StringBuilder 则没有实现线程安全功能，所以性能略高。因此在通常情况下，如果需要创建一个内容可变的字符串对象，则应该优先考虑使用 StringBuilder 类。
区别
StringBuffer、StringBuilder、String 中都实现了 CharSequence 接口。CharSequence 是一个定义字符串操作的接口，它只包括 length()、charAt(int index)、subSequence(int start, int end) 这几个 API。
StringBuffer、StringBuilder、String 对 CharSequence 接口的实现过程不一样
对CharSequence接口的实现
String 直接实现了 CharSequence 接口，StringBuilder 和 StringBuffer 都是可变的字符序列，它们都继承于 AbstractStringBuilder，实现了 CharSequence 接口。
使用
String 是 Java 中基础且重要的类，被声明为 final class，是不可变字符串。因为它的不可变性，所以拼接字符串时候会产生很多无用的中间对象，如果频繁的进行这样的操作对性能有所影响。
StringBuffer 就是为了解决大量拼接字符串时产生很多中间对象问题而提供的一个类。它提供了 append 和 add 方法，可以将字符串添加到已有序列的末尾或指定位置，它的本质是一个线程安全的可修改的字符序列。
在很多情况下我们的字符串拼接操作不需要线程安全，所以 StringBuilder 登场了。StringBuilder 是 JDK1.5 发布的，它和 StringBuffer 本质上没什么区别，就是去掉了保证线程安全的那部分，减少了开销。
线程安全：
StringBuffer：线程安全
StringBuilder：线程不安全
速度：
一般情况下，速度从快到慢为 StringBuilder > StringBuffer > String，当然这是相对的，不是绝对的。
使用环境：
操作少量的数据使用 String。
单线程操作大量数据使用 StringBuilder。
多线程操作大量数据使用 StringBuffer。
字符串拼接方法
在 Java 中，有几种常用的方法可以用于字符串拼接：
1.使用加号（+）操作符：
javaCopy CodeString str1 = "Hello";
String str2 = "world!";
String result = str1 + " " + str2; // 结果为 "Hello world!"
高并发，性能较低
2.使用 StringBuilder 类：
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("world!");
String result = sb.toString(); // 结果为 "Hello world!"
使用 StringBuilder 可以有效避免大量字符串拼接操作时产生的临时对象，提高性能。
例子：
3.使用 String.format() 方法：
javaCopy CodeString str1 = "Hello";
String str2 = "world!";
String result = String.format("%s %s", str1, str2); // 结果为 "Hello world!"
使用 String.format() 方法可以按照指定的格式将多个字符串拼接成一个字符串。
需要注意的是，以上方法中的字符串拼接都是创建了新的字符串对象，并不会修改原有的字符串对象。如果频繁进行字符串拼接操作，建议使用 StringBuilder 或 StringBuffer 类来提高性能。另外，从 Java 9 开始，还引入了更简洁的字符串拼接方法 String.join()，可以更方便地拼接多个字符串。
2.3.2String类
简介
java.lang.String 类是 Java 程序设计语言中用于表示和操作字符串的基本类。它是 java.lang 包的一部分，因此无需特别导入即可直接使用。
特点
- 不可变性：
String 对象一旦创建，其值就不能被改变。这意味着任何看似修改字符串的操作实际上都会创建一个新的String 对象。 - 内存优化：Java 通过所谓的字符串池（String Pool）来优化内存使用。当创建字符串常量时，Java 虚拟机会在字符串池中查找是否已经存在相同的字符串，如果存在，则重用该字符串对象。
- 自动装箱与拆箱：
String 类实现了String 类型的自动装箱和拆箱，可以与String 对象和字符串字面量之间无缝转换。
构造方法
String中的构造方法很多，即可以通过很多方法创建String对象。
-
构造方法1：使用字符串字面值创建
- 示例：
String str1 = "Hello"; // 使用字符串字面值创建
-
构造方法2：使用字符数组创建
- 示例：
char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str2 = new String(charArray); // 使用字符数组创建
-
构造方法3：使用字符数组指定起始位置和长度创建
- 示例：
char[] charArray = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'};
String str3 = new String(charArray, 6, 5); // 从字符数组的第6个位置开始，长度为5创建字符串对象
-
构造方法4：使用字节数组创建
- 示例：
byte[] byteArray = {72, 101, 108, 108, 111}; // 对应ASCII编码的 "Hello"
String str4 = new String(byteArray); // 使用字节数组创建
-
构造方法5：使用字节数组指定字符集创建
- 示例：
byte[] byteArray = {72, 101, 108, 108, 111}; // 对应ASCII编码的 "Hello"
String str5 = new String(byteArray, StandardCharsets.UTF\_8); // 使用指定字符集创建
-
构造方法6：使用String对象创建
- 示例：
String original = "Hello";
String str6 = new String(original); // 使用String对象创建
方法
s.length() : 返回字符串的长度
s.charAt(index) : 获取字符串s的第index位置的字符，返回的是字符。index可以看成下标，范围从0开始到字符 串的长度减1结束 0 <= index <= s.length()-1 。 超过这个长度 就会有字符串下标越界
s.compareTo(s2) : 比较两个字符串的大小。返回的是整数。正数代表s大，负数代表s2大。
s.concat(s2) : 将s2拼接到s的后，生成一个新的字符串，原字符串不变 等同于+的功能
s.contains(s2): 判断s中是否包含字符串s2，返回boolean类型
s.endsWith(s2) : 判断字符串s是否以字符串s2结尾 返回boolean类型
s.startsWith(s2):判断字符串s是否以字符串s2开始 返回boolean类型
s.equals(Object o) : 判断传过来的o是否是一个字符串且与s中的值一样。（判断两个字符串是否一样，不能使用 ==号，应该使用equals方法）
s.equalsIgnoreCase(s2) : 忽略大小写判断s与s2是否一样。
s.indexOf(s2) : 返回s2 在s中第一次出现的位置 （s2 可以是字符串也可以是字符），如果s中不包含s2子字符串， 则返回-1.
s.lastIndexOf(s2) : 返回s2在s中最后一次出现的位置
s.isEmpty() : 判断s是否是空字符串，不是null，而是"" 即 长度是0;
s.replace(s1,s2) : 将字符串s中的所有s1子字符串用字符串s2替换，生成一个新的字符串，原字符串不变。 s2替 换s中所有的子字符串s1.
s.split(s2) : 使用s2将字符串s拆开,返回的是一个字符串数组，原字符串不变(s2是一个正则表达式)
s.substring(int n) : 从字符串s的第n个位置开始，截取后面所有的子字符串。
s.substring(n,m) : 从字符串s的第n个位置开始截取到第m个位置，包含第n个位置，不包含第m个位置，原字符串 不变，返回一个新的字符串。
s.toLowerCase() : 将字符串s中的所有大写字母转成小写字母，原字符串不变，生成一个新的字符串。
s.toUpperCase() : 转大写
s.trim() : 去掉字符串s两边的空格，不包含中间的空格
String.valueOf(x) : String的静态方法，将x转成字符串。
s.replaceAll：Java 中用于替换字符串中的匹配项的方法。它使用正则表达式来指定要替换的模式，并用指定的字符串进行替换。
示例
public class StringExample {
public static void main(String[] args) {
// 创建字符串
String str1 = "Hello,";
String str2 = "world!";
// 字符串拼接
String result = str1 + " " + str2;
System.out.println(result); // 输出: Hello, world!
// 获取字符串长度
int length = result.length();
System.out.println("Length: " + length); // 输出: Length: 13
// 字符串比较
String str3 = "hello";
if (str1.equalsIgnoreCase(str3)) {
System.out.println("str1 equals to str3 ignoring case");
} else {
System.out.println("str1 not equals to str3 ignoring case"); // 输出: str1 not equals to str3 ignoring case
}
// 查找子字符串
int index = result.indexOf("world");
if (index != -1) {
System.out.println("Substring 'world' found at index " + index); // 输出: Substring 'world' found at index 7
} else {
System.out.println("Substring not found");
}
// 提取子字符串
String subStr = result.substring(7);
System.out.println("Substring: " + subStr); // 输出: Substring: world!
// 字符串分割
String[] words = result.split(",");
for (String word : words) {
System.out.println(word);
}
// 替换字符串
String replacedStr = result.replace("world", "Java");
System.out.println("Replaced string: " + replacedStr); // 输出: Replaced string: Hello, Java!
// 去除首尾空格
String stringWithSpaces = " Trim me! ";
String trimmedStr = stringWithSpaces.trim();
System.out.println("Trimmed string: " + trimmedStr); // 输出: Trimmed string: Trim me!
}
}
2.3.2StringBuilder类
简介
java.lang.StringBuffer类是可变的字符串类，它可以动态修改字符串的内容。StringBuffer类的对象是一个动态的字符序列，可以进行插入、追加、删除和修改等操作，适用于需要频繁修改字符串内容的情况。
构造方法
StringBuilder(): 构造一个空的字符串构建器，初始容量为 16 个字符。StringBuilder(CharSequence seq): 构造一个字符串构建器，初始化为指定的字符序列。StringBuilder(int capacity): 构造一个空的字符串构建器，初始容量由 capacity 参数指定。StringBuilder(String str): 构造一个字符串构建器，并初始化为指定的字符串内容。
- 使用空的构造方法创建一个空的
StringBuilder 对象：
StringBuilder sb1 = new StringBuilder();
- 使用指定容量的构造方法创建一个空的
StringBuilder 对象，初始容量为 20 个字符：
StringBuilder sb2 = new StringBuilder(20);
- 使用字符串参数的构造方法创建一个包含指定字符串内容的
StringBuilder 对象：
StringBuilder sb3 = new StringBuilder("Hello, World!");
- 使用字符序列参数的构造方法创建一个包含指定字符序列内容的
StringBuilder 对象：
CharSequence charSeq = "This is a char sequence";
StringBuilder sb4 = new StringBuilder(charSeq);
方法
append(String str): 在末尾追加字符串。insert(int offset, String str): 在指定位置插入字符串。replace(int start, int end, String str): 替换指定范围内的字符串。delete(int start, int end): 删除指定范围内的字符。reverse(): 反转字符串。substring(int start): 返回从指定位置开始到末尾的子字符串。substring(int start, int end): 返回指定范围的子字符串。charAt(int index): 返回指定索引处的字符。length(): 返回字符串长度。indexOf(String str): 返回字符串中第一次出现指定子字符串的索引。lastIndexOf(String str): 返回字符串中最后一次出现指定子字符串的索引。toString(): 将StringBuilder 对象转化为字符串。
示例
public class StringBuilderExample {
public static void main(String[] args) {
// 创建一个空的 StringBuilder 对象
StringBuilder sb = new StringBuilder();
// 在末尾追加字符串
sb.append("Hello");
// 在指定位置插入字符串
sb.insert(5, ", World");
// 输出当前 StringBuilder 对象内容
System.out.println("StringBuilder内容: " + sb.toString());
// 替换指定范围内的字符串
sb.replace(6, 11, "Java");
// 删除指定范围内的字符
sb.delete(0, 5);
// 反转字符串
sb.reverse();
// 输出结果
System.out.println("处理后的StringBuilder内容: " + sb.toString());
}
}
2.3.3StringBuffer类
简介
java.lang.StringBuffer 是 Java 中的一个可变字符序列，它提供了 String 类所没有的某些功能，尤其是在多线程环境中。与 String 类似，StringBuffer 也是 java.lang 包的一部分，因此可以直接使用而无需导入。
主要特性
- 可变性：
StringBuffer 对象的内容可以在创建后进行修改，这与String 对象的不可变性形成对比。 - 线程安全：所有
StringBuffer 的公共方法都是同步的，这意味着它们是线程安全的，可以在多线程环境中安全使用，不会有并发问题。 - 性能：由于
StringBuffer 的可变性，它在某些情况下比String 更高效，尤其是在需要频繁修改字符串内容的场景中。
构造方法
StringBuffer()：创建一个空的StringBuffer 对象。StringBuffer(int capacity)：创建一个指定初始容量的StringBuffer 对象。StringBuffer(String str)：创建一个与指定字符串内容相同的StringBuffer 对象。
方法
append(String str): 在末尾追加字符串。insert(int offset, String str): 在指定位置插入字符串。replace(int start, int end, String str): 替换指定范围内的字符串。delete(int start, int end): 删除指定范围内的字符。reverse(): 反转字符串。substring(int start): 返回从指定位置开始到末尾的子字符串。substring(int start, int end): 返回指定范围的子字符串。charAt(int index): 返回指定索引处的字符。length(): 返回字符串长度。setCharAt(int index, char ch): 将指定索引处的字符设置为指定字符。indexOf(String str): 返回字符串中第一次出现指定子字符串的索引。lastIndexOf(String str): 返回字符串中最后一次出现指定子字符串的索引。capacity(): 返回当前容量。ensureCapacity(int minimumCapacity): 确保容量至少等于指定值。toString(): 将StringBuffer 对象转化为字符串。
示例
public class StringBufferExample {
public static void main(String[] args) {
// 创建一个空的 StringBuffer 对象
StringBuffer sb = new StringBuffer();
// 在末尾追加字符串
sb.append("Hello");
// 在指定位置插入字符串
sb.insert(5, ", World");
// 输出当前 StringBuffer 对象内容
System.out.println("StringBuffer内容: " + sb.toString());
// 替换指定范围内的字符串
sb.replace(6, 11, "Java");
// 删除指定范围内的字符
sb.delete(0, 5);
// 反转字符串
sb.reverse();
// 输出结果
System.out.println("处理后的StringBuffer内容: " + sb.toString());
}
}
2.4包装类
2.4.1关于包装类
简介
包装类是一种用于将基本数据类型转换为对象的类。这些基本数据类型包括整数、浮点数、字符和布尔值。每种基本数据类型都有对应的包装类。包装类提供了许多实用的方法来处理基本数据类型的值，以及在集合类中使用基本数据类型的值。
基本数据类型及其对应的包装类
| 基本数据类型 | 包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
功能
这些包装类提供了一系列方法来进行基本数据类型与对象之间的转换，以及进行数学运算、比较等操作。此外，它们还提供了一些静态方法来解析字符串、转换为字符串等功能。
例如，可以使用包装类将整数转换为对象，并执行一些操作：
Integer num = new Integer(10); // 将整数10转换为Integer对象
int value = num.intValue(); // 从Integer对象获取整数值
String str = num.toString(); // 将Integer对象转换为字符串
另外，自动装箱（autoboxing）和自动拆箱（unboxing）使得基本数据类型和包装类之间的转换更加方便。例如：
Integer num = 10; // 自动装箱：将整数10自动转换为Integer对象
int value = num; // 自动拆箱：将Integer对象自动转换为整数值
总体而言，包装类为基本数据类型提供了更多的操作和功能，使得基本数据类型可以更方便地在Java的面向对象环境中使用。
2.4.2Integer类
简介
Integer 类是 Java 中用于表示整数的包装类之一。它提供了许多方法来处理整数值，以及将整数值转换为其他数据类型。
构造方法
-
Integer 类提供了两种构造方法：Integer(int value)：通过一个基本数据类型的整数值创建一个Integer 对象。Integer(String s)：通过一个字符串参数创建一个Integer 对象，该字符串必须表示一个有效的整数。
方法
intValue()：返回Integer 对象的整数值。doubleValue()：返回Integer 对象的双精度浮点值。toString()：返回Integer 对象的字符串表示形式。parseInt(String s)：将指定字符串解析为带符号的十进制整数。valueOf(int i)：返回表示指定的int 值的Integer 实例。
示例
public class IntegerExample {
public static void main(String[] args) {
// 使用构造方法创建 Integer 对象
Integer num1 = new Integer(10); // 通过整数值创建
Integer num2 = new Integer("20"); // 通过字符串创建
// 调用方法获取值或执行操作
int value1 = num1.intValue(); // 获取整数值
double value2 = num2.doubleValue(); // 获取双精度浮点值
String str = num1.toString(); // 转换为字符串
// 解析字符串为整数
int parsedInt = Integer.parseInt("30");
// 使用 valueOf 方法创建 Integer 对象
Integer num3 = Integer.valueOf(40);
// 输出结果
System.out.println("Value of num1: " + value1);
System.out.println("Value of num2 as double: " + value2);
System.out.println("String representation of num1: " + str);
System.out.println("Parsed integer from string: " + parsedInt);
System.out.println("Value of num3: " + num3);
}
}
2.5线程类及接口
2.5.1Thread类
简介
在Java中，Thread类是用于创建和操作线程的类。
- Thread类是Java提供的用于多线程编程的核心类之一，用于创建和操作线程。
- 通过继承Thread类并重写run()方法，可以定义线程要执行的任务代码。
构造方法
- Thread() ：创建一个新的线程对象。
- Thread(Runnable target) ：创建一个新的线程对象，并指定实现了Runnable接口的对象作为线程的目标。
- Thread(Runnable target, String name) ：创建一个新的带有指定名称的线程对象。
- Thread(String name) ：创建一个新的带有指定名称的线程对象。
- Thread(ThreadGroup group, Runnable target) ：在指定线程组中创建一个新线程对象。
方法
- start() ：启动线程，使其进入就绪状态，当CPU时间片分配到时自动执行run()方法。
- run() ：线程的主体方法，包含线程要执行的任务代码。
- sleep(long millis) ：让当前线程休眠指定毫秒数。
- join() ：等待该线程终止。
- interrupt() ：中断线程。
- isAlive() ：判断线程是否处于活动状态。
- setName(String name) ：设置线程的名称。
- getState() ：获取线程的状态。
示例
class MyThread extends Thread {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
try {
Thread.sleep(1000); // 休眠1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Main {
public static void main(String[] args) {
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
thread1.setName("Thread 1");
thread2.setName("Thread 2");
thread1.start();
thread2.start();
}
}
在上面的示例中，定义了一个继承自Thread的自定义线程类MyThread，重写了run()方法，在main函数中创建了两个线程对象，分别启动这两个线程，输出各自线程的执行结果。
2.5.2Runnable接口
简介
Runnable 是 Java 中的一个接口，它定义了那些可以由新线程执行的任务。
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注Python）
}
}
}
public class Main {
public static void main(String[] args) {
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
thread1.setName("Thread 1");
thread2.setName("Thread 2");
thread1.start();
thread2.start();
}
}
在上面的示例中，定义了一个继承自Thread的自定义线程类MyThread，重写了run()方法，在main函数中创建了两个线程对象，分别启动这两个线程，输出各自线程的执行结果。
#### 2.5.2Runnable接口
##### 简介
`Runnable` 是 Java 中的一个接口，它定义了那些可以由新线程执行的任务。
**自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**
**深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**
**因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**
[外链图片转存中...(img-DT79EYui-1712477322890)]
[外链图片转存中...(img-7fn4xiUO-1712477322890)]
**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！**
**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**
**如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注Python）**
<img src="https://img-community.csdnimg.cn/images/fd6ebf0d450a4dbea7428752dc7ffd34.jpg" alt="img" style="zoom:50%;" />
扫一扫
144
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
