Java �ַ����ܽ�

java�ַ��������������ܣ�javaĬ���ַ�����Unicode����;����ʹ��System.out.println(Charset.defaultCharset());�鿴jvmĬ�ϵ��ַ������ҵ�WIN10Ϊutf-8��

JVM���ַ�������ȡ���Dz���ϵͳĬ�ϵ��ַ�������һ������£�

  • win xp ��һ����GBK��
  • WIN 10 :UTF-8
  • Linux �������Ի��������ļ���

*.java�ļ�������GBK��UTF-8�ȱ���,*.class�ļ�ͳһʹ�õ���Unicode(UTF-16)���롣����������ʱ��ȡ�ⲿ���ļ������ݿ���߽�����Ϣ�ͻ����ڴ��в�����Unicode�����ַ����������ַ������������ڴ���ͨ��Unicode����Ϊ��������ת�������ֻ�ת�����ַ�������Ӧ���㹻����������Ҫת�����ַ������������ַ�������ͻ�������루������UTF-8����ASCII����

������������������棺JVM֮�ں�JVM֮��

JAVA�����г����ı����������ʽ

1. �ļ�������γ�class

�����ڱ���ǰjava�ļ�ʹ�ú��ֱ��룬�ڱ����class�����Ƕ�Unicode�����ʾ

2. JVM�еı���

JVM����class�ļ���ȡʱ��ʹ��Unicode���뷽ʽ��ȷ��ȡclass�ļ�����ôԭ�������String s=”����”;���ڴ��еı�����ʽ��Unicode���롣

������String.getBytes()��ʱ����ʵ�Ѿ�Ϊ���������˻�������Ϊ�˷���ʹ��ƽ̨Ĭ�ϵ��ַ�������ȡ�ַ�����Ӧ���ֽ����顣��WindowsXP���İ��У�ʹ�õ�Ĭ�ϱ�����GBK��

����ͬ��ϵͳ�����ݿ⾭����α������������е�ԭ�������⣬�����׵������롣��ˣ���һ��ϵͳ�У��б�Ҫ���ַ����ı�����һ��ͳһ�����ͳһģ����˵�����Ƕ���ͳһ�����緽���ַ���������IO����������ϵͳ�У�����ͳһʹ��GBK��GB13080��UTF-8��UTF-16�ȵȶ����ԣ�ֻ��Ҫѡ����Щ�����ַ������Ա�֤�κο����õ����ַ�������������ʾ��������������⡣����������е��ļ�����ASCII�룩��ô���޷�ʵ��˫��ת���ˡ�

Ҫ�ر�ע����ǣ�UTF-8���������������е������ַ������룬��ˣ�����������£�UTF-8תGB18030���ܻ�������롣

3. �ڴ����ַ����ı���

�ڴ��е��ַ��������������ڴ�class������ֱ�Ӽ��ض������ַ���������һЩ�ַ����Ǵ��ı��ļ��ж�ȡ�ģ����е���ͨ�����ݿ��ȡ�ģ����п����Ǵ��ֽ����鹹���ģ�Ȼ�����ǻ����϶�����Unicode����ģ�ԭ��ܼ򵥣��洢�Ż�

��˾���Ҫ�������ָ����ı������⣬�ڴ���֮ǰ��������ȷ��Դ���ı��룬Ȼ����ָ���ı��뷽ʽ��ȷ��ȡ���ڴ��С������һ�������IJ�����ʵ���ϱ�����ȷ���ַ��������ı��룬��Ϊ�����������������һ������ϵͳ���ݹ����ġ�����ȷ���ַ�������ʱ�򣬾Ϳ��԰���Ҫ����ȷ�����ַ������Ա������롣
�ڶ��ַ������н�������ʱ��Ӧ�õ�������ķ�����

1
2
getBytes(String charsetName)    
String(byte[] bytes, String charsetName)

����Ҫʹ����Щ�����ַ������Ƶķ���ǩ����ͨ�������������������Զ��ڴ��е��ַ��������±���

�ַ���Ӧ��

JVM Ĭ���ַ������� Charset.defaultCharset ()

Java �У��ַ��ֽ�ת��ʱ��������ṩ�ַ�����ʹ��Ĭ���ַ��������磬�ַ������ֽ�����ת��ʱ���ֽ������ַ���ת��ʱ�ȡ�

Java ��������ļ��� main ���������ļ��� ���� ���� System.getProperty(“file.encoding”)

�ñ���Ĭ��ֵȡ���� Java ��������ļ��� main ���������ļ��� ���� �ı��뷽ʽ��������ο��������£�Ҳ���������� Java ����ʱͨ�� -Dfile.encoding="GBK" ���趨����� -Dfile.encoding ָ���ı��뷽ʽ�� Java ��������ļ����ַ�����һ�£����ᵼ������ ��Ҳ�����ڳ�����ͨ�� setP roperty ����ֱ�����ã�����������Ȼ�ı��ˡ�file.encoding����ֵ�������ƺ�ûʲô�� ��

