Java 使用char-toUpperCase时实际会发生什么

我想确保我真正理解使用.toUpperCase时发生的事情 这是一段工作正常的代码。我只是想知道我的评论是否正确地描述了正在发生的事情

char first = 'j';   //Declare char variable & initialize it's value: j

/* toUpperCase method of the Character Class Wrapper is invoked
 * char primitives are autoboxed to Character Objects
 * toUpperCase method unboxes the converted Characters to char primitives
 */

char firstUp = Character.toUpperCase(first);

感谢大家给出简单而详细的回答。非常感谢。

不，请参阅。

toUpperCase

的签名为

public static char toUpperCase(char ch)

换句话说，一个

char

进入，一个

char

出来。在您的示例中，根本不会发生自动装箱或自动取消装箱。

否。请参阅。

toUpperCase

的签名为

public static char toUpperCase(char ch)

换句话说，一个

char

进入，一个

char

出来。在您的示例中，根本不会发生自动装箱或自动取消装箱。

否。请参阅。

toUpperCase

的签名为

public static char toUpperCase(char ch)

换句话说，一个

char

进入，一个

char

出来。在您的示例中，根本不会发生自动装箱或自动取消装箱。

否。请参阅。

toUpperCase

的签名为

public static char toUpperCase(char ch)

---

换句话说，一个

char

进入，一个

char

出来。在您的示例中，根本不会发生自动装箱或自动取消装箱。

除了其他答案之外，源代码：

Character.java

public static char toUpperCase(char ch) {
    return (char)toUpperCase((int)ch);
}

public static int toUpperCase(int codePoint) {
    return CharacterData.of(codePoint).toUpperCase(codePoint);
}

CharacterData.java

static final CharacterData of(int ch) {
    if (ch >>> 8 == 0) {     // fast-path
        return CharacterDataLatin1.instance;
    } else {
        switch(ch >>> 16) {  //plane 00-16
        case(0):
            return CharacterData00.instance;
        case(1):
            return CharacterData01.instance;
        case(2):
            return CharacterData02.instance;
        case(14):
            return CharacterData0E.instance;
        case(15):   // Private Use
        case(16):   // Private Use
            return CharacterDataPrivateUse.instance;
        default:
            return CharacterDataUndefined.instance;
        }
    }
}

CharacterData00.java（例如）

int-toUpperCase（int-ch）{
int mapChar=ch；
int val=getProperties（ch）；
如果（（val&0x00010000）！=0）{
如果（（val&0x07FC0000）=0x07FC0000）{
开关（ch）{
//具有溢出偏移量的映射字符
案例0x00B5:mapChar=0x039C；中断；
案例0x017F:mapChar=0x0053；中断；
案例0x1FBE:mapChar=0x0399；中断；
//同时具有1:1和1:M映射的映射字符
案例0x1F80:mapChar=0x1F88；中断；
案例0x1F81:mapChar=0x1F89；中断；
案例0x1F82:mapChar=0x1F8A；中断；
案例0x1F83:mapChar=0x1F8B；中断；
案例0x1F84:mapChar=0x1F8C；中断；
案例0x1F85:mapChar=0x1F8D；中断；
案例0x1F86:mapChar=0x1F8E；中断；
//更多
}
}
否则{
内部偏移量=val>（5+18）；
mapChar=ch-偏移量；
}
}
返回mapChar；
}

---

正如您所看到的：装箱/拆箱在任何时候都不会发生。

作为其他答案的补充，源代码：

Character.java

public static char toUpperCase(char ch) {
    return (char)toUpperCase((int)ch);
}

public static int toUpperCase(int codePoint) {
    return CharacterData.of(codePoint).toUpperCase(codePoint);
}

CharacterData.java

static final CharacterData of(int ch) {
    if (ch >>> 8 == 0) {     // fast-path
        return CharacterDataLatin1.instance;
    } else {
        switch(ch >>> 16) {  //plane 00-16
        case(0):
            return CharacterData00.instance;
        case(1):
            return CharacterData01.instance;
        case(2):
            return CharacterData02.instance;
        case(14):
            return CharacterData0E.instance;
        case(15):   // Private Use
        case(16):   // Private Use
            return CharacterDataPrivateUse.instance;
        default:
            return CharacterDataUndefined.instance;
        }
    }
}

CharacterData00.java（例如）

