Coffee break #169. Paghahambing ng mga uri. Java.io - I/O Operations sa Java

Paghahambing ng mga uri sa Java

Pinagmulan: Theflashreads Sa post na ito, matututunan mo ang tungkol sa ilang uri ng mga pagpipilian sa paghahambing sa Java. Ang pinakakaraniwang paraan upang matukoy kung ang isang ibinigay na bagay ay isang halimbawa ng isang partikular na klase, superclass, o interface ay ang paggamit ng binary instanceof operator . Kabilang dito ang isang implicit null check at bumubuo ng isang compile-time na error kung ang mga uri ay hindi nakatali. Gayunpaman, hindi nito pinapayagan ang paggamit ng mga primitive at nangangailangan na malaman ang mga uri sa oras ng pag-compile.

Kung kailangan mo ng dynamic na runtime checking

Sa kasong ito, gamitin ang katumbas na boolean isInstance(Object obj) na pamamaraan sa Class . Kasama rin dito ang null checking, ngunit pinapayagan ang mga 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);

Sinusuri ang pagiging tugma ng dalawang uri

Kung kailangan mong suriin ang subtype na relasyon, gamitin ang boolean isAssignableFrom(Class<?> cls) na pamamaraan sa Class . Makakatulong ito na mahuli ang 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

Pagtutugma ng Pattern (Java 14)

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

Mga espesyal na uri

// 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 - I/O Operations sa Java

Source: Medium Ang nilalaman ng artikulong ito ay tungkol sa mga operasyon ng I/O sa Java. Sa Android at Java application development, ang input/output (Java I/O) ay isa sa mga paksang kadalasang ginagamit, ngunit sa ilang kadahilanan ay bihirang banggitin. Gayunpaman, malawak ang saklaw ng aplikasyon nito: halimbawa, nagsasagawa kami ng mga operasyong I/O kapag nagko-convert ng bitmap na imahe sa JPEG na format o habang nagbabasa/nagsusulat ng regular na file. Ang Java package na java.io ay mayroong lahat ng kinakailangang klase na kinakailangan upang maisagawa ang mga operasyon ng I/O. Ang mga operasyong ito ay ginagawa gamit ang mga thread. Kaugnay nito, ang mga thread ay tumutulong sa pagsasagawa ng mga operasyon sa pagbasa o pagsulat. Halimbawa, ang pagsusulat ng mensahe sa isang file.

Mga uri ng batis

Mayroong dalawang uri ng mga thread sa Java:

1. Byte Stream (byte stream)
2. Stream ng Character

Byte stream

Ang isang Byte Stream ay ginagamit upang magbasa at magsulat ng isang byte ng data. Kabilang dito ang mga klase ng Java InputStream at OutputStream . Tumutulong ang InputStream na magbasa ng data at tumutulong ang OutputStream na magsulat ng data sa isang target (maaaring isang file).

Stream ng character

Ginagamit ang Character Stream upang basahin at isulat ang isang character ng data. Kabilang dito ang mga klase ng Reader at Writer Java . Upang maunawaan ang Reader at Writer , dapat mong maunawaan ang mga nagmula na klase tulad ng InputStreamReader , FileReader , OutputStreamWriter , FileWriter at iba pa.

InputStream at OutputStream

Ang InputStream ay ginagamit upang basahin ang data mula sa isang pinagmulan (maaaring isang file). Hindi ito kapaki-pakinabang sa sarili nitong, ngunit mayroon itong ilang mga nagmula na klase tulad ng FileInputStream , ByteArrayInputStream , at ObjectInputStream . Ginagamit ang OutputStream upang magsulat ng data sa isang target (maaaring isang file). Ang mga nagmula nitong klase ay FileOutputStream , ByteArrayOutputStream , at 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()
    }
}

Bukod sa mga stream sa itaas, mayroon din kaming DataInputStream at DataOutputStream . Ginagawa nila ang parehong gawain tulad ng ibang mga thread. Ang pagkakaiba ay ang DataInput / OutputStream ay pangunahing ginagamit para sa pagbabasa/pagsusulat ng mga primitive na uri, habang ang ObjectInput / OutputStream ay pangunahing ginagamit para sa mga bagay at iba pa.

Mga Mambabasa at Manunulat

Sa Java I/O, kung nagbabasa/nagsusulat tayo ng data sa mga stream, dapat muna nating i-convert ang mga ito sa bytes. Saka lamang natin ito mababasa o maisusulat sa mga stream. Awtomatikong ginagawa ito ng InputStreamReader at OutputStreamWriter .

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

Parallel read and write

Minsan kailangan namin ng suporta sa multithreading sa Streams. Sa madaling salita, gusto naming magbasa at magsulat sa mga stream mula sa magkahiwalay na mga thread. Para dito kailangan nating gumamit ng 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()
   }