在 Java 中 String 对象是我们最常用的对象。 在本文章中，我们主要对 String 对象使用的 String Pool 进行一些简单的介绍。 Java 定义 String 后，String 是存储在 String Pool 中的，以便于加快字符串的访问和处理。 正是有这个方面的访问需求，JVM 为 String 对象在内存中特地开辟了一个存储区域来加快对 String 对象的访问，这个特定的内存区域就是我们说的 String Pool 了。 字符串引用（String Interning） 我们都知道 Strings 在 Java 中是不可变的（ immutable），因此 JVM 可以通过访问这个字符串的引用，或者我们可以借用指针的这个概念来访问 String 字符串。 通过指针访问字符串值的这个过程就可以称为引用（interning）。 当我们在内存中创建一个字符串的时候，JVM 将会根据你创建字符串的值在内存中进行查找有没有和你创建值相同的 String 对象已经被创建了。 如果，JVM 找到了这个对象的话，JVM 就将会为你创建的对象返回已经存在 String 的地址的引用，而不会继续申请新的内存空间，以便于提高内存的利用率。 如果，JVM 没有找到与创建对象相同的值的话，JVM 将会申请内存空间并且创建这个 String 对象，然后将新创建的这个 String 的对象进行返回，这个过程就称为引用（interned）。 让我们使用下面的方法进行验证： @Test public void whenCreatingConstantStrings_thenTheirAddressesAreEqual() { String constantString1 = "HoneyMoose"; String constantString2 = "HoneyMoose"; assertThat(constantString1).isSameAs(constantString2); } 上面的方法将会通过，原因是 constantString2 在创建的时候，将会得到的是 constantString1 内存地址的引用。 因此上面 2 个字符串是完全相同的。 String 构造方法中的内存分配 因为构造 String 对象有几种不同的方法，我们可以通过直接赋值的方式构造 String 对象，我们也可以通过 new 的方式来构造一个 String 对象。 在这里我们需要说如果使用 new 这个关键字来构造的 String对象。 简单来说，如果你使用了 new 这个关键字来构造 String 对象的话，不管 String 对象中的值是不是相同，JVM 都会为构造的对象开辟存储空间，这个存储空间在 JVM 的 heap 中。 因此每个使用 new 构造的 String 对象都会有自己的内存地址。 让我们来看看下面的代码： @Test public void whenCreatingStringsWithTheNewOperator_thenTheirAddressesAreDifferent() { String newString1 = new String("HoneyMoose"); String newString2 = new String("HoneyMoose"); assertThat(newString1).isNotSameAs(newString2); logger.info("newString1 Address: {}", System.identityHashCode(newString1)); logger.info("newString2 Address: {}", System.identityHashCode(newString2)); } 上面的代码将会输出： 16:03:38.916 [main] INFO c.o.stringpool.StringPoolUnitTest - newString1 Address: 429075478 16:03:38.919 [main] INFO c.o.stringpool.StringPoolUnitTest - newString2 Address: 1802066694 我们可以看到使用 new 以后的 String 的地址空间是不一样的。 String 文字（Literal）和 对象（Object） 当我们创建 String 对象的时候，如果使用 new() 的方式来创建一个 String 对象，JVM 将会每次都会在 heap 内存中为我们创建的 String 对象开辟一个存储空间来进行存储。 但是，如果我们使用赋值方式创建 String 对象的话，JVM 首先将会对我们赋的值到 String Pool 中进行查找，如果找到的话，就返回已经存在这个值的引用。 如果没有找到，就创建一个新的 String 对象并且返回这个创建对象的引用。 例如，我们如果使用赋值方式将值 “HoneyMoose” 创建的话，我们有可能会得到的是已经存在值的内存地址让我们能够来重新利用已经划分的内存，也有可能是一个全新的内存地址。 简单来说，这 2 种方式创建的 String 字符串都是 String 对象，唯一不同的是 new 操作每次都会给出新的地址，另外的操作则不能每次都是新的内存地址。 要解释这种情况，我们可以用一个数据基本面试问题的题目来进行解释，就是为什么使用 == 进行字符串比较的时候有时候会得到 False 的值。 因为，我们都知道 == 比较的是地址，而不是 String 中存储的值。 考察下面的代码： String first = "HoneyMoose"; String second = "HoneyMoose"; System.out.println(first == second); // True 在上面的初始化后比较中，我们会得到 True 的值，因为上面 2 个 String 的地址是相同的。 下面，我们再使用 new 关键字来创建 2 个新的 String 对象，然后再来比较 String 对象的引用： String third = new String("HoneyMoose"); String fourth = new String("HoneyMoose"); System.out.println(third == fourth); // False 相同的，我们使用 new 的方式来创建对象，我们可以看到上面创建的 String 的地址是不相同的。 因此使用 == 计算的结果是 False。 String fifth = "HoneyMoose"; String sixth = new String("HoneyMoose"); System.out.println(fifth == sixth); // False 通常来说，我们建议对 String 对象初始化的时候，使用文字方式对 String 对象初始化，这样的话我们能够让…

