关于String的intern方法的讨论

最新推荐文章于 2022-08-26 23:47:50 发布
最新推荐文章于 2022-08-26 23:47:50 发布
阅读量729 收藏
点赞数
分类专栏： java语言 文章标签： java String
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/quanzhongzhao/article/details/47341447
版权

引子

今天，同学发来一个关于String的程序段，让我判断，先给出代码，大家可先想想执行结果。

 

public class InternTest {

	public static void main(String[] args) {
	    String s = new String("1");
	    s.intern();
	    String s2 = "1";
	    System.out.println(s == s2);
	    System.out.println(s.equals(s2));
	    
	    String s3 = new String("1") + new String("1");
	    s3.intern();
	    String s4 = "11";
	    System.out.println(s3 == s4);
	    System.out.println(s3.equals(s4));
	}

}

 

何为String

在《java8语言规范中》中String类型的说明如下：
1、Instances of class String represent sequences of Unicode code points（String类的实例表示Unicode字符序列）
2、A String object has a constant (unchanging) value （一个String对象有一个不可变的常量值）。
3、String literals are references to instances of class String（String字段时String类实例的引用）。
4、The string concatenation operator + implicitly creates a new String object when the result is not a constant expression（String的合并操作“+”会隐式的生成一个新的String对象）。
有了语言规范的定义，我们大概清楚了String使用的限制。一般，String变量的定义方式有3种：
1、使用关键字 new，如：String str = new String("spring");
2、直接定义，如 String str = “spring";

3、连接生成，如 String str = "spr"+new String("ing");

== & equals

我们知道java中使用 == 和 equals来比较两个对象。equals最初是在Object对象中实现的。

 

 public boolean equals(Object obj) {
        return (this == obj);  //这里 equals与==是等价的
    }
但是一般我们定义类的时候，会重载Object的hashCode与equals方法。String也不例外，重载后equals表示String的内容组成是否相等。

 

 

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }
总结下来，==一般用来比较java虚拟机栈中的对象（虚拟机栈中保存基本类型和引用类型的引用）是否相等，而equals表示堆中的内容是否相等。

 

 

String的intern()方法

 public native String intern();它返回一个字符串对象的标准表示形式。字符串池最初是空的，由String类私有并维护。调用该方法，如果池中包含一个字符串，有equals(Object)判断，等于该字符串对象 则返回池中的字符串。否则，该字符串对象将添加到池中，并返回该字符串对象的引用。
因此， 对于任意两个字符串S和T，S intern() = = T intern()是真的当且仅当s.equals（t）是真的。
String的intern()方法时一个本地方法。通过JNI调用底层的C++动态库，其实现源代码如下

 

 

JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
  JVMWrapper("JVM_InternString");
  JvmtiVMObjectAllocEventCollector oam;
  if (str == NULL) return NULL;
  oop string = JNIHandles::resolve_non_null(str);
  oop result = StringTable::intern(string, CHECK_NULL);
  return (jstring) JNIHandles::make_local(env, result);
JVM_END
再继续看看StringTable::intern(String,CHECK_NULL)
oop StringTable::intern(oop string, TRAPS)
{
  if (string == NULL) return NULL;
  ResourceMark rm(THREAD);
  int length;
  Handle h_string (THREAD, string);
  jchar* chars = java_lang_String::as_unicode_string(string, length);
  oop result = intern(h_string, chars, length, CHECK_NULL);
  return result;
}

 

