【Java 基础】学习系统封装类

亦凉 2024-05-04 08:04 90阅读 0赞

![在这里插入图片描述][43baa9053b4d490985bd0eb5b23b5ca4.png]

> ?**博主介绍**： 博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家，WEB架构师，阿里云专家博主，华为云云享专家，51CTO 专家博主

⛪️ 个人社区：[个人社区][Link 1]  
? 个人主页：[个人主页][Link 2]  
? 专栏地址： ✅ [Java 进阶之路][Java]  
?八股文专题：[剑指大厂，手撕 Java 八股文][Java 1]

#### 文章目录 ####

*   *   *  一、包装类
         *  二、String类常用方法
         *  三、字符串内存分析
         *  四、日期类
         *  五、BigDecimal
         *  六、System
         *  七、按值传递和按地址传递

#### 一、包装类 ####

Java的包装类（Wrapper Class）是一种特殊的类，用于将基本数据类型（如int、char、boolean等）封装为对象。每种基本数据类型都有对应的包装类，它们位于 `java.lang` 包下。

Java的包装类提供了一些方法和属性，用于操作和处理基本数据类型的值。包装类的主要作用有以下几个方面：

1.  将基本数据类型转换为对象：包装类允许将基本数据类型转换为对应的对象。例如，可以将一个int类型的值转换为Integer对象。
2.  提供了一些方法和属性：包装类提供了一些方法和属性，用于操作和处理基本数据类型的值。例如，Integer类提供了 `parseInt()` 方法用于将字符串转换为整数。
3.  允许在集合中存储基本数据类型：Java的集合框架只能存储对象，而不能直接存储基本数据类型。通过使用包装类，可以将基本数据类型转换为对象，从而在集合中存储基本数据类型的值。

以下是一些常见的包装类及其对应的基本数据类型：

*  `Boolean` ：对应boolean
 *  `Byte` ：对应byte
 *  `Short` ：对应short
 *  `Integer` ：对应int
 *  `Long` ：对应long
 *  `Float` ：对应float
 *  `Double` ：对应double
 *  `Character` ：对应char

使用包装类可以方便地进行基本数据类型与对象之间的转换和操作。例如，可以使用 `Integer` 包装类的 `parseInt()` 方法将字符串转换为整数，或者使用 `Integer` 包装类的 `toString()` 方法将整数转换为字符串。

#### 二、String类常用方法 ####

Java中的String类是一个非常常用的类，用于表示和操作字符串。String类位于 `java.lang` 包下，不需要额外导入就可以使用。

以下是String类的一些常用方法：

1.  `length()` ：返回字符串的长度。

String str = "Hello World";
    int length = str.length(); // 返回11

1.  `charAt(int index)` ：返回指定索引位置的字符。

String str = "Hello";
    char ch = str.charAt(1); // 返回'e'

1.  `substring(int beginIndex, int endIndex)` ：返回从指定索引开始到指定索引结束的子字符串。

String str = "Hello World";
    String subStr = str.substring(6, 11); // 返回"World"

1.  `indexOf(String str)` ：返回指定字符串在原字符串中第一次出现的索引位置。

String str = "Hello World";
    int index = str.indexOf("World"); // 返回6

1.  `toUpperCase()` ：将字符串中的所有字符转换为大写。

String str = "hello";
    String upperCaseStr = str.toUpperCase(); // 返回"HELLO"

1.  `toLowerCase()` ：将字符串中的所有字符转换为小写。

String str = "HELLO";
    String lowerCaseStr = str.toLowerCase(); // 返回"hello"

1.  `trim()` ：去除字符串两端的空格。

String str = "  Hello World  ";
    String trimmedStr = str.trim(); // 返回"Hello World"

1.  `replace(char oldChar, char newChar)` ：将字符串中的指定字符替换为新字符。

String str = "Hello";
    String replacedStr = str.replace('e', 'a'); // 返回"Hallo"

这些只是String类的一部分常用方法，还有很多其他方法可以用于字符串的操作和处理。

#### 三、字符串内存分析 ####

在Java中，字符串是不可变的对象，即一旦创建就不能修改其值。当我们创建一个字符串时，它将被存储在内存中的字符串常量池中。字符串常量池是Java运行时环境中的一个特殊区域，用于存储字符串字面量。

当我们创建一个字符串对象时，Java首先检查字符串常量池中是否已经存在相同值的字符串。如果存在，那么新的字符串对象将不会被创建，而是直接引用已经存在的字符串对象。这样可以节省内存空间并提高性能。

让我们来看一个示例：

String str1 = "Hello";
    String str2 = "Hello";
    String str3 = new String("Hello");
    System.out.println(str1 == str2); // true，引用相同的字符串对象
    System.out.println(str1 == str3); // false，不同的字符串对象