一直到 Java 8，Strings 在 Java 中使用字符数组进行存储的，同时使用的是 UTF-16 字符集，因此每一个字符将会使用 2 字节的内存。 从 Java 9 开始，Java 提供了一个叫做压缩字符（Compact Strings）的存储概念。 这个存储将会针对字符串使用 char[] 和 byte[] 中字符编码，这个将会与你需要存储的内容有关。 简单来说就是从 Java 9 开始，String 将会根据存储内容的不同来使用不同的存储格式，只会在必要的时候才会使用 UTF-16 编码，这种设计将会显著降低 String 对内存的使用，并且能够让来让垃圾清理程序（Garbage Collector）更有效率的工作。 简单来说就是 Java 9 以后对 String 字符串的存储进行了优化，针对不同字符集设置了不同的存储方案以降低空间的使用。 https://www.ossez.com/t/java-string-pool/14017

在 Java 6 中，我们唯一可以做的优化就是通过增加 PermGen 内存空间来提供更多的存储。 可以通过在 JVM 中使用参数来实现： -XX:MaxPermSize=1G 从 Java 7 开始，我们可以为 String Pool 指定更多的参数来扩展和减少 String Pool 的大小。 让我们来看看下面使用的 2 个参数： -XX:+PrintFlagsFinal -XX:+PrintStringTableStatistics 如果我们希望增加 String Pool 的 buckets 大小，我们可以使用 JVM 提供的 StringTableSize 参数选项： -XX:StringTableSize=4901 在 Java 7u40，默认的 String Pool 大小为 1009 buckets。 但是这个值在最近的一些 Java 版本更新中有了改变，从 7u40 到 Java 11 String Pool 的大小为 60013 buckets，在 Java 11 的后续版本中，这个值增加到了 65536 buckets。 需要注意的是，增加 String Pool 的大小将会增加 JVM 的内存消耗，但是也会降低在我们对 String 进行赋值的时候 JVM 对 String 表的处理时间。   https://www.ossez.com/t/java-string-pool/14017

手工修改引用的意思就是通过程序来手工修改 String 字符串使用的指针来获得我们需要的值。 手工修改指针的方法为 intern()。 手工修改 String 在 String 存储池中的引用，JVM 将会在我们需要的时候返回这个引用。   让我们来创建一个测试用例： String constantString = "interned HoneyMoose"; String newString = new String("interned HoneyMoose"); assertThat(constantString).isNotSameAs(newString); String internedString = newString.intern(); assertThat(constantString) .isSameAs(internedString); 上面代码中的第一次判断是不相同的，后来我们在创建一个新的 String 的对象的时候，使用了一个已经创建的 String 字符串的引用，那么我们的后面再进行判断的时候就是相同的了。   https://www.ossez.com/t/java-string-pool/14017

当我们创建 String 对象的时候，如果使用 new() 的方式来创建一个 String 对象，JVM 将会每次都会在 heap 内存中为我们创建的 String 对象开辟一个存储空间来进行存储。 但是，如果我们使用赋值方式创建 String 对象的话，JVM 首先将会对我们赋的值到 String Pool 中进行查找，如果找到的话，就返回已经存在这个值的引用。 如果没有找到，就创建一个新的 String 对象并且返回这个创建对象的引用。 例如，我们如果使用赋值方式将值 “HoneyMoose” 创建的话，我们有可能会得到的是已经存在值的内存地址让我们能够来重新利用已经划分的内存，也有可能是一个全新的内存地址。 简单来说，这 2 种方式创建的 String 字符串都是 String 对象，唯一不同的是 new 操作每次都会给出新的地址，另外的操作则不能每次都是新的内存地址。 要解释这种情况，我们可以用一个数据基本面试问题的题目来进行解释，就是为什么使用 == 进行字符串比较的时候有时候会得到 False 的值。 因为，我们都知道 == 比较的是地址，而不是 String 中存储的值。 考察下面的代码： String first = "HoneyMoose"; String second = "HoneyMoose"; System.out.println(first == second); // True 在上面的初始化后比较中，我们会得到 True 的值，因为上面 2 个 String 的地址是相同的。 下面，我们再使用 *new* 关键字来创建 2 个新的 String 对象，然后再来比较 String 对象的引用： String third = new String("HoneyMoose"); String fourth = new String("HoneyMoose"); System.out.println(third == fourth); // False 相同的，我们使用 new 的方式来创建对象，我们可以看到上面创建的 String 的地址是不相同的。 因此使用 == 计算的结果是 False。 String fifth = "HoneyMoose"; String sixth = new String("HoneyMoose"); System.out.println(fifth == sixth); // False 通常来说，我们建议对 String 对象初始化的时候，使用文字方式对 String 对象初始化，这样的话我们能够让 JVM 有机会对 String 初始化之前进行判断来完成内存优化而不需要重复创建相同的对象。   https://www.ossez.com/t/java-string-pool/14017

因为构造 String 对象有几种不同的方法，我们可以通过直接赋值的方式构造 String 对象，我们也可以通过 new 的方式来构造一个 String 对象。 在这里我们需要说如果使用 new 这个关键字来构造的 String对象。 简单来说，如果你使用了 new 这个关键字来构造 String 对象的话，不管 String 对象中的值是不是相同，JVM 都会为构造的对象开辟存储空间，这个存储空间在 JVM 的 heap 中。 因此每个使用 new 构造的 String 对象都会有自己的内存地址。 让我们来看看下面的代码： @Test public void whenCreatingStringsWithTheNewOperator_thenTheirAddressesAreDifferent() { String newString1 = new String("HoneyMoose"); String newString2 = new String("HoneyMoose"); assertThat(newString1).isNotSameAs(newString2); logger.info("newString1 Address: {}", System.identityHashCode(newString1)); logger.info("newString2 Address: {}", System.identityHashCode(newString2)); } 上面的代码将会输出： 16:03:38.916 [main] INFO c.o.stringpool.StringPoolUnitTest - newString1 Address: 429075478 16:03:38.919 [main] INFO c.o.stringpool.StringPoolUnitTest - newString2 Address: 1802066694 我们可以看到使用 new 以后的 String 的地址空间是不一样的。   https://www.ossez.com/t/java-string-pool/14017

我们都知道 Strings 在 Java 中是不可变的（ immutable），因此 JVM 可以通过访问这个字符串的引用，或者我们可以借用指针的这个概念来访问 String 字符串。 通过指针访问字符串值的这个过程就可以称为引用（interning）。 当我们在内存中创建一个字符串的时候，JVM 将会根据你创建字符串的值在内存中进行查找有没有和你创建值相同的 String 对象已经被创建了。 如果，JVM 找到了这个对象的话，JVM 就将会为你创建的对象返回已经存在 String 的地址的引用，而不会继续申请新的内存空间，以便于提高内存的利用率。 如果，JVM 没有找到与创建对象相同的值的话，JVM 将会申请内存空间并且创建这个 String 对象，然后将新创建的这个 String 的对象进行返回，这个过程就称为引用（interned）。 让我们使用下面的方法进行验证： @Test public void whenCreatingConstantStrings_thenTheirAddressesAreEqual() { String constantString1 = "HoneyMoose"; String constantString2 = "HoneyMoose"; assertThat(constantString1).isSameAs(constantString2); } 上面的方法将会通过，原因是 constantString2 在创建的时候，将会得到的是 constantString1 内存地址的引用。 因此上面 2 个字符串是完全相同的。   https://www.ossez.com/t/java-string-pool/14017

