关于String类的实现的补充：Java 9 之后，String 类的实现改用 byte 数组存储字符串 #675

Activity

1. Snailclimb commented on Mar 7, 2020

   

   Snailclimb

   on Mar 7, 2020

   Owner

   More actions

   感谢补充！
2. Snailclimb

   added

   enhancementNew feature or request or suggestionNew feature or request or suggestion

   on Mar 7, 2020
3. Snailclimb

   closed this as completedon Mar 7, 2020
4. jinpenggit commented on Apr 22, 2020

   

   jinpenggit

   on Apr 22, 2020

   More actions

   为什么使用byte字节而舍弃了char字符:

   节省内存占用，byte占一个字节(8位)，char占用2个字节（16），相较char节省一半的内存空间。节省gc压力。
   针对初始化的字符，对字符长度进行判断选择不同的编码方式。如果是 LATIN-1 编码，则右移0位，数组长度即为字符串长度。而如果是 UTF16 编码，则右移1位，数组长度的二分之一为字符串长度。

   👍React with 👍23Reacted by YK Leung, sang666, xuyiwei, Hao, nopoetry, fangzx, 周, glister, Yixin Ji, FebBird and 13 more
5. HE996 commented on Sep 20, 2020

   

   HE996

   on Sep 20, 2020

   More actions

   String 可以存放汉字，String的 []方法返回值还是char，估计是两个byte实现的，
6. HE996 commented on Sep 20, 2020

   

   HE996

   on Sep 20, 2020

   More actions

   这是why？
   public class Main {
   private static final char[] value = {'1','2','3'};
   public static void main(String[] args) {
   System.out.println(value[0]);
   value[0] = '3';
   System.out.println(value[0]);
   }
   }
   output：
   1
   3
7. luonianxin commented on Dec 4, 2020

   

   luonianxin

   on Dec 4, 2020

   More actions

   这是why？
   public class Main {
   private static final char[] value = {'1','2','3'};
   public static void main(String[] args) {
   System.out.println(value[0]);
   value[0] = '3';
   System.out.println(value[0]);
   }
   }
   output：
   1
   3

   这里的被final修饰的变量指向的是一个数组，被final修饰的不可更改指的是　value变量存储的值也就是字符数组的地址不能再更改，即不能再将一个新的对象赋值给value（value = new char[3]，这样编译是会报错的）．但是value指向的数组里头的元素值还是可以修改的

   👍React with 👍11Reacted by furtheranddeeper, Ericwyn, FebBird, 岛辰, shi747826, the5traight, g_wangjiyuan, guozq, zzzi, Joker-K2 and 1 more
8. sslalxh commented on Feb 19, 2021

   

   sslalxh

   on Feb 19, 2021

   More actions

   这是why？
   public class Main {
   private static final char[] value = {'1','2','3'};
   public static void main(String[] args) {
   System.out.println(value[0]);
   value[0] = '3';
   System.out.println(value[0]);
   }
   }
   output：
   1
   3

   这里的被final修饰的变量指向的是一个数组，被final修饰的不可更改指的是　value变量存储的值也就是字符数组的地址不能再更改，即不能再将一个新的对象赋值给value（value = new char[3]，这样编译是会报错的）．但是value指向的数组里头的元素值还是可以修改的

   那为什么String对象是不可变的呢？String对象字符数组不是可以通过下标更改字符串的某个元素么。。。
