喝咖啡休息#169。類型比較。Java.io - Java 中的 I/O 操作

在 Random-TW 群組發布

Java中類型的比較

來源：Theflashreads 在這篇文章中，您將了解 Java 中的幾種類型比較選項。 喝咖啡休息#169。類型比較。 Java.io - Java 中的 I/O 操作 - 1

確定給定物件是否是給定類別、超類別或介面的實例的最常見方法是使用二進位instanceof運算子。它包括隱式空檢查，如果類型未綁定，則會產生編譯時錯誤。但是，它不允許使用原語，並且要求在編譯時知道類型。

如果您需要動態執行時間檢查

在這種情況下，請在Class中使用等效的boolean isInstance(Object obj)方法。它還包括空檢查，但允許基元：

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

檢查兩種類型的相容性

如果需要檢查子類型關係，請使用Class中的boolean isAssignableFrom(Class<?> cls)方法。這將有助於捕獲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 - Java 中的 I/O 操作

來源：Medium 本文內容是關於Java中的I/O操作。 喝咖啡休息#169。類型比較。 Java.io - Java 中的 I/O 操作 - 2

在Android和Java應用程式開發中，輸入/輸出（Java I/O）是經常使用的主題之一，但由於某種原因很少被提及。然而，它的應用範圍很廣泛：例如，我們在將點陣圖影像轉換為JPEG格式時或在讀取/寫入常規檔案時執行I/O操作。Java 套件 java.io 具有執行 I/O 操作所需的所有必要類別。這些操作是使用執行緒執行的。反過來，執行緒幫助執行讀取或寫入操作。例如，將訊息寫入檔案。

流的類型

Java中有兩種類型的線程：

位元組流（位元組流）
字元流

位元組流

位元組流用於讀取和寫入一個位元組的資料。它包括 Java InputStream和OutputStream類別。InputStream幫助讀取數據，OutputStream幫助將數據寫入目標（可能是檔案）。

字元流

字元流用於讀寫一個字元的資料。它包括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()
   }

留言

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION