深入理解Java包装类与泛型的应用

🕗 发布于 2024-11-20 05:51 java 开发语言

今天我将带领大家进入Java包装类和泛型应用的学习。

我的个人主页

我的Java-数据结构专栏 ：Java-数据结构，希望能帮助到大家。

一、Java包装类基础

在Java中，装箱（boxing）是指将基本数据类型（如int, char, double等）转换为对应的包装类对象（如Integer, Character, Double等）的过程。相反，拆箱（unboxing）是指将包装类对象转换回基本数据类型的过程。

从Java 5（JDK 1.5）开始，Java引入了自动装箱和拆箱机制，以简化基本数据类型和包装类之间的转换。这意味着在需要的时候，Java编译器会自动进行装箱和拆箱操作，而不需要程序员显式地调用转换方法。

包装类的定义与作用：包装类（Wrapper Classes）在Java编程语言中，指的是将基本数据类型（也称为原始数据类型，如int、char、double等）封装为对象的类。这些类使得基本数据类型可以作为对象进行处理，从而提供了更多的灵活性和功能。
Java中的包装类：在Java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，Java给每个基本类型都对应了一个包装类型。

注意：除了 Integer 和 Character，其余基本类型的包装类都是首字母大写。

自动装箱和拆箱示例代码

public class BoxingUnboxingExample {
    public static void main(String[] args) {
        // 自动装箱
        int primitiveInt = 10;
        Integer boxedInt = primitiveInt; // 编译器会自动调用 Integer.valueOf(int)

        // 自动拆箱
        int unboxedInt = boxedInt; // 编译器会自动调用 boxedInt.intValue()

        // 在算术运算中自动拆箱
        Integer anotherBoxedInt = 20;
        int result = boxedInt + anotherBoxedInt; // 实际上会拆箱为 int，然后执行加法运算，再装箱为 Integer（如果赋值给 Integer 变量）
        // 但由于 result 是 int 类型，所以这里只涉及拆箱，不涉及装箱

        // 显式装箱和拆箱（通常不需要这样做，因为自动装箱和拆箱已经足够）
        Integer explicitlyBoxedInt = Integer.valueOf(primitiveInt); // 显式装箱
        int explicitlyUnboxedInt = explicitlyBoxedInt.intValue(); // 显式拆箱

        // 打印结果以验证
        System.out.println("Primitive int: " + primitiveInt);
        System.out.println("Boxed int: " + boxedInt);
        System.out.println("Unboxed int: " + unboxedInt);
        System.out.println("Result of boxed int addition: " + result);
        System.out.println("Explicitly boxed int: " + explicitlyBoxedInt);
        System.out.println("Explicitly unboxed int: " + explicitlyUnboxedInt);
    }
}

性能考虑：虽然自动装箱和拆箱为程序员提供了便利，但在性能敏感的应用中，过多的装箱和拆箱操作可能会导致性能下降。因为装箱操作需要创建新的对象，而拆箱操作则涉及方法调用。
空指针异常：由于包装类对象是引用类型，因此它们可以是null。在进行拆箱操作时，如果包装类对象为null，则会抛出NullPointerException。例如，Integer nullInt = null; int value = nullInt; 这段代码会抛出空指针异常。
缓存机制：Java对某些包装类（如Integer、Boolean、Byte、Short、Character和Long，但不适用于Float和Double）的值进行了缓存。对于Integer来说，缓存范围是-128到127。在这个范围内的值被装箱时，会返回缓存中的对象，而不是创建新的对象。这有助于提高性能并减少内存使用。
比较操作：当比较两个包装类对象时，应该使用equals()方法而不是==运算符，因为==比较的是对象的引用而不是值。但是，对于缓存范围内的Integer值，使用==可能会得到正确的结果（因为它们是同一个对象的引用），但这是一种不可靠的做法，因为它依赖于Java的内部实现。
包装类的常用方法
- 转换方法（如valueOf, intValue等）
- 比较方法（如compareTo, equals等）
- 静态方法（如parseInt, parseDouble等）

二、Java泛型基础：