9. luonianxin commented on Feb 20, 2021

   

   luonianxin

   on Feb 20, 2021

   More actions

   虽然我们可以使用反射跳过安全检查，设置字符数组的值,改变值后，打印出的字符串确实是改变了，但是我们通过对象的hashCode方法查看hash值发现,hashCode并没有随着字符数组被修改而改变．根据hash值的计算规则我们知道，如果一个对象的被修改了，那么它的hash值肯定也会跟着变化,我理解的String不可变指的是这个.虽然我们可以通过反射来改变字符数组的值而在显示上改变字符串的值，实际上该字符串的hash值并没有改变．在实际中不建议这样做．

         public static void main(String [] args) throws IllegalAccessException, InstantiationException {
           Class clazz = String.class;
           String strObj = "12345";
           Field [] fields = clazz.getDeclaredFields();
           char [] obj = null;
           System.out.println("before change hashcode is "+ strObj.hashCode());
           // before change hashcode is 46792755
           for (int i = 0; i < fields.length; i++) {
               if(fields[i].getName().equals("value")) {
                   fields[i].setAccessible(true);
                   obj = (char[]) fields[i].get(strObj);
                   obj[0] = 'c';
               }
           }
           System.out.println(strObj);
           // c2345
           System.out.println("after change new hashCode is "+strObj.hashCode());
           // after change new hashCode is 46792755 与之前相同
           System.out.println("12345".hashCode()); // 46792755
           System.out.println("c2345".hashCode()); // 92968805
       }

   上面的代码只能解释一种情况,经测试又发现了新的情况,我也不知道为什么出现这样的情况，希望有大佬释疑一下？谢谢

       public static void main(String [] args) throws IllegalAccessException, InstantiationException {
           Class clazz = String.class;
           String strObj = new String("12345");
           Field [] fields = clazz.getDeclaredFields();
           char [] obj = null;
           Field hash = null;
           System.out.println("before change hashcode is "+ strObj.hashCode());
           // before change hashcode is 46792755
           for (int i = 0; i < fields.length; i++) {
               if(fields[i].getName().equals("value")) {
                   fields[i].setAccessible(true);
                   obj = (char[]) fields[i].get(strObj);
                   obj[0] = 'c';
               }
           }
   
           System.out.println(strObj);
           // c2345
           System.out.println("after change new hashCode is "+strObj.hashCode());
           // after change new hashCode is 46792755 与之前相同
           System.out.println("12345".hashCode()); // 92968805
           System.out.println("c2345".hashCode()); // 92968805
       }
10. Snailclimb

    reopened this on Feb 20, 2021
11. Snailclimb

    changed the title [-]String类的实现[/-] [+]关于String类的实现的补充：Java 9 之后，String 类的实现改用 byte 数组存储字符串[/+] on Feb 20, 2021
12. Snailclimb

    added

    discussdiscuss a problemdiscuss a problem

    perfectImprove knowledge points or descriptionsImprove knowledge points or descriptions

    on Feb 20, 2021
13. YannySky commented on Jul 6, 2021

    

    YannySky

    on Jul 6, 2021

    Last edited by YannySky

    More actions

    这个问题有意思，:joy::joy:
    String strObj = new String("12345");
    这种字符串创建方式先在常量池里面创建了12345这个字符串，然后把常量池里面的char[]的引用赋值给了strObj

    public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }
    

    所有后面代码在修改这个数组的是否把常量池里的string对象数组给改了

    System.out.println("12345".hashCode()); // 92968805
    System.out.println("c2345".hashCode()); // 92968805
    

    这两行代码打印hash的时候取的是常量池里面的对象所以计算结果实际就是“c2345"的hash
    实际上这时候执行 System.out.println("12345");输出的也是”c2345"

    虽然我们可以使用反射跳过安全检查，设置字符数组的值,改变值后，打印出的字符串确实是改变了，但是我们通过对象的hashCode方法查看hash值发现,hashCode并没有随着字符数组被修改而改变．根据hash值的计算规则我们知道，如果一个对象的被修改了，那么它的hash值肯定也会跟着变化,我理解的String不可变指的是这个.虽然我们可以通过反射来改变字符数组的值而在显示上改变字符串的值，实际上该字符串的hash值并没有改变．在实际中不建议这样做．

          public static void main(String [] args) throws IllegalAccessException, InstantiationException {
            Class clazz = String.class;
            String strObj = "12345";
            Field [] fields = clazz.getDeclaredFields();
            char [] obj = null;
            System.out.println("before change hashcode is "+ strObj.hashCode());
            // before change hashcode is 46792755
            for (int i = 0; i < fields.length; i++) {
                if(fields[i].getName().equals("value")) {
                    fields[i].setAccessible(true);
                    obj = (char[]) fields[i].get(strObj);
                    obj[0] = 'c';
                }
            }
            System.out.println(strObj);
            // c2345
            System.out.println("after change new hashCode is "+strObj.hashCode());
            // after change new hashCode is 46792755 与之前相同
            System.out.println("12345".hashCode()); // 46792755
            System.out.println("c2345".hashCode()); // 92968805
        }

    上面的代码只能解释一种情况,经测试又发现了新的情况,我也不知道为什么出现这样的情况，希望有大佬释疑一下？谢谢

        public static void main(String [] args) throws IllegalAccessException, InstantiationException {
            Class clazz = String.class;
            String strObj = new String("12345");
            Field [] fields = clazz.getDeclaredFields();
            char [] obj = null;
            Field hash = null;
            System.out.println("before change hashcode is "+ strObj.hashCode());
            // before change hashcode is 46792755
            for (int i = 0; i < fields.length; i++) {
                if(fields[i].getName().equals("value")) {
                    fields[i].setAccessible(true);
                    obj = (char[]) fields[i].get(strObj);
                    obj[0] = 'c';
                }
            }
    
            System.out.println(strObj);
            // c2345
            System.out.println("after change new hashCode is "+strObj.hashCode());
            // after change new hashCode is 46792755 与之前相同
            System.out.println("12345".hashCode()); // 92968805
            System.out.println("c2345".hashCode()); // 92968805
        }

    👍React with 👍3Reacted by Da-Li, 苏凯 and Jeff
