首页 > 基础资料 博客日记

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

2024-07-16 02:00:06基础资料围观175次

Java资料网推荐Java学习八—常用包(类)之java.lang包这篇文章给大家，欢迎收藏Java资料网享受知识的乐趣

一、关于包

1.1简介

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

  1. 作用：

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

  2. 命名规范：

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

  3. 包的声明：

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

  4. 包的导入：

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

    例如：

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

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

  5. 包的结构：

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

  6. 标准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.
     * <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()​实现应该满足以下条件：

  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<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. 构造方法1：使用字符串字面值创建

    • 示例：
    String str1 = "Hello"; // 使用字符串字面值创建

  2. 构造方法2：使用字符数组创建

    • 示例：
    char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str2 = new String(charArray); // 使用字符数组创建

  3. 构造方法3：使用字符数组指定起始位置和长度创建

    • 示例：
    char[] charArray = {'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'};
String str3 = new String(charArray, 6, 5); // 从字符数组的第6个位置开始，长度为5创建字符串对象

  4. 构造方法4：使用字节数组创建

    • 示例：
    byte[] byteArray = {72, 101, 108, 108, 111}; // 对应ASCII编码的 "Hello"
String str4 = new String(byteArray); // 使用字节数组创建

  5. 构造方法5：使用字节数组指定字符集创建

    • 示例：
    byte[] byteArray = {72, 101, 108, 108, 111}; // 对应ASCII编码的 "Hello"
String str5 = new String(byteArray, StandardCharsets.UTF_8); // 使用指定字符集创建

  6. 构造方法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类的对象是一个动态的字符序列，可以进行插入、追加、删除和修改等操作，适用于需要频繁修改字符串内容的情况。

‍

构造方法
  1. StringBuilder(): 构造一个空的字符串构建器，初始容量为 16 个字符。
  2. StringBuilder(CharSequence seq): 构造一个字符串构建器，初始化为指定的字符序列。
  3. StringBuilder(int capacity): 构造一个空的字符串构建器，初始容量由 capacity 参数指定。
  4. StringBuilder(String str): 构造一个字符串构建器，并初始化为指定的字符串内容。

‍

  1. 使用空的构造方法创建一个空的 StringBuilder​ 对象：
StringBuilder sb1 = new StringBuilder();
  1. 使用指定容量的构造方法创建一个空的 StringBuilder​ 对象，初始容量为 20 个字符：
StringBuilder sb2 = new StringBuilder(20);
  1. 使用字符串参数的构造方法创建一个包含指定字符串内容的 StringBuilder​ 对象：
StringBuilder sb3 = new StringBuilder("Hello, World!");
  1. 使用字符序列参数的构造方法创建一个包含指定字符序列内容的 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关于包装类

简介

包装类是一种用于将基本数据类型转换为对象的类。这些基本数据类型包括整数、浮点数、字符和布尔值。每种基本数据类型都有对应的包装类。包装类提供了许多实用的方法来处理基本数据类型的值，以及在集合类中使用基本数据类型的值。

‍

基本数据类型及其对应的包装类
基本数据类型包装类
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean

‍

功能

这些包装类提供了一系列方法来进行基本数据类型与对象之间的转换，以及进行数学运算、比较等操作。此外，它们还提供了一些静态方法来解析字符串、转换为字符串等功能。

例如，可以使用包装类将整数转换为对象，并执行一些操作：

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​ 类提供了两种构造方法：

    1. Integer(int value)​：通过一个基本数据类型的整数值创建一个 Integer​ 对象。
    2. 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()方法，可以定义线程要执行的任务代码。

‍

​

‍

构造方法
  1. Thread() ：创建一个新的线程对象。
  2. Thread(Runnable target) ：创建一个新的线程对象，并指定实现了Runnable接口的对象作为线程的目标。
  3. Thread(Runnable target, String name) ：创建一个新的带有指定名称的线程对象。
  4. Thread(String name) ：创建一个新的带有指定名称的线程对象。
  5. Thread(ThreadGroup group, Runnable target) ：在指定线程组中创建一个新线程对象。

‍

方法
  1. start() ：启动线程，使其进入就绪状态，当CPU时间片分配到时自动执行run()方法。
  2. run() ：线程的主体方法，包含线程要执行的任务代码。
  3. sleep(long millis) ：让当前线程休眠指定毫秒数。
  4. join() ：等待该线程终止。
  5. interrupt() ：中断线程。
  6. isAlive() ：判断线程是否处于活动状态。
  7. setName(String name) ：设置线程的名称。
  8. 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 中的一个接口，它定义了那些可以由新线程执行的任务。

​

‍

方法
  • run() : 必须由实现类提供的方法，用于执行线程的任务。当线程被启动时，run()​ 方法将被调用。

‍

示例
public class MyRunnableTask implements Runnable {
    @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 方法
    }
}

在这个示例中，MyRunnableTask​ 类实现了 Runnable​ 接口，并提供了 run()​ 方法的实现。Main​ 类中的主方法创建了 MyRunnableTask​ 的实例，并将其传递给 Thread​ 构造方法来创建一个新的线程。调用 thread.start()​ 启动线程，这将导致 MyRunnableTask​ 的 run()​ 方法被执行。

