Pause café #169. Comparaison des types. Java.io - Opérations d'E/S en Java

Comparaison des types en Java

Source : Theflashreads Dans cet article, vous découvrirez plusieurs types d'options de comparaison en Java. La manière la plus courante de déterminer si un objet donné est une instance d'une classe, d'une superclasse ou d'une interface donnée consiste à utiliser l'opérateur binaire instanceof . Il inclut une vérification nulle implicite et génère une erreur de compilation si les types ne sont pas liés. Cependant, il ne permet pas l'utilisation de primitives et nécessite que les types soient connus au moment de la compilation.

Si vous avez besoin d'une vérification dynamique de l'exécution

Dans ce cas, utilisez la méthode booléenne isInstance(Object obj) équivalente dans Class . Il inclut également la vérification des valeurs nulles, mais autorise les primitives :

a instanceof B
    // returns false for null
    null instanceof B

    a.getClass().isInstance(b);
    // commonly used for generics
    Class<T> type = b.getClass();
    type.isInstance(a);

    // Note that the parameter is autoboxed to type Integer
    int x = 4;
    Integer.class.isInstance(x);

Vérification de la compatibilité de deux types

Si vous devez vérifier la relation de sous-type, utilisez la méthode boolean isAssignableFrom(Class<?> cls) dans Class . Cela aidera à attraper NullPointerException .

// is it possible to B b = new A()
   Class<?> aClass = CharSequence.class;
   Class<?> bClass = String.class;
   bClass.isAssignableFrom(aClass());

   // works for arrays
   CharSequence[].class.isAssignableFrom(String[].class); // true
   Integer[].class.isAssignableFrom(String[].class); //false

Correspondance de modèles (Java 14)

if(a instanceof B b) {
       // b is casted
       b.toString();
   }

Types spéciaux

// Enums
    enum Color { WHITE, GRAY, BLACK }

    Color.class.isEnum(); // Enum.class.isAssignableFrom(Color.class);
    Color.WHITE instanceof Enum; // true

    // Arrays
    String[].class.isArray();
    // get the type of the variables in an array (null if obj is not an array)
    Class<?> componentType = obj.getComponentType();

    // Primitives
    int.class.isPrimitive();

Java.io - Opérations d'E/S en Java

Source : Medium Le contenu de cet article concerne les opérations d'E/S en Java. Dans le développement d'applications Android et Java, les entrées/sorties (Java I/O) sont l'un des sujets souvent utilisés, mais pour une raison quelconque, ils sont rarement mentionnés. Cependant, son champ d'application est large : par exemple, nous effectuons des opérations d'E/S lors de la conversion d'une image bitmap au format JPEG ou lors de la lecture/écriture d'un fichier normal. Le package Java java.io possède toutes les classes nécessaires pour effectuer des opérations d'E/S. Ces opérations sont effectuées à l'aide de threads. À leur tour, les threads aident à effectuer des opérations de lecture ou d’écriture. Par exemple, écrire un message dans un fichier.

Types de flux

Il existe deux types de threads en Java :

1. Flux d'octets (flux d'octets)
2. Flux de personnages

Flux d'octets

Un Byte Stream est utilisé pour lire et écrire un octet de données. Il comprend les classes Java InputStream et OutputStream . InputStream aide à lire les données et OutputStream aide à écrire des données sur une cible (éventuellement un fichier).

Flux de personnages

Character Stream est utilisé pour lire et écrire un caractère de données. Il comprend les classes Java Reader et Writer . Pour comprendre Reader et Writer , vous devez comprendre les classes dérivées telles que InputStreamReader , FileReader , OutputStreamWriter , FileWriter et autres.

InputStream et OutputStream

InputStream est utilisé pour lire les données d'une source (éventuellement un fichier). Ce n'est pas utile en soi, mais il possède plusieurs classes dérivées telles que FileInputStream , ByteArrayInputStream et ObjectInputStream . OutputStream est utilisé pour écrire des données sur une cible (éventuellement un fichier). Ses classes dérivées sont FileOutputStream , ByteArrayOutputStream et ObjectOutputStream .

class InputOutput {

    data class Car(val name: String): java.io.Serializable

    fun fileStream() {
        //Create FileOutputStream that used for writing to file
        val outputStream = FileOutputStream("kotlin.txt")

        //write to output stream
        outputStream.write(1) //write a int
        outputStream.write("hello".toByteArray()) //write a string as byte array

        //Create FileInputStream that used for reading from file
        val inputStream = FileInputStream("kotlin.txt")

        //reading single first byte from input stream
        //output - 1
        println(inputStream.read())

        //reading string from input stream
        //output - hello
        val msg = String(inputStream.readBytes())
        println(msg)

        //close
        outputStream.close()
        inputStream.close()
    }