�ļ����ֱ��롪�� System.getProperty(“sun.jnu.encoding”)

System.getProperty(“sun.jnu.encoding”)

java���ַ��Ĵ���

��javaӦ�������У����жദ�漰���ַ������룬��Щ�ط���Ҫ������ȷ�����ã���Щ�ط���Ҫ����һ���̶ȵĴ�����

getBytes(charset)

����java�ַ���������һ����׼�������������ǽ��ַ�������ʾ���ַ�����charset���룬�����ֽڷ�ʽ��ʾ��ע���ַ�����java�ڴ������ǰ�unicode����洢�ġ�����”����”����������£���û�д����ʱ�򣩴洢Ϊ”4e2d 6587”�����charsetΪ”gbk”���򱻱���Ϊ”d6d0 cec4”��Ȼ�󷵻��ֽ�”d6 d0 ce c4”�����charsetΪ”utf8”�������”e4 b8 ad e6 96 87”�������”iso8859-1”���������޷����룬��󷵻� “3f 3f”�������ʺţ���

new String(charset)

����java�ַ�����������һ����׼����������һ�������������෴�����ֽ����鰴��charset����������ʶ�����ת��Ϊunicode�洢���ο�����getBytes�����ӣ�”gbk” ��”utf8”�����Եó���ȷ�Ľ��”4e2d 6587”����iso8859-1�������”003f 003f”�������ʺţ���

��Ϊutf8����������ʾ/���������ַ�������new String(str.getBytes("utf8"),"utf8") == str������ȫ���档

setCharacterEncoding()

�ú�����������http���������Ӧ�ı��롣

����request����ָ�ύ���ݵı��룬ָ�������ͨ��getParameter()��ֱ�ӻ����ȷ���ַ����������ָ������Ĭ��ʹ��iso8859-1���룬��Ҫ��һ���������μ�����”��������”��ֵ��ע�������ִ��setCharacterEncoding()֮ǰ������ִ���κ�getParameter()��java doc��˵����This method must be called prior to reading request parameters or reading input using getReader()�����ң���ָ��ֻ��POST������Ч����GET������Ч������ԭ��Ӧ������ִ�е�һ��getParameter()��ʱ��java���ᰴ�ձ���������е��ύ���ݣ���������getParameter()���ٽ��з���������setCharacterEncoding()��Ч��������GET�����ύ�����ǣ��ύ��������URL�У�һ��ʼ���Ѿ����ձ���������е��ύ���ݣ�setCharacterEncoding()��Ȼ����Ч��

����response������ָ��������ݵı��룬ͬʱ�������ûᴫ�ݸ�����������������������������õı��롣

��������

������������д����Ե����ӣ�˵��java�Ա����й�����Ĵ���������

��������

User input *(gbk:d6d0 cec4) browser *(gbk:d6d0 cec4) web server iso8859-1(00d6 00d 000ce 00c4) class����Ҫ��class�н��д�����getbytes(“iso8859-1”)Ϊd6 d0 ce c4��new String(“gbk”)Ϊd6d0 cec4���ڴ�����unicode������Ϊ4e2d 6587��

  1. �û�����ı��뷽ʽ��ҳ��ָ���ı����йأ�Ҳ���û��IJ���ϵͳ�йأ������Dz�ȷ���ģ�������gbkΪ����
  2. ��browser��web server�������ڱ�����ָ���ύ����ʱʹ�õ��ַ����������ʹ��ҳ��ָ���ı��롣�������url��ֱ����?�ķ�ʽ���������������������Dz���ϵͳ�����ı��룬��Ϊ��ʱ��ҳ���޹ء������Ծ���gbk����Ϊ����
  3. Web server���յ������ֽ�����Ĭ��ʱ��getParameter������iso8859-1���봦��֮������Dz���ȷ�ģ�������Ҫ���д����������Ԥ�������˱��루ͨ��request. setCharacterEncoding ()�������ܹ�ֱ�ӻ�ȡ����ȷ�Ľ����
  4. ��ҳ����ָ�������Ǹ���ϰ�ߣ��������ʧȥ���ƣ��޷�ָ����ȷ�ı��롣

�ļ�����

�����ļ���gbk���뱣��ģ������������ֱ���ѡ��gbk����iso8859-1��ǰ��������windows��Ĭ�ϱ��룬������linux��Ĭ�ϱ��룬��ȻҲ�����ڱ���ʱָ�����롣

Jsp *(gbk:d6d0 cec4) java file *(gbk:d6d0 cec4) compiler read uincode(gbk: 4e2d 6587; iso8859-1: 00d6 00d 000ce 00c4) compiler write utf(gbk: e4b8ad e69687; iso8859-1: *) compiled file unicode(gbk: 4e2d 6587; iso8859-1: 00d6 00d 000ce 00c4) class��������gbk���뱣�棬����iso8859-1����Ľ���Dz���ȷ�ġ�

