String.getBytes("XXX")时发生了什么

首先要了解，java里边，String是以char数组的形式存储的，而char字符是16 bits的Unicode字符。
1、当执行new String("i am a 字符ゅ").getBytes()的时候，是把内存中的char数组，转化成Charset.defaultCharset()这种字符集的字符数组，而这种字符集是提取的系统属性里边"file.encoding"属性的值，参见Charset的源代码：

public static Charset defaultCharset() {
        if (defaultCharset == null) {
	    synchronized (Charset.class) {
		java.security.PrivilegedAction pa =
		    new GetPropertyAction("file.encoding");
		String csn = (String)AccessController.doPrivileged(pa);
		Charset cs = lookup(csn);
		if (cs != null)
		    defaultCharset = cs;
                   else 
		    defaultCharset = forName("UTF-8");
            }
	}
	return defaultCharset;
}

(我本机就是utf-8)然后会创建一个StringEncoder而StringEncoder会创建一个CharsetEncoder:UTF-8$Encoder，创建UTF-8$Encoder时在调到CharsetEncoder的构造函数时会传入一个new byte[]{(byte)'?'}用来在解析到不能解析的字符的时候，把不能解析的字符替换成'?'(63,0x3F)（当然utf-8编码格式是可以表示java的char可以表示的所有字符的，这个在后边讲到iso-8859-1的时候会用到）。接下来就用StringEncoder#encode()，最终还是调用CharsetEncoder－UTF_8$Encoder来encode。而真正一个一个char解析的地方是UTF_8$Encoder#encodeArrayLoop(CharBuffer src, ByteBuffer dst)方法中：

	if (c < 0x80) {
		// Have at most seven bits
		if (dp >= dl)
			return overflow(src, sp, dst, dp);
		da[dp++] = (byte) c;
	} else if (c < 0x800) {
		// 2 bytes, 11 bits
		if (dl - dp < 2)
			return overflow(src, sp, dst, dp);
		da[dp++] = (byte) (0xc0 | ((c >> 06)));
		da[dp++] = (byte) (0x80 | (c & 0x3f));
	} else if (Surrogate.is(c)) {
		// Have a surrogate pair
		if (sgp == null)
			sgp = new Surrogate.Parser();
		int uc = sgp.parse((char) c, sa, sp, sl);
		if (uc < 0) {
			updatePositions(src, sp, dst, dp);
			return sgp.error();
		}
		if (dl - dp < 4)
			return overflow(src, sp, dst, dp);
		da[dp++] = (byte) (0xf0 | ((uc >> 18)));
		da[dp++] = (byte) (0x80 | ((uc >> 12) & 0x3f));
		da[dp++] = (byte) (0x80 | ((uc >> 06) & 0x3f));
		da[dp++] = (byte) (0x80 | (uc & 0x3f));
		sp++; // 2 chars
	} else {
		// 3 bytes, 16 bits
		if (dl - dp < 3)
			return overflow(src, sp, dst, dp);
		da[dp++] = (byte) (0xe0 | ((c >> 12)));
		da[dp++] = (byte) (0x80 | ((c >> 06) & 0x3f));
		da[dp++] = (byte) (0x80 | (c & 0x3f));
	}
	sp++; 

以上代码是判断当前char字符的int值的范围，然后确定是需要一个、两个或是三个字节，这个可以根据utf-8编码规则来确定：
UTF-8的编码规则很简单，只有二条：

1）对于单字节的符号，字节的第一位设为0，后面7位为这个符号的unicode码。因此对于英语字母，UTF-8编码和ASCII码是相同的。

2）对于n字节的符号（n>1），第一个字节的前n位都设为1，第n+1位设为0，后面字节的前两位一律设为10。剩下的没有提及的二进制位，全部为这个符号的unicode码。
即小于1000 0000(0x80)需要一个字节（0xxxxxxx）,小于0000 1000 0000 0000(0x200)需要两个字节（110xxxxx 10yyyyyy），其余最多占满16位的需要三个字节（1110xxxx 10yyyyyy 10zzzzzz）。以上代码根据这些规则进行了移位和按位操作，把两个字节的unicode字符编码成了utf-8格式的字节数组，这个时候，占用两个字节的字符不会丢失信息。
2、当执行new String("i am a 字符ゅ").getBytes("iso-8859-1")的时候，StringEncoder也会创建一个CharsetEncoder:ISO_8859_1$Encoder，创建的时候已然会传入一个new byte[]{(byte)'?'}用来在解析到不能解析的字符的时候，把不能解析的字符替换成'?'(63,0x3F)，来看看ISO_8859_1$Enoder的encodeArrayLoop方法：

	while (sp < sl) {
		char c = sa[sp];
		if (c <= '\u00FF') {
			if (dp >= dl)
				return CoderResult.OVERFLOW;
			da[dp++] = (byte) c;
			sp++;
			continue;
		}
		if (sgp.parse(c, sa, sp, sl) < 0)
			return sgp.error();
		return sgp.unmappableResult();
	}

这里可以看到如果遇到unicode值大于'\u00FF'(1111 1111, 0xFF,即一个字节)的字符，全部当做不可映射字符(unmappable-input)，在CharsetEncoder#encode()调用过encodeLoop()后替换不可映射的字符为replacement，即我们传入的new byte[]{(byte)'?'}

	if (action == CodingErrorAction.REPLACE) {
		if (out.remaining() < replacement.length)
			return CoderResult.OVERFLOW;
		out.put(replacement);
	}

这样就是为什么我们在运行如下代码的时候

new String("This is a 中文的 String!".getBytes("iso-8859-1"),"utf-8").toString();

结果是：This is a ??? String!
当然这也就是涉及到了把byte[]按照某种编码格式解析成String（java的unicode字符集合char[]）的问题，本质跟上边原理是相反的。
3、new String("i am a 字符ゅ").getBytes("XXX")按照如上的过程，再根据XXX编码规则（不知为何参数类型叫做Charset），就可以解析出来了。