Flux Java、Fichier、IO
Le package Java.io contient presque toutes les classes nécessaires pour faire fonctionner les entrées et les sorties. Toutes ces classes de flux représentent des sources d'entrée et des destinations de sortie.
Les flux du package Java.io prennent en charge de nombreux formats, tels que les types de base, les objets, les jeux de caractères localisés, etc.
Un flux peut être compris comme une séquence de données. Un flux d'entrée représente la lecture de données à partir d'une source et un flux de sortie représente l'écriture de données vers une destination.
Java offre une prise en charge puissante et flexible des E/S, ce qui le rend plus largement utilisé dans le transfert de fichiers et la programmation réseau.
Mais cette section décrit les fonctions les plus basiques liées aux flux et aux E/S. Nous apprendrons ces fonctions à travers des exemples un par un.
Lire l'entrée de la console
L'entrée de la console de Java est complétée par System.in.
Pour obtenir un flux de caractères lié à la console, vous pouvez créer un flux de caractères en encapsulant System.in dans un objet BufferedReader.
Ce qui suit est la syntaxe de base pour créer un BufferedReader :
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Après la création de l'objet BufferedReader, nous pouvons utiliser la méthode read() pour lire un caractère depuis la console, ou utiliser le Méthode readLine() pour lire une chaîne.
Lire l'entrée multi-caractères depuis la console
Pour lire un caractère à partir d'un objet BufferedReader, utilisez la méthode read() Sa syntaxe est la suivante :
int read( ) throws IOException<. 🎜>Chaque Lorsque la méthode read() est appelée, elle lit un caractère dans le flux d'entrée et renvoie le caractère sous forme de valeur entière. Renvoie -1 à la fin du flux. Cette méthode lève IOException. Le programme suivant montre l'utilisation de la méthode read() pour lire en continu les caractères de la console jusqu'à ce que l'utilisateur saisisse « q ».
// 使用 BufferedReader 在控制台读取字符
import java.io.*;
public class BRRead {
public static void main(String args[]) throws IOException
{
char c;
// 使用 System.in 创建 BufferedReader
BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
System.out.println("Enter characters, 'q' to quit.");
// 读取字符
do {
c = (char) br.read();
System.out.println(c);
} while(c != 'q');
}
}Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :Enter characters, 'q' to quit. 123abcq 1 2 3 a b c q
La lecture d'une chaîne depuis la consoleLa lecture d'une chaîne à partir de l'entrée standard nécessite en utilisant la méthode readLine de BufferedReader (). Son format général est :
String readLine( ) throws IOExceptionLe programme suivant lit et affiche des lignes de caractères jusqu'à ce que vous saisissiez le mot "fin".
// 使用 BufferedReader 在控制台读取字符
import java.io.*;
public class BRReadLines {
public static void main(String args[]) throws IOException
{
// 使用 System.in 创建 BufferedReader
BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
String str;
System.out.println("Enter lines of text.");
System.out.println("Enter 'end' to quit.");
do {
str = br.readLine();
System.out.println(str);
} while(!str.equals("end"));
}
}Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :Enter lines of text. Enter 'end' to quit. This is line one This is line one This is line two This is line two end end
Dans les versions postérieures au JDK 5, nous pouvons également utiliser la classe Java Scanner pour obtenir les entrées de la console.Sortie de la consoleComme mentionné précédemment, la sortie de la console est complétée par print() et println(). Ces méthodes sont définies par la classe PrintStream et System.out est une référence à l'objet de cette classe. PrintStream hérite de la classe OutputStream et implémente la méthode write(). De cette façon, write() peut également être utilisé pour écrire des opérations sur la console. PrintStream La forme la plus simple de définition de write() est la suivante :
void write(int byteval)Cette méthode écrit l'octet inférieur de l'octet dans le flux. ExempleL'exemple suivant utilise write() pour afficher le caractère « A » et le caractère de nouvelle ligne suivant à l'écran :
import java.io.*;
// 演示 System.out.write().
public class WriteDemo {
public static void main(String args[]) {
int b;
b = 'A';
System.out.write(b);
System.out.write('\n');
}
}Exécutez l'exemple ci-dessus pour afficher dans le caractère "A" de la fenêtre de sortieA
Remarque : La méthode write() n'est pas souvent utilisée car les méthodes print() et println() sont plus pratiques à utiliser.
Lecture et écriture de fichiers Comme mentionné précédemment, un flux est défini comme une séquence de données. Le flux d'entrée est utilisé pour lire les données de la source et le flux de sortie est utilisé pour écrire des données sur la cible. La figure suivante est un diagramme hiérarchique de classes décrivant le flux d'entrée et le flux de sortie.
Les deux flux importants qui seront abordés ci-dessous sont FileInputStream et FileOutputStream :
FileInputStream
Ce flux est utilisé pour lire les données de un fichier, ses objets peuvent être créés à l'aide du mot-clé new.
Il existe différentes méthodes de construction utilisées pour créer des objets.
Vous pouvez utiliser un nom de fichier chaîne pour créer un objet de flux d'entrée pour lire le fichier :
InputStream f = new FileInputStream("C:/java/hello");Vous pouvez également utiliser un objet fichier pour créer un objet de flux d'entrée pour lire le fichier. Nous devons d'abord utiliser la méthode File() pour créer un objet fichier :
File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);Après avoir créé l'objet InputStream, vous pouvez utiliser les méthodes suivantes pour lire le flux ou effectuer d'autres opérations sur le flux.
| 序号 | 方法及描述 |
|---|---|
| 1 | public void close() throws IOException{} 关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。 |
| 2 | protected void finalize()throws IOException {} 这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。 |
| 3 | public int read(int r)throws IOException{} 这个方法从InputStream对象读取指定字节的数据。返回为整数值。返回下一字节数据，如果已经到结尾则返回-1。 |
| 4 | public int read(byte[] r) throws IOException{} 这个方法从输入流读取r.length长度的字节。返回读取的字节数。如果是文件结尾则返回-1。 |
| 5 | public int available() throws IOException{} 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取的字节数。返回一个整数值。 |
En plus d'InputStream, il existe d'autres flux d'entrée. Pour plus de détails, veuillez vous référer au lien ci-dessous :
ByteArrayInputStream
- <🎜. >DataInputStream
FileOutputStreamCette classe est utilisée pour créer un fichier et écrire des données dans le fichier. Si le fichier cible n'existe pas avant que le flux n'ouvre le fichier pour la sortie, alors le flux créera le fichier. Il existe deux constructeurs qui peuvent être utilisés pour créer des objets FileOutputStream. Utilisez un nom de fichier chaîne pour créer un objet de flux de sortie :
OutputStream f = new FileOutputStream("C:/java/hello")Vous pouvez également utiliser un objet fichier pour créer un flux de sortie afin d'écrire des fichiers. Nous devons d'abord utiliser la méthode File() pour créer un objet fichier : File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);Après avoir créé l'objet OutputStream, vous pouvez utiliser les méthodes suivantes pour écrire dans le flux ou effectuer d'autres opérations sur le flux. En plus d'OutputStream, il existe d'autres flux de sortie. Pour plus de détails, veuillez vous référer au lien ci-dessous :
ByteArrayOutputStream
- <🎜. >DataOutputStream
import java.io.*;
public class fileStreamTest{
public static void main(String args[]){
try{
byte bWrite [] = {11,21,3,40,5};
OutputStream os = new FileOutputStream("test.txt");
for(int x=0; x < bWrite.length ; x++){
os.write( bWrite[x] ); // writes the bytes
}
os.close();
InputStream is = new FileInputStream("test.txt");
int size = is.available();
for(int i=0; i< size; i++){
System.out.print((char)is.read() + " ");
}
is.close();
}catch(IOException e){
System.out.print("Exception");
}
}
}Le programme ci-dessus crée d'abord le fichier test. txt et met les nombres donnés. Les nombres sont écrits dans le fichier sous forme binaire et affichés sur la console en même temps. Étant donné que le code ci-dessus est écrit en binaire, il peut y avoir des caractères tronqués. Vous pouvez utiliser les exemples de code suivants pour résoudre le problème de code tronqué : //文件名 :fileStreamTest2.java
import java.io.*;
public class fileStreamTest2{
public static void main(String[] args) throws IOException {
File f = new File("a.txt");
FileOutputStream fop = new FileOutputStream(f);
// 构建FileOutputStream对象,文件不存在会自动新建
OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
// 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk
writer.append("中文输入");
// 写入到缓冲区
writer.append("\r\n");
//换行
writer.append("English");
// 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入
writer.close();
//关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉
fop.close();
// 关闭输出流,释放系统资源
FileInputStream fip = new FileInputStream(f);
// 构建FileInputStream对象
InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
// 构建InputStreamReader对象,编码与写入相同
StringBuffer sb = new StringBuffer();
while (reader.ready()) {
sb.append((char) reader.read());
// 转成char加到StringBuffer对象中
}
System.out.println(sb.toString());
reader.close();
// 关闭读取流
fip.close();
// 关闭输入流,释放系统资源
}
}Fichier et E/S. Il existe également quelques classes sur les fichiers et les E/S que nous devons également connaître :
- Classe de fichiers (classe)
- Classe FileReader (classe)
- Classe FileWriter (classe)
Répertoire en JavaCréer directory : Il existe deux méthodes dans la classe File qui peuvent être utilisées pour créer des dossiers :
mkdir()La méthode crée un dossier et renvoie vrai en cas de succès, sinon renvoie faux. Un échec indique que le chemin spécifié par l'objet File existe déjà ou que le dossier ne peut pas être créé car le chemin complet n'existe pas encore. La méthode
mkdirs() crée un dossier et tous ses dossiers parents.
import java.io.File;
public class CreateDir {
public static void main(String args[]) {
String dirname = "/tmp/user/java/bin";
File d = new File(dirname);
// 现在创建目录
d.mkdirs();
}
}Compilez et exécutez le code ci-dessus pour créer le répertoire "/tmp/ utilisateur/java/bin". Remarque : Java distingue automatiquement les séparateurs de chemin de fichier par convention sous UNIX et Windows. Si vous utilisez le séparateur (/) dans la version Windows de Java, le chemin sera toujours analysé correctement.
Lire le répertoire Un répertoire est en fait un objet File, qui contient d'autres fichiers et dossiers. Si vous créez un objet File et qu'il s'agit d'un répertoire, l'appel de la méthode isDirectory() retournera true. La liste des fichiers et dossiers qu'il contient peut être extraite en appelant la méthode list() sur cet objet. L'exemple ci-dessous illustre comment utiliser la méthode list() pour vérifier le contenu contenu dans un dossier :
import java.io.File;
public class DirList {
public static void main(String args[]) {
String dirname = "/tmp";
File f1 = new File(dirname);
if (f1.isDirectory()) {
System.out.println( "Directory of " + dirname);
String s[] = f1.list();
for (int i=0; i < s.length; i++) {
File f = new File(dirname + "/" + s[i]);
if (f.isDirectory()) {
System.out.println(s[i] + " is a directory");
} else {
System.out.println(s[i] + " is a file");
}
}
} else {
System.out.println(dirname + " is not a directory");
}
}
}Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants : Directory of /tmp bin is a directory lib is a directory demo is a directory test.txt is a file README is a file index.html is a file include is a directory
