Java装箱与拆箱

最新推荐文章于 2024-07-15 21:12:35 发布
最新推荐文章于 2024-07-15 21:12:35 发布
阅读量1k 收藏 3
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m00123456789/article/details/77431040
版权

装箱拆箱详解
今天面试，遇到了这个问题，不注意，答错了。回顾一下相关java知识。
装箱：将基本数据类型包装成引用数据类型，使其具有对象的性质。
拆箱：将引用型数据简化成基本数据类型。
举个例子：
Integer a=4；自动装箱
int b=new Integer(4);自动拆箱
为了进一步说明问题，写段代码。

public class DataType {

    public static void main(String args[]) {
        DataType dt = new DataType();
        dt.m1();
        dt.m2();
        dt.m3();
        dt.m4();
        dt.m5();
        dt.m6();
        dt.m7();
        dt.m8();

    }

    public void m1() {
        Integer a = new Integer(4);
        Integer b = 4;
        System.out.println("m1 result " + (a == b));
    }

    public void m2() {
        Integer a = new Integer(128);
        Integer b = 128;
        System.out.println("m2 result " + (a == b));
    }

    public void m3() {
        Integer a = new Integer(4);
        Integer b = new Integer(4);
        System.out.println("m3 result " + (a == b));
    }

    public void m4() {
        Integer a = new Integer(128);
        Integer b = new Integer(128);
        System.out.println("m4 result " + (a == b));
    }

    public void m5() {
        Integer a = 4;
        Integer b = 4;
        System.out.println("m5 result " + (a == b));
    }

    public void m6() {
        Integer a =128;
        Integer b =128;
        System.out.println("m6 result " + (a == b));
    } 

     public void m7() {
        Integer a = Integer.valueOf(4);
        Integer b = 4;
        System.out.println("m7 result " + (a == b));
    }

    public void m8() {
        Integer a = Integer.valueOf(128);
        Integer b = 128;
        System.out.println("m8 result " + (a == b));
    } 


}

分析一下执行结果吧。

下面给出打印结果。你是否都对了呢？

运行结果

我们来看一下。

第一组：
观察 m1，m2。
a和b是两个不同的对象，不难看出，上面两组都是false。

第二组：
观察m3,m4。
a和b 依旧是两个不同的对象。都为false。

第三组
观察m5，m6。
为什么一个true，一个false呢？

第四组
观察m7，m8。
为什么一个true，一个false呢？
true说明a和b是同一个对象。a通过Integer.valueOf()生成，b通过自动装箱生成。为什么会是同一个对象呢？下面为false又是怎么回事？

为说明问题，回顾一下装箱、拆箱的两个方法：
Integer.valueOf()返回一个Integer类型对象。
Integer.parseInt()返回一个int类型对象。
查看valueOf方法实现，代码如下：


/**
 * Returns a <tt>Integer</tt> instance representing the specified
 * <tt>int</tt> value.
 * If a new <tt>Integer</tt> instance is not required, this method
 * should generally be used in preference to the constructor
 * {@link #Integer(int)}, as this method is likely to yield
 * significantly better space and time performance by caching
 * frequently requested values.
 *
 * @param  i an <code>int</code> value.
 * @return a <tt>Integer</tt> instance representing <tt>i</tt>.
 * @since  1.5
 */
public static Integer valueOf(int i) {
final int offset = 128;
if (i >= -128 && i <= 127) { // must cache 
    return IntegerCache.cache[i + offset];
}
    return new Integer(i);
}

发现，[-128,127]区间的数据返回的是缓冲区中的对象，其他则是新创建的装箱对象。这就解释得通了。为进一步说明问题，这里看一下IntegerCache的源码：

private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

对于这个例子，也可以使用javap解析字节码查看：

f:\>javap -c DataType
Compiled from "DataType.java"
public class DataType {
  public DataType();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class DataType
       3: dup
       4: invokespecial #3                  // Method "<init>":()V
       7: astore_1
       8: aload_1
       9: invokevirtual #4                  // Method m1:()V
      12: aload_1
      13: invokevirtual #5                  // Method m2:()V
      16: aload_1
      17: invokevirtual #6                  // Method m3:()V
      20: aload_1
      21: invokevirtual #7                  // Method m4:()V
      24: aload_1
      25: invokevirtual #8                  // Method m5:()V
      28: aload_1
      29: invokevirtual #9                  // Method m6:()V
      32: aload_1
      33: invokevirtual #10                 // Method m7:()V
      36: aload_1
      37: invokevirtual #11                 // Method m8:()V
      40: return