class unicode(4e2d 6587) system.out / jsp.out gbk(d6d0 cec4) os console / browser��

  1. �ļ������Զ��ֱ��뷽ʽ���棬����windows�£�Ĭ��Ϊansi/gbk��
  2. ��������ȡ�ļ�ʱ����Ҫ�õ��ļ��ı��룬���δָ������ʹ��ϵͳĬ�ϱ��롣һ��class�ļ�������ϵͳĬ�ϱ��뱣��ģ����Ա��벻������⣬������jsp�ļ������������windows�±༭���棬��������Ӣ��linux������/���룬���������⡣������Ҫ��jsp�ļ�����pageEncodingָ�����롣
  3. Java�����ʱ���ת����ͳһ��unicode���봦������󱣴��ʱ����ת��Ϊutf���롣
  4. ��ϵͳ����ַ���ʱ�򣬻ᰴָ�������������������windows�£�System.out��ʹ��gbk���룬������response�������������ʹ��jsp�ļ�ͷָ����contentType�����߿���ֱ��Ϊresponseָ�����롣ͬʱ�������browser��ҳ�ı��롣���δָ�������ʹ��iso8859-1���롣�������ģ�Ӧ��Ϊbrowserָ������ַ����ı��롣
  5. browser��ʾ��ҳ��ʱ������ʹ��response��ָ���ı��루jsp�ļ�ͷָ����contentType����Ҳ��ӳ��response�ϣ������δָ�������ʹ����ҳ��meta��ָ���е�contentType��

�پٿ�ͷ������˵��ָ������ı�Ҫ:
���һ����ҳָ������Ϊutf-8, <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />, ҳ������һ��form���ύ��һ��servlet
��ô�û�������ַ����������ֽ������ǰ�ָ������encoding�ģ�������������”Hello���”,�����utf-8����ô�������ľ������£�

[104, 101, 108, 108, 111, -28, -67, -96, -27, -91, -67]

���ǿ������溺��ÿ������3���ֽڣ�������Բο�Utf-8�����֪ʶ��
�������ҳ��ָ������GBK���Ǵ������ľͲ�һ����:

[104, 101, 108, 108, 111, -60, -29, -70, -61]

����servlet�ˣ���ʹ��request.getParameter��ʱ���ڲ�Ӧ���ǵ���
String s = new String(bytes, response.getEncoding())�ģ������responseû�����ñ��룬��ô�Ͳ���Ĭ�ϵı���null��תΪjava ƽ̨��GBK�������ľͱ�������ˡ�

����Ϊ�˱������룬jspվ��һ����һ��������,���е�ҳ�桢servet������ͳһ�ı��롣response.setEncoding, request.setEncoding.

Java��String�ڲ���һ��char[], char��һ����16λ�洢��utf-16����ĵ�Ԫ��Ϊ�ˣ���Ҫ���ַ����ַ���תΪ�ֽ�������ļ������磬���ߴ��ļ�������������ֽ�����ԭΪ��ʵ��������ַ�����Ҫ�����������ʲô��

ת��

֪������֪ʶת��ͱȽϼ��ˣ�

��ͨ����ת��

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package vip.infotech.charset;

import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.Arrays;

/**
* @ClassName:
* @Description: ����ת��
* @author: ljp
* @Copyright: www.infotech.vip, Ltd. All rights reserved.
*/
public class CodeChange {
public static void main(String[] args) throws UnsupportedEncodingException {
System.out.println("��ǰJRE��" + System.getProperty("java.version"));
System.out.println("��ǰJVM��Ĭ���ַ�����" + Charset.defaultCharset());
String str = "����";
// to gbk
byte[] gbkByteArray = str.getBytes("GBK");
String gbkCode = new String(gbkByteArray, "GBK");
System.out.println("gbkByteArray:" + Arrays.toString(gbkByteArray));
System.out.println("GBKString:" + gbkCode);

// to utf-8
byte[] utfByteArray = str.getBytes("UTF-8");
String utfCode = new String(utfByteArray, "UTF-8");
System.out.println("utf-8ByteArray:" + Arrays.toString(utfByteArray));
System.out.println("utf-8String:" + utfCode);

}
}

��ҳ����ת��

��ҳ�ı���ת������ͨ��iso-8859-1��������ת����֤��ҳ����Tomcat�ı����ʽ��iso8859-1��java��ȡiso8859-1�ַ����ֽ��룬ͨ��new String(,"UTF-8")��UTF-8����

js��ҳ��

1
encodeURI('�����ַ�')

java��̨����

1
new String(str.getBytes("ISO8859-1"),"UTF-8")

