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

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

激流丶

3460人浏览 · 2023-07-31 11:09:22

激流丶 · 2023-07-31 11:09:22 发布

在这里插入图片描述

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

⛪️ 个人社区：个人社区
💞 个人主页：个人主页
🙉 专栏地址： ✅ Java 进阶之路
🙉八股文专题：剑指大厂，手撕 Java 八股文

文章目录

一、包装类

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

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

将基本数据类型转换为对象：包装类允许将基本数据类型转换为对应的对象。例如，可以将一个int类型的值转换为Integer对象。
提供了一些方法和属性：包装类提供了一些方法和属性，用于操作和处理基本数据类型的值。例如，Integer类提供了 parseInt() 方法用于将字符串转换为整数。
允许在集合中存储基本数据类型：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类的一些常用方法：

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 类。

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

java.util.Date 类：

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

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 类的一些用法示例：

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相同");
        }
    }
}

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 类的一些用法示例：

创建 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);
    }
}

进行基本的算术运算：

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);
    }
}

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

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 类的一些常用方法示例：

获取当前时间的毫秒数：

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

获取系统的属性：

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

标准输入、输出、错误流：

// 从标准输入读取数据
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("发生了一个错误！");

退出程序：

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卷）+ 面试指导
✅ 精选100套 Java 项目案例
✅ 面试需要避开的坑（活动）
✅ 你找不到的核心代码
✅ 带你手撕 Spring

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

在这里插入图片描述

MCP技术社区

欢迎加入 MCP 技术社区！与志同道合者携手前行，一同解锁 MCP 技术的无限可能！

更多推荐

【CodeBuddy + 自制MCP】给AI装上翅膀，快速绘制思维导图

MCP技术社区

如何将普通HTTP API接口改造为MCP服务器

创建.proto通过本文的四步改造法，你可获得：✅ 配置更新延迟降低90%✅ 网络带宽消耗减少70%✅ 服务端资源占用下降60%✅ 原生支持百万级节点连接升级到MCP不仅是协议转换，更是配置分发模式的架构进化。立即行动，让你的微服务配置管理进入实时推送时代！更多Istio进阶技巧请关注专栏【Service Mesh深度实践】