在上面的示例中， `str1` 和 `str2` 都是使用字符串字面量创建的，它们引用的是同一个字符串对象。而 `str3` 是通过 `new` 关键字创建的，它引用的是一个新的字符串对象。

当我们对字符串进行一些操作时，例如拼接、替换等，每次操作都会创建一个新的字符串对象。原始的字符串对象不会被修改，而是创建一个新的字符串对象来保存操作后的结果。

String str = "Hello";
    str += " World"; // 创建了一个新的字符串对象，"Hello World"
    System.out.println(str); // Hello World

在上面的示例中，当我们对 `str` 进行拼接操作时，实际上是创建了一个新的字符串对象来保存拼接后的结果。

总结起来，Java中的字符串是不可变的对象，每次对字符串进行操作都会创建一个新的字符串对象。这种设计有助于提高性能和安全性，并且可以通过字符串常量池来节省内存空间。

#### 四、日期类 ####

Java中有多个日期类可用于处理日期和时间。其中最常用的是 `java.util.Date` 和 `java.util.Calendar` 类。

以下是关于这两个类的简要介绍：

1.  `java.util.Date` 类：

*  `Date` 类表示特定的瞬间，精确到毫秒级别。它存储的是从1970年1月1日午夜开始经过的毫秒数。
 *  `Date` 类提供了许多方法来获取和设置日期和时间，例如 `getDate()` 、 `getMonth()` 、 `getYear()` 等。
 *  `Date` 类也可以进行日期和时间的计算和比较，例如 `before()` 、 `after()` 、 `compareTo()` 等。

1.  `java.util.Calendar` 类：

*  `Calendar` 类是一个抽象类，用于表示日期和时间，并提供了一些方法来操作日期和时间。
 *  `Calendar` 类可以获取和设置年、月、日、时、分、秒等各个字段的值。
 *  `Calendar` 类还提供了一些方法来进行日期和时间的计算和比较，例如 `add()` 、 `roll()` 、 `compareTo()` 等。

除了上述两个类，Java 8引入了新的日期和时间API，即 `java.time` 包。这个新的API提供了多个类来处理日期和时间，例如 `LocalDate` 、 `LocalTime` 、 `LocalDateTime` 等。这些类提供了更多的功能和更好的性能，并且更易于使用和理解。

以上是关于Java中日期类的简要介绍。根据具体的需求，您可以选择使用 `Date` 类、 `Calendar` 类或者新的 `java.time` 包中的类来处理日期和时间。

以下是 `java.util.Date` 和 `java.util.Calendar` 类的一些用法示例：

1.  `java.util.Date` 类的用法示例：

import java.util.Date;
     
    public class DateExample {
        
        public static void main(String[] args) {
        
            // 创建一个当前时间的Date对象
            Date currentDate = new Date();
            System.out.println("当前时间：" + currentDate);
             // 设置特定的日期和时间
            Date specificDate = new Date(121, 0, 1, 12, 30, 0);
            System.out.println("特定日期和时间：" + specificDate);
             // 获取日期和时间的各个字段值
            int year = specificDate.getYear() + 1900;
            int month = specificDate.getMonth() + 1;
            int day = specificDate.getDate();
            int hour = specificDate.getHours();
            int minute = specificDate.getMinutes();
            int second = specificDate.getSeconds();
            System.out.println("年：" + year);
            System.out.println("月：" + month);
            System.out.println("日：" + day);
            System.out.println("时：" + hour);
            System.out.println("分：" + minute);
            System.out.println("秒：" + second);
             // 比较两个日期的先后
            Date date1 = new Date(121, 0, 1);
            Date date2 = new Date(121, 0, 2);
            int comparison = date1.compareTo(date2);
            if (comparison < 0) {
        
                System.out.println("date1在date2之前");
            } else if (comparison > 0) {
        
                System.out.println("date1在date2之后");
            } else {
        
                System.out.println("date1与date2相同");
            }
        }
    }

1.  `java.util.Calendar` 类的用法示例：