oop StringTable::intern(Handle string_or_null, jchar* name,
                        int len, TRAPS) {
  unsigned int hashValue = hash_string(name, len);
  int index = the_table()->hash_to_index(hashValue);
  oop found_string = the_table()->lookup(index, name, len, hashValue); //调用lookup（）方法

  // Found
  if (found_string != NULL) return found_string;

  debug_only(StableMemoryChecker smc(name, len * sizeof(name[0])));
  assert(!Universe::heap()->is_in_reserved(name) || GC_locker::is_active(),
         "proposed name of symbol must be stable");

  Handle string;
  // try to reuse the string if possible
  if (!string_or_null.is_null() && (!JavaObjectsInPerm || string_or_null()->is_perm())) {
    string = string_or_null;
  } else {
    string = java_lang_String::create_tenured_from_unicode(name, len, CHECK_NULL);
  }

  // Grab the StringTable_lock before getting the_table() because it could
  // change at safepoint.
  MutexLocker ml(StringTable_lock, THREAD);

  // Otherwise, add to symbol to table
  return the_table()->basic_add(index, string, name, len,
                                hashValue, CHECK_NULL);
}
Symbol* SymbolTable::lookup(int index, const char* name,
                              int len, unsigned int hash) {
  int count = 0;
  for (HashtableEntry<Symbol*, mtSymbol>* e = bucket(index); e != NULL; e = e->next()) {
    count++;  // count all entries in this bucket, not just ones with same hash
    if (e->hash() == hash) {
      Symbol* sym = e->literal();
      if (sym->equals(name, len)) {     //如上所述，用equals方式比较
        // something is referencing this symbol now.
        sym->increment_refcount();
        return sym;
      }
    }
  }
  // If the bucket size is too deep check if this hash code is insufficient.
  if (count >= BasicHashtable<mtSymbol>::rehash_count && !needs_rehashing()) {
    _needs_rehashing = check_rehash_table(count);
  }
  return NULL;
}

 

下面是StringTable的数据结构，注意，StringTable并非常量池。

 

class StringTable : public Hashtable<oop, mtSymbol> {
  friend class VMStructs;
private:
  // The string table
  static StringTable* _the_table;
  // Set if one bucket is out of balance due to hash algorithm deficiency
  static bool _needs_rehashing;
  // Claimed high water mark for parallel chunked scanning
  static volatile int _parallel_claimed_idx;

  static oop intern(Handle string_or_null, jchar* chars, int length, TRAPS);
  oop basic_add(int index, Handle string_or_null, jchar* name, int len,
                unsigned int hashValue, TRAPS);

  oop lookup(int index, jchar* chars, int length, unsigned int hashValue);

  // Apply the give oop closure to the entries to the buckets
  // in the range [start_idx, end_idx).
  static void buckets_do(OopClosure* f, int start_idx, int end_idx);

  StringTable() : Hashtable<oop, mtSymbol>((int)StringTableSize,
                              sizeof (HashtableEntry<oop, mtSymbol>)) {} ....}

 

StringTable数据结构是我们常用的java中的hashtable, 先计算字符串的hashcode，根据hashcode到对应的数组，然后遍历里面的链表结构比较字符串里的每个字符，直到找到相同的。当数据比较多的时候，会导致查找效率变慢，java会在进入safepoint点的时候判断是否需要做一次rehash，就是扩大数组的容量来提高查找的效率。

引子的具体分析

1、命令行切换到类所在目录，编译程序：javac InternTest.java
2、分析编译后的字节码：javap -verbose InternTest
首先是常量池： 
public class InternTest
  SourceFile: "InternTest.java"
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #16.#29        //  java/lang/Object."<init>":()V
   #2 = Class              #30            //  java/lang/String
   #3 = String             #31            //  1
   #4 = Methodref          #2.#32         //  java/lang/String."<init>":(Ljava/l
ang/String;)V
   #5 = Methodref          #2.#33         //  java/lang/String.intern:()Ljava/la
ng/String;
   #6 = Fieldref           #34.#35        //  java/lang/System.out:Ljava/io/Prin
tStream;
   #7 = Methodref          #36.#37        //  java/io/PrintStream.println:(Z)V
   #8 = Methodref          #2.#38         //  java/lang/String.equals:(Ljava/lan