14. ckp-0217 commented on Oct 4, 2021

    

    ckp-0217

    on Oct 4, 2021

    Last edited by ckp-0217

    More actions

    涉及到hash的初始化和缓存 new string和直接字面量 两者strObj 不一样

     public static void main(String[] args) throws  IllegalAccessException {
    
            Class clazz = String.class;
            String strObj = new String("12345");
    //        相当于执行以下代码
    //           public String(String original) {
    //            this.value = original.value; 
    //            this.hash = original.hash;     strObj 的hash为“12345” 的hash  ！！！ 两者都没有初始化  hash都为0
    //        }
            
            Field [] fields = clazz.getDeclaredFields();
            
            System.out.println(strObj.hashCode());//第一次加载strObj的hash strObj 的hash为46792755 此时 “12345”hash依旧为0
    //        （如果不执行这句代码，那么hash依旧为0，最后执行时会对hash初始化，变为92968805）
    //        public int hashCode() {//初始化 会根据value的值进行hash
    //            int h = hash;
    //            if (h == 0 && value.length > 0) {
    //                char val[] = value;
    //
    //                for (int i = 0; i < value.length; i++) {
    //                    h = 31 * h + val[i];
    //                }
    //                hash = h;  ！！！//strObj 的hash被缓存了 不会再随着value改变而改变
    //            }
    //            return h; 
    //        }
            System.out.println("12345".hashCode()); //第一次加载“12345”的hash  “12345” 的hash为46792755 同上
            // （如果不执行这句代码，那么hash依旧为0，最后执行时会对hash初始化，变为92968805）
    
            char [] obj = null;
            Field hash = null;
            System.out.println("before change hashcode is "+ strObj.hashCode());//这地方调用了 hashcode函数 相当于初始化
            // before change hashcode is 46792755
            for (int i = 0; i < fields.length; i++) {
                if(fields[i].getName().equals("value")) {
                    fields[i].setAccessible(true);
                    obj = (char[]) fields[i].get(strObj);
                    obj[0] = 'c';
                }
            }
    
            System.out.println(strObj);
            // c2345
            System.out.println("after change new hashCode is "+strObj.hashCode());
            // after change new hashCode is 46792755 与之前相同
            
            System.out.println("12345".hashCode());//strObj 的hash为46792755
            System.out.println(strObj.hashCode());//“12345” 的hash为46792755
            System.out.println("c2345".hashCode()); // 92968805
    
        }
    

    虽然我们可以使用反射跳过安全检查，设置字符数组的值,改变值后，打印出的字符串确实是改变了，但是我们通过对象的hashCode方法查看hash值发现,hashCode并没有随着字符数组被修改而改变．根据hash值的计算规则我们知道，如果一个对象的被修改了，那么它的hash值肯定也会跟着变化,我理解的String不可变指的是这个.虽然我们可以通过反射来改变字符数组的值而在显示上改变字符串的值，实际上该字符串的hash值并没有改变．在实际中不建议这样做．

          public static void main(String [] args) throws IllegalAccessException, InstantiationException {
            Class clazz = String.class;
            String strObj = "12345";
            Field [] fields = clazz.getDeclaredFields();
            char [] obj = null;
            System.out.println("before change hashcode is "+ strObj.hashCode());
            // before change hashcode is 46792755
            for (int i = 0; i < fields.length; i++) {
                if(fields[i].getName().equals("value")) {
                    fields[i].setAccessible(true);
                    obj = (char[]) fields[i].get(strObj);
                    obj[0] = 'c';
                }
            }
            System.out.println(strObj);
            // c2345
            System.out.println("after change new hashCode is "+strObj.hashCode());
            // after change new hashCode is 46792755 与之前相同
            System.out.println("12345".hashCode()); // 46792755
            System.out.println("c2345".hashCode()); // 92968805
        }

    上面的代码只能解释一种情况,经测试又发现了新的情况,我也不知道为什么出现这样的情况，希望有大佬释疑一下？谢谢

        public static void main(String [] args) throws IllegalAccessException, InstantiationException {
            Class clazz = String.class;
            String strObj = new String("12345");
            Field [] fields = clazz.getDeclaredFields();
            char [] obj = null;
            Field hash = null;
            System.out.println("before change hashcode is "+ strObj.hashCode());
            // before change hashcode is 46792755
            for (int i = 0; i < fields.length; i++) {
                if(fields[i].getName().equals("value")) {
                    fields[i].setAccessible(true);
                    obj = (char[]) fields[i].get(strObj);
                    obj[0] = 'c';
                }
            }
    
            System.out.println(strObj);
            // c2345
            System.out.println("after change new hashCode is "+strObj.hashCode());
            // after change new hashCode is 46792755 与之前相同
            System.out.println("12345".hashCode()); // 92968805
            System.out.println("c2345".hashCode()); // 92968805
        }