��չ���ļ��ϴ�������Ҫ encodeURI(encodeURI(url))
ΪʲôҪ�������ε���encodeURI(String)�����أ�����ΪJava�е�request.getParameter(String)���������һ��URI�Ľ�����̣�����ʱ���õĽ�����̻ᵼ��������֡���URI�������κ�request.getParameter(String)�����õ�����ԭ��ϢURI����һ�ε����ݡ�������java.net.URLDecoder.decode(String str,String codename)���������Ѿ������URI ת����ԭ�ġ�

һ�������, ���� encodeURIComponent(parmeName)+”=”+encodeURIComponent(parmeValue);
����ʱ, ֱ�� String paramValue = request.getParameter(paramName); // �����Զ�����.

����֪�� encodeURIComponent ʹ�õ��� UTF-8 ������������.
��� request.getParameter(paramName) ʱ,����Ҳ�� UTF-8 ��Ļ�,����ȷ��. ���������ڿͻ���
���ж��ε� encodeURIComponent(…)
��� request.getParameter(paramName),����û�а� UTF-8 ��Ļ�, ���ֻ��һ��,��������!
������ʲô����������,������ request.setCharacterEncoding(***) ���� ��������������.
������� jsp ������,�ܹ� request.setCharacterEncoding(“UTF-8”), ���� �޸ķ���������,�������ڽ� GET �ύ�IJ���ʱ,ʹ�� UTF-8.

�ͻ����ύǰ���ö��α���, ����ʱ,ҲֻҪֱ�� request.getParameter(paramName) ����
Ϊʲô���ϻ���������ڿͻ��˶��ַ����ظ�����������.
�����Ϊ��Ŀ��Ҫ,����ָ������ʹ�ú��ֱ�������������ύ�IJ���, ����:��Ҫ�������Բ�ͬҳ�棬���ر���IJ�������ʱ�� (�ֻ����ǿ�����Ա�����е㸴�ӵĶ��������ͷת�򣬲����������ȷ��ȥ��������ղ����Ĺ���)���ʱ���ڿͻ��˶Բ������ж��α��룬������Ч�ıܿ����ύ���ֽ��ַ���������������⡣��Ϊ��һ�α��룬��IJ������ݱ㲻���ж��ֽ��ַ��ˣ����˴���� Ascii �ַ�����(����ѱ��һ�εĽ���г� [STR_ENC1] ���ˡ�[STR_ENC1] �Dz����ж��ֽ��ַ���)�ٱ�һ�κ��ύ������ʱ�����Զ���һ�Ρ��������Զ������һ�Σ������ǰ� GBK ���� UTF-8 ���� ISO-8859-1 ���ã����ܹ���ȷ�ĵõ� [STR_ENC1]��
Ȼ�����ڳ�����ʵ��һ�� decodeURIComponent (Java��ͨ��ʹ�� java.net.URLDecoder(***, “UTF-8”)) �Ϳ��Եõ����ύ�IJ�����ԭֵ��

ʵ��-����DEMO

ʵ��һ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
package vip.infotech.charset;

import java.io.*;
import java.nio.charset.Charset;
import java.util.Arrays;

/**
* @ClassName:
* @Description: �ַ�����Ϣ����
* @author: ljp
* @Copyright: www.infotech.vip. All rights reserved.
*/
public class CharsetTest {
public static void main(String[] args) throws IOException {
File directory = new File("");//��ȡ���̵�ǰĿ¼
String filaPath = directory.getAbsolutePath()+"/learn-basic/src/main/java/vip/infotech/charset/encode.txt";
System.out.println(directory.getAbsolutePath());

System.out.println("��ǰJRE��" + System.getProperty("java.version"));
System.out.println("��ǰJVM��Ĭ���ַ�����" + Charset.defaultCharset());

String str = "����";
// ��ȡJVMĬ���ַ���
System.out.println("defaultCharset:" + Charset.defaultCharset());

System.out.println("##�ַ���ת����byte����");
byte[] defaultByteArray = str.getBytes();
byte[] gbkByteArray = str.getBytes("GBK");
byte[] utfByteArray = str.getBytes("UTF-8");
System.out.println("defaultByteArray:"
+ Arrays.toString(defaultByteArray));
System.out.println("gbkByteArray:" + Arrays.toString(gbkByteArray));
System.out.println("utfByteArray:" + Arrays.toString(utfByteArray));

System.out.println("##byte����ת�����ַ���");
String defaultStr = new String(defaultByteArray);
String gbkStr = new String(defaultByteArray, "GBK");
String utfStr = new String(defaultByteArray, "UTF-8");
System.out.println("defaultStr:" + defaultStr);
System.out.println("gbkStr:" + gbkStr);
System.out.println("utfStr:" + utfStr);

System.out.println("##�ֽ���ת�����ַ���");
System.out.println(System.getProperty("user.dir"));
// �ļ���ֻ�С����ġ�2����,�ļ����á�UTF-8�����룬��6��byte
BufferedReader defaultReader = new BufferedReader(
new InputStreamReader(new FileInputStream(filaPath)));
BufferedReader gbkReader = new BufferedReader(new InputStreamReader(
new FileInputStream(filaPath), "GBK"));
BufferedReader utfReader = new BufferedReader(new InputStreamReader(
new FileInputStream(filaPath), "UTF-8"));
System.out.println("defaultReader:" + defaultReader.readLine());
System.out.println("gbkReader:" + gbkReader.readLine());
System.out.println("utfReader:" + utfReader.readLine());

System.out.println("##�ַ���ת�����ֽ���");
BufferedWriter defaultWriter = new BufferedWriter(
new OutputStreamWriter(System.out));
BufferedWriter gbkWriter = new BufferedWriter(new OutputStreamWriter(
System.out, "GBK"));
BufferedWriter utfWriter = new BufferedWriter(new OutputStreamWriter(
System.out, "UTF-8"));
System.out.print("defaultWriter:");
defaultWriter.write(str);
// ���ﲻ����close()����������System.outҲ���رգ����������
defaultWriter.flush();
System.out.print("\r\ngbkReader:");
gbkWriter.write(str);
gbkWriter.flush();
System.out.print("\r\nutfReader:");
utfWriter.write(str);
utfWriter.flush();

}
}