g/Object;)Z
   #9 = Methodref          #36.#39        //  java/io/PrintStream.println:()V
  #10 = Class              #40            //  java/lang/StringBuilder
  #11 = Methodref          #10.#29        //  java/lang/StringBuilder."<init>":(
)V
  #12 = Methodref          #10.#41        //  java/lang/StringBuilder.append:(Lj
ava/lang/String;)Ljava/lang/StringBuilder;
  #13 = Methodref          #10.#42        //  java/lang/StringBuilder.toString:(
)Ljava/lang/String;
  #14 = String             #43            //  11
  #15 = Class              #44            //  InternTest
  #16 = Class              #45            //  java/lang/Object
  #17 = Utf8               <init>
  #18 = Utf8               ()V
  #19 = Utf8               Code
  #20 = Utf8               LineNumberTable
  #21 = Utf8               main
  #22 = Utf8               ([Ljava/lang/String;)V
  #23 = Utf8               StackMapTable
  #24 = Class              #46            //  "[Ljava/lang/String;"
  #25 = Class              #30            //  java/lang/String
  #26 = Class              #47            //  java/io/PrintStream
  #27 = Utf8               SourceFile
  #28 = Utf8               InternTest.java
  #29 = NameAndType        #17:#18        //  "<init>":()V
  #30 = Utf8               java/lang/String
  #31 = Utf8               1
  #32 = NameAndType        #17:#48        //  "<init>":(Ljava/lang/String;)V
  #33 = NameAndType        #49:#50        //  intern:()Ljava/lang/String;
  #34 = Class              #51            //  java/lang/System
  #35 = NameAndType        #52:#53        //  out:Ljava/io/PrintStream;
  #36 = Class              #47            //  java/io/PrintStream
  #37 = NameAndType        #54:#55        //  println:(Z)V
  #38 = NameAndType        #56:#57        //  equals:(Ljava/lang/Object;)Z
  #39 = NameAndType        #54:#18        //  println:()V
  #40 = Utf8               java/lang/StringBuilder
  #41 = NameAndType        #58:#59        //  append:(Ljava/lang/String;)Ljava/l
ang/StringBuilder;
  #42 = NameAndType        #60:#50        //  toString:()Ljava/lang/String;
  #43 = Utf8               11
  #44 = Utf8               InternTest
  #45 = Utf8               java/lang/Object
  #46 = Utf8               [Ljava/lang/String;
  #47 = Utf8               java/io/PrintStream
  #48 = Utf8               (Ljava/lang/String;)V
  #49 = Utf8               intern
  #50 = Utf8               ()Ljava/lang/String;
  #51 = Utf8               java/lang/System
  #52 = Utf8               out
  #53 = Utf8               Ljava/io/PrintStream;
  #54 = Utf8               println
  #55 = Utf8               (Z)V
  #56 = Utf8               equals
  #57 = Utf8               (Ljava/lang/Object;)Z
  #58 = Utf8               append
  #59 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #60 = Utf8               toString
再看看我们的main方法 
<public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=4, locals=5, args_size=1          //<span style="color:#ff0000;">深度为4的操作数栈，局部变量Slot个数为5，一个输入参数</span>
         0: new           #2                  // class java/lang/String
         3: dup                               //复制栈顶数值 并将 复制值压入栈顶
         4: ldc           #3                  // String 1
         6: invokespecial #4                  // Method java/lang/String."<init>   
":(Ljava/lang/String;)V                       //创建String  s对象    
         9: astore_1                         // 将String 1的引用 保存到 slot 1中，即s变量。
        10: aload_1
        11: invokevirtual #5                  // Method java/lang/String.intern:()Ljava/lang/String;
        14: pop
        <span style="color:#ff0000;">15: ldc           #3 </span>                 // String 1
        <span style="color:#ff0000;">17: astore_2    </span>                      
        18: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
        21: aload_1
        22: aload_2
        23: if_acmpne     30
        26: iconst_1
        27: goto          31
        30: iconst_0
        31: invokevirtual #7                  // Method java/io/PrintStream.println:(Z)V
        34: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
        37: aload_1
        38: aload_2
        39: invokevirtual #8                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z
        42: invokevirtual #7                  // Method java/io/PrintStream.println:(Z)V
        45: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
        48: invokevirtual #9                  // Method java/io/PrintStream.println:()V
        51: new           #10                 // class java/lang/StringBuilder
        54: dup
        55: invokespecial #11                 // Method java/lang/StringBuilder."<init>":()V
        58: new           #2                  // class java/lang/String
        61: dup
        62: ldc           #3                  // String 1
        64: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
        67: invokevirtual #12                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        70: new           #2                  // class java/lang/String
        73: dup
        74: ldc           #3                  // String 1
        76: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
        79: invokevirtual #12                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        82: invokevirtual #13                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        85: astore_3
        86: aload_3
        87: invokevirtual #5                  // Method java/lang/String.intern:()Ljava/lang/String;
        90: pop
        91: ldc           #14                 // String 11
        93: astore        4
        95: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
        98: aload_3
        99: aload         4
       101: if_acmpne     108
       104: iconst_1
       105: goto          109
       108: iconst_0
       109: invokevirtual #7                  // Method java/io/PrintStream.println:(Z)V
       112: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
       115: aload_3
       116: aload         4
       118: invokevirtual #8                  // Method java/lang/String.equals:(Ljava/lang/Object;)Z
       121: invokevirtual #7                  // Method java/io/PrintStream.println:(Z)V
       124: return
其中 String s2 = "1";的代码对应字节码 为 ldc #3 ,astore_2 。其中ldc表示将 int.float或者String类型从常量池中推到 操作数栈顶。 在interpreterRuntime.cpp中我们看到了ldc的执行 
IRT_ENTRY(void, InterpreterRuntime::ldc(JavaThread* thread, bool wide))
  // access constant pool
  constantPoolOop pool = method(thread)->constants();
  int index = wide ? get_index_u2(thread, Bytecodes::_ldc_w) : get_index_u1(thread, Bytecodes::_ldc);
  constantTag tag = pool->tag_at(index);

  if (tag.is_unresolved_klass() || tag.is_klass()) {
    klassOop klass = pool->klass_at(index, CHECK);
    oop java_class = klass->java_mirror();
    thread->set_vm_result(java_class);
  } else {
#ifdef ASSERT
    // If we entered this runtime routine, we believed the tag contained
    // an unresolved string, an unresolved class or a resolved class.
    // However, another thread could have resolved the unresolved string
    // or class by the time we go there.
    assert(tag.is_unresolved_string()|| tag.is_string(), "expected string");
#endif
    oop s_oop = pool->string_at(index, CHECK);
    thread->set_vm_result(s_oop);
  }
IRT_END
因为这是个字符串常量，代码调用了pool->string_at(index, CHECK) ，最后代码调用了string_at_impl方法
  
