Rehat kopi #169. Perbandingan jenis. Java.io - Operasi I/O di Java

Perbandingan tipe di Jawa

Sumber: Theflashreads Pada postingan kali ini, Anda akan mempelajari beberapa tipe opsi perbandingan di Java. Cara paling umum untuk menentukan apakah suatu objek merupakan turunan dari kelas, superkelas, atau antarmuka tertentu adalah dengan menggunakan operator instanceof biner . Ini mencakup pemeriksaan nol implisit dan menghasilkan kesalahan waktu kompilasi jika tipenya tidak terikat. Namun, ini tidak mengizinkan penggunaan primitif dan mengharuskan tipenya diketahui pada waktu kompilasi.

Jika Anda memerlukan pemeriksaan runtime dinamis

Dalam hal ini, gunakan metode boolean isInstance(Object obj) yang setara di Class . Ini juga mencakup pemeriksaan nol, tetapi mengizinkan primitif:

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

Memeriksa kompatibilitas dua jenis

Jika Anda perlu memeriksa hubungan subtipe, gunakan metode boolean isAssignableFrom(Class<?> cls) di Class . Ini akan membantu menangkap 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

Pencocokan Pola (Jawa 14)

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

Tipe khusus

// 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 - Operasi I/O di Java

Sumber: Medium Isi artikel ini tentang operasi I/O di Java. Dalam pengembangan aplikasi Android dan Java, input/output (Java I/O) merupakan salah satu topik yang sering digunakan, namun karena alasan tertentu jarang disebutkan. Namun, cakupan penerapannya luas: misalnya, kami melakukan operasi I/O saat mengonversi gambar bitmap ke format JPEG atau saat membaca/menulis file biasa. Paket Java java.io memiliki semua kelas yang diperlukan untuk melakukan operasi I/O. Operasi ini dilakukan menggunakan utas. Pada gilirannya, thread membantu melakukan operasi baca atau tulis. Misalnya, menulis pesan ke file.

Jenis aliran

Ada dua jenis thread di Java:

1. Aliran Byte (aliran byte)
2. Aliran Karakter

Aliran byte

Aliran Byte digunakan untuk membaca dan menulis satu byte data. Ini mencakup kelas Java InputStream dan OutputStream . InputStream membantu membaca data dan OutputStream membantu menulis data ke target (mungkin file).

Aliran karakter

Character Stream digunakan untuk membaca dan menulis satu karakter data. Ini mencakup kelas Java Reader dan Writer . Untuk memahami Reader dan Writer , Anda harus memahami kelas turunan seperti InputStreamReader , FileReader , OutputStreamWriter , FileWriter dan lain-lain.

Aliran Masukan dan Aliran Keluaran

InputStream digunakan untuk membaca data dari sumber (mungkin file). Itu tidak berguna jika berdiri sendiri, tetapi memiliki beberapa kelas turunan seperti FileInputStream , ByteArrayInputStream , dan ObjectInputStream . OutputStream digunakan untuk menulis data ke target (mungkin file). Kelas turunannya adalah FileOutputStream , ByteArrayOutputStream , dan 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()
    }
}

Selain aliran di atas, kami juga memiliki DataInputStream dan DataOutputStream . Mereka melakukan pekerjaan yang sama seperti thread lainnya. Perbedaannya adalah DataInput / OutputStream terutama digunakan untuk membaca/menulis tipe primitif, sedangkan ObjectInput / OutputStream terutama digunakan untuk objek dan seterusnya.

Pembaca dan Penulis

Di Java I/O, jika kita membaca/menulis data ke stream, kita harus mengonversinya menjadi byte terlebih dahulu. Hanya dengan begitu kita dapat membaca atau menulisnya ke stream. InputStreamReader dan OutputStreamWriter melakukan ini secara otomatis.

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

Membaca dan menulis secara paralel

Terkadang kita memerlukan dukungan multithreading di Streams. Sederhananya, kami ingin membaca dan menulis ke aliran dari thread terpisah. Untuk ini kita perlu menggunakan 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()
   }