Exemple d'analyse de flux de caractères Java

1. L'origine du flux de caractères

Comme il n'est pas très pratique d'utiliser un flux d'octets pour contrôler le chinois, Java fournit un flux de caractères pour contrôler le chinois

Principe d'implémentation : flux d'octets + table d'encodage

Pourquoi utiliser Is y a-t-il un problème lors de la copie de fichiers texte contenant des caractères chinois dans le flux d'octets ?

Parce que l'opération sous-jacente fusionnera automatiquement les octets en chinois

Comment identifier que l'octet est chinois ?

Lorsque des caractères chinois sont stockés, qu'il s'agisse d'UTF-8 ou de GBK, le premier octet est un nombre négatif à inviter

2. Table de codage

Jeu de caractères :

est un ensemble de tous les caractères pris en charge par le système, y compris les caractères nationaux, les signes de ponctuation, les symboles graphiques, les chiffres, etc.

Pour stocker et reconnaître avec précision divers symboles de jeux de caractères, un ordinateur a besoin d'un codage de caractères. Un ensemble de jeux de caractères doit avoir au moins un ensemble d'encodages de caractères

Caractère commun. les jeux incluent le jeu de caractères ASCII, le jeu de caractères GBXXX, le jeu de caractères Unicode, etc.

GBK : La table de codes chinois la plus couramment utilisée est une spécification étendue basée sur la norme GB2312. Elle utilise un schéma de codage à deux octets et contient un total de. 21 003 caractères chinois. Il est entièrement compatible avec la norme GB2312, il prend également en charge les caractères chinois traditionnels, les caractères chinois japonais et coréens, etc.

GB18030 : La dernière table de codes chinois, contenant 70 244 caractères chinois, utilisant un codage multi-octets, chaque caractère. peut être composé de 1, 2 ou 4 octets. Prend en charge les caractères des minorités ethniques chinoises, ainsi que les caractères chinois traditionnels, les caractères chinois japonais et coréens, etc.

Jeu de caractères Unicode :

Conçu pour exprimer n'importe quel caractère dans n'importe quelle langue, il s'agit d'un standard dans l'industrie, également connu comme Unicode et Standard Universal Code ; il utilise jusqu'à 4 octets de chiffres pour représenter chaque lettre, symbole ou texte. Il existe trois schémas d'encodage : UTF-8, UTF-16, UTF32. Le plus couramment utilisé est UTF-8

UTF-8 : il peut être utilisé pour représenter n'importe quel caractère de la norme Unicode. Il est utilisé pour le courrier électronique et le Web. pages et autres stockages ou transmissions. Dans les applications de fichiers, l'encodage est préféré. L'Internet Working Group exige que tous les protocoles Internet prennent en charge le format de codage UTF-8. Il utilise un à quatre octets pour encoder chaque caractère

Règles d'encodage UTF-8 :

128 caractères US-ASCII, n'ont besoin que d'un octet pour encoder

Caractères latins et autres, ont besoin de deux octets pour encoder

Caractères les plus couramment utilisés (y compris le chinois) sont codés sur trois octets

D'autres caractères auxiliaires UniCode rarement utilisés sont codés sur quatre octets

Résumé : quels types de règles sont utilisés lors de l'encodage et les règles correspondantes doivent être utilisées pour le décodage, sinon elles seront tronquées

3. Problèmes d'encodage et de décodage dans les chaînes

Méthode d'encodage (IDEA) :

byte[] getBytes() : utilisez le jeu de caractères par défaut de la plateforme pour encoder la chaîne en une série d'octets et convertir le résultat stocké dans un nouveau tableau d'octets

byte[] getBytes(String charsetName) : Utilisez le jeu de caractères spécifié pour encoder la chaîne dans une série d'octets et stockez le résultat dans un nouveau tableau d'octets

Méthode de décodage (IDEA) :

String( byte[]bytes) : construit une nouvelle chaîne en décodant le tableau d'octets spécifié à l'aide du jeu de caractères par défaut de la plateforme

String(byte[]bytes,String charsetName) : décodant le tableau d'octets spécifié à l'aide du jeu de caractères par défaut de la plateforme. Tableau d'octets à construire une nouvelle chaîne

Le format d'encodage par défaut dans IDEA est UTF-8

IV. Problèmes d'encodage et de décodage du flux de caractères

Classe de base abstraite du flux de caractères :

Lecteur : classe abstraite du flux d'entrée de caractères

Writer : classe abstraite de flux de sortie de caractères