oop constantPoolOopDesc::string_at_impl(constantPoolHandle this_oop, int which, TRAPS) {
  oop str = NULL;
  CPSlot entry = this_oop->slot_at(which);
  if (entry.is_metadata()) {
    ObjectLocker ol(this_oop, THREAD);
    if (this_oop->tag_at(which).is_unresolved_string()) {
      // Intern string
      Symbol* sym = this_oop->unresolved_string_at(which);
      <span style="font-size:14px;">str = StringTable::intern(sym, CHECK_(constantPoolOop(NULL)));</span>
      this_oop->string_at_put(which, str);
    } else {
      // Another thread beat us and interned string, read string from constant pool
      str = this_oop->resolved_string_at(which);
    }
  } else {
    str = entry.get_oop();
  }
  assert(java_lang_String::is_instance(str), "must be string");
  return str;
}
在代码中，我们可以看到在没有调用ldc 之前，字符串常量值是用symbol 来表示的，而当调用ldc之后，通过调用StringTable::intern产生了String的引用，并且存放在常量池中。如果再调用ldc指令的话，直接从常量池根据索引取出String的引用(this_oop->resolved_string_at(which))，而避免再次从StringTable中去查找一次。
以此方法来分析。
1、堆中new一个String变量，s持有其堆中引用，并且会在常量池中生成一个”1“对象。
2、调用s.intern()方法，最终调用StringTable.intern()，试图将变量s的引用加入到常量池中，发现其已经存在。
3、s2="1",查找常量池中是否有”1“，有，则返回常量池中”1“的引用 保存在 s2中。
4、所以 s==s2 结果为false。
5、s3 = new String("1")+new String("1"); 首先 会在堆中生成String对象 并在常量池中生成”1“。我们知道jvm会使用StringBuilder来优化使用”+“的字符串生成。语句执行完成后，堆中有 String "11"的对象，而常量池中并没有。
6、s3.intern()将其加入常量池，jdk7开始，不再复制常量值，与堆栈中的s3相同，常量池中保存s3在堆中的引用。
7、s4 = "11",调用ldc命令，查询常量池，存在，直接返回其引用。所以 s3==s4.
 
大致就是这样子，后来搜索了一下，发现同学也是在一篇博客中看到的， 深入解析String#intern,讲解的很细致，推荐大家看看，本篇对其也有参考，另外，参考了  Java (JDK7)中的String常量和String.intern的实现，因为String的intern（）方法使用hashTable，故数据量比较大的时候会出现较多的哈希冲突，链接法效率较低，所以会经常出现性能问题，这方面暂不讨论，上述博客有分析到，大家自己去看看并探索吧。

 

