Nghỉ giải lao #169. So sánh các loại. Java.io - Hoạt động I/O trong Java

So sánh các loại trong Java

Nguồn: Theflashreads Trong bài đăng này, bạn sẽ tìm hiểu về một số tùy chọn so sánh loại trong Java. Cách phổ biến nhất để xác định xem một đối tượng nhất định có phải là một thể hiện của một lớp, siêu lớp hoặc giao diện nhất định hay không là sử dụng toán tử instanceof nhị phân . Nó bao gồm kiểm tra null ngầm định và tạo ra lỗi thời gian biên dịch nếu các loại không bị ràng buộc. Tuy nhiên, nó không cho phép sử dụng kiểu nguyên thủy và yêu cầu phải biết các kiểu đó tại thời điểm biên dịch.

Nếu bạn cần kiểm tra thời gian chạy động

Trong trường hợp này, hãy sử dụng phương thức boolean isInstance(Object obj) tương đương trong Class . Nó cũng bao gồm việc kiểm tra null, nhưng cho phép các kiểu nguyên thủy:

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

Kiểm tra tính tương thích của hai loại

Nếu bạn cần kiểm tra mối quan hệ kiểu con, hãy sử dụng phương thức boolean isAssignableFrom(Class<?> cls) trong Class . Điều này sẽ giúp bắt 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

Khớp mẫu (Java 14)

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

Các loại đặc biệt

// 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 - Hoạt động I/O trong Java

Nguồn: Medium Nội dung của bài viết này là về các thao tác I/O trong Java. Trong phát triển ứng dụng Android và Java, đầu vào/đầu ra (Java I/O) là một trong những chủ đề thường được sử dụng nhưng vì một lý do nào đó lại ít được nhắc đến. Tuy nhiên, phạm vi ứng dụng của nó rất rộng: ví dụ: chúng tôi thực hiện các thao tác I/O khi chuyển đổi hình ảnh bitmap sang định dạng JPEG hoặc khi đọc/ghi một tệp thông thường. Gói Java java.io có tất cả các lớp cần thiết để thực hiện các thao tác I/O. Các hoạt động này được thực hiện bằng cách sử dụng các luồng. Đổi lại, các luồng giúp thực hiện các thao tác đọc hoặc ghi. Ví dụ, viết một tin nhắn vào một tập tin.

Các loại luồng

Có hai loại luồng trong Java:

1. Luồng byte (luồng byte)
2. Luồng ký tự

Luồng byte

Luồng Byte được sử dụng để đọc và ghi một byte dữ liệu. Nó bao gồm các lớp Java OutputStream và OutputStream . inputStream giúp đọc dữ liệu và OutputStream giúp ghi dữ liệu vào mục tiêu (có thể là tệp).

Luồng ký tự

Luồng ký tự được sử dụng để đọc và ghi một ký tự dữ liệu. Nó bao gồm các lớp Java Reader và Writer . Để hiểu Reader và Writer , bạn phải hiểu các lớp dẫn xuất như inputStreamReader , FileReader , OutputStreamWriter , FileWriter và các lớp khác.

Luồng đầu vào và luồng đầu ra

inputStream được sử dụng để đọc dữ liệu từ một nguồn (có thể là tệp). Bản thân nó không hữu ích nhưng nó có một số lớp dẫn xuất như FileInputStream , ByteArrayInputStream và ObjectInputStream . OutputStream được sử dụng để ghi dữ liệu vào đích (có thể là tệp). Các lớp dẫn xuất của nó là FileOutputStream , ByteArrayOutputStream và 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()
    }
}

Ngoài các luồng trên, chúng tôi còn có DataInputStream và DataOutputStream . Họ làm công việc tương tự như các chủ đề khác. Sự khác biệt là DataInput / OutputStream chủ yếu được sử dụng để đọc/ghi các kiểu nguyên thủy, trong khi ObjectInput / OutputStream chủ yếu được sử dụng cho các đối tượng, v.v.

Người đọc và người viết

Trong Java I/O, nếu chúng ta đọc/ghi dữ liệu thành luồng, trước tiên chúng ta phải chuyển đổi chúng thành byte. Chỉ khi đó chúng ta mới có thể đọc hoặc ghi chúng vào luồng. inputStreamReader và OutputStreamWriter thực hiện việc này một cách tự động.

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

Đọc và ghi song song

Đôi khi chúng tôi cần hỗ trợ đa luồng trong Luồng. Nói một cách đơn giản, chúng ta muốn đọc và ghi vào các luồng từ các luồng riêng biệt. Để làm được điều này, chúng ta cần sử dụ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()
   }