    fun byteArrayStream() {
        //Create ByteArrayOutputStream
        val outputStream = ByteArrayOutputStream()

        //write to output stream
        outputStream.write(1)
        outputStream.write("hello".toByteArray())

        //Create ByteArrayInputStream
        val readByteArray = outputStream.toByteArray()
        val inputStream = ByteArrayInputStream(readByteArray)

        //Reading a single byte from input stream
        //output - 1
        println(inputStream.read())

        //Reading string from input stream
        //output - hello
        val msg = String(inputStream.readBytes())
        println(msg)

        //close
        outputStream.close()
        inputStream.close()
    }

    fun objectStream() {
        //custom object
        val car = Car(name = "BMW")

        //Create ObjectOutputStream
        val fileOutputStream = FileOutputStream("kotlin.txt")
        val objOutputStream = ObjectOutputStream(fileOutputStream)

        //writing to output stream
        objOutputStream.writeObject(car)

        //Create ObjectInputStream
        val fileInputStream = FileInputStream("kotlin.txt")
        val objInputStream = ObjectInputStream(fileInputStream)

        //Reading from input stream
        val carObject = objInputStream.readObject() as Car
        println(carObject.name) //output - BMW

        //close
        fileOutputStream.close()
        objOutputStream.close()

        fileInputStream.close()
        objInputStream.close()
    }

    fun bufferStream() {
        //Buffer - Buffer is used for storing stream of data in Java I/O
        //BufferStream is faster way to write and read bytes in streams.

        //Create BufferOutputStream
        val fileOutputStream = FileOutputStream("kotlin.txt")
        val outputStream = BufferedOutputStream(fileOutputStream)

        //Write to output stream
        outputStream.write("hello".toByteArray())

        //flush() - Sending the data from BufferedOutputStream to main stream.
        //This is required to push changes to main stream.
        outputStream.flush()

        //Create BufferInputStream
        val fileInputStream = FileInputStream("kotlin.txt")
        val inputStream = BufferedInputStream(fileInputStream)

        //Reading from input stream
        val msg = String(inputStream.readBytes())
        println(msg)

        //close
        fileOutputStream.close()
        fileInputStream.close()
    }
}

Outre les flux ci-dessus, nous avons également DataInputStream et DataOutputStream . Ils font le même travail que les autres fils. La différence est que DataInput / OutputStream est principalement utilisé pour la lecture/écriture de types primitifs, tandis que ObjectInput / OutputStream est principalement utilisé pour les objets, etc.

Lecteurs et écrivains

Dans Java I/O, si nous lisons/écrivons des données dans des flux, nous devons d’abord les convertir en octets. Ce n'est qu'alors que nous pouvons les lire ou les écrire dans des flux. InputStreamReader et OutputStreamWriter le font automatiquement.

class ReaderWriter {
    fun readerWriter() {
        //StreamReader or Writer:
        //It reads bytes and decodes them into characters using a specified charset.

        //Create OutputStreamWriter
        val outputStream = FileOutputStream("kotlin.txt")
        val writer = OutputStreamWriter(outputStream)

        //write to output stream
        writer.write("Hello Kotlin")
        writer.flush()

        //Create InputStreamReader
        val inputStream = FileInputStream("kotlin.txt")
        val reader = InputStreamReader(inputStream)

        //read from input stream
        //output - Hello Kotlin
        println(reader.readText())
    }
}

Lecture et écriture parallèles

Parfois, nous avons besoin du support multithread dans Streams. En termes simples, nous voulons lire et écrire dans des flux à partir de threads distincts. Pour cela, nous devons utiliser PipedInput / OutputStream .

fun pipedStream() {
       //Create PipedInput/OutputStream for parallel read/writes
       val inputStream = PipedInputStream()
       val outputStream = PipedOutputStream()

       //make a connection
       inputStream.connect(outputStream)

       //write from separate thread
       val writeThread = object : Thread() {
           override fun run() {
               try {
                   for (i in 0..100) {
                       outputStream.write(i)
                       println("Write : $i")
                       sleep(100)
                   }
               } catch (e: Exception) {
                   e.printStackTrace()
               }
           }
       }

       //read from another thread
       val readThread = object : Thread() {
           override fun run() {
               try {
                   for (i in 0..100) {
                       println("Read : ${inputStream.read()}")
                   }
               } catch (e: Exception) {
                   e.printStackTrace()
               }
           }
       }

       //start
       writeThread.start()
       readThread.start()
   }