  public void m1();
    Code:
       0: new           #12                 // class java/lang/Integer
       3: dup
       4: iconst_4
       5: invokespecial #13                 // Method java/lang/Integer."<init>":(I)V
       8: astore_1
       9: iconst_4
      10: invokestatic  #14                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      13: astore_2
      14: getstatic     #15                 // Field java/lang/System.out:Ljava/io/PrintStream;
      17: new           #16                 // class java/lang/StringBuilder
      20: dup
      21: invokespecial #17                 // Method java/lang/StringBuilder."<init>":()V
      24: ldc           #18                 // String m1 result
      26: invokevirtual #19                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      29: aload_1
      30: aload_2
      31: if_acmpne     38
      34: iconst_1
      35: goto          39
      38: iconst_0
      39: invokevirtual #20                 // Method java/lang/StringBuilder.append:(Z)Ljava/lang/StringBuilder;
      42: invokevirtual #21                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      45: invokevirtual #22                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      48: return

  public void m2();
    Code:
       0: new           #12                 // class java/lang/Integer
       3: dup
       4: sipush        128
       7: invokespecial #13                 // Method java/lang/Integer."<init>":(I)V
      10: astore_1
      11: sipush        128
      14: invokestatic  #14                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      17: astore_2
      18: getstatic     #15                 // Field java/lang/System.out:Ljava/io/PrintStream;
      21: new           #16                 // class java/lang/StringBuilder
      24: dup
      25: invokespecial #17                 // Method java/lang/StringBuilder."<init>":()V
      28: ldc           #23                 // String m2 result
      30: invokevirtual #19                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      33: aload_1
      34: aload_2
      35: if_acmpne     42
      38: iconst_1
      39: goto          43
      42: iconst_0
      43: invokevirtual #20                 // Method java/lang/StringBuilder.append:(Z)Ljava/lang/StringBuilder;
      46: invokevirtual #21                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      49: invokevirtual #22                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      52: return

  public void m3();
    Code:
       0: new           #12                 // class java/lang/Integer
       3: dup
       4: iconst_4
       5: invokespecial #13                 // Method java/lang/Integer."<init>":(I)V
       8: astore_1
       9: new           #12                 // class java/lang/Integer
      12: dup
      13: iconst_4
      14: invokespecial #13                 // Method java/lang/Integer."<init>":(I)V
      17: astore_2
      18: getstatic     #15                 // Field java/lang/System.out:Ljava/io/PrintStream;
      21: new           #16                 // class java/lang/StringBuilder
      24: dup
      25: invokespecial #17                 // Method java/lang/StringBuilder."<init>":()V
      28: ldc           #24                 // String m3 result
      30: invokevirtual #19                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      33: aload_1
      34: aload_2
      35: if_acmpne     42
      38: iconst_1
      39: goto          43
      42: iconst_0
      43: invokevirtual #20                 // Method java/lang/StringBuilder.append:(Z)Ljava/lang/StringBuilder;
      46: invokevirtual #21                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      49: invokevirtual #22                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      52: return

  public void m4();
    Code:
       0: new           #12                 // class java/lang/Integer
       3: dup
       4: sipush        128
       7: invokespecial #13                 // Method java/lang/Integer."<init>":(I)V
      10: astore_1
      11: new           #12                 // class java/lang/Integer
      14: dup
      15: sipush        128
      18: invokespecial #13                 // Method java/lang/Integer."<init>":(I)V
      21: astore_2
      22: getstatic     #15                 // Field java/lang/System.out:Ljava/io/PrintStream;
      25: new           #16                 // class java/lang/StringBuilder
      28: dup
      29: invokespecial #17                 // Method java/lang/StringBuilder."<init>":()V
      32: ldc           #25                 // String m4 result
      34: invokevirtual #19                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      37: aload_1
      38: aload_2
      39: if_acmpne     46
      42: iconst_1
      43: goto          47
      46: iconst_0
      47: invokevirtual #20                 // Method java/lang/StringBuilder.append:(Z)Ljava/lang/StringBuilder;
      50: invokevirtual #21                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      53: invokevirtual #22                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      56: return