概述 在本文章中，我们主要用来说明为什么应该使用 char[] 数组来存储密码，而不是使用 String 来存储密码。 需要注意的是，为了密码的安全，我们通常都会将用户输入的密码 MD5 加密哈希后进行存储。 我们通常是不会在后台中存储明文的用户密码的，这篇文章主要目的就是为了说明字符串在 Java 中的存储方式和在存储中的实现，就算你应该使用 char[] 数组来存储，你也不应该在程序中使用明文。 同时，本文章还假设你没有办法对 String 字符串进行控制。例如你获得密码是从某些第三方工具上面获得的，或者第三方 API 传递过来的，通常你是没有办法对上面的字符串进行控制的。 因此，你还不得不使用 java.lang.String 对象来对密码进行实现，经过 Java 的官方小组还是推荐使用 char[] 数组来实现。 你可以通过单击 JPasswordField 这个链接来查看 JPasswordField API 的使用，这个 API 是存在 javax.swing 包中的。 我们可以知道 getText() 这个返回 String 的方法从 Java 2 开始就被丢弃了，你应该使用 getPassword() 来返回密码，这个方法实际上是返回的 char[] 字符串。     下面来让我们看看为什么应该使用 char[] 数组来存储密码了。 Strings 是不可变的（Immutable） String 在 Java 中是不可变的。这个不可变的意思是，String 是不能被更高一级的 API 进行操作的。 任何对 String 对象的修改都会创建一个新的 String 对象，同时将老的 String 对象保存在内存中。 上面这句话的意思就是：如果密码（Password）使用 String 来进行存储的话，如果你对密码进行操作后，老的密码还是在内存中存在的，知道 Java 的垃圾回收程序来清理掉。 这个垃圾回收的过程，我们是没有办法进行控制的，我们也不知道 JVM 什么时候执行垃圾清理。这个清理的过程与其他对象的清理对比来说，可能需要等待比较长的时间。这是因为 String 在 JVM 中是存储在 String Pool 中的，这个主要是为了便于对 String 的再次利用。 因为有这个缓存的存在，所以 String 在内存中保留的时间会比较长。 在这个过程中，任何人如果对 JVM 进行 Dump 内存操作的话，任何人都可以从内存中获得密码的明文。 如果我们使用 char[] 数组来存储密码的话，我们可以在对密码的计算完成后来使用程序对数组进行清理。因此，我们可以保证我们使用过的密码从内存中完全清楚，而不是等候 JVM 垃圾清理程序来进行清理。 下面我们来看代码来对上面的用例进行说明： String 测试 @Test public void immutableForString() { String stringPassword = "password"; System.out.print("Original String password value: "); System.out.println(stringPassword); System.out.println("Original String password hashCode: " + Integer.toHexString(stringPassword.hashCode())); String newString = "********"; stringPassword.replace(stringPassword, newString); System.out.print("String password value after trying to replace it: "); System.out.println(stringPassword); System.out.println("hashCode after trying to replace the original String: " + Integer.toHexString(stringPassword.hashCode())); } 上面程序将会有如下输出： Original String password value: password Original String password hashCode: 4889ba9b String password value after trying to replace it: password hashCode after trying to replace the original String: 4889ba9b char 数组测试 @Test public void immutableForCharArray() { char[] charPassword = new char[]{'p', 'a', 's', 's', 'w', 'o', 'r', 'd'}; System.out.print("Original char password value: "); System.out.println(charPassword); System.out.println("Original char password hashCode: " + Integer.toHexString(charPassword.hashCode())); Arrays.fill(charPassword, '*'); System.out.print("Changed char password value: "); System.out.println(charPassword); System.out.println("Changed char password hashCode: " + Integer.toHexString(charPassword.hashCode())); } 针对数组的测试输出如下： Original char password value: password Original char password hashCode: 10d59286 Changed char password value: ******** Changed char password hashCode: 10d59286     正如我们所看到的那样，当我们对 String 进行了操作后，操作后的结果是不会改变原始输入 String 的结果的。 我们可以看到上面的代码，hashCode() 方法返回的结果是一样的，并没有给我们有不同的结果，同时 String 中的值也保持一致。 使用 char[] 数组的时候，我们注意到,hashCode() 的值是一样的，但是内容却不一样了。这是因为我们对 char[] 进行了操作所导致的，我们可以对相同的对象中的数据进行修改。 需要注意 stringPassword.replace(stringPassword, newString); 方法，如果你需要获得这个方法替换后的值得话，你需要将方法执行后的值重新赋值才可以。 避免意外打印密码 使用 char[] 数组来存储密码的好处就是能够避免意外的将内存中存储的密码数据输出到控制台，显示器或者其他并不安全的地方。 让我们来考察下面的代码： @Test public void accidentallyPassword_print() { String passwordString = "password"; char[] passwordArray = new char[]{'p', 'a', 's',…

Discourse 使用了用户等级的方式来识别用户的级别和对网站的忠诚程度。 通常新用户的级别是比较低，限制也是比较多的。 如下图显示的用户级别数量：     通常在网站中，第 0 和 第 1 的信任级别比较多。 建议，如果你使用 Discourse 的网站的话，尽量进入信任级别 1 中。 如何进入信任级别 1 进入信任级别 1 比较简单。 就是多花点时间读点帖子就好了。 通常有下面 3 种办法： 发布超过 5 个主题 阅读超过 30 个主题 在阅读上的总计时间超过 10 分钟 如下图官方的说法：     通常来说还是比较容易达到的，上面的 3 个选项，不是需要同时达到的，只需要满足其中一个就可以了。 https://www.ossez.com/t/discourse/14014

虽然这个问题不是一个非常大的问题。 但是还是比较闹心的。     针对新用户，Discourse 默认配置新用户只能插入 1 张图片。 如果你插入多张图片，上面的配置限制显然是有点闹心。 在技术文档中，显然这个是不够的。 解决方案 这个其实是可以在后台进行配置的。 在配置对话框中，搜索 new user，然后再 Posting 中对 newuser max embedded media 进行修改就可以了。     建议对新用户修改参数为至少允许插入 8 张图片吧。   https://www.ossez.com/t/discourse/14013