커피 브레이크 #169. 유형 비교. Java.io - Java의 I/O 작업

Java의 유형 비교

출처: Theflashreads 이 게시물에서는 Java의 여러 유형 비교 옵션에 대해 알아봅니다. 주어진 객체가 주어진 클래스, 슈퍼클래스 또는 인터페이스의 인스턴스 커피 브레이크 #169. 유형 비교. Java.io - Java의 I/O 작업 - 1

인지 확인하는 가장 일반적인 방법은 바이너리 인스턴스of 연산자를 사용하는 것입니다 . 여기에는 암시적 null 검사가 포함되며 유형이 바인딩되지 않은 경우 컴파일 시간 오류가 생성됩니다. 그러나 기본 형식의 사용을 허용하지 않으며 컴파일 타임에 유형을 알아야 합니다.

동적 런타임 확인이 필요한 경우

이 경우 Class 에서 동등한 부울 isInstance(Object obj) 메서드를 사용하세요 . 또한 null 검사도 포함하지만 기본 형식도 허용합니다.

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 에서 부울 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 작업

출처: 중간 이 기사의 내용은 Java의 I/O 작업에 관한 것입니다. 커피 브레이크 #169. 유형 비교. Java.io - Java의 I/O 작업 - 2

Android 및 Java 애플리케이션 개발에서 입출력(Java I/O)은 자주 사용되는 주제 중 하나이지만 어떤 이유로 거의 언급되지 않습니다. 그러나 적용 범위는 넓습니다. 예를 들어 비트맵 이미지를 JPEG 형식으로 변환하거나 일반 파일을 읽거나 쓰는 동안 I/O 작업을 수행합니다. Java 패키지 java.io에는 I/O 작업을 수행하는 데 필요한 모든 클래스가 있습니다. 이러한 작업은 스레드를 사용하여 수행됩니다. 결과적으로 스레드는 읽기 또는 쓰기 작업을 수행하는 데 도움이 됩니다. 예를 들어, 파일에 메시지를 씁니다.

스트림 유형

Java에는 두 가지 유형의 스레드가 있습니다.

바이트 스트림(바이트 스트림)
캐릭터 스트림

바이트 스트림

바이트 스트림은 1바이트의 데이터를 읽고 쓰는 데 사용됩니다. 여기에는 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