15. JuiceApp1e commented on Mar 5, 2022

    

    JuiceApp1e

    on Mar 5, 2022

    Last edited by JuiceApp1e

    Contributor

    More actions

    因为理想情况下 String 是不可变的， hashCode 按理说是不会发生改变的，因此在设计的时候是这样设计的：在新建 String 对象的时候就会计算一次 hashCode 的值，并保存在 String 类的成员变量 hash 中，当你调用 hashCode() 方法时，仅仅是返回了 hash 值，而不是重新计算一次该字符串对应的 hashCode。

    虽然我们可以使用反射跳过安全检查，设置字符数组的值,改变值后，打印出的字符串确实是改变了，但是我们通过对象的hashCode方法查看hash值发现,hashCode并没有随着字符数组被修改而改变．根据hash值的计算规则我们知道，如果一个对象的被修改了，那么它的hash值肯定也会跟着变化,我理解的String不可变指的是这个.虽然我们可以通过反射来改变字符数组的值而在显示上改变字符串的值，实际上该字符串的hash值并没有改变．在实际中不建议这样做．

          public static void main(String [] args) throws IllegalAccessException, InstantiationException {
            Class clazz = String.class;
            String strObj = "12345";
            Field [] fields = clazz.getDeclaredFields();
            char [] obj = null;
            System.out.println("before change hashcode is "+ strObj.hashCode());
            // before change hashcode is 46792755
            for (int i = 0; i < fields.length; i++) {
                if(fields[i].getName().equals("value")) {
                    fields[i].setAccessible(true);
                    obj = (char[]) fields[i].get(strObj);
                    obj[0] = 'c';
                }
            }
            System.out.println(strObj);
            // c2345
            System.out.println("after change new hashCode is "+strObj.hashCode());
            // after change new hashCode is 46792755 与之前相同
            System.out.println("12345".hashCode()); // 46792755
            System.out.println("c2345".hashCode()); // 92968805
        }

    上面的代码只能解释一种情况,经测试又发现了新的情况,我也不知道为什么出现这样的情况，希望有大佬释疑一下？谢谢

        public static void main(String [] args) throws IllegalAccessException, InstantiationException {
            Class clazz = String.class;
            String strObj = new String("12345");
            Field [] fields = clazz.getDeclaredFields();
            char [] obj = null;
            Field hash = null;
            System.out.println("before change hashcode is "+ strObj.hashCode());
            // before change hashcode is 46792755
            for (int i = 0; i < fields.length; i++) {
                if(fields[i].getName().equals("value")) {
                    fields[i].setAccessible(true);
                    obj = (char[]) fields[i].get(strObj);
                    obj[0] = 'c';
                }
            }
    
            System.out.println(strObj);
            // c2345
            System.out.println("after change new hashCode is "+strObj.hashCode());
            // after change new hashCode is 46792755 与之前相同
            System.out.println("12345".hashCode()); // 92968805
            System.out.println("c2345".hashCode()); // 92968805
        }
16. WHeLiosC commented on Mar 19, 2022

    

    WHeLiosC

    on Mar 19, 2022

    More actions

    为什么使用byte字节而舍弃了char字符:

    节省内存占用，byte占一个字节(8位)，char占用2个字节（16），相较char节省一半的内存空间。节省gc压力。 针对初始化的字符，对字符长度进行判断选择不同的编码方式。如果是 LATIN-1 编码，则右移0位，数组长度即为字符串长度。而如果是 UTF16 编码，则右移1位，数组长度的二分之一为字符串长度。

    https://openjdk.java.net/jeps/254