คอฟฟี่เบรค #169. เปรียบเทียบประเภท Java.io - การดำเนินการ I/O ใน Java

การเปรียบเทียบประเภทใน Java

ที่มา: Theflashreads ในโพสต์นี้ คุณจะได้เรียนรู้เกี่ยวกับตัวเลือกการเปรียบเทียบหลายประเภทใน Java วิธีที่พบบ่อยที่สุดในการพิจารณาว่าอ็อบเจ็กต์ที่กำหนดนั้นเป็นอินสแตนซ์ของคลาส ซูเปอร์คลาส หรืออินเทอร์เฟซที่กำหนดหรือไม่ คือการใช้อินสแตนซ์ไบนารีของตัวดำเนิน การ รวมถึงการตรวจสอบค่า null โดยนัย และสร้างข้อผิดพลาดเวลาคอมไพล์หากประเภทไม่ได้ถูกผูกไว้ อย่างไรก็ตาม ไม่อนุญาตให้ใช้ข้อมูลพื้นฐานและกำหนดให้ต้องทราบประเภท ณ เวลารวบรวม

หากคุณต้องการการตรวจสอบรันไทม์แบบไดนามิก

ในกรณีนี้ ให้ใช้เมธอด isInstance(Object obj)แบบ บู ลี นที่เทียบเท่า ในClass นอกจากนี้ยังมีการตรวจสอบค่าว่างด้วย แต่อนุญาตให้ใช้ข้อมูลพื้นฐาน:

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

การตรวจสอบความเข้ากันได้ของสองประเภท

หากคุณต้องการตรวจสอบความสัมพันธ์ของประเภทย่อย ให้ใช้ เมธอดบูลี นisAssignableFrom(Class<?> cls)ในClass สิ่งนี้จะช่วยจับ 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

การจับคู่รูปแบบ (Java 14)

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

ชนิดพิเศษ

// 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 ใน Java

ที่มา: สื่อ เนื้อหาของบทความนี้เกี่ยวกับการดำเนินการ I/O ใน Java ในการพัฒนาแอปพลิเคชัน Android และ Java อินพุต/เอาท์พุต (Java I/O) เป็นหนึ่งในหัวข้อที่มักใช้ แต่ไม่ค่อยมีการกล่าวถึงด้วยเหตุผลบางประการ อย่างไรก็ตาม ขอบเขตการใช้งานนั้นกว้าง: ตัวอย่างเช่น เราดำเนินการ I/O เมื่อแปลงภาพบิตแมปเป็นรูปแบบ JPEG หรือในขณะที่อ่าน/เขียนไฟล์ปกติ แพ็คเกจ Java java.io มีคลาสที่จำเป็นทั้งหมดที่จำเป็นในการดำเนินการ I/O การดำเนินการเหล่านี้ดำเนินการโดยใช้เธรด ในทางกลับกัน เธรดจะช่วยดำเนินการอ่านหรือเขียน เช่น การเขียนข้อความลงไฟล์

ประเภทของสตรีม

เธรดใน Java มีสองประเภท:

1. ไบต์สตรีม (ไบต์สตรีม)
2. สตรีมตัวละคร

กระแสไบต์

Byte Stream ใช้เพื่ออ่านและเขียนข้อมูลหนึ่งไบต์ ประกอบด้วย คลาส Java InputStreamและOutputStream InputStreamช่วยในการอ่านข้อมูล และOutputStreamช่วยในการเขียนข้อมูลไปยังเป้าหมาย (อาจเป็นไฟล์)

สตรีมตัวละคร

Character Stream ใช้เพื่ออ่านและเขียนข้อมูลหนึ่งอักขระ ประกอบด้วย คลาส ReaderและWriter Java เพื่อทำความเข้าใจReaderและWriterคุณต้องเข้าใจคลาสที่ได้รับ เช่นInputStreamReader , FileReader , OutputStreamWriter , FileWriterและอื่นๆ

สตรีมอินพุตและเอาต์พุตสตรีม

InputStreamใช้เพื่ออ่านข้อมูลจากแหล่งที่มา (อาจเป็นไฟล์) มันไม่มีประโยชน์ในตัวเอง แต่มีคลาส ที่ ได้รับมาหลายคลาสเช่นFileInputStream , ByteArrayInputStreamและObjectInputStream OutputStreamใช้เพื่อเขียนข้อมูลไปยังเป้าหมาย (อาจเป็นไฟล์) คลาสที่ได้รับคือ FileOutputStream , ByteArrayOutputStreamและ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()
    }
}

นอกเหนือจากสตรีมข้างต้นแล้ว เรายังมีDataInputStream และ DataOutputStream อีก ด้วย พวกมันทำงานเหมือนกับเธรดอื่น ความแตกต่างก็คือDataInput / OutputStreamส่วนใหญ่จะใช้สำหรับการอ่าน/การเขียนประเภทดั้งเดิม ในขณะที่ObjectInput / OutputStreamส่วนใหญ่จะใช้สำหรับวัตถุและอื่นๆ

ผู้อ่านและนักเขียน

ใน Java I/O หากเราอ่าน/เขียนข้อมูลไปยังสตรีม เราจะต้องแปลงเป็นไบต์ก่อน จากนั้นเราจะอ่านหรือเขียนลงในสตรีมได้ InputStreamReaderและ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())
    }
}

อ่านและเขียนแบบขนาน

บางครั้งเราต้องการการสนับสนุนแบบมัลติเธรดใน Streams พูดง่ายๆ ก็คือ เราต้องการอ่านและเขียนไปยังสตรีมจากเธรดที่แยกจากกัน สำหรับสิ่งนี้เรา จำเป็น ต้องใช้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()
   }