Java学习八—常用包(类)之java.lang包

一、关于包

1.1简介

在Java中，package（包）是用来组织和管理类（class）的一种机制。包可以将相关的类进行分组，有助于代码的管理和组织。

1. 作用：

   • 包可以避免类名冲突：不同包中的类可以使用相同的类名，因为它们的完全限定名（package + 类名）不同。
   • 提供了命名空间管理：通过包的结构，可以很方便地管理类和其他资源。

   • 命名规范：

     • 包名一般使用小写字母，多个单词之间可以使用.​分隔，如com.example.myapp​。
     • 包名应该具有唯一性，通常使用公司域名的倒置形式来确保包名的唯一性。

     • 包的声明：

       • 在Java类的文件中使用package​语句声明所属的包，通常在文件开头声明。
       • 例如，package com.example.myapp;​ 表示该类属于com.example.myapp​包。

       • 包的导入：

         • 使用import​语句将其他包中的类引入到当前类中使用。
         • 可以使用通配符*​来导入整个包或特定类，例如import java.util.*;​ 或 import java.util.ArrayList;​。

           例如：

           import java.util.Date;
           import com.example.myapp.MyClass;
           

           这允许在代码中直接使用Date​和MyClass​，而不需要每次都写出完整的包名。

         • 包的结构：

           • 包是按照目录结构来组织的，包名中的.​会被转换成文件系统的路径分隔符。
           • 例如，包com.example.myapp​对应的目录结构为com/example/myapp​。

           • 标准Java包：

             • Java提供了许多标准的包，如java.lang​、java.util​、java.io​等，用于提供常用类和接口。
             • 标准库中的类无需导入即可直接使用。

‍

1.2java常用包

Java提供了大量的标准库包，这些包包含了各种功能丰富的类和接口，以支持广泛的应用程序开发。以下是一些Java中最常用和重要的包及其简要介绍：

1. java.lang - 这是Java语言的核心包，包含了许多基本类，如String​、Math​、System​、Thread​和Runnable​等。这个包中的类被自动导入到每个Java程序中，无需显式导入。
2. java.util - 包含集合框架、日期时间功能、事件模型、随机数生成器等。常见的类有ArrayList​、HashMap​、HashSet​、Date​、Calendar​、Random​等。
3. java.io - 提供了输入输出功能，包括文件读写、序列化和网络通信等。重要的类有File​、FileInputStream​、FileOutputStream​、BufferedReader​、PrintWriter​、InputStream​、OutputStream​等。
4. java.net - 包含了编写网络应用程序所必需的类，如URL、URI和网络连接的管理。主要类有URL​、URLConnection​、Socket​、ServerSocket​等。
5. java.nio - 提供了更高效的I/O操作方法，支持直接内存访问，是java.io的一个补充。关键类包括ByteBuffer​、CharBuffer​、Channels​和Selectors​。
6. java.sql - 包含了用于处理数据库相关的类和接口，如Connection​、Statement​、ResultSet​等，支持JDBC（Java数据库连接）。
7. java.awt - 是Java的原始图形用户界面工具包，包含了创建桌面应用程序所需的基本组件和工具类。
8. java.swing - 建立在AWT之上，提供了一套更加强大的图形用户界面组件，用于创建复杂的桌面应用程序。
9. java.security - 提供了安全性和加密功能，包括安全的随机数生成、加密、摘要、签名等。主要类有KeyStore​、Cipher​、MessageDigest​、Signature​等。
10. java.math - 包含了BigDecimal​类，用于任意精度的整数和定点数的数学运算。
11. java.concurrent - 包含了并发编程的工具类，如线程池、同步器、并发集合等。关键类有ExecutorService​、Future​、Callable​、CountDownLatch​、CyclicBarrier​、ConcurrentHashMap​等。
12. 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常用类和接口

1. Object - 所有类的根类，提供了一些基本的方法，如 toString()​、equals(Object)​、hashCode()​ 和 getClass()​。
2. String - 表示不可变的字符串。String​ 类提供了创建和操作字符串的方法，如 length()​、charAt(int)​、substring(int, int)​、indexOf(String)​ 等。
3. Math - 提供了基本的数学运算功能，如 abs()​、sqrt()​、random()​、pow(double, double)​ 等。
4. System - 提供了与系统相关的方法，如 out​（PrintStream​ 类型的 System.out​）、err​（PrintStream​ 类型的 System.err​）、exit(int)​、gc()​ 等。
5. Thread - 用于创建和控制线程的类。Thread​ 类提供了线程的创建、启动、等待、同步和通信的方法。
6. Runnable - 一个标记接口，其实现类的对象可以作为线程执行。通常与 Thread​ 类一起使用，以定义线程的任务。
7. Throwable - 所有错误和异常的超类。Exception​ 和 Error​ 是 Throwable​ 的两个主要子类。
8. Exception - 程序可以处理的异常的基类。RuntimeException​ 和 IOException​ 是 Exception​ 的常见子类。
9. RuntimeException - 非检查性异常的超类，表示那些可能在Java虚拟机正常运行期间抛出的异常，如 NullPointerException​、IllegalArgumentException​ 等。
10. ClassLoader - 用于动态加载 Java 类的类。Java 虚拟机会使用 ClassLoader​ 来加载 .class​ 文件。
11. StringBuilder 和 StringBuffer - 可变字符串类，提供了可修改字符串的方法。StringBuffer​ 是线程安全的，而 StringBuilder​ 不是。
12. 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方法