Deux classes liées aux problèmes d'encodage et de décodage dans le flux de caractères :

InputStreamReader : il s'agit d'un pont entre le flux d'octets et le flux de caractères : il lit les octets et utilise le jeu de caractères spécifié pour le décoder en caractères. Le jeu de caractères qu'il utilise peut être spécifié par son nom, peut être spécifié explicitement ou peut accepter le jeu de caractères par défaut de la plate-forme

Méthode Constructor :

InputStreamReader(InputStream in)	Créer un InputStreamReader qui utilise le jeu de caractères par défaut .
InputStreamReader(InputStream in, String charsetName)	Crée un InputStreamReader qui utilise un jeu de caractères nommé.

OutputStreamWruter : C'est un pont entre le flux de caractères et le flux d'octets : il utilise un jeu de caractères personnalisé pour coder les caractères écrits en octets. Le jeu de caractères qu'il utilise peut être spécifié par son nom ou explicitement spécifié. jeu de caractères par défaut de la plateforme

Méthode de construction :

OutputStreamWriter(OutputStream out)	Créez un OutputStreamWriter en utilisant l'encodage de caractères par défaut.
OutputStreamWriter(OutputStream out, String charsetName)	Créez un OutputStreamWriter qui utilise un jeu de caractères nommé.

public class ConversionStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建一个默认编码格式的InputStreamReader\OutputStreamWriter
        InputStreamReader ipsr = new InputStreamReader(new FileInputStream("E:\\abc.txt"));
        OutputStreamWriter opsw = new OutputStreamWriter(new FileOutputStream("E:\\abc.txt"));
        //写入数据
        opsw.write("你好啊");
        opsw.close();
        //读数据，方式一：一次读取一个字节数据
        int ch;
        while ((ch = ipsr.read()) != -1) {
            System.out.print((char) ch);
        }
        ipsr.close();

    }
}

四、字符流写数据的五种方法

方法名	说明
void write(int c)	写一个字符
void write(char[] cbuf)	写入一个字符数组
void write(char[] cbuf,int off,int len)	写入字符数组的一部分
void write(String str)	写入一个字符串
void write(String str,int off,int len)	写入一个字符串的一部分

字符流写数据需要注意缓冲区的问题，如果想要将缓冲区的数据加载出来需要在写入方法后加上刷新方法flush();

前三个方法与字节流写入方法使用相同，这里重点介绍下面两种方式

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        //创建一个默认编码格式的OutputStreamWriter对象
        OutputStreamWriter opsw=new OutputStreamWriter(new FileOutputStream("E:\\abc.txt"));
        //方式一：写入一个字节
        opsw.write(97);
        opsw.flush();//如果需要在文件中立即显示输入的数据，就需要加入刷新方法
        //方式二：写入一个字符数组
        char[]ch={'a','b','c','二'};
        opsw.write(ch);
        opsw.flush();//如果需要在文件中立即显示输入的数据，就需要加入刷新方法
        //方式三：写入一个字符数组的一部分
        opsw.write(ch,0,2);
        opsw.flush();//如果需要在文件中立即显示输入的数据，就需要加入刷新方法
        //方式四：写入一个字符串
        opsw.write("一二三");
        opsw.flush();//如果需要在文件中立即显示输入的数据，就需要加入刷新方法
        //方式五：写入一个字符串的一部分
        opsw.write("三四五",1,2);
        opsw.flush();//如果需要在文件中立即显示输入的数据，就需要加入刷新方法
    }
}

五、字符流读数据的两种方法

方法名	说明
int read()	一次读取一个字符数据
int read(char[] cbuf)	一次读取一个字符数组数据

public class InputStreamReadDemo {
    public static void main(String[] args) throws IOException {
        //创建一个默认编码格式的InputStreamReader
        InputStreamReader ipsr=new InputStreamReader(new FileInputStream("E:\\abc.txt"));
        //读取数据，方式一一次读取一个字符数据
        int ch;
        while ((ch=ipsr.read())!=-1){
            System.out.print((char) ch);
        }
        ipsr.close();
        //方式二：一次读取一个字符数组数据
        char []ch=new char[1024];
        int len;
        while ((len=ipsr.read(ch))!=-1){
            System.out.print(new String(ch,0,len));
        }
        ipsr.close();
    }
}

小结：如果使用默认编码格式的话，那么字符输入流InputStreamReader可以使用子类FileReader来替代，字符输出流OutputStreamWriter可以使用其子类FileWriter来替代，两者在使用默认编码格式的情况下作用一致。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!