泛型的引入与意义
- 在Java 5之前，集合类（如ArrayList、HashMap等）只能存储Object类型的对象。这意味着在存储和取出元素时，需要进行强制类型转换，这不仅繁琐，而且容易出现类型错误，如ClassCastException。为了解决这个问题，Java引入了泛型机制，允许在定义类、接口和方法时，使用类型参数来指代具体的类型，从而实现代码的通用性和类型安全性。
- 类型安全：
  - 泛型可以在编译时期检查数据类型的合法性，避免出现类型不匹配导致的运行时错误。
  - 编译器可以在编译期验证数据结构中的类型使用是否正确，降低运行时错误的概率。
- 代码复用：
  - 泛型使得代码能够操作多种数据类型，而无需为每种类型单独实现一个版本。
  - 一个泛型数据结构可适配多种类型，提高了代码的复用性。
- 代码清晰与简洁：
  - 使用泛型可以使代码更加清晰、易懂，降低了代码阅读的难度。
  - 避免了不必要的类型转换，减少了代码的冗余，提高了代码的可读性。
- 性能提升：
  - 由于泛型避免了不必要的类型转换，所以在一定程度上可以提高程序的性能。
- 增强程序的健壮性：
  - 通过在编译时期进行类型检查，泛型可以帮助开发者更早地发现并修复类型相关的错误，从而增强程序的健壮性。
- 泛型类：
  - 在定义类时使用泛型参数，可以将具体的数据类型作为参数传递给类，并在类内部使用这些数据类型。
- 泛型方法：
  - 在方法的返回值前使用泛型参数，可以将具体的数据类型作为参数传递给方法，并在方法内部使用这些数据类型。
- 泛型接口：
  - 在定义接口时使用泛型参数，可以将具体的数据类型作为参数传递给接口，并在实现接口的类中使用这些数据类型。
- Java泛型的引入极大地增强了代码的类型安全性和可读性，提高了代码的复用性和维护性。无论是标准库中的集合类，还是自定义的数据结构，都可以通过泛型实现更灵活、更高效的代码设计。在数据结构中，泛型为开发者提供了统一性和扩展性，同时也为程序的安全性和健壮性保驾护航。

泛型类是指在定义类时使用类型参数（也称为类型占位符）的类。类型参数在类名后面的尖括号<>中指定。

// 定义一个泛型类 Box
public class Box<T> {
    // T 是类型参数，表示任意类型
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

使用泛型类时，可以指定具体的类型参数：

Box<Integer> integerBox = new Box<>();
integerBox.setContent(100);
Integer content = integerBox.getContent();

泛型接口与泛型类的定义类似，只是在接口名后使用尖括号指定类型参数。

// 定义一个泛型接口 Pair
public interface Pair<K, V> {
    K getKey();
    V getValue();
}

实现泛型接口时，需要指定具体的类型参数：

public class OrderedPair<K, V> implements Pair<K, V> {
    private K key;
    private V value;

    public OrderedPair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }
}

泛型方法是指在方法定义时使用类型参数的方法。类型参数在方法返回类型前和方法名后的尖括号中指定。

// 定义一个泛型方法 printArray
public static <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.print(element + " ");
    }
    System.out.println();
}

使用泛型方法时，无需指定类型参数，因为编译器会根据方法调用时的实际参数类型进行推断：

Integer[] intArray = {1, 2, 3, 4, 5};
printArray(intArray); // 输出: 1 2 3 4 5

Java集合框架中的许多类都是泛型的，如ArrayList、HashMap等。使用泛型集合可以避免类型转换和潜在的ClassCastException。

ArrayList<String> stringList = new ArrayList<>();
stringList.add("Hello");
stringList.add("World");

for (String s : stringList) {
    System.out.println(s);
}

泛型通配符?用于表示未知的类型。它主要有两种形式：无界通配符（?）、上界通配符（? extends SomeType）和下界通配符（? super SomeType）。

// 使用无界通配符
List<?> unknownList = new ArrayList<String>();

// 使用上界通配符
List<? extends Number> numberList = new ArrayList<Integer>();
// numberList 可以是 Integer、Double、Float 等 Number 子类的列表，但不能添加除 null 以外的元素