ִ�н��

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
D:\Source\learn\java-learning-code
��ǰJRE��1.8.0_171
��ǰJVM��Ĭ���ַ�����UTF-8
defaultCharset:UTF-8
##�ַ���ת����byte����
defaultByteArray:[-28, -72, -83, -26, -106, -121]
gbkByteArray:[-42, -48, -50, -60]
utfByteArray:[-28, -72, -83, -26, -106, -121]
##byte����ת�����ַ���
defaultStr:����
gbkStr:中文
utfStr:����
##�ֽ���ת�����ַ���
D:\Source\learn\java-learning-code
defaultReader:�й�
gbkReader:中国
utfReader:�й�
##�ַ���ת�����ֽ���
defaultWriter:����
gbkReader:????
utfReader:����

ʵ����

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package vip.infotech.charset;

import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
public class Code {
public static void main(String[] args) throws UnsupportedEncodingException {
System.out.println("��ǰJRE��" + System.getProperty("java.version"));
System.out.println("��ǰJVM��Ĭ���ַ�����" + Charset.defaultCharset());
System.out.println(System.getProperty("file.encoding")); //GBK
System.out.println(System.getProperty("user.language")); //zh
System.out.println(System.getProperty("user.region")); //CN

String str = "����" ;
byte[] codeByte=str.getBytes();//����
//eclipse�ļ�Ĭ��gbk--��gb2312��������ļ��޸ij�utf-8��ʽ������ֽ����getBytes("UTF-8"һ��)
//�����Ĭ�ϵ�GBKģʽdefault��ȡ���ֽ����gb2312һ��
System.out.println("default===="+bytesToHex(codeByte));
byte[] codeByteUTF=str.getBytes("UTF-8");//����
System.out.println("UTF-8===="+bytesToHex(codeByteUTF));
byte[] decodeGB= str.getBytes("gb2312") ; //����
System.out.println("gb2312===="+bytesToHex(decodeGB));
String codeGB = new String(decodeGB,"gb2312");//���� �������Ľ��벻�� ���ܳ�������
String codeUTF = new String(codeByteUTF,"UTF-8");//���� �������Ľ��벻�� ���ܳ�������
System.out.println("gb2312===="+codeGB);
System.out.println("UTF-8===="+codeUTF);
}


public static String bytesToHex(byte[] src) {
if (src == null || src.length <= 0) {
return null;
}
StringBuilder stringBuilder = new StringBuilder("");
for (int i = 0; i < src.length; i++) {
// ֮������byte��0xff���룬����Ϊint��32λ����0xff����������ǰ���24λ��ֻ������8λ
String str = Integer.toHexString(src[i] & 0xff);
if (str.length() < 2) { // ������λҪ��0
stringBuilder.append(0);
}
stringBuilder.append(str);
}
return stringBuilder.toString();
}
}

���

1
2
3
4
5
6
7
8
9
10
��ǰJRE��1.8.0_171
��ǰJVM��Ĭ���ַ�����UTF-8
UTF-8
zh
null
default====e5bca0e4b889
UTF-8====e5bca0e4b889
gb2312====d5c5c8fd
gb2312====����
UTF-8====����

ʵ����

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
package test;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.Arrays;
//java�ļ�Ϊgbk��utf-8�Ľ����֤�����е�ʱ��JVM��Ĭ���ַ��������java������ļ���ʽ��
public class Code2 {
public static void main(String[] args) throws IOException {
System.out.println("��ǰJRE��" + System.getProperty("java.version"));
System.out.println("��ǰJVM��Ĭ���ַ�����" + Charset.defaultCharset());
System.out.println(System.getProperty("file.encoding")); //GBK
System.out.println(System.getProperty("user.language")); //zh
System.out.println(System.getProperty("user.region")); //CN
InputStreamReader isr = new InputStreamReader(System.in, "iso8859-1");//�Ȱ�gbk������iso8859-1����
// Create an InputStreamReader that uses the given charset decoder
BufferedReader br = new BufferedReader(isr);
String strLine = br.readLine();
br.close();
isr.close();
System.out.println(strLine);
System.out.println(new String(strLine.getBytes(), "iso8859-1"));// ����ķ���gbk����-iso����
// Encodes this String (strLine) into a sequence of bytes using the
// platform's
// default charset(gb2312) then constructs a new String by decoding the
// specified array of bytes using the specified charset (iso8859-1)
// because this String (strLine) uses the charset decoder "iso8859-1",so
// it can
// only be encoded by "iso8859-1",cann't be encoded by the platform's
// default
// charset "gb2312",so this line is wrong.
System.out.println(new String(strLine.getBytes("iso8859-1")));// ��ȷ�ķ���iso���룬gbk����
// Encodes this String (strLine) into a sequence of bytes using the
// named
// charset (iso8859-1),then constructs a new String by decoding the
// specified array of bytes using the platform's default charset
// (gb2312).
// This line is right.
System.out.println(bytesToHex(strLine.getBytes("iso8859-1")));
System.out.println(new String("��������".getBytes("iso8859-1"),"iso8859-1"));
System.out.println(bytesToHex("��������".getBytes("iso8859-1")));//��������Ĭ�����ļ��������ԣ�gbk������ַ�����iso������ֽ���
String iso = new String("��������".getBytes("UTF-8"),"ISO-8859-1");
System.out.println(iso);
System.out.println(Arrays.toString(iso.getBytes("ISO-8859-1")));
System.out.println(new String(iso.getBytes("ISO-8859-1"),"UTF-8"));

iso = new String("��������".getBytes("GBK"),"ISO-8859-1");
System.out.println(iso);
System.out.println(Arrays.toString(iso.getBytes("ISO-8859-1")));
System.out.println(new String(iso.getBytes("ISO-8859-1"),"GBK"));
}
public static String bytesToHex(byte[] src) {
if (src == null || src.length <= 0) {
return null;
}
StringBuilder stringBuilder = new StringBuilder("");
for (int i = 0; i < src.length; i++) {
// ֮������byte��0xff���룬����Ϊint��32λ����0xff����������ǰ���24λ��ֻ������8λ
String str = Integer.toHexString(src[i] & 0xff);
if (str.length() < 2) { // ������λҪ��0
stringBuilder.append(0);
}
stringBuilder.append(str);
}
return stringBuilder.toString();
}
}

����

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
                �ļ�ΪGBK��ʽ�Ľ��
* ��ǰJRE��1.8.0_91
��ǰJVM��Ĭ���ַ�����GBK
GBK
zh
null
��������
????????
????????
��������
ced2ced2ced2ced2
????
3f3f3f3f
????????????
[-26, -120, -111, -26, -120, -111, -26, -120, -111, -26, -120, -111]
��������
????????
[-50, -46, -50, -46, -50, -46, -50, -46]
��������

�ļ�ΪUTF-8�Ľ��
��ǰJRE��1.8.0_91
��ǰJVM��Ĭ���ַ�����UTF-8
UTF-8
zh
null
��������
??��??��??��??��
?????��?????��?????��?????��
��������
e68891e68891e68891e68891
????
3f3f3f3f
??��??��??��??��
[-26, -120, -111, -26, -120, -111, -26, -120, -111, -26, -120, -111]
��������
????????
[-50, -46, -50, -46, -50, -46, -50, -46]
��������

��������֪ʶ

��Java�У�String��getBytes()�����ǵõ�һ������ϵͳĬ�ϵı����ʽ���ֽ����顣�����ʾ�ڲ�ͬ����£����صĶ�����һ����
String.getBytes(String decode)���������ָ����decode���뷵��ij�ַ����ڸñ����µ�byte�����ʾ���磺

1
2
3
4
5
6
7
8
9
10
11
12
13
14
byte[] b_gbk = "���".getBytes("GBK");
byte[] b_utf8 = "���".getBytes("UTF-8");
byte[] b_iso88591 = "���".getBytes("ISO8859-1");
byte[] b_unicode = "��������".getBytes("unicode");
System.out.println("length:"+b_gbk.length);
System.out.println("length:"+b_utf8.length);
System.out.println("length:"+b_iso88591.length);
System.out.println("length:"+b_unicode.length);
/**
* length:4
* length:6
* length:2
* length:10
*/

