Pausa para el café #169. Comparación de tipos. Java.io - Operaciones de E/S en Java

Comparación de tipos en Java

Fuente: Theflashreads En esta publicación, aprenderá sobre varios tipos de opciones de comparación en Java. La forma más común de determinar si un objeto determinado es una instancia de una clase, superclase o interfaz determinada es utilizar el operador binario instancia de . Incluye una verificación nula implícita y genera un error en tiempo de compilación si los tipos no están vinculados. Sin embargo, no permite el uso de primitivas y requiere que los tipos se conozcan en el momento de la compilación.

Si necesita verificación dinámica del tiempo de ejecución

En este caso, utilice el método booleano isInstance(Object obj) equivalente en Class . También incluye verificación de nulos, pero permite primitivas:

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);

Comprobando la compatibilidad de dos tipos.

Si necesita verificar la relación de subtipo, use el método booleano isAssignableFrom(Class<?> cls) en Class . Esto ayudará a detectar 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

Coincidencia de patrones (Java 14)

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

tipos especiales

// 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 - Operaciones de E/S en Java

Fuente: Medio El contenido de este artículo trata sobre operaciones de E/S en Java. En el desarrollo de aplicaciones Android y Java, la entrada/salida (Java I/O) es uno de los temas que se utiliza con frecuencia, pero por alguna razón rara vez se menciona. Sin embargo, su ámbito de aplicación es amplio: por ejemplo, realizamos operaciones de E/S al convertir una imagen de mapa de bits al formato JPEG o mientras leemos/escribimos un archivo normal. El paquete Java java.io tiene todas las clases necesarias para realizar operaciones de E/S. Estas operaciones se realizan mediante subprocesos. A su vez, los hilos ayudan a realizar operaciones de lectura o escritura. Por ejemplo, escribir un mensaje en un archivo.

tipos de corrientes

Hay dos tipos de subprocesos en Java:

1. Flujo de bytes (flujo de bytes)
2. Flujo de personajes

flujo de bytes

Un Byte Stream se utiliza para leer y escribir un byte de datos. Incluye las clases Java InputStream y OutputStream . InputStream ayuda a leer datos y OutputStream ayuda a escribir datos en un destino (posiblemente un archivo).

Flujo de personajes

Character Stream se utiliza para leer y escribir un carácter de datos. Incluye las clases Java Reader y Writer . Para comprender Reader y Writer , debe comprender las clases derivadas como InputStreamReader , FileReader , OutputStreamWriter , FileWriter y otras.

Flujo de entrada y flujo de salida

InputStream se utiliza para leer datos de una fuente (posiblemente un archivo). No es útil por sí solo, pero tiene varias clases derivadas como FileInputStream , ByteArrayInputStream y ObjectInputStream . OutputStream se utiliza para escribir datos en un destino (posiblemente un archivo). Sus clases derivadas son FileOutputStream , ByteArrayOutputStream y 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()
    }
}

Además de las transmisiones anteriores, también tenemos DataInputStream y DataOutputStream . Hacen el mismo trabajo que otros hilos. La diferencia es que DataInput / OutputStream se usa principalmente para leer/escribir tipos primitivos, mientras que ObjectInput / OutputStream se usa principalmente para objetos, etc.

Lectores y escritores

En Java I/O, si leemos/escribimos datos en flujos, primero debemos convertirlos a bytes. Sólo entonces podremos leerlos o escribirlos en transmisiones. InputStreamReader y OutputStreamWriter hacen esto automáticamente.

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())
    }
}

Lectura y escritura paralelas

A veces necesitamos soporte multiproceso en Streams. En pocas palabras, queremos leer y escribir en transmisiones desde subprocesos separados. Para esto necesitamos usar 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()
   }