Confronto di tipi in Java
Fonte:
Theflashreads In questo post imparerai diversi tipi di opzioni di confronto in Java. Il modo più comune per determinare se un dato oggetto è
un'istanza di una determinata classe, superclasse o interfaccia è utilizzare l'operatore binario
di istanza di . Include un controllo null implicito e genera un errore in fase di compilazione se i tipi non sono associati. Tuttavia, non consente l'uso di primitive e richiede che i tipi siano conosciuti in fase di compilazione.
Se hai bisogno di un controllo dinamico del runtime
In questo caso, utilizzare il metodo
booleano equivalente isInstance(Object obj) in
Class . Include anche il controllo nullo, ma consente le primitive:
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);
Verifica della compatibilità dei due tipi
Se è necessario verificare la relazione del sottotipo, utilizzare il metodo
booleano isAssignableFrom(Class<?> cls) in
Class . Questo aiuterà a catturare
NullPointerException .
Class<?> aClass = CharSequence.class;
Class<?> bClass = String.class;
bClass.isAssignableFrom(aClass());
CharSequence[].class.isAssignableFrom(String[].class);
Integer[].class.isAssignableFrom(String[].class);
Corrispondenza di modelli (Java 14)
if(a instanceof B b) {
b.toString();
}
Tipi speciali
enum Color { WHITE, GRAY, BLACK }
Color.class.isEnum();
Color.WHITE instanceof Enum;
String[].class.isArray();
Class<?> componentType = obj.getComponentType();
int.class.isPrimitive();
Java.io - Operazioni di I/O in Java
Fonte:
Medium Il contenuto di questo articolo riguarda le operazioni di I/O in Java. Nello sviluppo di applicazioni Android e Java, l'input/output (Java I/O) è uno degli argomenti utilizzati spesso, ma per qualche motivo viene menzionato raramente. Tuttavia, il suo campo di applicazione è ampio: ad esempio, eseguiamo operazioni di I/O durante la conversione di un'immagine bitmap in formato JPEG o durante la lettura/scrittura di un file normale. Il pacchetto Java java.io contiene tutte le classi necessarie per eseguire operazioni di I/O. Queste operazioni vengono eseguite utilizzando i thread. A loro volta, i thread aiutano a eseguire operazioni di lettura o scrittura. Ad esempio, scrivere un messaggio in un file.
Tipi di flussi
Esistono due tipi di thread in Java:
- Flusso di byte (flusso di byte)
- Flusso di personaggi
Flusso di byte
Un flusso di byte viene utilizzato per leggere e scrivere un byte di dati. Include le classi Java
InputStream e
OutputStream .
InputStream aiuta a leggere i dati e
OutputStream aiuta a scrivere i dati su una destinazione (possibilmente un file).
Flusso di caratteri
Il flusso di caratteri viene utilizzato per leggere e scrivere un carattere di dati. Include
le classi Java Reader e
Writer . Per comprendere
Reader e
Writer , è necessario comprendere le classi derivate come
InputStreamReader ,
FileReader ,
OutputStreamWriter ,
FileWriter e altre.
InputStream e OutputStream
InputStream viene utilizzato per leggere i dati da una fonte (possibilmente un file). Non è utile di per sé, ma ha diverse classi derivate come
FileInputStream ,
ByteArrayInputStream e
ObjectInputStream .
OutputStream viene utilizzato per scrivere dati su una destinazione (possibilmente un file). Le sue classi derivate sono
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()
}
}
Oltre ai flussi di cui sopra, abbiamo anche
DataInputStream e
DataOutputStream . Fanno lo stesso lavoro degli altri thread. La differenza è che
DataInput /
OutputStream viene utilizzato principalmente per leggere/scrivere tipi primitivi, mentre
ObjectInput /
OutputStream viene utilizzato principalmente per oggetti e così via.
Lettori e scrittori
Nell'I/O Java, se leggiamo/scriviamo dati nei flussi, dobbiamo prima convertirli in byte. Solo allora possiamo leggerli o scriverli nei flussi.
InputStreamReader e
OutputStreamWriter lo fanno 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())
}
}
Lettura e scrittura parallela
A volte abbiamo bisogno del supporto multithreading in Streams. In poche parole, vogliamo leggere e scrivere su flussi da thread separati. Per questo dobbiamo usare
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