在 Java 字符（16 位）中存储 UTF-8 字符（8 位）时如何避免内存浪费。二合一？

Question

恐怕我对一个相当过饱和的主题的细节有疑问，我搜索了很多，但找不到一个明确的答案来解决这个特定的明显-imho-重要的问题：

使用UTF-8将byte[]转换为String时，每个字节（8bit）都变成了UTF-8编码的8位字符，但是java中每个UTF-8字符都保存为16位字符。那是对的吗？ 如果是，这意味着每个愚蠢的 java 字符只使用前 8 位，并消耗双倍的内存？这也正确吗？我想知道这种浪费行为是如何被接受的......

是不是有一些技巧来拥有一个 8 位的伪字符串？这实际上会导致更少的内存消耗吗？ 或者，有没有办法在一个java 16位字符中存储>两个

感谢您提供任何令人困惑的答案...

编辑： 你好，谢谢大家的回答。我知道 UTF-8 的可变长度属性。但是，由于我的源是 8 位字节，我理解（显然是错误的）它只需要 8 位 UTF-8 字。 UTF-8 转换是否实际上保存了您在 CLI 上执行“cat somebinary”时看到的奇怪符号？我认为 UTF-8 只是以某种方式用于将字节的每个可能的 8 位字映射到 UTF-8 的一个特定的 8 位字。错误的？我考虑过使用 Base64，但它很糟糕，因为它只使用 7 位..

问题重新表述：有没有更聪明的方法将字节转换为字符串？ 可能最喜欢的是将 byte[] 转换为 char[]，但我仍然有 16 位字。

其他用例信息：

我将Jedis（NoSQL Redis 的 java 客户端）改编为 hypergraphDB 的“原始存储层”。所以，jedis是另一个“数据库”的数据库。 我的问题是我必须一直为 jedis 提供 byte[] 数据，但在内部，>Redis 字符串转换并使用那个Filteroutputstream...？）

现在我想知道：如果我必须一直相互转换 byte[] 和 String，数据大小从非常小到可能非常大，将每个 8 位字符传递为java中的16位？

Answer 1

8位伪字符串不是有什么技巧吗？

是的，请确保您拥有最新版本的 Java。 ;)

http://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.html

-XX:+UseCompressedStrings 对可以表示为纯 ASCII 的字符串使用 byte[]。 （在 Java 6 Update 21 Performance Release 中引入）

编辑：此选项在 Java 6 更新 22 中不起作用，并且默认情况下在 Java 6 更新 24 中未启用。注意：此选项似乎可能会使性能降低约 10%。

下面的程序

public static void main(String... args) throws IOException {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 10000; i++)
        sb.append(i);

    for (int j = 0; j < 10; j++)
        test(sb, j >= 2);
}

private static void test(StringBuilder sb, boolean print) {
    List<String> strings = new ArrayList<String>();
    forceGC();
    long free = Runtime.getRuntime().freeMemory();

    long size = 0;
    for (int i = 0; i < 100; i++) {
        final String s = "" + sb + i;
        strings.add(s);
        size += s.length();
    }
    forceGC();
    long used = free - Runtime.getRuntime().freeMemory();
    if (print)
        System.out.println("Bytes per character is " + (double) used / size);
}

private static void forceGC() {
    try {
        System.gc();
        Thread.sleep(250);
        System.gc();
        Thread.sleep(250);
    } catch (InterruptedException e) {
        throw new AssertionError(e);
    }
}

默认打印

Bytes per character is 2.0013668655941212
Bytes per character is 2.0013668655941212
Bytes per character is 2.0013606946433575
Bytes per character is 2.0013668655941212

使用选项-XX:+UseCompressedStrings

Bytes per character is 1.0014671435440285
Bytes per character is 1.0014671435440285
Bytes per character is 1.0014609725932648
Bytes per character is 1.0014671435440285

Answer 2

其实你把UTF-8部分搞错了：UTF-8是变长多字节编码，所以有1-4个字节长度的有效字符（换句话说，有些UTF-8字符是8位的，有些是 16 位的，有些是 24 位的，有些是 32 位的）。虽然 1 字节字符占用 8 位，但还有更多的多字节字符。如果您只有 1 个字节的字符，则总共只能有 256 个不同的字符（又名“扩展 ASCII”）；这可能足以满足 90% 的英语使用（我的 naïve 猜测），但一旦你甚至 想到 超出该子集的任何内容（看到 naïve 这个词 - 英语，但不能只用 ASCII 写）。

