摘要
 
1.概念
2.获取方法
3.代码点与代码单元的代码示例

 
1.概念
 
代码点(code point):与一个编码表中的某个字符对应的代码值.
 
 
 
在Unicode标准中,代码点采用十六进制书写,并加上前缀U+,例U+0041就是字母A的代码点.
 
 
 
  
Unicode的代码点可以分成17个代码级别(code plane).
 第一个代码级别成为基本的多语言级别,代码点从U+0000到U+FFFF,其中包括了经典的Unicode代码.
 其余的16个附加级别,代码点从U+10000到U+10FFFF,其中包括了一些辅助字符(增补字符).
 增补字符是用一个长度为2的char数组表示的，分别表示高代理项和低代理项。
 关于增补字符的具体描述请看:关于Java增补字符
 
 
 
 
代码单元(code unit):在第一代码级别中,每个字符用16位表示(即代码单元);而辅助字符采用一对连续的代码单元进行编码.
 
 
 
UTF-16编码采用不同长度的编码表示所有的Unicode代码点.
 
 
通俗理解 :
 代码点 : Unicode中的各个字符
 代码单元 : 若一个字符的代码长度为16位,则为一个代码单元;若一个字符的代码长度有两个16的代码长度编码,则该字符有两个代码单元.
 
Unicode(代码点)
常用字符
辅助字符
数量(代码单元)
一个代码单元
一对代码单元

 (图片来源:char 码点和代码单元)
 
 
 
在Java中一个Unicode占2个字节(byte)
 一个字节等于8比特位(bit)
 因此,每个Unicode码占用16个比特位
 
 
2.获取方法
 
String.length()方法 :
 返回采用UTF-16编码表示的给定字符串所需要的代码单元数量.
 String.codePointCount(int beginIndex, int endIndex) :
 返回此String指定文本范围内的Unicode代码点数.
 String.charAt(int index) :
 返回位置index的代码单元,n介于0~String.length()-1之间.
 
3.代码点与代码单元的代码示例
 
从Unicode字符百科里面找到U+10000以后的一个字符进行试验.
 
public class CodePointDemo {
	public static void main(String[] args) {
		String str = "?";
		System.out.println(str.length());// 输出该字符串的代码单元的数量
		System.out.println(str.codePointCount(0, str.length()));// 输出该字符串的代码点数
		System.out.println(Integer.toHexString(str.charAt(0)));// 先获得该字符第一个位置的代码单元的char类型字符,编译器先将char类型强转为int类型的值,后将int值转换为16进制数进行输出
		System.out.println(Integer.toHexString(str.charAt(1)));// 
		System.out.println("\ud801\udcd1");// 将两个char类型字符输出组成了一个代码点?
	}
}
/*输出:
2
1
d801
dcd1
?
*/
 
 
 
Integer.toHexString(str.charAt(0))需要注意,该代码用到了强转
 关于强转的详细信息,请看:
 首先,str.charAt(0)返回一个char类型字符,Integer.toHexString(int i)接受一个int类型的值,故需要先将char强转为int,在完成该代码.
 
 
public class StrongTurnDemo {
	public static void main(String[] args) {
		String str = "?";
		int i = str.charAt(0);
		System.out.println(i);
		System.out.println(Integer.toHexString(i));
	}
}
/*输出 :
55297
d801
*/
 
 
对于char类型来说,charAt(int index)只能获取BMP的字符,对于增补字符,是无法正常获得的.所以当字符串中包含增补字符又该如何获取呢,当文档当中有增补字符呢?请看:如何读取字符串(包含增补字符)?-java

Java中码点和代码单元
 
前言
 
码点和代码单元这两个概念还是在《Java核心技术 卷一》发现的，这也是我看过这本书里面前五章中比较有用的一个知识点（PS：毕竟Java开发都一年了，基础应用都差不多了），以前都没听过。
 
概念
 