����getBytes��Եģ�����ͨ��new String(byte[], decode)�ķ�ʽ����ԭ��������ʱ�����new String(byte[], decode)ʵ����ʹ��decodeָ���ı�������byte[]�������ַ�����

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
String utf8 = new String(b_utf8, "UTF8");
System.out.println(utf8);
String gbk = new String(b_gbk, "GBK");
System.out.println(gbk);
String s = new String(b_iso88591, "ISO8859-1");
System.out.println(s);
String unicode = new String(b_unicode, "unicode");
System.out.println(unicode);

/**
* ���
* ���
* ??
* ��������
*/
     һ������           һ���ַ�

UTF8 3 1
GBK 2 1
ISO88591 1 1
Unicode 2n+2 2n+2

java gbkתutf8

�ҵ������

û�в���ǰ��spring boot��Ŀ��ǰ̨����IJ��������ʽ��utf8
�ڴ��jar����ǰ̨����IJ��������ʽ��gbk

���룺

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
String reqUrl = "";
String str = new String(reqUrl.getBytes(), "gbk");
byte[] bytes = str.getBytes(StandardCharsets.UTF_8);
reqUrl = new String(bytes);


��ʵ�������ж�������ʽ���ٽ��б����ʽ��ת������
String iso8859 = new String(reqUrl.getBytes("iso8859-1"));
String gbk = new String(reqUrl.getBytes("gbk"));
if(iso8859.equals(reqUrl)){
String str = new String(reqUrl.getBytes(), "iso8859-1");
byte[] bytes = str.getBytes(StandardCharsets.UTF_8);
reqUrl = new String(bytes);
System.out.println("iso8859");
}else if(gbk.equals(reqUrl)){
String str = new String(reqUrl.getBytes(), "gbk");
byte[] bytes = str.getBytes(StandardCharsets.UTF_8);
reqUrl = new String(bytes);
System.out.println("gbk");
}

java�ַ���ת�����⣺��utf-8ת��gbk��ת��utf-8Ϊʲô����ֲ��������أ�

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Test {
public static void main(String[] args) throws Exception {

String a = "�Һܺ�";
String b=new String(a.getBytes("utf-8"),"gbk");
System.out.println(b);
String c=new String(b.getBytes("gbk"),"utf-8");
System.out.println(c);

}

}

�����
我很�?
�Һ�??

���谡�����岻�ǽ��ϵİ����ڲ����Ƚϸ��ӣ���ÿ������UTF-8������Ҫʹ��3���ֽڣ�ÿ������GBK������Ҫ2���ֽڡ��ã��������ڿ�ʼת����
�ȿ�����ɣ�a.getBytes(“utf-8”),”gbk”������������UTF-8������ֽ����飬�ţ������ռ9���ֽڰ�������ֽ�������GBK������ַ�����ÿ��ȡ�������ֽڷ����һ���֣�����ǰ8���ֽ��ƺ�û��ʲô̫�����⣨��ʵ�����⣬����˵�����������4���֡�Ȼ��ֻʣһ���ֽ��ˣ���Ҫ��ô�㣬�˼��Լ�������һ���ֽڣ��ճ�������Ȼ���ٷ��롣
Ҳ����˵һ����5���ֶ԰ɣ��㿴����������我很�?�ٿ����������b.getBytes(“gbk”),”utf-8”�ѡ�我很�?����GBK������ֽ����飬���ûʲô����ɣ��ͷ������������10���ֽڣ����һ���ֽ������Լ��ӵģ�����10���ֽ���UTF-8������ַ�������ȡ����������������ң���ȡ��������������˺ܣ���ȡ���������ƺ�û�з���ɺð����������ģ�����˵�ġ���ʵ���������������������ȡ�������ֽڣ�����GBK��һ���ж�Ӧ���ְ���û�ж�Ӧ����ô�죬��һ���ȽϽӽ��Ĵ��棬Ҳ����˵ԭ�����ֽ����鱻�ı��ˡ����������ڷ����ȥ�ͳ������⡣
���ʣһ���ֽڰ��������������Լ��ӵ��Ǹ���������Ҫ�����ֽڲ��ܷ��밡���Ǿ��ټ������£��ʹճ������ˣ�������������֪Ҫ�����ʲô���߰�����������
���Ծ�����ķ�����������������������������ַ���ʱ��ȡ�����ɸ��ֽڣ�����������������û����֮��Ӧ���֣�ʹ�������ӽ��Ĵ���ǰ��ÿ��ȡ�����������붼�ܿ��ģ�����ֲ����ˣ�Ҫ�Լ��Ӽ����ֽڲ��ܷ���һ��ʹ��Tomcat��ʱ����Ĭ��ʹ��ISO-8859-1������Servlet�淶Ҫ��ģ�����������������ľ�Ҫ���룬������������ˣ�������ô�㰡��

