💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici
En Java, la classe InputStream est utilisée pour lire des données à partir de fichiers dans une séquence ordonnée. Pour utiliser les données sous forme de chaîne, nous devons convertir l'InputStream en une chaîne de caractères. Ce laboratoire vous apprendra différentes méthodes pour convertir un InputStream en une chaîne de caractères.
La classe InputStreamReader fournit une méthode read() pour lire des données à partir d'un InputStream dans un tableau de caractères. Nous pouvons convertir le tableau de caractères en une chaîne de caractères. Créez un nouveau fichier source Java InputStreamToString.java dans le répertoire ~/project avec le contenu suivant :
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public class InputStreamToString {
public static String inputStreamToString(InputStream input) throws IOException {
InputStreamReader reader = new InputStreamReader(input);
char[] charArray = new char[256];
reader.read(charArray);
return new String(charArray);
}
public static void main(String[] args) {
try {
InputStream input = new ByteArrayInputStream("hello world".getBytes());
String strFromInputStream = inputStreamToString(input);
System.out.print("String from the Input Stream is: " + strFromInputStream);
} catch(Exception e) {
System.out.print(e);
}
}
}Pour exécuter le code, ouvrez un terminal, puis compilez et exécutez le code avec la commande suivante :
javac InputStreamToString.java && java InputStreamToStringL'étape précédente peut être inefficace pour des entrées plus volumineuses. Au lieu de cela, nous pouvons utiliser un BufferedReader pour encapsuler l'InputStreamReader afin d'améliorer l'efficacité. Ensuite, nous utiliserons un objet StringBuilder pour ajouter les lignes lues à partir du BufferedReader. Créez une nouvelle étape dans InputStreamToString.java après l'Étape 1 avec le code suivant :
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public class InputStreamToString {
public static String inputStreamToString(InputStream input) throws IOException {
StringBuilder builder = new StringBuilder();
InputStreamReader reader = new InputStreamReader(input);
BufferedReader bufferedReader = new BufferedReader(reader);
String line;
while ((line = bufferedReader.readLine())!= null) {
builder.append(line);
}
return builder.toString();
}
public static void main(String[] args) {
try {
InputStream input = new ByteArrayInputStream("hello world".getBytes());
String strFromInputStream = inputStreamToString(input);
System.out.print("String from the Input Stream is: " + strFromInputStream);
} catch(Exception e) {
System.out.print(e);
}
}
}Nous pouvons utiliser une approche plus simple en utilisant la méthode lines() de la classe BufferedReader. Cela nous permet d'éviter d'ajouter chaque ligne à une instance séparée de StringBuilder. Créez une nouvelle étape dans InputStreamToString.java après l'Étape 2 avec le code suivant :
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.stream.Collectors;
public class InputStreamToString {
public static String inputStreamToString(InputStream input) throws IOException {
InputStreamReader reader = new InputStreamReader(input);
BufferedReader bufferedReader = new BufferedReader(reader);
String str = bufferedReader.lines().collect(Collectors.joining("\n"));
return str;
}
public static void main(String[] args) {
InputStream input = new ByteArrayInputStream("hello world".getBytes());
String strFromInputStream = inputStreamToString(input);
System.out.print("String from the Input Stream is: " + strFromInputStream);
}
}La classe InputStream a introduit la méthode readAllBytes() dans Java 9. Cela peut convertir efficacement l'objet InputStream entier en une chaîne de caractères en une seule ligne de code. Cependant, cette méthode n'est pas recommandée pour des entrées plus volumineuses. Créez une nouvelle étape dans InputStreamToString.java après l'Étape 3 avec le code suivant :
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
public class InputStreamToString {
public static String inputStreamToString(InputStream input) throws IOException {
return new String(input.readAllBytes());
}
public static void main(String[] args) {
try {
InputStream input = new ByteArrayInputStream("hello world".getBytes());
String strFromInputStream = inputStreamToString(input);
System.out.print("String from the Input Stream is: " + strFromInputStream);
} catch(Exception e) {
System.out.print(e);
}
}
}Nous pouvons également utiliser la classe Scanner, une classe couramment utilisée pour lire et analyser des données, pour convertir le flux d'entrée en une chaîne de caractères. Créez une nouvelle étape dans InputStreamToString.java après l'Étape 4 avec le code suivant :
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;
public class InputStreamToString {
public static String inputStreamToString(InputStream input) throws IOException {
Scanner scanner = new Scanner(input);
StringBuilder builder = new StringBuilder();
while (scanner.hasNext()) {
builder.append(scanner.nextLine());
}
return builder.toString();
}
public static void main(String[] args) {
try {
InputStream input = new ByteArrayInputStream("hello world".getBytes());
String strFromInputStream = inputStreamToString(input);
System.out.print("String from the Input Stream is: " + strFromInputStream);
} catch(Exception e) {
System.out.print(e);
}
}
}Nous pouvons utiliser la classe ByteArrayOutputStream dans le package java.io et copier les données du flux d'entrée dans le tableau d'octets. Ensuite, nous pouvons écrire le tableau d'octets dans le ByteArrayOutputStream. Enfin, nous utiliserons la méthode toString() du ByteArrayOutputStream pour obtenir la représentation sous forme de chaîne de caractères. Créez une nouvelle étape dans InputStreamToString.java après l'Étape 5 avec le code suivant :
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
public class InputStreamToString {
public static String inputStreamToString(InputStream input) throws IOException {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
byte[] buffer = new byte[128];
int length;
while ((length = input.read(buffer))!= -1) {
byteArrayOutputStream.write(buffer, 0, length);
}
return byteArrayOutputStream.toString();
}
public static void main(String[] args) {
try {
InputStream input = new ByteArrayInputStream("hello world".getBytes());
String strFromInputStream = inputStreamToString(input);
System.out.print("String from the Input Stream is: " + strFromInputStream);
} catch(Exception e) {
System.out.print(e);
}
}
}Dans le package java.nio, nous pouvons créer un fichier temporaire à l'aide de Files.createTempFile et copier les données du InputStream dans ce fichier. Ensuite, nous pouvons lire le contenu de ce fichier temporaire dans une chaîne de caractères. Créez une nouvelle étape dans InputStreamToString.java après l'Étape 6 avec le code suivant :
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
public class InputStreamToString {
public static String inputStreamToString(InputStream input) throws IOException {
Path file = Files.createTempFile(null, null);
Files.copy(input, file, StandardCopyOption.REPLACE_EXISTING);
return new String(Files.readAllBytes(file));
}
public static void main(String[] args) {
try {
InputStream input = new ByteArrayInputStream("hello world".getBytes());
String strFromInputStream = inputStreamToString(input);
System.out.print("String from the Input Stream is: " + strFromInputStream);
} catch(Exception e) {
System.out.print(e);
}
}
}La bibliothèque Google Guava fournit la classe CharStreams pour convertir un InputStream en une chaîne de caractères. Nous pouvons utiliser la méthode toString() de cette classe pour ce faire. Elle prendra un objet Readable (comme InputStreamReader) et lira les données à partir de celui-ci pour les convertir en une chaîne de caractères. Créez une nouvelle étape dans InputStreamToString.java après l'Étape 7 avec le code suivant :
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import com.google.common.io.CharStreams;
public class InputStreamToString {
public static String inputStreamToString(InputStream input) throws IOException {
try(InputStreamReader reader = new InputStreamReader(input)) {
return CharStreams.toString(reader);
}
}
public static void main(String[] args) {
try {
InputStream input = new ByteArrayInputStream("hello world".getBytes());
String strFromInputStream = inputStreamToString(input);
System.out.print("String from the Input Stream is: " + strFromInputStream);
} catch(Exception e) {
System.out.print(e);
}
}
}La classe IOUtils du package org.apache.commons.io contient également une méthode toString(). Nous pouvons directement passer l'objet InputStream à cette méthode, et elle lira les données à partir de celui-ci pour les convertir en une chaîne de caractères. Nous devons également spécifier un Charset. Créez une nouvelle étape dans InputStreamToString.java après l'Étape 8 avec le code suivant :
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import org.apache.commons.io.IOUtils;
public class InputStreamToString {
public static void main(String[] args) {
try {
InputStream input = new ByteArrayInputStream("hello world".getBytes());
String strFromInputStream = IOUtils.toString(input, StandardCharsets.UTF_8.name());
System.out.print("String from the Input Stream is: " + strFromInputStream);
} catch(Exception e) {
System.out.print(e);
}
}
}Nous pouvons utiliser la classe StringWriter du package java.io et copier le contenu du InputStream dans le StringWriter. Nous utiliserons la méthode copy() de la classe IOUtils. Créez une nouvelle étape dans InputStreamToString.java après l'Étape 9 avec le code suivant :
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.StringWriter;
import java.nio.charset.StandardCharsets;
import org.apache.commons.io.IOUtils;
public class InputStreamToString {
public static void main(String[] args) {
try {
InputStream input = new ByteArrayInputStream("hello world".getBytes());
StringWriter sw = new StringWriter();
IOUtils.copy(input, sw, StandardCharsets.UTF_8.name());
String strFromInputStream = sw.toString();
System.out.print("String from the Input Stream is: " + strFromInputStream);
} catch(Exception e) {
System.out.print(e);
}
}
}Dans ce laboratoire, vous avez appris différentes façons de convertir un InputStream en une chaîne de caractères en Java. Vous pouvez utiliser la classe ByteArrayOutputStream ou la classe BufferedReader pour améliorer l'efficacité. La classe Scanner est également disponible pour convertir le flux d'entrée en une chaîne de caractères. La méthode readAllBytes() est appropriée uniquement pour les entrées plus petites. Nous pouvons utiliser des bibliothèques externes telles que Google Guava ou Apache Commons IO pour simplifier le processus. N'oubliez pas de gérer les exceptions et de fermer le InputStream pour éviter les fuites de ressources.