// 使用下界通配符
List<? super Integer> integerSuperList = new ArrayList<Number>();
// integerSuperList 可以是 Number 或 Number 的父类（如 Object）的列表，可以添加 Integer 或 Integer 的子类对象

三、Java包装类与泛型的结合

包装类与泛型的结合：

当包装类与泛型结合使用时，可以创建更加灵活和类型安全的集合和数据结构。例如，ArrayList<Integer>是一个使用Integer包装类的泛型集合，它可以存储整数值，并且提供了类型安全的保证。

import java.util.ArrayList;
import java.util.List;

public class WrapperGenericsExample {
    public static void main(String[] args) {
        // 创建一个存储Integer对象的ArrayList
        List<Integer> integerList = new ArrayList<>();

        // 向列表中添加整数（自动装箱）
        integerList.add(10);
        integerList.add(20);
        integerList.add(30);

        // 遍历列表并打印每个元素（自动拆箱）
        for (Integer integer : integerList) {
            System.out.println(integer);
        }

        // 使用包装类的方法
        int sum = 0;
        for (Integer integer : integerList) {
            sum += integer.intValue(); // 使用intValue()方法将Integer转换为int
        }
        System.out.println("Sum: " + sum);
    }
}

ArrayList<Integer>是一个泛型集合，它使用Integer包装类来存储整数。由于使用了泛型，我们得到了类型安全的保证：我们不能向integerList中添加除Integer对象以外的任何对象（除了null，但在Java 5及更高版本中，泛型集合通常不允许存储null以避免潜在的NullPointerException）。

四、Java泛型进阶：

泛型擦除示例：

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

// 定义一个简单的泛型类
public class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }

    // 一个用于反射获取泛型类型信息的方法（注意：这个方法在泛型擦除后无法直接获取到T的具体类型）
    public Type getGenericType() {
        return ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.setContent("Hello, World!");
        System.out.println(stringBox.getContent());

        // 通过反射尝试获取泛型类型信息（实际上在运行时已经擦除）
        Type genericType = stringBox.getGenericType();
        System.out.println("Generic type (at runtime, may be erased): " + genericType);

        // 但我们可以通过子类化并立即获取泛型信息来“绕过”擦除（这种方法不适用于所有情况）
        class StringBox extends Box<String> {}
        Type stringBoxType = StringBox.class.getGenericSuperclass().getActualTypeArguments()[0];
        System.out.println("Generic type of StringBox (inferred at compile time): " + stringBoxType);

        // 注意到，直接使用Box<String>的实例在运行时无法获取到T的具体类型，因为泛型信息已被擦除
    }
}

Java的类型推断机制允许编译器根据上下文自动推断出变量的类型，从而简化了代码的编写。以下是一个使用类型推断的示例：

import java.util.ArrayList;
import java.util.List;

public class TypeInferenceExample {
    public static void main(String[] args) {
        // 在Java 7及更高版本中，可以在右侧的构造函数调用中省略泛型类型参数
        List<String> list1 = new ArrayList<>(); // 类型推断为List<String>

        // 在Java 10及更高版本中，可以使用var关键字进一步简化变量声明
        var list2 = new ArrayList<String>(); // 类型推断为ArrayList<String>（但var的使用应谨慎，以避免降低代码可读性）

        // 方法调用中的类型推断
        printList(list1); // 编译器可以推断出list1的类型为List<String>

        // 泛型方法调用中的类型推断
        List<Integer> numbers = createListWithNumbers(1, 2, 3, 4, 5); // 编译器可以推断出返回类型为List<Integer>
    }

    // 一个简单的泛型方法，用于创建并返回一个包含指定元素的列表
    public static <T> List<T> createListWithElements(T... elements) {
        List<T> list = new ArrayList<>();
        for (T element : elements) {
            list.add(element);
        }
        return list;
    }

    // 一个用于打印列表内容的方法（注意：这里不是泛型方法，只是接受泛型类型的参数）
    public static void printList(List<?> list) {
        for (Object element : list) {
            System.out.println(element);
        }
    }

    // 一个具体的泛型方法调用示例，用于创建并返回一个包含数字的列表
    public static List<Integer> createListWithNumbers(Integer... numbers) {
        return createListWithElements(numbers); // 这里再次调用了泛型方法createListWithElements，并进行了类型推断
    }
}