因此，尽管 UTF-16（Java 使用的）看起来很浪费，但实际上并非如此。无论如何，除非你在一个非常有限的嵌入式系统上（在这种情况下，你在用 Java 做什么？），试图减少字符串是毫无意义的微优化。

有关字符编码的稍长介绍，请参见例如这个：http://www.joelonsoftware.com/articles/Unicode.html

Answer 3

当使用 UTF-8 将 byte[] 转换为 String 时，每个字节（8bit）变成一个 UTF-8 编码的 8 位字符

没有。使用 UTF-8 将 byte[] 转换为 String 时，每个 1-6 字节的 UTF-8 sequence 都将转换为 1-2 的 UTF-16 sequence 16 位字符。

在几乎所有情况下，全球，这个 UTF-16 序列都包含一个字符。

在西欧和北美，对于大多数文本，仅使用了这个 16 位字符中的 8 位。但是，如果您有欧元符号，则需要超过 8 位。

有关详细信息，请参阅Unicode。或Joel Spolsky's article。

Answer 4

Java 在内部将其所有“字符”存储为值的两个字节表示形式。但是，它们的存储方式与 UTF-8 不同。例如，支持的最大值是“\uFFFF”（十六进制 FFFF，十进制 65536），或 11111111 11111111 二进制（两个字节） - 但这将是磁盘上的 3 字节 Unicode 字符。

唯一可能的浪费是内存中真正的“单”字节字符（大多数 ASCII“语言”字符实际上适合 7 位）。当字符写入磁盘时，它们无论如何都会采用指定的编码（因此 UTF-8 单字节字符只会占用一个字节）。

唯一不同的地方是 JVM 堆。但是，您必须拥有成千上万个 8 位字符才能注意到 Java 堆使用的任何真正差异——这将远远超过您所做的所有额外（hacky）处理。

无论如何，RAM 中的一百万个 8 位字符只会“浪费”大约 1 MiB...

Answer 5

Redis（实际的服务器）只处理“二进制安全”字符串。

我认为这意味着您可以对键/值使用任意八位字节序列。如果您可以使用任何 C char 序列而不考虑字符编码，那么 Java 中的等价物就是 byte 类型。

Java 中的字符串隐含为UTF-16。我的意思是，您可以在其中粘贴任意数字，但该类的目的是表示 Unicode 字符数据。执行byte-to-char 转换的方法执行从已知编码到 UTF-16 的转码操作。

如果 Jedis 将键/值视为 UTF-8，那么它不会支持 Redis 支持的每个值。 并非每个字节序列都是有效的 UTF-8，因此无法使用编码用于二进制安全字符串。

---

UTF-8 或 UTF-16 是否消耗更多内存取决于数据 - 例如欧元符号 (€) 在 UTF-8 中消耗三个字节，而在 UTF-16 中仅消耗两个字节。

Answer 6

为了记录，我编写了自己的字节[] 字符串互转换器的小实现，它通过将每 2 个字节转换为 1 个字符来工作。它大约快 30-40% 并且消耗（可能少于）Java 标准方式的一半内存：new String(somebyte) 和 someString.getBytes()。

但是，它与现有的字符串编码字节或字节编码字符串不兼容。此外，在共享数据上从不同的 JVM 调用该方法是不安全的。

https://github.com/ib84/castriba

Answer 7

也许这就是你想要的：

// Store them into the 16 bit datatype.
char c1_8bit = 'a';
char c2_8bit = 'h';
char two_chars = (c1_8bit << 8) + c2_8bit;

// extract them
char c1_8bit = two_chars >> 8;
char c2_8bit = two_chars & 0xFF;

当然，这个技巧只适用于 ASCII 字符（[0-255] 范围内的字符）。为什么？ 因为您想以这种方式存储字符：
xxxx xxxx yyyy yyyy 和 x 是字符 1，y 是字符 2。所以这意味着每个字符只有 8 位。用 8 位可以得到的最大整数是多少？答案：255

255 = 0000 0000 1111 1111（8 位）。当您使用大于 255 的字符时，您将拥有：
256 = 0000 0001 0000 0000（超过 8 位），这不适合您为 1 个字符提供的 8 位。

另外：请记住，Java 是一种由聪明人开发的语言。他们知道他们在哪里做什么。 推动 Java API