  public void m5();
    Code:
       0: iconst_4
       1: invokestatic  #14                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
       4: astore_1
       5: iconst_4
       6: invokestatic  #14                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
       9: astore_2
      10: getstatic     #15                 // Field java/lang/System.out:Ljava/io/PrintStream;
      13: new           #16                 // class java/lang/StringBuilder
      16: dup
      17: invokespecial #17                 // Method java/lang/StringBuilder."<init>":()V
      20: ldc           #26                 // String m5 result
      22: invokevirtual #19                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      25: aload_1
      26: aload_2
      27: if_acmpne     34
      30: iconst_1
      31: goto          35
      34: iconst_0
      35: invokevirtual #20                 // Method java/lang/StringBuilder.append:(Z)Ljava/lang/StringBuilder;
      38: invokevirtual #21                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      41: invokevirtual #22                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      44: return

  public void m6();
    Code:
       0: sipush        128
       3: invokestatic  #14                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
       6: astore_1
       7: sipush        128
      10: invokestatic  #14                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      13: astore_2
      14: getstatic     #15                 // Field java/lang/System.out:Ljava/io/PrintStream;
      17: new           #16                 // class java/lang/StringBuilder
      20: dup
      21: invokespecial #17                 // Method java/lang/StringBuilder."<init>":()V
      24: ldc           #27                 // String m6 result
      26: invokevirtual #19                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      29: aload_1
      30: aload_2
      31: if_acmpne     38
      34: iconst_1
      35: goto          39
      38: iconst_0
      39: invokevirtual #20                 // Method java/lang/StringBuilder.append:(Z)Ljava/lang/StringBuilder;
      42: invokevirtual #21                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      45: invokevirtual #22                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      48: return

  public void m7();
    Code:
       0: iconst_4
       1: invokestatic  #14                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
       4: astore_1
       5: iconst_4
       6: invokestatic  #14                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
       9: astore_2
      10: getstatic     #15                 // Field java/lang/System.out:Ljava/io/PrintStream;
      13: new           #16                 // class java/lang/StringBuilder
      16: dup
      17: invokespecial #17                 // Method java/lang/StringBuilder."<init>":()V
      20: ldc           #28                 // String m7 result
      22: invokevirtual #19                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      25: aload_1
      26: aload_2
      27: if_acmpne     34
      30: iconst_1
      31: goto          35
      34: iconst_0
      35: invokevirtual #20                 // Method java/lang/StringBuilder.append:(Z)Ljava/lang/StringBuilder;
      38: invokevirtual #21                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      41: invokevirtual #22                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      44: return

  public void m8();
    Code:
       0: sipush        128
       3: invokestatic  #14                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
       6: astore_1
       7: sipush        128
      10: invokestatic  #14                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
      13: astore_2
      14: getstatic     #15                 // Field java/lang/System.out:Ljava/io/PrintStream;
      17: new           #16                 // class java/lang/StringBuilder
      20: dup
      21: invokespecial #17                 // Method java/lang/StringBuilder."<init>":()V
      24: ldc           #29                 // String m8 result
      26: invokevirtual #19                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      29: aload_1
      30: aload_2
      31: if_acmpne     38
      34: iconst_1
      35: goto          39
      38: iconst_0
      39: invokevirtual #20                 // Method java/lang/StringBuilder.append:(Z)Ljava/lang/StringBuilder;
      42: invokevirtual #21                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      45: invokevirtual #22                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      48: return
}

总结：
以Integer为例，说明。
1.使用new Integer()方式装箱每次创建的对象都不同。对于任何数值，即使数值相同，它们也是不同的对象。
2.对于自动装箱，其实是调用了Integer.valueOf()。对于使用这种方式装箱的对象，在[-128,127]之间的数据会优先使用缓冲区中的对象，如果数值相同，它们是同一个对象。在此区间外，即使是同一数值也是不同的对象。
3.使用new Integer()方式装箱，两者无论数值相同与否，都是不同对象。