五、Java包装类与泛型实战

在实际开发中，包装类与泛型经常一起使用。例如，当需要将基本数据类型存储在集合中时，由于集合的泛型参数必须是对象类型，因此需要使用包装类。

import java.util.ArrayList;
import java.util.List;

public class WrapperAndGenericsExample {
    public static void main(String[] args) {
        // 创建一个存储Integer对象的列表
        List<Integer> integerList = new ArrayList<>();
        integerList.add(10);
        integerList.add(20);
        integerList.add(30);

        // 遍历列表并打印元素
        for (Integer integer : integerList) {
            System.out.println(integer);
        }

        // 创建一个存储Double对象的列表
        List<Double> doubleList = new ArrayList<>();
        doubleList.add(1.1);
        doubleList.add(2.2);
        doubleList.add(3.3);

        // 使用泛型方法来打印Double列表
        printList(doubleList);
    }

    // 泛型方法，用于打印列表中的元素
    public static <T> void printList(List<T> list) {
        for (T element : list) {
            System.out.println(element);
        }
    }
}

原文地址：https://blog.csdn.net/2301_80350265/article/details/143846608

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：2411rust,实现特征
下一篇：Github工作流

Windows电脑本地部署llamafile并接入Qwen大语言模型远程AI对话实战
Windows电脑本地部署llamafile并接入Qwen大语言模型远程AI对话实战
阅读更多2024-11-23
解决vm虚拟机中ctrl键粘滞问题（一直处于按下状态）
虚拟机中点击鼠标左键没有问题，单独按下键盘也没有问题，但是如果按下键盘的同时在按下鼠标左键就会卡住。而且100%稳定复现。发现问题原因：vm版本的问题，我的版本是17.5.0，升级成17.5.2 bu
阅读更多2024-11-23
第十章 JavaScript的应用
10.1.1 JavaScript简介1 简单性JavaScript 设计之初就考虑到了非专业程序员的使用，因此它的语法相对简单，容易上手。2 动态性JavaScript 是一种解释型语言，代码可以在
阅读更多2024-11-23
非root用户安装CUDA
4.下载完成后执行.run文件，需要添加两个参数，一个是--override，用于跳过某些检查或限制；另一个是--toolkitpath，它表示安装路径，必须是自己目录下面的路径，如果是根目录就会安装
阅读更多2024-11-23
Python操作neo4j库py2neo使用之py2neo 删除及事务相关操作（三）
【代码】## Python操作neo4j库py2neo使用之py2neo 删除及事务相关操作（三）
阅读更多2024-11-23
【通俗理解】Jensen不等式与变分分布q(z)在积分计算中的应用
Jensen不等式 #变分分布 #积分计算 #期望 #凸函数 #优化问题 #下界估计 #机器学习。
阅读更多2024-11-23
「Mac玩转仓颉内测版27」基础篇7 - 字符串类型详解
本篇将介绍 Cangjie 中的字符串类型，包括字符串的定义、字面量形式、插值表达、常用操作及应用场景，帮助开发者熟练掌握字符串的使用。
阅读更多2024-11-23
数据科学与SQL：组距分组分析 | 区间分布问题
绝对值分布分析也可以理解为组距分组分析。对于某个指标而言，一个记录对应的指标值的绝对值，肯定落在所有指标值的绝对值的最小值和最大值构成的区间内，根据一定的算法，在把这个区间划分为等距离的几个小区间，，
阅读更多2024-11-23
c++编译报C1004错误的原因及解决办法
可能是你的代码文件最后没有正确的结束符，或者是缺少了一些必要的头文件或语句。默认磁盘驱动器没有足够的空间用于临时文件，需要大约两倍于源文件的空间。编译器到达了源文件尾但未解析构造。计算结果为假的 #i
阅读更多2024-11-23
mysql 去重补全取出重复变量函数和存储过程
mysql 去重补全取出重复变量函数和存储过程
阅读更多2024-11-23

深入理解Java包装类与泛型的应用

一、Java包装类基础

二、Java泛型基础：

三、Java包装类与泛型的结合

四、Java泛型进阶：

五、Java包装类与泛型实战

相关文章