int-toUpperCase（int-ch）{
int mapChar=ch；
int val=getProperties（ch）；
如果（（val&0x00010000）！=0）{
如果（（val&0x07FC0000）=0x07FC0000）{
开关（ch）{
//具有溢出偏移量的映射字符
案例0x00B5:mapChar=0x039C；中断；
案例0x017F:mapChar=0x0053；中断；
案例0x1FBE:mapChar=0x0399；中断；
//同时具有1:1和1:M映射的映射字符
案例0x1F80:mapChar=0x1F88；中断；
案例0x1F81:mapChar=0x1F89；中断；
案例0x1F82:mapChar=0x1F8A；中断；
案例0x1F83:mapChar=0x1F8B；中断；
案例0x1F84:mapChar=0x1F8C；中断；
案例0x1F85:mapChar=0x1F8D；中断；
案例0x1F86:mapChar=0x1F8E；中断；
//更多
}
}
否则{
内部偏移量=val>（5+18）；
mapChar=ch-偏移量；
}
}
返回mapChar；
}

---

正如您所看到的：装箱/拆箱在任何时候都不会发生。

作为其他答案的补充，源代码：

Character.java

public static char toUpperCase(char ch) {
    return (char)toUpperCase((int)ch);
}

public static int toUpperCase(int codePoint) {
    return CharacterData.of(codePoint).toUpperCase(codePoint);
}

CharacterData.java

static final CharacterData of(int ch) {
    if (ch >>> 8 == 0) {     // fast-path
        return CharacterDataLatin1.instance;
    } else {
        switch(ch >>> 16) {  //plane 00-16
        case(0):
            return CharacterData00.instance;
        case(1):
            return CharacterData01.instance;
        case(2):
            return CharacterData02.instance;
        case(14):
            return CharacterData0E.instance;
        case(15):   // Private Use
        case(16):   // Private Use
            return CharacterDataPrivateUse.instance;
        default:
            return CharacterDataUndefined.instance;
        }
    }
}

CharacterData00.java（例如）

int-toUpperCase（int-ch）{
int mapChar=ch；
int val=getProperties（ch）；
如果（（val&0x00010000）！=0）{
如果（（val&0x07FC0000）=0x07FC0000）{
开关（ch）{
//具有溢出偏移量的映射字符
案例0x00B5:mapChar=0x039C；中断；
案例0x017F:mapChar=0x0053；中断；
案例0x1FBE:mapChar=0x0399；中断；
//同时具有1:1和1:M映射的映射字符
案例0x1F80:mapChar=0x1F88；中断；
案例0x1F81:mapChar=0x1F89；中断；
案例0x1F82:mapChar=0x1F8A；中断；
案例0x1F83:mapChar=0x1F8B；中断；
案例0x1F84:mapChar=0x1F8C；中断；
案例0x1F85:mapChar=0x1F8D；中断；
案例0x1F86:mapChar=0x1F8E；中断；
//更多
}
}
否则{
内部偏移量=val>（5+18）；
mapChar=ch-偏移量；
}
}
返回mapChar；
}

---

正如您所看到的：装箱/拆箱在任何时候都不会发生。

作为其他答案的补充，源代码：

Character.java

public static char toUpperCase(char ch) {
    return (char)toUpperCase((int)ch);
}

public static int toUpperCase(int codePoint) {
    return CharacterData.of(codePoint).toUpperCase(codePoint);
}

CharacterData.java

static final CharacterData of(int ch) {
    if (ch >>> 8 == 0) {     // fast-path
        return CharacterDataLatin1.instance;
    } else {
        switch(ch >>> 16) {  //plane 00-16
        case(0):
            return CharacterData00.instance;
        case(1):
            return CharacterData01.instance;
        case(2):
            return CharacterData02.instance;
        case(14):
            return CharacterData0E.instance;
        case(15):   // Private Use
        case(16):   // Private Use
            return CharacterDataPrivateUse.instance;
        default:
            return CharacterDataUndefined.instance;
        }
    }
}

CharacterData00.java（例如）

int-toUpperCase（int-ch）{
int mapChar=ch；
int val=getProperties（ch）；
如果（（val&0x00010000）！=0）{
如果（（val&0x07FC0000）=0x07FC0000）{
开关（ch）{
//具有溢出偏移量的映射字符
案例0x00B5:mapChar=0x039C；中断；
案例0x017F:mapChar=0x0053；中断；
案例0x1FBE:mapChar=0x0399；中断；
//同时具有1:1和1:M映射的映射字符
案例0x1F80:mapChar=0x1F88；中断；
案例0x1F81:mapChar=0x1F89；中断；
案例0x1F82:mapChar=0x1F8A；中断；
案例0x1F83:mapChar=0x1F8B；中断；
案例0x1F84:mapChar=0x1F8C；中断；
案例0x1F85:mapChar=0x1F8D；中断；
案例0x1F86:mapChar=0x1F8E；中断；
//更多
}
}
否则{
内部偏移量=val>（5+18）；
mapChar=ch-偏移量；
}
}
返回mapChar；
}

---

如您所见：装箱/拆箱在任何时候都不会发生。

内部

toUpperCase

使用

CharacterData

及其子类（包私有）查找从小写字符到大写对应字符的映射

实际上，大多数内部操作都是使用

int

vari来完成的