Study_WangYL
关注
专栏目录
Java 装箱与拆箱详解及实例代码
08-31
本文将深入讲解Java装箱与拆箱的基本概念，并通过实例代码进行演示。 装箱（Boxing）是Java自动将基本数据类型转换为对应的包装类的过程。例如，int类型转换为Integer，char类型转换为Character等。这是Java 5引入...
JAVA中拆箱和装箱
qq_37432174的博客
07-13 1394
浅谈JAVA中拆箱与装箱 一. 什么是装箱？什么是拆箱？ 在Java SE5之前，如果要生成一个数值为10的Integer对象，必须这样进行： Integer i = new Integer(10); 在栈中储存引用变量；该引用变量指向在堆中储存的对象i; 而在从Java SE5开始就提供了自动装箱的特性，如果要生成一个数值为10的Integer对象，只需要这样就可以了： Integer i=1...
Java基础之拆箱和装箱
你与昨日
03-07 8186
Java基础之拆箱和装箱 一、什么是拆箱和装箱 1）什么是拆箱 • 拆箱就是自动将包装器类型转换为基本数据类型 • 拆箱调用Integer.intValue方法 2）什么是装箱 • 装箱就是自动将基本数据类型转换为包装器类型 • 装箱调用的Integer.valueOf方法 二、什么是自动装箱 1.基本数据转型转包装器类型，自动装箱 2.包装器类型转基本数据类型，自动拆箱 3.基本数据类型，在初始化值时，在缓存值范围之外自动装箱 4.包装器类型，在初始化值时，在缓存值范围之内自动拆箱 5.分配新内存地址：装
Java的自动装箱和拆箱机制
最新发布
程序猿小样的博客
07-15 1082
性能开销：频繁的装箱和拆箱操作可能导致性能问题，应尽量避免在高频率操作中使用包装类。空指针异常：在自动拆箱时，应检查包装类对象是否为null，以避免空指针异常。对象比较：在比较包装类对象时，应使用equals()方法进行值比较，而不是使用==进行引用比较。缓存机制：了解Integer缓存机制的影响，避免在范围内的整数对象比较中出现误判。混合运算：注意混合运算中的隐式转换，确保运算结果符合预期。通过注意这些问题，可以更好地利用Java的自动装箱和拆箱机制，提高代码的安全性和性能。
Java中的装箱与拆箱
weixin_73986007的博客
06-11 594
集合中的装箱拆箱
Java 入门：装箱与拆箱
guanshengg的博客
08-09 2129
Java 是基于面向对象设计的，因此，每创建一次包装类型就会放到堆里，然后通过栈中的地址来找寻堆中的对象。但是基本类型不具有对象性质，当我们使用集合的时候，又可以使用其包装类型。当然，我们每次使用的时候，例如往集合中添加基本类型，Java 会自动装箱为包装类，后面的示例也会演示到。在这篇文章中，我们将使用一些示例，来学习 Java 中的装箱与拆箱操作。原始数据类型的处理是不同的，因此引入了包装类，其中有两个组件起着作用，即自动装箱和解箱。在拆箱中，Java编译器会自动将包装类对象转换为其相应的原始类型。..
JAVA中的装箱和拆箱
douyusorrymaker的博客
05-20 155
所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。byte、int、long、double 等为 java 的基础数据类型。的整数进行缓存，所以当定义两个变量初始化值位于。（2）当两个 Integer 变量的数值超出。(3) 关于装箱和拆箱。（1）Java 会对。
java自动装箱拆箱深入剖析
09-05
Java中的自动装箱和拆箱是自J2SE 5.0版本引入的特性，它极大地简化了基本数据类型与其对应的包装类之间的转换过程。基本数据类型包括int、double、boolean等，而包装类如Integer、Double和Boolean分别对应这些基本...
深入理解Java中的装箱和拆箱
08-25
“深入理解Java中的装箱和拆箱” 一、什么是装箱？什么是拆箱？ 在Java中，每种基本数据类型都有对应的包装器类型，例如int对应Integer、byte对应Byte等。装箱是指将基本数据类型自动转换为包装器类型的过程，而...
Java中的自动装箱与拆箱
01-20
自动装箱与拆箱的机制可以让我们在Java的变量赋值或者是方法调用等情况下使用原始类型或者对象类型更加简单直接。 　如果你在Java1.5下进行过编程的话，你一定不会陌生这一点，你不能直接地向集合(Collections)中放...
浅谈Java自动装箱与拆箱及其陷阱
09-02
Java中的自动装箱和拆箱是自JDK 1.5版本引入的一种语言特性，它极大地简化了基础数据类型（如int）与它们对应的包装类（如Integer）之间的转换过程。这一特性使得开发者无需手动创建包装类实例或使用显式类型转换，...
java知识点---装箱拆箱
u011489056的专栏
04-22 1764
在Java中，和是指基本数据类型（也称为值类型）与它们对应的包装器类（引用类型）之间相互转换的过程。
Java——装箱和拆箱
LxinY213的博客
04-25 1785
Java中的装箱和拆箱
探寻Java装箱和拆箱的奥妙
weixin_39158966的博客
04-25 274
今天在逛某知名论坛的时候，看到一篇"请不要使用包装类型，避免造成性能损失"的文章。一下子就吸引了我的注意。大意就是，能用基本数据类型就尽量用基本数据类型，因为包装类型自动拆箱、装箱会带来性能损失尤其是循环使用时会大量创建对象。所以今天聊一下，Java的装箱和拆箱。Java中的装箱（boxing）和拆箱（unboxing）是指将基本数据类型与其对应的包装类之间进行转换的过程。装箱装箱是将基本数据类型转换为其对应的包装类，例如将int类型转换为Integer类型。
【Java】拆箱和装箱（附示例代码讲解）
TechnicalXiaobai的博客
07-17 1355
装箱（Boxing）： 装箱是指将基本数据类型转换为对应的包装类对象。这是通过调用包装类的构造函数或静态工厂方法来完成的。装箱过程将基本数据类型的值封装成一个包装类对象。拆箱（Unboxing）： 拆箱是指将包装类对象转换为基本数据类型。这是通过调用包装类的 xxxValue() 方法来完成的。拆箱过程将包装类对象中的值提取出来，转换为对应的基本数据类型。拆箱和装箱可以在基本数据类型和包装类之间实现无缝转换，这在 Java 中很常见，尤其是在泛型和集合类中，因为集合类只能存储对象而不支持基本数据类型。
⛳ Java中的装箱和拆箱
松柏123的博客
07-22 542
在Java SE5之前，如果要生成一个数值为10的Integer这个过程中会自动根据数值创建对应的 Integer对象，这就是装箱。那什么是拆箱呢？//装箱 int n = i;//拆箱简单一点说，装箱就是 自动将基本数据类型转换为包装器类型；​拆箱就是 自动将包装器类型转换为基本数据类型。int（4字节）Integerbyte（1字节）Byteshort（2字节）Shortlong（8字节）Longfloat（4字节）Floatdouble（8字节）Double。
JAVA小知识13：浅谈拆箱与装箱
jialuosi的博客
06-05 819
如果你是一个初学者，你肯定会经常听到大佬说什么拆箱会有什么空指针异常啊之类的术语，今天就来说说什么叫拆箱和装箱。
Java的自动装箱和自动拆箱
常备不懈
06-04 1498
在Java开发中，自动装箱（Autoboxing）和自动拆箱（Unboxing）是指基本数据类型与其对应的包装类之间的自动转换。这些特性可以使代码更加简洁和易读，但在实际项目中也带来了某些潜在的问题。本文将详细介绍自动装箱和拆箱的概念，并探讨在Spring Boot项目开发和Bean转换中的应用与注意事项。
Java中的装箱和拆箱—这一篇全了解
Franco的博客
08-21 9250
Java中的拆箱装箱—这一篇全了解 一.什么是装箱？什么是拆箱？ Java为每种基本数据类型都提供了对应的包装器类型，让基本类型具备对象的特征,实现更多的功能.。在Java SE5之前，如果要生成一个数值为10的Integer对象，必须这样进行： Integer i = new Integer(10); 而在从Java SE5开始就提供了自动装箱的特性，如果要生成一个数值为10的Inte...
Java自动装箱与拆箱详解及陷阱解析
"Java自动装箱与拆箱的原理及陷阱" 在Java编程语言中，自动装箱（Autoboxing）和自动拆箱（Unboxing）是自JDK 1.5版本引入的一种便利特性，它允许开发人员在基本数据类型（如int、char等）与它们对应的包装器类（如...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值