import java.util.Calendar;
    
    public class CalendarExample {
        
        public static void main(String[] args) {
        
            // 创建一个Calendar对象并设置特定的日期和时间
            Calendar calendar = Calendar.getInstance();
            calendar.set(2021, Calendar.JANUARY, 1, 12, 30, 0);
            System.out.println("特定日期和时间：" + calendar.getTime());
             // 获取日期和时间的各个字段值
            int year = calendar.get(Calendar.YEAR);
            int month = calendar.get(Calendar.MONTH) + 1;
            int day = calendar.get(Calendar.DAY_OF_MONTH);
            int hour = calendar.get(Calendar.HOUR_OF_DAY);
            int minute = calendar.get(Calendar.MINUTE);
            int second = calendar.get(Calendar.SECOND);
            System.out.println("年：" + year);
            System.out.println("月：" + month);
            System.out.println("日：" + day);
            System.out.println("时：" + hour);
            System.out.println("分：" + minute);
            System.out.println("秒：" + second);
             // 进行日期和时间的计算
            calendar.add(Calendar.DAY_OF_MONTH, 7);
            calendar.add(Calendar.HOUR_OF_DAY, -2);
            System.out.println("计算后的日期和时间：" + calendar.getTime());
             // 比较两个日期的先后
            Calendar calendar1 = Calendar.getInstance();
            calendar1.set(2021, Calendar.JANUARY, 1);
            Calendar calendar2 = Calendar.getInstance();
            calendar2.set(2021, Calendar.JANUARY, 2);
            int comparison = calendar1.compareTo(calendar2);
            if (comparison < 0) {
        
                System.out.println("calendar1在calendar2之前");
            } else if (comparison > 0) {
        
                System.out.println("calendar1在calendar2之后");
            } else {
        
                System.out.println("calendar1与calendar2相同");
            }
        }
    }

以上是 `java.util.Date` 和 `java.util.Calendar` 类的一些用法示例。

#### 五、BigDecimal ####

`java.math.BigDecimal` 是 Java 中用于精确表示大数的类。它提供了高精度的浮点运算和舍入操作。下面是 `java.math.BigDecimal` 类的一些用法示例：

1.  **创建 `BigDecimal` 对象**：

import java.math.BigDecimal;
    
    public class BigDecimalExample {
        
        public static void main(String[] args) {
        
            // 使用整数创建 BigDecimal 对象
            BigDecimal number1 = new BigDecimal(10);
            System.out.println("整数 BigDecimal：" + number1);
             // 使用字符串创建 BigDecimal 对象
            BigDecimal number2 = new BigDecimal("3.14");
            System.out.println("字符串 BigDecimal：" + number2);
        }
    }

1.  **进行基本的算术运算**：

import java.math.BigDecimal;
    
    public class BigDecimalExample {
        
        public static void main(String[] args) {
        
            BigDecimal number1 = new BigDecimal("10");
            BigDecimal number2 = new BigDecimal("3");
             // 加法
            BigDecimal sum = number1.add(number2);
            System.out.println("加法结果：" + sum);
             // 减法
            BigDecimal difference = number1.subtract(number2);
            System.out.println("减法结果：" + difference);
             // 乘法
            BigDecimal product = number1.multiply(number2);
            System.out.println("乘法结果：" + product);
             // 除法
            BigDecimal quotient = number1.divide(number2);
            System.out.println("除法结果：" + quotient);
        }
    }

1.  **设置精确的小数位数和舍入模式**：

import java.math.BigDecimal;
    import java.math.RoundingMode;
    
    public class BigDecimalExample {
        
        public static void main(String[] args) {
        
            BigDecimal number = new BigDecimal("3.1415926");
             // 设置小数位数为2位，使用默认的舍入模式
            BigDecimal roundedNumber1 = number.setScale(2);
            System.out.println("舍入结果（默认）：" + roundedNumber1);
             // 设置小数位数为2位，使用向下舍入模式
            BigDecimal roundedNumber2 = number.setScale(2, RoundingMode.DOWN);
            System.out.println("舍入结果（向下舍入）：" + roundedNumber2);
             // 设置小数位数为2位，使用向上舍入模式
            BigDecimal roundedNumber3 = number.setScale(2, RoundingMode.UP);
            System.out.println("舍入结果（向上舍入）：" + roundedNumber3);
        }
    }

以上是 `java.math.BigDecimal` 类的一些用法示例。使用 `BigDecimal` 类可以确保在进行大数运算时获得精确的结果。

#### 六、System ####

`java.lang.System` 是 Java 中的一个类，它提供了与系统相关的方法和属性。 `System` 类包含了一些常用的静态方法，用于访问系统的标准输入、输出、错误流，以及获取系统的属性和当前时间等。

下面是 `System` 类的一些常用方法示例：

1.  **获取当前时间的毫秒数**：

long currentTimeMillis = System.currentTimeMillis();
    System.out.println("当前时间的毫秒数：" + currentTimeMillis);

1.  **获取系统的属性**：

String osName = System.getProperty("os.name");
    System.out.println("操作系统名称：" + osName);
    String javaVersion = System.getProperty("java.version");
    System.out.println("Java 版本：" + javaVersion);

1.  **标准输入、输出、错误流**：