在介绍这个概念之前，建议大家先去看看一些编码方面的知识。《编码格式简介（ANSI、GBK、GB2312、UTF-8、GB18030和 UNICODE）》，这篇文章讲的挺好。每个国都有把自己的语言编码，于是出现了各种各样的编码(美国的ASCII，中国的GBK，俄罗斯的KOI-8等），如果你不安装相应的编码，就无法解释相应编码想表达的内容。最后 ISO 一起创造了一种编码 UNICODE ，这种编码非常大，大到可以容纳世界上任何一个文字和标志。所以只要电脑上有 UNICODE 这种编码系统，无论是全球哪种文字，只需要保存文件的时候，保存成 UNICODE 编码就可以被其他电脑正常解释。
 而在设计Java时，当时的Unicode才发布1.0版本，字符连65536代码值一半都不到，为了方便后面增加，Java使用了16位的Unicode字符集。但是没想到，随着计算机的普及，各国计算机的发展，16位也放不下人类的集体文化财富。
 码点是指一个编码表中的某个字符对应的代码值。Unicode的码点分为17个代码级别，第一个级别是基本的多语言级别，码点从U+0000——U+FFFF，其余的16个级别从U+10000——U+10FFFF，其中包括一些辅助字符。
 基本的多语言级别，每个字符用16位表示代码单元，而辅助字符采用连续的一对连续代码单元进行编码。
 
代码实例
 
下面hi𝕆中的𝕆实际上是是一个辅助字符，它实际上占用了两个char来保存，这个字符串中总共为4个char，3个代码点。
 
    public static void main(String[] args) {
        String hello = "hi𝕆";
        System.out.println(hello.length());//4
        System.out.println(hello.codePointCount(0, hello.length()));//3
    }
 
下列代码中显示了每个char的16进制和每个代码单元的16进制。
 
    public static void main(String[] args) {
        String hello = "hi𝕆";
        int length = hello.length();
        for(int i=0;i<length;i++) {
            char charAt = hello.charAt(i);
            System.out.println(Integer.toHexString(charAt));
        }
        int codePointCount = hello.codePointCount(0, length);
        for(int i=0;i<codePointCount;i++) {
            int index = hello.offsetByCodePoints(0,i);
            int charAt = hello.codePointAt(index);
            System.out.println(Integer.toHexString(charAt));
        }
    }
 
分为4个代码单元
 
68
69
d835
dd46
 
3个码点
 
68
69
1d546
 
而码点转化为字符串则需要使用一些特殊的API，比如：
 判读是不是一个码点，上文的d835或者dd46肯定不是
 
Character.isValidCodePoint(codePoint)
 
码点转化为字符串：
 
char[] chars = Character.toChars(0x1d546);
String str = new String(chars);
System.out.println(str);//𝕆

一个码点是信息原子的单元。文本是一连串的码点。每一个码点是一个由标准的Unicode编码规定的数字；
 一个代码单元是一个用来存储编码码点的一部分的单元。在UTF-8中，一个代码单元是8位；在UTF-16中，一个代码单元是16位。
 单独的一个代码单元可能代表一个完整的码点，也可能是一个码点的一部分。
 例如，一个雪人字符（☃），是一个Unicode码点，也就是一个Unicode编码所代表的符号，在UTF-8中用3个代码单元表示，在UTF-16中用一个代码单元表示。
 
String对象中操作码点和代码单元
 
 
 
     length()方法是获取给定字符串所需的代码单元数量。charAt(i)方法是获取位置i的代码单元，i介于0~s.leng()-1之间。
 
     “?”符号 在Unicode中编码中，对应的十六进制编码为：1d546。“?”符号 在Java中的代码单元为："\uD835\uDD46"。
 
// 以此打印码点
private static void showCodePoint(){
    //String str01="\u1D546";
    String str01="\uD835\uDD46";
    try {
        // 将Unicode字符转为UTF-8格式
        byte[] b = str01.getBytes("UTF-8");
        String rb = new String(b,"UTF-8");
        // 为rb拼接一些内容
        rb = rb+"abc";
        // 打印rb的内容
        System.out.println(rb);
        // 打印rb的代码单元长度
        System.out.println(rb.length());
        // 打印rb的码点长度
        int codePointLen = rb.codePointCount(0, rb.length());
        System.out.println(codePointLen);
        System.out.println("*******************");
        // 根据码点长度，遍历各个码点
        for(int i=0;i<codePointLen;i++){
            // 码点的偏移量
            int index = rb.offsetByCodePoints(0, i);
            System.out.println(index);
            // 码点的十进制表示
            int cp = rb.codePointAt(index);
            // 码点的十六进制表示
            String cpHex = Integer.toHexString(cp);
            System.out.println(cp+" , "+cpHex);
        }
    } catch (Exception e) {
        System.err.println(e);
    }
}
 
上面的代码，打印出的结果如下：
 
 
 
?abc
 
 
5
 
 
4
 
 
*******************
 
 
0
 
 
120134 , 1d546
 
 
2
 
 
97 , 61
 
 
3
 
 
98 , 62
 
 
4
 
 
99 , 63
 
 
【正向操作】遍历一个字符串，并依次参看每一个码点：
 
// 遍历一个字符串并查看每一个码点
private static void printCodePoint(){
    String str01="\uD835\uDD46";
    String str02 = str01+"hello"+str01+"World";
    int i=0;
    // 判断i是否小于str02的代码单元长度
    while(i<str02.length()){
        System.out.println("i: "+i);
        // 码点的十进制表示
        int cp = str02.codePointAt(i);
        // 码点的十六进制表示
        String cpHex = Integer.toHexString(cp);
        System.out.println(cp+" , "+cpHex);
        // 判断是否为补充码点，如果是补充码点就加2，如果不是补充码点就加1
        if(Character.isSupplementaryCodePoint(cp)) i+=2;
        else i++;
    }
}
 
【回退操作】从后往前操作，遍历字符串，并查看每一个码点
 
// 从后往前操作，遍历字符串，并查看每一个码点
private static void fromLastLoopCodePoint(){
    String str01="\uD835\uDD46";
    String str02 = str01+"hello"+str01+"World";
    // 代码单元的长度
    int codeUtilLen=str02.length();
    for(int i=codeUtilLen;i>0;){
        i--;
        if(Character.isSurrogate(str02.charAt(i))) i--;

        System.out.println("i: "+i);
        // 码点的十进制
        int cp = str02.codePointAt(i);
        //码点的十六进制
        String cpHex = Integer.toHexString(cp);
        System.out.println(cp+" , "+cpHex);
    }
}
 
上面块代码打印的结果如下：
 
 
 
正向遍历                                回退操作
 i: 0                                      i: 13
 120134 , 1d546                            100 , 64
 i: 2                                      i: 12
 104 , 68                                  108 , 6c
 i: 3                                      i: 11
 101 , 65                                  114 , 72
 i: 4                                      i: 10
 108 , 6c                                  111 , 6f
 i: 5                                      i: 9
 108 , 6c                                  87 , 57
 i: 6                                      i: 7
 111 , 6f                                  120134 , 1d546
 i: 7                                      i: 6
 120134 , 1d546                            111 , 6f
 i: 9                                      i: 5
 87 , 57                                   108 , 6c
 i: 10                                     i: 4
 111 , 6f                                  108 , 6c
 i: 11                                     i: 3
 114 , 72                                  101 , 65
 i: 12                                     i: 2
 108 , 6c                                  104 , 68
 i: 13                                     i: 0
 100 , 64                                  120134 , 1d546
 
 
 

1. 解释一
 
 
 
char：Java中，char类型为16个二进制位，原本用于表示一个字符。但后来发现，16位已经不够表示所有的字符，所以后来发展出了代码点表示字符的方法。
 
 
代码点(code point)：是指编码字符集中，字符所对应的数字。有效范围从U+0000到U+10FFFF。其中U+0000到U+FFFF为基本字符，U+10000到U+10FFFF为增补字符。
 
 
代码单元(code unit)：对代码点进行编码得到的1或2个16位序列。其中基本字符的代码点直接用一个相同值的代码单元表示，增补字符的代码点用两个代码单元的进行编码，这个范围内没有数字用于表示字符，因此程序可以识别出当前字符是单单元的基本字符，还是双单元的增补字符。
 
 
以上摘自漂洋过海来看你的博客。
 
2. 解释二
 
《Java核心技术 卷1》中这样描述：
 
 
 
代码点(code point)是指与一个编码表中的某个字符对应的代码值。UTF-16编码采用不同长度的编码表示所有Unicode代码点，每个16位二进制表示一个代码单元(code unit)。基本字符的范围为[U+0000~U+FFFF]，辅助字符，即上面提到的增补字符，其两个代码单元的范围分别为[U+D800~U+DBFF]和[U+DC00~U+DFFF]。这样很容易就能知道一个代码单元是一个基本字符的编码还是一个辅助字符的第一或第二部分。
 
 
3. 解释三
 
Java中String.length()方法返回的是代码单元(code unit)的个数，而String.codePointCount(0, length)返回的是码点(code point)个数，即字符的个数。当然，通常这两个值是一致的。
 
System.out.println("---------------我是分割线-----------------");
String sentence = "\u0041 \u0042";  // 该字符串的第二个（从一开始计）字符是空格
System.out.println(sentence);
int lengthU = sentence.length();
int lengthP = sentence.codePointCount(0, lengthU);
System.out.println(lengthU);        // 3个code units
System.out.println(lengthP);        // 3个code points
 
如图所示： 
 
 
System.out.println("---------------我是分割线-----------------");
String sentence = "\u03C0 \uD835\uDD6B";    // 该字符串的第二个（从一开始计）字符是空格
System.out.println(sentence);
int lengthU = sentence.length();
int lengthP = sentence.codePointCount(0, lengthU);
System.out.println(lengthU);        // 4个code units
System.out.println(lengthP);        // 3个code points
 
如图所示： 
 
 
* 以上是小灰个人的理解，如有错误，欢迎指正。