Comparação de tipos em Java
Fonte:
Theflashreads Neste post, você aprenderá sobre diversas opções de comparação de tipos em Java. A maneira mais comum de determinar se um determinado objeto é
uma instância de uma determinada classe, superclasse ou interface é usar o operador binário
instanceof . Inclui uma verificação nula implícita e gera um erro em tempo de compilação se os tipos não estiverem vinculados. Porém, não permite o uso de primitivas e exige que os tipos sejam conhecidos em tempo de compilação.
Se você precisar de verificação dinâmica de tempo de execução
Nesse caso, use o método
booleano isInstance(Object obj) equivalente em
Class . Também inclui verificação de nulos, mas permite primitivas:
a instanceof B
null instanceof B
a.getClass().isInstance(b);
Class<T> type = b.getClass();
type.isInstance(a);
int x = 4;
Integer.class.isInstance(x);
Verificando a compatibilidade de dois tipos
Se você precisar verificar o relacionamento do subtipo, use o método
booleano isAssignableFrom(Class<?> cls) em
Class . Isso ajudará a capturar
NullPointerException .
Class<?> aClass = CharSequence.class;
Class<?> bClass = String.class;
bClass.isAssignableFrom(aClass());
CharSequence[].class.isAssignableFrom(String[].class);
Integer[].class.isAssignableFrom(String[].class);
Correspondência de padrões (Java 14)
if(a instanceof B b) {
b.toString();
}
Tipos especiais
enum Color { WHITE, GRAY, BLACK }
Color.class.isEnum();
Color.WHITE instanceof Enum;
String[].class.isArray();
Class<?> componentType = obj.getComponentType();
int.class.isPrimitive();
Java.io - Operações de E/S em Java
Fonte:
Médio O conteúdo deste artigo é sobre operações de E/S em Java. No desenvolvimento de aplicativos Android e Java, entrada/saída (Java I/O) é um dos tópicos frequentemente usados, mas por algum motivo raramente é mencionado. No entanto, seu escopo de aplicação é amplo: por exemplo, realizamos operações de E/S ao converter uma imagem bitmap para o formato JPEG ou durante a leitura/gravação de um arquivo normal. O pacote Java java.io possui todas as classes necessárias para realizar operações de E/S. Essas operações são realizadas usando threads. Por sua vez, os threads ajudam a realizar operações de leitura ou gravação. Por exemplo, escrevendo uma mensagem em um arquivo.
Tipos de fluxos
Existem dois tipos de threads em Java:
- Fluxo de bytes (fluxo de bytes)
- Fluxo de caracteres
Fluxo de bytes
Um Byte Stream é usado para ler e gravar um byte de dados. Inclui as classes Java
InputStream e
OutputStream .
InputStream ajuda a ler dados e
OutputStream ajuda a gravar dados em um destino (possivelmente um arquivo).
Fluxo de caracteres
Character Stream é usado para ler e escrever um caractere de dados. Inclui as classes Java
Reader e
Writer . Para entender
Reader e
Writer , você deve entender classes derivadas como
InputStreamReader ,
FileReader ,
OutputStreamWriter ,
FileWriter e outras.
InputStream e OutputStream
InputStream é usado para ler dados de uma fonte (possivelmente um arquivo). Não é útil por si só, mas possui várias classes derivadas, como
FileInputStream ,
ByteArrayInputStream e
ObjectInputStream .
OutputStream é usado para gravar dados em um destino (possivelmente um arquivo). Suas classes derivadas são
FileOutputStream ,
ByteArrayOutputStream e
ObjectOutputStream .
class InputOutput {
data class Car(val name: String): java.io.Serializable
fun fileStream() {
val outputStream = FileOutputStream("kotlin.txt")
outputStream.write(1)
outputStream.write("hello".toByteArray())
val inputStream = FileInputStream("kotlin.txt")
println(inputStream.read())
val msg = String(inputStream.readBytes())
println(msg)
outputStream.close()
inputStream.close()
}
fun byteArrayStream() {
val outputStream = ByteArrayOutputStream()
outputStream.write(1)
outputStream.write("hello".toByteArray())
val readByteArray = outputStream.toByteArray()
val inputStream = ByteArrayInputStream(readByteArray)
println(inputStream.read())
val msg = String(inputStream.readBytes())
println(msg)
outputStream.close()
inputStream.close()
}
fun objectStream() {
val car = Car(name = "BMW")
val fileOutputStream = FileOutputStream("kotlin.txt")
val objOutputStream = ObjectOutputStream(fileOutputStream)
objOutputStream.writeObject(car)
val fileInputStream = FileInputStream("kotlin.txt")
val objInputStream = ObjectInputStream(fileInputStream)
val carObject = objInputStream.readObject() as Car
println(carObject.name)
fileOutputStream.close()
objOutputStream.close()
fileInputStream.close()
objInputStream.close()
}
fun bufferStream() {
val fileOutputStream = FileOutputStream("kotlin.txt")
val outputStream = BufferedOutputStream(fileOutputStream)
outputStream.write("hello".toByteArray())
outputStream.flush()
val fileInputStream = FileInputStream("kotlin.txt")
val inputStream = BufferedInputStream(fileInputStream)
val msg = String(inputStream.readBytes())
println(msg)
fileOutputStream.close()
fileInputStream.close()
}
}
Além dos streams acima, também temos
DataInputStream e
DataOutputStream . Eles fazem o mesmo trabalho que outros threads. A diferença é que
DataInput /
OutputStream é usado principalmente para leitura/gravação de tipos primitivos, enquanto
ObjectInput /
OutputStream é usado principalmente para objetos e assim por diante.
Leitores e Escritores
No Java I/O, se lermos/escrevermos dados em fluxos, devemos primeiro convertê-los em bytes. Só então poderemos lê-los ou gravá-los em streams.
InputStreamReader e
OutputStreamWriter fazem isso automaticamente.
class ReaderWriter {
fun readerWriter() {
val outputStream = FileOutputStream("kotlin.txt")
val writer = OutputStreamWriter(outputStream)
writer.write("Hello Kotlin")
writer.flush()
val inputStream = FileInputStream("kotlin.txt")
val reader = InputStreamReader(inputStream)
println(reader.readText())
}
}
Leitura e gravação paralela
Às vezes precisamos de suporte multithreading no Streams. Simplificando, queremos ler e escrever em fluxos de threads separados. Para isso precisamos usar
PipedInput /
OutputStream .
fun pipedStream() {
val inputStream = PipedInputStream()
val outputStream = PipedOutputStream()
inputStream.connect(outputStream)
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()
}
}
}
val readThread = object : Thread() {
override fun run() {
try {
for (i in 0..100) {
println("Read : ${inputStream.read()}")
}
} catch (e: Exception) {
e.printStackTrace()
}
}
}
writeThread.start()
readThread.start()
}
GO TO FULL VERSION