// 从标准输入读取数据
    Scanner scanner = new Scanner(System.in);
    System.out.print("请输入一个整数：");
    int number = scanner.nextInt();
    System.out.println("输入的整数是：" + number);
     // 输出到标准输出
    System.out.println("Hello, World!");
     // 输出到标准错误
    System.err.println("发生了一个错误！");

1.  **退出程序**：

System.exit(0);

以上是 `java.lang.System` 类的一些常用方法示例。 `System` 类提供了访问系统资源和操作的便捷方式，方便开发者在程序中进行相关的操作。

#### 七、按值传递和按地址传递 ####

在Java中，所有的基本数据类型（如int、double等）都是按值传递的，而对象类型（如String、数组等）则是按地址传递的。

按值传递意味着将实际参数的副本传递给方法或函数。这意味着在方法或函数中对参数进行的任何修改都不会影响原始的实际参数。

例如，考虑以下示例：

public class PassByValueExample {
        
        public static void main(String[] args) {
        
            int number = 10;
            System.out.println("Before calling changeValue method: " + number);
            changeValue(number);
            System.out.println("After calling changeValue method: " + number);
        }
        
        public static void changeValue(int value) {
        
            value = 20;
            System.out.println("Inside changeValue method: " + value);
        }
    }

输出结果为：

Before calling changeValue method: 10
    Inside changeValue method: 20
    After calling changeValue method: 10

可以看到，尽管在 `changeValue` 方法中将 `value` 的值更改为20，但在 `main` 方法中， `number` 的值仍然是10。这是因为基本数据类型按值传递， `changeValue` 方法只是操作了 `value` 的副本，而没有影响原始的 `number` 。

相反，对象类型是按地址传递的，意味着将实际参数的引用传递给方法或函数。这意味着在方法或函数中对对象进行的修改会影响原始的实际参数。

例如，考虑以下示例：

public class PassByReferenceExample {
        
        public static void main(String[] args) {
        
            int[] numbers = {
        1, 2, 3};
            System.out.println("Before calling changeArray method: " + Arrays.toString(numbers));
            changeArray(numbers);
            System.out.println("After calling changeArray method: " + Arrays.toString(numbers));
        }
        
        public static void changeArray(int[] array) {
        
            array[0] = 10;
            System.out.println("Inside changeArray method: " + Arrays.toString(array));
        }
    }

输出结果为：

Before calling changeArray method: [1, 2, 3]
    Inside changeArray method: [10, 2, 3]
    After calling changeArray method: [10, 2, 3]

可以看到，尽管在 `changeArray` 方法中将 `array[0]` 的值更改为10，但在 `main` 方法中， `numbers[0]` 的值也变为了10。这是因为对象类型按地址传递， `changeArray` 方法实际上是操作了 `numbers` 数组的引用，所以对数组的修改会影响原始的 `numbers` 。

总结起来，Java中的基本数据类型是按值传递的，而对象类型是按地址传递的。理解这两种传递方式对于正确地编写和理解Java代码非常重要。

>  精彩专栏推荐订阅：在下方专栏??  
>  ✅ [2023年华为OD机试真题（A卷&B卷）+ 面试指导 ][2023_OD_A_B_ _]  
>  ✅ [ 精选100套 Java 项目案例 ][_100_ Java _]  
>  ✅ [面试需要避开的坑（活动）][Link 3]  
>  ✅ [你找不到的核心代码][Link 4]  
>  ✅ [带你手撕 Spring][Spring]

> ?? 本文由激流原创，原创不易，希望大家关注、点赞、收藏，给博主一点鼓励，感谢！！！

![在这里插入图片描述][7b7478e55aa24a948b358051ef941b6a.webp_pic_center]

[43baa9053b4d490985bd0eb5b23b5ca4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/04/3e42735baac145f89f05b4bf7ad3d629.png
[Link 1]: https://bbs.csdn.net/forums/45c04d3f41cc4dadaf312be1d1379b45?category=10003
[Link 2]: https://jiliu.blog.csdn.net/
[Java]: https://blog.csdn.net/qq_37967783/category_9902143.html
[Java 1]: https://blog.csdn.net/qq_37967783/article/details/130940512
[2023_OD_A_B_ _]: https://blog.csdn.net/qq_37967783/category_12389634.html
[_100_ Java _]: https://blog.csdn.net/qq_37967783/category_12388267.html
[Link 3]: https://blog.csdn.net/qq_37967783/category_12380337.html
[Link 4]: https://blog.csdn.net/qq_37967783/category_12391346.html
[Spring]: https://blog.csdn.net/qq_37967783/category_12391987.html
[7b7478e55aa24a948b358051ef941b6a.webp_pic_center]: https://img-blog.csdnimg.cn/7b7478e55aa24a948b358051ef941b6a.webp#pic_center