1
2
3
4
5
String a = "�Һܺ�";
String b=new String(a.getBytes("utf-8"),"ISO-8859-1");
System.out.println(b);
String c=new String(b.getBytes("ISO-8859-1"),"utf-8");
System.out.println(c);

�ܶ���ʦ������ʪ���������ô˵�ɣ����һ�����ⶼû�С�ISO-8859-1һ��ֻҪһ���ֽڣ�����ʹ���˵��ֽ��ڵ����пռ䣬���仰˵�����һ���ֽڣ��Ҷ��ܸ��㷭�룬�����������1��˵��������ÿ��ֻҪһ���ֽڣ���Ȼ�Ͳ���������2��˵��������������ok�ġ�

���۾��Dz���UTF8תGBK��Ȼ����GBKתUTF8���ᶪʧ���룬������GBKתUTF8����ʹ��GBK������GBK�ֽ��룬Ȼ����ת���UTF8�����ܰ�GBK������ֽ�������UTF8������ַ�����
��������ļ��������GBK���룬java����getName��ʱ��ʹ�õ��ֽ�����GBK�ģ�����ʹ����UTF8�����з�����ַ������������ͳ������ˡ�

java��GBKתUTF-8������ν��

����С�����ҷ�������java��GBKתUTF-8������ν�������źܶ��˶���̫�˽⣬Ϊ���ô�Ҹ����˽�GBKתUTF-8����Ľ�����������Ը�����ܽ����������ݣ�һ�����¿��ɡ�һ���������ջ��Ŷ��

java��GBKתUTF-8����Ľ������

����Լ����õ���GBK���룬�Է����õõ���UTF-8���룬��������ʱ��Ҫ��GBK��������ת����UTF-8�������ݣ������Է��Ų������롣

������֣�GBKתUTF-8ʱ�����������Ļ����룬ż�������IJ������롣

ԭ�������

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void analyze() throws UnsupportedEncodingException {
String gbk = "������";
String utf8 = new String(gbk.getBytes("UTF-8"));
for (byte b : gbk.getBytes("UTF-8")) {
System.out.print(b + " ");
}
System.out.println();
for (byte b : utf8.getBytes()) {
System.out.print(b + " ");
}
}
/*
-26 -120 -111 -26 -99 -91 -28 -70 -122
-26 -120 -111 -26 -99 -91 -28 -70 63 !
*/

ע�����һ���ֽڲ�ͬ������һ�в�����ȷ��UTF-8���롣��ôΪʲô����һ�����һ���ֽ���63��������-122�أ�����ǵ��������ԭ�����ڡ�
GBK������һ������2���ֽڣ���UTF-8������һ������3���ֽڣ������ǵ���getBytes(“UTF-8”)����ʱ����ͨ�������������ֽڣ�ʹ�ô�GBK��2���ֽڱ��UTF-8��Ӧ��3���ֽڡ���ˣ�����3�����������9���ֽڡ�
�������
��֤�ֽ���ȷ����Ӳ������������getBytes(“UTF-8”)ת�����ֽ�����󣬴���ISO-8859-1������ַ�����ISO-8859-1������һ���ֽڶ�Ӧһ���ַ�����˲���ʹ���һ���ֽڴ���

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void correctEncode() throws UnsupportedEncodingException {
String gbk = "������";
String iso = new String(gbk.getBytes("UTF-8"),"ISO-8859-1");
for (byte b : iso.getBytes("ISO-8859-1")) {
System.out.print(b + " ");
}
System.out.println();
//ģ��UTF-8�������վ��ʾ
System.out.println(new String(iso.getBytes("ISO-8859-1"),"UTF-8"));
}
/*
-26 -120 -111 -26 -99 -91 -28 -70 -122
������
*/

����java��GBKתUTF-8������ν���ͷ����������ˣ�ϣ���������ݿ��ԶԴ����һ���IJο���ֵ������ѧ�����á����ϲ����ƪ���£���������������ȥ�ø�����˿�����

���ַ����������ļ������룬��Ҫ�ӵײ㿪ʼ�ģ������inotify�͸�inotify��д��Cģ�飬���������ַ�����iso8859-1������java��߾��а취ת���ˣ������File()Ҳһ��������Ҫ�޸ĵײ�jdkԴ�룬Ҫ֧�ֶ��ֱ���϶������޸�ȫ�ֱ����ģ���Ȼ�����Ե����ⲿ�����ȡ�ļ�������ȷ�ֽ��룬����JNIдһ��Cģ��������Ҳ�ǿ��Եģ�Ҳ���Ե���convmv ����ͨ���������ʵ��ת�롣Ҳ���ǿ����Ҳ����ļ�������ʱ����convmvת�����ٴδ��������ǻ�Ҫ������ѭ������ת�������

�ο