Vergleich von Typen in Java
Quelle:
Theflashreads In diesem Beitrag erfahren Sie mehr über verschiedene Typenvergleichsoptionen in Java. Die gebräuchlichste Methode, um festzustellen, ob ein bestimmtes Objekt
eine Instanz einer bestimmten Klasse, Superklasse oder Schnittstelle ist, ist die Verwendung des binären
Instanzoperators . Es beinhaltet eine implizite Nullprüfung und generiert einen Fehler bei der Kompilierung, wenn die Typen nicht gebunden sind. Es erlaubt jedoch nicht die Verwendung von Grundelementen und erfordert, dass die Typen zur Kompilierungszeit bekannt sind.
Wenn Sie eine dynamische Laufzeitprüfung benötigen
Verwenden Sie in diesem Fall die entsprechende boolesche Methode isInstance(Object obj) in
Class . Es umfasst auch eine Nullprüfung, erlaubt jedoch Grundelemente:
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);
Überprüfung der Kompatibilität zweier Typen
Wenn Sie die Subtypbeziehung überprüfen müssen, verwenden Sie die
boolesche Methode isAssignableFrom(Class<?> cls) in
Class . Dies hilft dabei,
NullPointerException abzufangen .
Class<?> aClass = CharSequence.class;
Class<?> bClass = String.class;
bClass.isAssignableFrom(aClass());
CharSequence[].class.isAssignableFrom(String[].class);
Integer[].class.isAssignableFrom(String[].class);
Mustervergleich (Java 14)
if(a instanceof B b) {
b.toString();
}
Sondertypen
enum Color { WHITE, GRAY, BLACK }
Color.class.isEnum();
Color.WHITE instanceof Enum;
String[].class.isArray();
Class<?> componentType = obj.getComponentType();
int.class.isPrimitive();
Java.io – E/A-Operationen in Java
Quelle:
Medium Der Inhalt dieses Artikels befasst sich mit E/A-Operationen in Java. Bei der Entwicklung von Android- und Java-Anwendungen ist Eingabe/Ausgabe (Java I/O) eines der Themen, die häufig verwendet werden, aber aus irgendeinem Grund selten erwähnt werden. Der Anwendungsbereich ist jedoch breit: Wir führen beispielsweise I/O-Vorgänge beim Konvertieren eines Bitmap-Bilds in das JPEG-Format oder beim Lesen/Schreiben einer normalen Datei durch. Das Java-Paket java.io verfügt über alle notwendigen Klassen, die zur Durchführung von I/O-Operationen erforderlich sind. Diese Vorgänge werden mithilfe von Threads ausgeführt. Threads wiederum helfen bei der Durchführung von Lese- oder Schreibvorgängen. Zum Beispiel das Schreiben einer Nachricht in eine Datei.
Arten von Streams
In Java gibt es zwei Arten von Threads:
- Byte-Stream (Byte-Stream)
- Charakter-Stream
Byte-Stream
Ein Byte Stream wird zum Lesen und Schreiben eines Datenbytes verwendet. Es umfasst die Java- Klassen
InputStream und
OutputStream .
InputStream hilft beim Lesen von Daten und
OutputStream hilft beim Schreiben von Daten in ein Ziel (möglicherweise eine Datei).
Charakterstrom
Der Zeichenstrom wird zum Lesen und Schreiben eines Datenzeichens verwendet. Es umfasst
die Java-Klassen Reader und
Writer . Um
Reader und
Writer zu verstehen , müssen Sie abgeleitete Klassen wie
InputStreamReader ,
FileReader ,
OutputStreamWriter ,
FileWriter und andere verstehen.
InputStream und OutputStream
InputStream wird verwendet, um Daten aus einer Quelle (möglicherweise einer Datei) zu lesen. Es ist für sich genommen nicht nützlich, verfügt aber über mehrere abgeleitete Klassen wie
FileInputStream ,
ByteArrayInputStream und
ObjectInputStream .
OutputStream wird verwendet, um Daten in ein Ziel (möglicherweise eine Datei) zu schreiben. Die abgeleiteten Klassen sind
FileOutputStream ,
ByteArrayOutputStream und
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()
}
}
Neben den oben genannten Streams gibt es auch
DataInputStream und
DataOutputStream . Sie erledigen die gleiche Arbeit wie andere Threads. Der Unterschied besteht darin, dass
DataInput /
OutputStream hauptsächlich zum Lesen/Schreiben primitiver Typen verwendet wird, während
ObjectInput /
OutputStream hauptsächlich für Objekte usw. verwendet wird.
Leser und Schriftsteller
Wenn wir in Java I/O Daten in Streams lesen/schreiben, müssen wir sie zuerst in Bytes konvertieren. Erst dann können wir sie lesen oder in Streams schreiben.
InputStreamReader und
OutputStreamWriter erledigen dies automatisch.
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())
}
}
Paralleles Lesen und Schreiben
Manchmal benötigen wir Multithreading-Unterstützung in Streams. Einfach ausgedrückt möchten wir Streams aus separaten Threads lesen und schreiben. Dazu müssen wir
PipedInput /
OutputStream verwenden .
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