Coffee break #169. Perbandingan jenis. Java.io - Operasi I/O di Jawa

Perbandingan jenis di Jawa

Sumber: Theflashreads Dalam siaran ini, anda akan belajar tentang beberapa jenis pilihan perbandingan dalam Java. Cara yang paling biasa untuk menentukan sama ada objek tertentu ialah contoh kelas, superclass atau antara muka tertentu adalah dengan menggunakan operator binari instanceof . Ia termasuk semakan nol tersirat dan menjana ralat masa kompilasi jika jenis tidak terikat. Walau bagaimanapun, ia tidak membenarkan penggunaan primitif dan memerlukan jenis itu diketahui pada masa penyusunan.

Jika anda memerlukan semakan masa jalan dinamik

Dalam kes ini, gunakan kaedah boolean isInstance(Object obj) yang setara dalam Class . Ia juga termasuk semakan nol, tetapi membenarkan 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);

Menyemak keserasian dua jenis

Jika anda perlu menyemak perhubungan subjenis, gunakan kaedah boolean isAssignableFrom(Class<?> cls) dalam 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

Padanan Corak (Java 14)

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

Jenis khas

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

Sumber: Sederhana Kandungan artikel ini adalah mengenai operasi I/O di Java. Dalam pembangunan aplikasi Android dan Java, input/output (Java I/O) merupakan salah satu topik yang sering digunakan, tetapi atas sebab tertentu jarang disebut. Walau bagaimanapun, skop aplikasinya adalah luas: contohnya, kami melakukan operasi I/O apabila menukar imej bitmap kepada format JPEG atau semasa membaca/menulis fail biasa. Pakej Java java.io mempunyai semua kelas yang diperlukan untuk melaksanakan operasi I/O. Operasi ini dilakukan menggunakan benang. Seterusnya, benang membantu melaksanakan operasi baca atau tulis. Contohnya, menulis mesej ke fail.

Jenis-jenis aliran

Terdapat dua jenis benang dalam Java:

1. Strim Byte (strim bait)
2. Aliran Watak

Strim bait

Strim Byte digunakan untuk membaca dan menulis satu bait data. Ia termasuk kelas Java InputStream dan OutputStream . InputStream membantu membaca data dan OutputStream membantu menulis data ke sasaran (mungkin fail).

Aliran watak

Character Stream digunakan untuk membaca dan menulis satu aksara data. Ia termasuk kelas Reader dan Writer Java . Untuk memahami Pembaca dan Penulis , anda mesti memahami kelas terbitan seperti InputStreamReader , FileReader , OutputStreamWriter , FileWriter dan lain-lain.

InputStream dan OutputStream

InputStream digunakan untuk membaca data daripada sumber (mungkin fail). Ia tidak berguna dengan sendirinya, tetapi ia mempunyai beberapa kelas terbitan seperti FileInputStream , ByteArrayInputStream , dan ObjectInputStream . OutputStream digunakan untuk menulis data ke sasaran (mungkin fail). Kelas terbitannya ialah 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 daripada aliran di atas, kami juga mempunyai DataInputStream dan DataOutputStream . Mereka melakukan kerja yang sama seperti benang lain. Perbezaannya ialah DataInput / OutputStream digunakan terutamanya untuk membaca/menulis jenis primitif, manakala ObjectInput / OutputStream digunakan terutamanya untuk objek dan sebagainya.

Pembaca dan Penulis

Dalam Java I/O, jika kita membaca/menulis data ke strim, kita mesti menukarnya kepada bait terlebih dahulu. Hanya selepas itu kita boleh membaca atau menulisnya ke strim. InputStreamReader dan OutputStreamWriter melakukan ini secara automatik.

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

Baca dan tulis selari

Kadangkala kita memerlukan sokongan multithreading dalam Strim. Ringkasnya, kami ingin membaca dan menulis ke strim daripada benang yang berasingan. 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()
   }