1. toString() - 返回对象的字符串表示，通常返回类的名称和对象的哈希码的无符号十六进制表示。可以通过重写此方法来提供对象的自定义字符串表示。
2. equals(Object obj) - 用于比较两个对象是否相等。默认实现是比较对象的引用，即只有当两个对象是同一个实例时才返回 true​。可以通过重写此方法来提供自定义的相等性比较逻辑。
3. hashCode() - 返回对象的哈希码，这是一个用于哈希表的整数值。默认实现依赖于对象的内部状态。通常，当你重写 equals​ 方法时，也应该重写 hashCode​ 方法，以确保 equals​ 方法的相等性与 hashCode​ 方法的一致性。
4. getClass() - 获取运行时对象的类信息，返回一个 Class​ 对象，表示对象的类型。
5. clone() - 创建并返回对象的一个副本。默认实现是浅拷贝，即复制对象的引用，而不是对象本身。可以通过实现 Cloneable​ 接口并重写 clone​ 方法来提供深拷贝或其他自定义的克隆行为。
6. wait() - 使当前线程等待，直到另一个线程调用此对象的 notify()​ 或 notifyAll()​ 方法，或者直到超过指定的超时时间。
7. notify() 和 notifyAll() - 用于唤醒在此对象监视器上等待的单个线程（notify()​）或所有线程（notifyAll()​）。
8. 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.
     * 

     * 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:
     * 
     * 
     * getClass().getName() + '@' + Integer.toHexString(hashCode())
     * 
     *
     * @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()​实现应该满足以下条件：

    1. 如果两个对象根据equals()​方法被认为是相等的，那么它们的hashCode()​返回值也必须相等。
    2. hashCode()​方法的返回值应该在对象的生命周期内保持不变。
    3. 应该尽量生成一个分布均匀的哈希码，以减少哈希冲突。

    以下是一个重写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 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. 构造方法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 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! } } 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()); } } 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()); } } public void run() { for (int i = 1; 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(); } } @Override public void run() { System.out.println("Runnable task is running..."); } } public class Main { public static void main(String[] args) { MyRunnableTask task = new MyRunnableTask(); Thread thread = new Thread(task); thread.start(); // 启动线程，将执行 MyRunnableTask 的 run 方法 } } public static void main(String[] args) { // 通过匿名内部类实现Runnable接口 Runnable myRunnable = new Runnable() { @Override public void run() { System.out.println("线程执行逻辑"); } }; // 创建线程并启动 Thread myThread = new Thread(myRunnable); myThread.start(); } } public static void main(String[] args) { try { throw new Exception("Sample exception"); } catch (Exception e) { Throwable throwable = (Throwable) e; System.out.println("Message: " + throwable.getMessage()); System.out.println("Cause: " + throwable.getCause()); throwable.printStackTrace(); } } } public static void main(String[] args) { try { throw new Exception("Sample exception"); } catch (Exception e) { Exception exception = (Exception) e; System.out.println("Message: " + exception.getMessage()); System.out.println("Cause: " + exception.getCause()); exception.printStackTrace(); } } } public MyError(String message) { super(message); } } public class ErrorExample { public static void main(String[] args) { try { throw new MyError("Sample error"); } catch (MyError e) { e.printStackTrace(); } } } public static void main(String[] args) { long startTime = System.currentTimeMillis(); int[] sourceArray = {1, 2, 3, 4, 5}; int[] destArray = new int[5]; System.arraycopy(sourceArray, 0, destArray, 0, sourceArray.length); System.out.println("Copied Array: " + Arrays.toString(destArray)); long endTime = System.currentTimeMillis(); long executionTime = endTime - startTime; System.out.println("Execution time: " + executionTime + " milliseconds"); } } public static void main(String[] args) { try { // 获取 Runtime 对象 Runtime runtime = Runtime.getRuntime(); // 执行操作系统命令 Process process = runtime.exec("ls -l"); // 获取可用内存、总内存和最大内存 long freeMemory = runtime.freeMemory(); long totalMemory = runtime.totalMemory(); long maxMemory = runtime.maxMemory(); // 输出系统信息 System.out.println("Free memory: " + freeMemory); System.out.println("Total memory: " + totalMemory); System.out.println("Max memory: " + maxMemory); } catch (IOException e) { e.printStackTrace(); } } } public static void main(String[] args) { int abs = Math.abs(-99);//求绝对值 System.out.println(abs); double pow = Math.pow(2,4);//求幂 System.out.println(pow); double ceil = Math.ceil(-3.123);//向上取整， // 返回=该参数的最小整数。 System.out.println(ceil); double floor = Math.floor(-8.99);//向下取整， // 放回 double rondom = Math.random();//求随机数 System.out.println(rondom); } int max = Math.max(100,123);//求最大值 System.out.println(max); double min = Math.min(123.123,123.111);//求最小值 System.out.println(min); } } public enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY } public static void main(String[] args) { // 遍历枚举常量 for (Day day : Day.values()) { System.out.println(day); } // 根据名称获取枚举常量 Day wednesday = Day.valueOf("WEDNESDAY"); System.out.println("The day is: " + wednesday); } }