Le bilan de l'utilisation des connaissances de base de java io et le codage liés
Je dois dire que , java io classes associées un lot de celui - ci, chaque fois que nous avons tous senti un peu chaotique, ne pas l' intention temporairement en savoir trop, la première partie de l' apprentissage, peut effectuer des opérations de base, peut être utilisé sur la ligne.
Source https://www.codercto.com/courses/d/1491.html
java io quelqu'un d' autre a écrit une série de tutoriels
java io classes associées peut être divisé en le personnage principal et un octet
À cet égard , je suis aussi sur l'autre blog pour apprendre, est l'image description ci - dessus, le sentiment selon ces deux méthodes pour distinguer, alors il est plus facile à comprendre
dans io, je préfère encore l'approche c / c ++ langue, par un caractère type peut résoudre tous les problèmes, bien que cette façon ne peut pas être facile à utiliser java io
Ce qui suit est un bref exposé sur la différence entre le caractère et l'octet type de io
Byte io, qui est, lorsque l'unité de base en octets lus. Tout dans l'ordinateur, en substance, est la représentation binaire
du code ascii de base, vous devez utiliser un octet (8 binaire) représentent directement l'unité de base que l' on peut lire à partir d' un fichier est le mot section.
nous pourrions envisager ici pourquoi pas un peu, mais l' octet, (compréhension personnelle, peu, alors que deux états, ne suffit pas à distinguer la base des caractères imprimables, qui est le code ascii par l'octet serait relativement facile, une fois supprimer 8 bits, une valeur qui est très facile de faire la distinction entre les différents caractères, il y a une raison d'être la plus petite unité de mémoire et l'ordinateur est une relation octets)Caractère io, par rapport à l'octet peut être considéré comme un langage de programmation pour vous aider à faire un pas, il lit l'ordre des octets, selon la table de codage, si elle est jugée pas un caractère valide, il continuerait à lire jusqu'à la formation un caractère valide. Ce codage a une relation. Pour un exemple courant, le nombre d'octets occupés par différents personnages dans différents codes, en caractères
GBKlorsque codés, 2 octets pour leutf-8codage, occupe 3 octets. Donc , dans les deux cas, nous pouvons décrire le travail de java caractère io, le java lors de la lecture汉du premier octet dans laGBKtable de codage ne peut pas trouver les caractères d'octets correspondant dans ce qu'il même après l' avoir lu à nouveau, va lire un octet, et un octet avant la fusion aller vérifier la table de codage pour trouver le caractère correspondant est汉le mot, en fait, ne se termine pas ici, parce que l'utilisation de char java 2 octets elle représente un personnage, de sorte que le java interne a également besoin de汉trouver une valeur char mot correspondant (compréhension personnelle, se sentant de plus en plus de mal). Autre codage est le même.
Afin d'expliquer la relation entre les deux, avec une brève explication au sujet du programme de langue c, ici vous verrez la console d'opération de décodage sur un caractère similaire io java
#include <stdio.h>
#include <string.h>
int main()
{
const char* str = "汉字";
int len = strlen(str);
printf("len is %d\n", len);
// 以 char 形式 逐个输出
for (int i = 0; i < len; i++) {
printf("%c", str[i]);
}
puts("");
return 0;
}- Créer une nouvelle test.c, définir le format de codage
GBK, dans des circonstances normales, la sortie de la console sur les fenêtres estlen = 4alors sortie汉字
si l' on met dans l'entrée de la consolechcp 65001, la console , la page de code actif modifié comme utf-8, qui est, laissez console utf-8 flux d'octets décodés sortie, la sortie peut être observélen = 4,汉字il n'y a pas de sortie de distorsion ou le symbole de sortie. (Notez que le programme devrait être modifié pour fonctionner dans une fenêtre de la page active dans le présent, parce que nous modifions une seule valide) - Ibid., Cette fois , nous allons définir le format de codage de texte est
utf-8le même test, il a été constaté que lorsque la page de code de la console active pour modifierutf-8l'ordre de la production normale, tout en étant capable de voirlen = 6
Ou à leur dossier que, si vous pouvez utiliser des outils xxd de Linux, vous pouvez utiliser cet outil pour afficher des caractères binaires de codage différent dit, d' abord , nous pouvons déterminer tout, pour GBKet utf8, Kanji dit dans le texte est différent pour la langue c , il ne se soucie pas de codage de texte, il sera tout lecteur binaire, compilé, la sortie de texte est une sortie binaire correspondant à afficher des résultats différents parce que la méthode de décodage console. le caractère de io ainsi.
Io apprentissage sur l'opération d'enregistrement
- Io caractère à lire et les fichiers d'écriture
package Learn.Io;
import java.io.*;
public class DemoFirst {
/**
* 按字符依次读取
*/
void readForeach() throws IOException {
final int MAX_SIZE = 1024; // 如果不能估计 文件字符个数，最好不要使用常量
char[] save = new char[MAX_SIZE];
FileReader in = new FileReader("./File/test.txt");
int charValue, count = 0;
while (-1 != (charValue = in.read())) {
save[count++] = (char) charValue;
}
in.close();
System.out.println(String.valueOf(save, 0, count));
}
/**
* 一次性读取到 char 数组中
* @throws IOException
*/
void readOnce() throws IOException {
final int MAX_SIZE = 1024;
FileReader in = new FileReader("./File/test.txt");
char[] data = new char[MAX_SIZE];
int num = in.read(data);
in.close();
System.out.println(String.valueOf(data, 0, num));
}
/**
* 字符方式写入文件
* @throws IOException
*/
void write() throws IOException {
// 文件内容会被清除
FileWriter out = new FileWriter("./File/test.txt");
String str = "待写入字符";
char[] s = {'测', '试', '一', '下'};
out.write(str);
out.write(s, 0, 2);
out.flush();
out.close(); // 关闭时会进行一次 flush 不过还是显式写一下比较好
}
public static void main(String[] args) throws IOException{
DemoFirst test = new DemoFirst();
test.readForeach();
test.readOnce();
test.write();
}
}- lecture d'octets et fichiers d'écriture
package Learn.Io;
import java.io.*;
public class ioByChar {
File file = new File("./File/test.txt");
/**
* 循环处理文本
* @throws IOException
*/
void readForeach() throws IOException {
InputStream read = new FileInputStream(file);
int byteValue, count = 0;
byte[] data = new byte[1024];
while (-1 != (byteValue = read.read())) {
data[count++] = (byte) byteValue;
}
System.out.println(new String(data, 0, count));
}
/**
* 一次将文本全部加载到 内存
* @throws IOException
*/
void readOnce() throws IOException {
InputStream in = new FileInputStream(file);
byte[] data = in.readAllBytes();
System.out.println(new String(data, 0, data.length));
}
/**
* 按字节写入
* @throws IOException
*/
void write() throws IOException {
OutputStream out = new FileOutputStream(file);
String str = "写入文本";
byte[] data = str.getBytes();
out.write(data, 0, data.length);
out.flush();
out.close();
}
/**
* 复制文件 //
* @param src 源文件
* @param dst 目的文件
* @throws IOException
*/
void copy(File src, File dst) throws IOException {
InputStream a = new FileInputStream(src);
OutputStream b = new FileOutputStream(dst, true);
a.transferTo(b);
a.close();
b.close();
}
public static void main(String[] args) throws IOException {
ioByChar test = new ioByChar();
test.readForeach();
test.readOnce();
test.write();
test.copy(new File("./File/src.txt"), new File("./File/dst.txt"));
}
}- io tampon
tampon io io par rapport au grand équivalent à l' ajout d' une couche d'emballage, en utilisant un tampon pour éviter l' accès aux fichiers multiples, et non mis en cache dans le procédé de base
package Learn.Io;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
/**
* 这里只写了 BufferedReader BufferedWriter
* 还有 BufferedInputStream 和 BufferedOutputStream
*/
public class bufferIo {
static final String filePath = "./File/test.txt";
/**
* 按行处理
* @throws IOException
*/
void lineRead() throws IOException {
// BufferedInputStream 不能按行处理
BufferedReader charRead = new BufferedReader(new FileReader(filePath));
String read;
List<String> data = new ArrayList<>();
while (null != (read = charRead.readLine())) {
data.add(read);
}
System.out.println(data.toString());
charRead.close();
// 使用 Stream 处理
// BufferedReader ano = new BufferedReader(new FileReader(filePath));
// ano.lines().map((e) -> e + '|' + e.length()).forEach(System.out::println);
// ano.close();
}
/**
*
* @throws IOException
*/
void Write() throws IOException {
BufferedWriter out = new BufferedWriter(new FileWriter(filePath));
out.write("line 1");
out.newLine();
out.write("line 2");
out.flush();
out.close();
}
public static void main(String[] args) throws IOException {
bufferIo s = new bufferIo();
s.lineRead();
s.Write();
}
}- Lire et fichiers d'écriture selon un codage spécifié
package Learn.Io;
import java.io.*;
public class fileIo {
/**
* 读取指定编码的文件
* 这里关心文件的编码 所以使用 Reader 和 Writer
* @param filePath 文件路径
* @param encoding 文件编码
*/
void read(String filePath, String encoding) throws IOException {
File file = new File(filePath);
InputStreamReader in = new InputStreamReader(new FileInputStream(file), encoding);
char[] data = new char[1024];
in.read(data);
in.close();
System.out.println(data);
}
/**
* 使用 bufferIo 读取
* @param filePath
* @param encoding
* @throws IOException
*/
void bufferRead(String filePath, String encoding) throws IOException {
File file = new File(filePath);
BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(file), encoding));
// Stream 很方便
in.lines().forEach(System.out::println);
in.close();
}
/**
* 字节流读取，使用 String 解码
* 这种方式没有 字符流安全，按字节读取有可能读取到某个字符的一部分就终止了
* 这时如果使用 字符集去解码，就会造成问题
* 如果是要将文件整体读入，作为一个字符串处理，则可以用这种方式
* @param filePath
* @param encoding
*/
void byteRead(String filePath, String encoding) throws IOException {
File file = new File(filePath);
InputStream in = new FileInputStream(file);
byte[] data = in.readAllBytes();
System.out.println(new String(data, encoding));
}
/**
* 输出与上述相反，Reader <=> Writer Input <=> Output 就不写了
*/
void write() {
}
public static void main(String[] args) throws IOException {
fileIo rw = new fileIo();
rw.read("./File/test.txt", "gbk");
rw.read("./File/test.txt", "gbk");
}
}- données formatées
package Learn.Io;
import java.io.*;
import java.util.stream.IntStream;
public class formatIo {
/**
* 利用 printf 格式化数据写入文件
* @throws FileNotFoundException
*/
void writeFormatDataToFile() throws FileNotFoundException {
PrintWriter out = new PrintWriter("./File/test.txt");
IntStream.range(0, 10).forEach(e -> out.printf("number of this line is %3d\n", e));
out.flush();
out.close();
}
/**
* 格式化数据输入 字符串
* @throws IOException
*/
void formatDataToString() throws IOException {
StringWriter str = new StringWriter();
PrintWriter w = new PrintWriter(str);
w.printf("10 的 16进制表示 : %#06x", 10);
w.flush();
w.close();
str.close();
System.out.println(str);
}
public static void main(String[] args) throws IOException {
formatIo rw = new formatIo();
rw.writeFormatDataToFile();
rw.formatDataToString();
}
}- autres
package Learn.Io;
import java.io.*;
public class vector {
/**
* 感觉 java 中的 ByteArrayOutputStream CharArrayWriter 实现的功能类似 c++ 中的 vector
* @throws IOException
*/
void readIntoByteArray() throws IOException {
InputStream in = new FileInputStream("./File/test.txt");
ByteArrayOutputStream data = new ByteArrayOutputStream();
int num;
while (-1 != (num = in.read())) {
data.write(num);
}
in.close();
System.out.println(data);
}
/**
* 使用 StringReader 和 StringWriter
* @throws IOException
*/
void rwString() throws IOException {
String str = "this is a string";
StringReader in = new StringReader(str);
StringWriter out = new StringWriter();
PrintWriter w = new PrintWriter(out);
w.println("first line");
in.transferTo(out); // 输入流传送到输出流
in.close();
out.close();
System.out.println(str);
System.out.println("---------------");
System.out.println(out);
}
public static void main(String[] args) throws IOException {
vector s = new vector();
s.readIntoByteArray();
s.rwString();
}
}