Kaffeepause Nr. 169. Vergleich der Typen. Java.io – E/A-Operationen in Java

Vergleich von Typen in Java

Quelle: Theflashreads In diesem Beitrag erfahren Sie mehr über verschiedene Typenvergleichsoptionen in Java. Die gebräuchlichste Methode, um festzustellen, ob ein bestimmtes Objekt eine Instanz einer bestimmten Klasse, Superklasse oder Schnittstelle ist, ist die Verwendung des binären Instanzoperators . Es beinhaltet eine implizite Nullprüfung und generiert einen Fehler bei der Kompilierung, wenn die Typen nicht gebunden sind. Es erlaubt jedoch nicht die Verwendung von Grundelementen und erfordert, dass die Typen zur Kompilierungszeit bekannt sind.

Wenn Sie eine dynamische Laufzeitprüfung benötigen

Verwenden Sie in diesem Fall die entsprechende boolesche Methode isInstance(Object obj) in Class . Es umfasst auch eine Nullprüfung, erlaubt jedoch Grundelemente:

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

Überprüfung der Kompatibilität zweier Typen

Wenn Sie die Subtypbeziehung überprüfen müssen, verwenden Sie die boolesche Methode isAssignableFrom(Class<?> cls) in Class . Dies hilft dabei, NullPointerException abzufangen .

// 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

Mustervergleich (Java 14)

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

Sondertypen

// 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 – E/A-Operationen in Java

Quelle: Medium Der Inhalt dieses Artikels befasst sich mit E/A-Operationen in Java. Bei der Entwicklung von Android- und Java-Anwendungen ist Eingabe/Ausgabe (Java I/O) eines der Themen, die häufig verwendet werden, aber aus irgendeinem Grund selten erwähnt werden. Der Anwendungsbereich ist jedoch breit: Wir führen beispielsweise I/O-Vorgänge beim Konvertieren eines Bitmap-Bilds in das JPEG-Format oder beim Lesen/Schreiben einer normalen Datei durch. Das Java-Paket java.io verfügt über alle notwendigen Klassen, die zur Durchführung von I/O-Operationen erforderlich sind. Diese Vorgänge werden mithilfe von Threads ausgeführt. Threads wiederum helfen bei der Durchführung von Lese- oder Schreibvorgängen. Zum Beispiel das Schreiben einer Nachricht in eine Datei.

Arten von Streams

In Java gibt es zwei Arten von Threads:

1. Byte-Stream (Byte-Stream)
2. Charakter-Stream

Byte-Stream

Ein Byte Stream wird zum Lesen und Schreiben eines Datenbytes verwendet. Es umfasst die Java- Klassen InputStream und OutputStream . InputStream hilft beim Lesen von Daten und OutputStream hilft beim Schreiben von Daten in ein Ziel (möglicherweise eine Datei).

Charakterstrom

Der Zeichenstrom wird zum Lesen und Schreiben eines Datenzeichens verwendet. Es umfasst die Java-Klassen Reader und Writer . Um Reader und Writer zu verstehen , müssen Sie abgeleitete Klassen wie InputStreamReader , FileReader , OutputStreamWriter , FileWriter und andere verstehen.

InputStream und OutputStream

InputStream wird verwendet, um Daten aus einer Quelle (möglicherweise einer Datei) zu lesen. Es ist für sich genommen nicht nützlich, verfügt aber über mehrere abgeleitete Klassen wie FileInputStream , ByteArrayInputStream und ObjectInputStream . OutputStream wird verwendet, um Daten in ein Ziel (möglicherweise eine Datei) zu schreiben. Die abgeleiteten Klassen sind FileOutputStream , ByteArrayOutputStream und 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()
    }
}

Neben den oben genannten Streams gibt es auch DataInputStream und DataOutputStream . Sie erledigen die gleiche Arbeit wie andere Threads. Der Unterschied besteht darin, dass DataInput / OutputStream hauptsächlich zum Lesen/Schreiben primitiver Typen verwendet wird, während ObjectInput / OutputStream hauptsächlich für Objekte usw. verwendet wird.

Leser und Schriftsteller

Wenn wir in Java I/O Daten in Streams lesen/schreiben, müssen wir sie zuerst in Bytes konvertieren. Erst dann können wir sie lesen oder in Streams schreiben. InputStreamReader und OutputStreamWriter erledigen dies automatisch.

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

Paralleles Lesen und Schreiben

Manchmal benötigen wir Multithreading-Unterstützung in Streams. Einfach ausgedrückt möchten wir Streams aus separaten Threads lesen und schreiben. Dazu müssen wir PipedInput / OutputStream verwenden .

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