通过实现 Runnable​ 接口，可以将任务与线程的创建和管理分离，这使得代码更加模块化和灵活。这种方式也便于多个线程共享同一个任务实例，或者将任务传递给线程池等高级并发机制。

‍

‍

public class Main {
    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();
    }
}

‍

‍

2.6错误和异常处理类

2.6.1Throwable类

简介

Throwable​ 类是 Java 中所有错误和异常的超类。它包含了有关错误或异常的信息，以便在程序出现问题时进行诊断和处理。Throwable​ 类有两个重要的子类：Error​ 和 Exception​。

‍

构造方法

1.Throwable(): 创建一个新的 Throwable​ 对象，并且没有详细消息。

Throwable throwable = new Throwable();

2.Throwable(String message): 创建一个新的 Throwable​ 对象，并指定详细消息。

Throwable throwable = new Throwable("Custom throwable message");

‍

方法
  1. public String getMessage(): 返回 Throwable​ 对象的详细消息字符串。
  2. public String toString(): 返回 Throwable​ 对象的简短描述。
  3. public void printStackTrace(): 将 Throwable​ 对象及其跟踪输出到标准错误流。
  4. public StackTraceElement[] getStackTrace(): 返回表示该 Throwable​ 对象堆栈跟踪的数组。

‍

示例
public class ThrowableExample {
    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();
        }
    }
}

在这个示例中，我们在一个 try-catch​ 块中抛出了一个 Exception​。在 catch​ 块中，我们将 Exception​ 捕获并将其转换为 Throwable​ 对象。然后，我们使用 Throwable​ 类提供的方法来获取错误信息、原因，并打印堆栈跟踪。

Throwable​ 类是 Java 异常处理机制的核心，它提供了一种统一的方式来处理程序运行时遇到的各种问题。通过使用 Throwable​ 类及其子类，我们可以更好地控制程序的异常流程，并提供更加详细的错误信息。

‍

2.6.2Exception类

简介

Exception​ 类是 Java 中所有可检查（checked）异常的超类。它继承自 Throwable​ 类，提供了异常处理的基本信息和机制。Exception​ 类及其子类通常用于程序运行时出现的异常情况，这些异常在编译时需要被捕获或者声明抛出。

‍

构造方法

Exception() : 创建一个新的 Exception​ 实例，没有错误信息和链式的异常原因。

	Exception exception = new Exception();

‍

Exception(String message) : 创建一个新的 Exception​ 实例，带有指定的错误信息。

Exception exception = new Exception("Custom exception message");

‍

Exception(String message, Throwable cause) : 创建一个新的 Exception​ 实例，带有指定的错误信息和异常原因。

Throwable cause = new Throwable("Cause of exception");
Exception exception = new Exception("Custom exception message", cause);

‍

Exception(Throwable cause) : 创建一个新的 Exception​ 实例，带有链式的异常原因。

Throwable cause = new Throwable("Cause of exception");
Exception exception = new Exception(cause);

‍

方法
  • getMessage() : 返回此 Throwable​ 的详细信息消息字符串。
  • getCause() : 返回此 Throwable​ 的原因，如果此 Throwable​ 没有原因，则返回 null​。
  • toString() : 返回一个包含 Throwable​ 的类名、详细消息和栈跟踪的字符串。
  • printStackTrace() : 打印此 Throwable​ 的堆栈跟踪信息到标准错误流。
  • addSuppressed(Throwable t) : 将给定的抑制异常添加到此 Throwable​ 的抑制异常列表中。

‍

示例
public class ExceptionExample {
    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();
        }
    }
}

在这个示例中，在一个 try-catch​ 块中抛出了一个 Exception​。在 catch​ 块中，我们将 Exception​ 捕获，并使用 Exception​ 类提供的方法来获取错误信息、原因，并打印堆栈跟踪。

‍

2.6.3Error类

简介

Error​ 类是 Java 中所有错误（Error​）的超类。与 Exception​ 类不同，Error​ 类表示的是由外部环境引起的严重问题，通常不是由程序本身控制的，例如 OutOfMemoryError​ 或 StackOverflowError​。这些错误通常是程序无法轻易恢复的，因此，通常不建议尝试捕获或处理这些错误。

‍

构造方法

Error 类提供了与 Throwable 类相同的构造方法，因为它也是 Throwable 的子类。以下是 Error 类的一些构造方法：

Error(): 创建一个新的 Error 实例，没有错误信息和链式的异常原因。

Error error = new Error();

Error(String message): 创建一个新的 Error 实例，带有指定的错误信息。

Error error = new Error("Custom error message");

Error(String message, Throwable cause): 创建一个新的 Error 实例，带有指定的错误信息和异常原因。

Throwable cause = new Throwable("Cause of error");
Error error = new Error("Custom error message", cause);

Error(Throwable cause): 创建一个新的 Error 实例，带有链式的异常原因。