Quartzhao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于java String中intern的深入讲解
08-26
主要给大家介绍了关于java String中intern的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用java具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
关于String.intern()
yunshixin的专栏
10-15 307
public static void main(String[] args) { String s = new String("1"); s.intern(); String s2 = "1"; System.out.println(s == s2); String s3 = new String("1") + new String("1"); s3.intern();
String字符串intern方法浅析
小铭铭的博客
04-13 185
String的intern方法（仅代表个人理解） 首先要明白： 1、直接使用双引号声明出来的的String对象是存储在常量池中，new出来的对象存在于堆中 2、如果不是双引号声明的String对象，可以使用String的intern方法。intern方法会从字符串常量池中查询当前字符串是否存在，若不存在则会将当前字符串放入常量池中 public static void main(String[] args) { String s = new String(“1”); s.intern(); String s
Strings1=newString("1")+newString("1"),new String 面试
伟大是熬出来的
12-02 1147
public class Intern { public static void main(String[] args) { test1(); test2(); } public static void test1(){ String s = new String("1"); s.intern(); ...
Java技术——你真的了解String类的intern()方法吗
热门推荐
关于Android开发的一些技术点总结 ╮(￣▽￣”)╭
08-23 6万+
0.引言 什么都先不说，先看下面这个引入的例子： String str1 = new String("SEU")+ new String("Calvin"); System.out.println(str1.intern() == str1); System.out.println(str1 == "SEUCalvin"); 本人JDK版本1.8，输出结果为： tru...
总结了一下StringTable/StringPool以及intern方法一些相关的问题，通俗易懂
sunao1106的博客
08-26 444
分析： new StringBuilder("计算机").append("软件").toString()，先new StringBuilder("计算机")，此时创建两个对象分别在堆和串池中，.append("软件")拼接堆中字符串，现在堆中也就如下图所示，然后将"软件"也放到串池中，注意，再说一遍.toString()不往串池中放东西！此时b引用指向堆中对象。 String internB = b.intern()，将b存入串池中，首页先判断串池是否有"计算机软件"字符串对象，发现没有，这........
java String的intern方法
09-01
本文主要介绍java 中String 的intern方法,这里主要通过实例来说明不同版本的JDK,intern方法的对比,有需要的小伙伴可以参考下
jdk1.8之后的String.intern()方法内存分析
01-20
关于String.intern()方法，这个问题都被问烂了，有的文章在分析的时候还在用jdk1.7，jdk1.8之后内存模型发生了变化，内存的变化也会影响intern方法的执行，这里有必要写文章分析一下，请大家务必从头开始看，这样...
Java String的intern用法解析
08-25
主要介绍了Java String的intern用法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
通过String.intern()方法浅谈堆中常量池
08-25
主要介绍了通过String.intern()方法浅谈堆中常量池，在JDK7之前，字符串常量是存在永久带Perm 区的，JDK7开始在将常量池迁移到堆中，这个变化也导致了String的新特性，下面我们慢慢进行介绍。,需要的朋友可以参考下
彻底搞懂String, 字符串常量池, intern方法
Light
09-09 188
来看一段代码： public static void main(String[] args) { String s = new String("1"); s.intern(); String s2 = "1"; System.out.println(s == s2); String s3 = new String("1") + new String("1"); s3.intern(); String s4 = "11"; System.out
java的string的intern_java String的intern()方法
weixin_30611317的博客
02-16 259
intern()方法用于将字符串对象加入常量池中。public native String intern();intern()方法返回的是一个常量池中的String对象(即常量池中某个String对象的引用)。String s = new String("1");s.intern();s是一个位于堆中的String对象，其字符串值为 "1" ， 调用s的intern()方法，可在常量池中创建一个字...
几张图轻松理解String.intern()
tyyking的博客
09-07 4万+
https://blog.csdn.net/soonfly/article/details/70147205 在翻《深入理解Java虚拟机》的书时，又看到了2-7的 String.intern()返回引用的测试。 其实要搞明白String.intern()，我总结了下面几条规则： 一、new String都是在堆上创建字符串对象。当调用 intern() 方法时，编译器会将字符串添加到常量池中（...
JVM源码分析之String.intern()导致的YGC不断变长
weixin_34198762的博客
04-10 401
概述 之所以想写这篇文章，是因为YGC过程对我们来说太过于黑盒，如果对YGC过程不是很熟悉，这类问题基本很难定位，我们就算开了GC日志，也最多能看到类似下面的日志 [GC (Allocation Failure) [ParNew: 91807K->10240K(92160K), 0.0538384 secs] 91807K->21262K(2...
关于Java String的一些总结
永远保持敬畏之心
12-01 184
关于Java String的一些总结 作者：大飞   不变模式设计        String是典型的不变模式设计。主要体现在两点：        1.String Class由final修饰，保证了无法产生可改变String语义的子类。        2.一些有"修改"行为的方法都会产生新的String实例，如concat、replace等方法。   ==相关的问题 ...
linux的系统无故报错，SIGSEGV (0xb) at pc=0x00007f7ba8eebfc1, pid=55066, tid=140167750223616
z90708833_yp的博客
04-11 5873
linux的系统herr_err.log的记录
java Final关键字语义剖析
Quartzhao的专栏
05-13 2261
常用用法 java中final关键字大家经常使用。final可以用于声明字段、方法和类。final声明字段时，若为基本类型，表示该变量值初始化后不再改变；若为引用类型，则表示引用不可变，但引用所指向的对象是可以改变的。final声明方法时表示方法不可覆写（常用来限制子类不可以改写父类中方法）。final声明类时，表示类不可继承，如String类就是final的，你不能继承它。 final字段的
String的intern方法有什么用
最新发布
06-08
String的intern方法可以用来实现字符串常量池，它的作用是：如果字符串常量池中已经存在一个等于此String对象的字符串，则返回代表池中这个字符串的String对象；否则，将此String对象添加到常量池中，并且返回此...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值