1. Aperçu des flux de tableaux d'octets
1.1 Flux de nœuds et flux d'emballage
Les flux d'E/S sont classés selon différents objets de traitement et peuvent être divisés en flux de nœuds et flux d'empaquetage.
1) Flux de nœuds : FileOutputStream, FileInputStream, FileWriter et FileReade
2) Flux d'empaquetage : le flux de tampon, le flux de conversion, le flux d'impression, le flux de données et le flux d'objets lui appartiennent tous.
Les flux de nœuds peuvent être exploités avec des flux de packages, par exemple :
L'utilisation de flux d'octets pour copier des fichiers est inefficace, nous pouvons donc utiliser des flux mis en mémoire tampon pour améliorer l'efficacité.
L'utilisation de flux d'octets pour accéder à des données de n'importe quel type de données est fastidieuse, nous pouvons donc utiliser des flux d'objets pour simplifier les opérations, etc.
1.2 Présentation des flux de tableaux d'octets
Flux de tableau d'octets , qui est également un flux de nœuds .
=====================Le flux du tableau d'octets est divisé en ? ================================
1) Flux d'entrée : ByteArrayInputStream
2) Flux de sortie : ByteArrayOutputStream
=====================Conseils ? ========================================
Lors de l'utilisation d'un flux de tableau d'octets, afin d'améliorer l'efficacité et de simplifier les opérations, le flux de tableau d'octets peut être utilisé avec le flux d'empaquetage .
=====================Quelle est la différence entre le reste du flux de nœuds et le flux de tableau d'octets ? ====================
Parmi les flux de nœuds courants, par exemple : FileInputStream et FileReader utilisent tous deux "file" comme source de données , tandis que ByteArrayInputStream utilise le "tableau d'octets" en mémoire comme source de données .
=====================Comment le flux de tableau d'octets est-il implémenté ? ===========================
Un flux de tableau d'octets est un flux lié à un tableau en mémoire . Il peut écrire des tableaux d'octets dans le flux de sortie ou lire des tableaux d'octets à partir du flux d'entrée , sans impliquer le disque. Le flux de sortie du tableau mémoire peut être considéré comme un tableau d'octets à expansion automatique, dans lequel des octets peuvent être écrits.
=====================Quelle est l'utilité des flux de tableaux d'octets ? =============================
Grâce au streaming de tableaux d'octets, nous pouvons convertir entre tous les types de données (types de données de base, types de données de référence) et les tableaux d'octets , puis les convertir en tableaux d'octets qui peuvent être enregistrés dans des fichiers ou transmis au réseau.
2. Classe ByteArrayOutputStream
Logique sous-jacente ByteArrayOutputStream
ByteArrayOutputStream Le flux de sortie du tableau d'octets crée un tampon de tableau d'octets en mémoire et toutes les données envoyées au flux de sortie sont enregistrées dans le tampon de tableau d'octets. La taille par défaut du tampon est de 32 octets lors de l'initialisation, qui augmentera automatiquement à mesure que les données sont écrites en continu. Cependant, la capacité maximale du tampon est de 2 Go. Tant que les données ne dépassent pas 2 Go, vous pouvez y écrire.
Une fois les données écrites, vous pouvez utiliser la méthode toByteArray() ou la méthode toString() pour obtenir les données, réalisant ainsi la conversion de n'importe quel type de données en un tableau d'octets .
Par exemple, étant donné un tableau d'octets, puis en plaçant diverses données dans le tableau, telles que des entiers, des types booléens, des types à virgule flottante, des chaînes et des objets, etc., cette exigence peut être réalisée en utilisant ByteArrayOutputStream.
[Exemple] Étude de cas sur la conversion de n'importe quel type de données en tableau d'octets
| classe publique ArrayStreamTest { public static void main (String[] arguments) { essayez { // Flux de sortie du tableau d'octets (flux de nœuds), qui peut convertir n'importe quel type de données en tableau d'octets ByteArrayOutputStream baos = new ByteArrayOutputStream(); // Flux tampon (classe wrapper), utilisé pour améliorer l'efficacité BufferedOutputStream bos = new BufferedOutputStream(baos); // Flux d'objets (flux de packaging) pour écrire n'importe quel type de données ObjectOutputStream oos = new ObjectOutputStream(bos); //Utiliser le flux d'objets pour écrire des données east.writeInt(123); oos.writeDouble(123.45); oos.writeChar('A'); oos.writeBoolean( false ); oos.writeUTF("nœud"); oos.writeObject( new Date()); // Actualiser le flux. Vous devez actualiser le flux avant d'obtenir les données car un flux wrapper est utilisé. oos.flush(); // récupérer les données octet [] bs = baos.toByteArray(); Système. out .println (Arrays. toString (bs)); } catch (IOException e) { e.printStackTrace(); } } } |
En examinant le code source sous-jacent, nous avons constaté que la méthode close() de la classe ByteArrayOutputStream n'était pas implémentée, le flux peut donc toujours être utilisé après avoir appelé la méthode close() pour le fermer.
Par exemple, ByteArrayInputStream
Le flux d'entrée du tableau d'octets enveloppe un tableau d'octets byte[] afin qu'il ait les propriétés d'un flux. Il peut être lu séquentiellement et marqué pour revenir en arrière pour continuer la lecture. Sa fonction principale est de lire le tableau d'octets. Les données.
De la même manière, la fermeture du ByteArrayInputStream n'est pas valide. L'appel de la méthode close() peut toujours être appelé après la fermeture du flux.
[Exemple] Lire le tableau de caractères obtenu dans le cas précédent
| classe publique ArrayStreamTest { public static void main (String[] arguments) { essayez { // Récupère le tableau d'octets et renvoie le tableau d'octets écrit via le flux de sortie du tableau d'octets dans le cas précédent byte[] bs = outputStreamMethod(); // 字节数组输入流(节点流)，用于读取字节数组中的数据 ByteArrayInputStream bios = new ByteArrayInputStream(bs); // 缓冲流(包装类)，用于提高效率 BufferedInputStream bis = new BufferedInputStream(bios); // 对象流(包装流)，实现读取指定类型的数据 ObjectInputStream ois = new ObjectInputStream(bis); // 读取数据 System.out.println(ois.readInt()); System.out.println(ois.readDouble()); System.out.println(ois.readChar()); System.out.println(ois.readBoolean()); System.out.println(ois.readUTF()); System.out.println(ois.readObject()); } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } } |
补充，ByteArrayInputStream和ByteArrayOutputStream是字节数组流，那么与之对应的字符数组流则是StringReader和StringWriter。
与字节数组流相比，字符数组流反而用得更少，因为StringBuilder和StringBuffer也能方便的用来存储动态长度的字符，而且大家更熟悉这些类。