Throwable cause = new Throwable("Cause of error");
Error error = new Error(cause);

‍

方法

作为 Throwable​ 的子类，Error​ 类继承了 Throwable​ 类的所有方法，包括 getMessage()​、getCause()​、toString()​ 和 printStackTrace()​ 等。这些方法可以用来获取错误的详细信息、原因、堆栈跟踪等。

‍

示例
public class MyError extends Error {
    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();
        }
    }
}

在这个示例中，我们定义了一个自定义的 MyError​ 类，它继承自 Error​ 类。在 main​ 方法中，我们抛出了一个 MyError​ 实例，并在 catch​ 块中捕获它，然后打印堆栈跟踪信息。

‍

2.7系统和运行类

2.7.1System类

简介

System​ 类是 Java 核心类库中的一个类，它提供了一些系统级的方法和属性，用于处理系统相关的操作。

​

‍

构造方法

System​ 类是一个 final 类，因此不能被实例化，也就是说它没有公共的构造方法。

‍

方法
  1. public static void exit(int status)​：终止当前运行的 Java 虚拟机。
  2. public static long currentTimeMillis()​：返回当前时间与 1970 年 1 月 1 日午夜之间以毫秒为单位的时间差。
  3. public static void gc()​：运行垃圾回收器。
  4. public static String getProperty(String key)​：获取指定系统属性的值。
  5. public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)​：将数组指定范围的元素复制到另一个数组。

‍

示例
public class SystemExample {
    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");
    }
}

这个示例展示了如何使用 System.currentTimeMillis()​ 方法获取程序执行时间，并使用 System.arraycopy()​ 方法将一个数组的内容复制到另一个数组中。

‍

2.7.2Runtime类

简介

Runtime​ 类是 Java 中用于管理运行时环境的类，它允许应用程序与其运行的环境进行交互。

‍

构造方法

在 Java 中，Runtime​ 类的构造方法是私有的，这意味着无法直接实例化一个 Runtime​ 对象。相反，可以使用静态方法 getRuntime()​ 来获取当前运行时对象的引用，如下所示：

Runtime runtime = Runtime.getRuntime();

‍

方法
  1. exec(String command)​：在单独的进程中执行指定的命令。
  2. freeMemory()​：返回可用内存的近似字节数。
  3. totalMemory()​：返回 JVM 的总内存量。
  4. maxMemory()​：返回 JVM 可以使用的最大内存量。
  5. gc()​：运行垃圾回收器。

‍

示例
public class RuntimeExample {
    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();
        }
    }
}

以上示例中，获取了 Runtime​ 对象，并使用 exec​ 方法执行了一个操作系统命令（ls -l​），然后获取了系统的内存信息并进行输出。

‍

2.8Math类（数据工具类）

2.8.1简介

Math​ 类是 Java 中的一个数学工具类，提供了很多用于数学运算的静态方法。这些方法可以帮助我们进行数学计算，如求绝对值、取最大最小值、四舍五入等。

‍

2.8.2构造方法

Math​ 类是一个工具类，并没有公有的构造方法，因为所有的方法都是静态方法，直接通过类名调用即可，无需实例化对象。

‍

2.8.3方法

  1. abs(double a)​：返回参数的绝对值。
  2. max(double a, double b)​：返回两个参数中的较大值。
  3. min(double a, double b)​：返回两个参数中的较小值。
  4. round(double a)​：将参数四舍五入为最接近的整数。
  5. sqrt(double a)​：返回参数的平方根。
  6. random()​：返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。

‍

2.8.4示例

public class MathMethod {
    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);//向下取整，
        // 放回<=该参数的最大整数。
        System.out.println(floor);

        long round = Math.round(3.14);//四舍五入 Math.floor(该参数+0.5）
        System.out.println(round);

        double sqrt = Math.sqrt(9);//开方
        System.out.println(sqrt);

        for (int i= 0; i < 10; i++) {
            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);

    }
}

输出结果

​

‍

2.9Enum类

2.9.1简介

Enum 类是 Java 中的一个枚举类型，它用于定义一组具名的常量。枚举类在 Java 中是一个特殊的类，可以通过关键字 enum​ 来定义。

​

‍

2.9.3构造方法

在 Enum 类中，构造方法默认是私有的，也就是说无法在外部使用 new​ 关键字来实例化枚举对象。

‍

2.9.4方法

  1. values()​ 方法：返回枚举类中所有枚举常量的数组。
  2. valueOf(String name)​ 方法：根据指定名称返回枚举类中对应的枚举常量。

‍

2.9.5示例

public class EnumExample {
    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);
    }
}

在上面的示例中，定义了一个枚举类 Day​ 包含星期几的常量，然后展示了如何遍历枚举常量以及如何通过名称获取枚举常量的示例。

‍


文章来源:https://blog.csdn.net/qq_17153885/article/details/137093920
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！

标签：

上一篇：springboot websocket 知识点汇总
下一篇：在 Linux 上搭建 Java 环境

相关文章

最新发布

点击排行

本站推荐

标签云