Reader sınıfı

Reader sınıfı
java.lang.Object
java.io.Reader
Karekter akımlarını okuyan soyut (abstract) sınıftır. Soyut olmasına neden olan ve dolayısıyla alt
sınıflarda kurulması gereken tek metodu read(char[], int, int) metodudur. Böyle olmakla
birlikte, alt sınıflarda çoğu öteki metotlarını baskılar (override).
Kılgıladığı Arayüzler:
Closeable, AutoCloseable, Readable
Kurucuları:
protected Reader()
Karekter akımı okumak için Reader nesnesi yaratır. Yaratılan nesne kendi kendisiyle eşzamanlı olur.
protected Reader(Object lock)
Karekter akımı okumak için Reader nesnesi yaratır. Yaratılan nesne parametrede verilen Object ile
eşzamanlı olur.
Alt Sınıfları:
BufferedReader, CharArrayReader, FilterReader, InputStreamReader, PipedReader, StringReader
Bildirimi:
public abstract class Reader
extends Object
implements Readable, Closeable
Karekter akımlarını okuyan soyut sınıf. Alt sınıfların kılgılaması gereken metotlar yalnızca
read(char[], int, int)
close()
metotlarıdır. Ancak alt sınıfların çoğu Reader sınıfının metotlarını baskılayarak (override) ek etkinlik
ya da ek işlevsellik kazandırırlar.
Reader sınıfının metotları:
abstract void close()
Akımı durdurur
ve ona tahsis edilen kaynakları serbest bırakır.
void mark(int readAheadLimit)
Akımda o andaki konumu işaretler.
boolean
markSupported()
Akımın mark işlemini destekleyip desteklemediği hakkında bilgi
verir..
int read()
Akımdan bir karekter okur.
read(char[] cbuf)
int
Akımdan karekterleri okur ve cbuf array’ine yazar
abstract
int read(char[] cbuf,
int off,
int len)
Array’in belirlenen bölgesine okuduğu karekterleri yazar.
int
read(CharBuffer target)
Okuduğu karekterleri,
parametrede
yazar.
ready()
boolean
Akımın okunmaya hazır olup olmadığını belirtir.
verilen
target
karekter
buffer’ına
void reset()
Akımı yeniden konumlandırır (reset).
long skip(long n)
Okunan akımda n karekter atlar.
java.lang.Object sınıfından kalıtsal gelen metotlar:
clone, equals, finalize, getClass, hashCode, notify, notifyAll,
toString, wait, wait, wait
Giriş/Çıkış’ın Üst Sınıflarını Kavramak
Reader ve InputStream sınıfları aynı read() metotlarına sahiptirler. Ancak işlevleri farklıdır.
InputStream sınıfının üç read() metodu byte ya da byte array’i okurlar:
int
int
int
read()
read(byte[] b)
read(byte[] b, int off, int len)
Reader sınıfının üç read() metodu cahar ya da char array’i okurlar:
int
read()
int
read(char[] cbuf)
bstract int
read(char[] cbuf, int off, int len)
Ayrıca Reader ve InputStream sınıfları akımda yer işaretleme (mark) belli yerleri atlama (skip)
ve akımda yer belirleyen metotlara sahiptirler.
Writer ve OutputStream sınıfları da benzer işlevlere sahiptirler. Her ikisinin write metotları
vardır. Writer sınıfının write() metotları hedefe char ya da char array’i yazarlar:
void
void
void
void
write(int c)
write(char cbuf[])
write(char cbuf[], int offset, int length)
write(String s)
OutputStream sınıfının write() metotları hedefe byte ya da byte array’i yazarlar:
void
void
void
write(int c)
write(byte[]
write(byte[]
cbuf)
cbuf, int offset, int length)
InputStream, OutputStream, Reader ve Writer nesneleri yaratılır yaratılmaz, ilgili akım
açılır ve veri akıtmaya hazır olur. Bir akımı kapatmak için close() metodu kullanılabilir. Eğer bu
yapılmazsa, nesnenin işi bitince (işaretçisi yok olunca), çöp toplayıcı (garbage collector) akımı kapatır.
//Unix cat aracını java'da kılgılma
import java.io.*;
class cat {
public static void main(String args[]) {
String thisLine;
// args üzerinde döngü
for (int i = 0; i < args.length; i++) {
// Dosyayı okumak için aç
try {
BufferedReader br = new BufferedReader(new
FileReader(args[i]));
while ((thisLine = br.readLine()) != null) {
System.out.println(thisLine);
}
} catch (IOException e) {
System.err.println("Error: " + e);
}
}
}
}
Klavyeden girilen satırları okur.
import java.io.*;
/**
* Klavyeden girilen satırları okur.
**/
public class Demo {
public static void main(String arg[]) {
// System.in std giriş akımı her zaman açoktır (default).
// 16-bit karekterleri okutmak için, InputStreamReader sınıfına göm.
InputStreamReader reader = new InputStreamReader(System.in);
// reader nesnesi BufferedReader içine gömülüyor.
BufferedReader buf_in = new BufferedReader(reader);
// 16-bit karekterleri yazmak için, OutputStreamWriter sınıfına göm.
OutputStreamWriter writer = new OutputStreamWriter(System.out);
// writer nesnesini PrintWriter sınıfına göm.
PrintWriter print_writer = new PrintWriter(writer, true);
String str = " ";
try {
/*
* Bir seferde bir satır oku. Döngüden çıkmak için "$" yaz.
*/
do {
// Klavyeden text oku
str = buf_in.readLine();
// Okunanı ekrana yaz
print_writer.println("echo " + str);
} while (!str.toLowerCase().equals("$"));
} catch (IOException e) {
System.out.println("IO exception = " + e);
}
}
}
import java.io.*;
class Demo {
public static void main(String args[]) throws IOException {
String s = "Bu © telif hakkı (copyright) simgesidir,"
+ " ama bu &copy değildir \\n";
char buf[] = new char[s.length()];
s.getChars(0, s.length(), buf, 0);
CharArrayReader in = new CharArrayReader(buf);
BufferedReader f = new BufferedReader(in);
int c;
boolean marked = false;
while ((c = f.read()) != -1) {
switch (c) {
case '&':
if (!marked) {
f.mark(32);
marked = true;
} else {
marked = false;
}
break;
case ';':
if (marked) {
marked = false;
System.out.print("(c)");
} else
System.out.print((char) c);
break;
case ' ':
if (marked) {
marked = false;
f.reset();
System.out.print("&");
} else
System.out.print((char) c);
break;
default:
if (!marked)
System.out.print((char) c);
break;
}
}
}
}
package inputstream;
import java.io.*;
public class InputStream {
public static void main(String[] args) {
char buf[] = new char[80];
System.out.println("Lütfen bir metin giriniz");
try {
//Reader x = new InputStreamReader(System.in);
InputStreamReader x = new InputStreamReader(System.in);
x.read(buf, 0, 80);
} catch (Exception e) {
System.out.println("Error: " + e.toString());
}
String s = new String(buf);
System.out.println(s);
}
}
Örnek:
Aşağıdaki örnekte, önce System.in değişkeni InputStreamReader sınıfına gömülüyor. Sonra
onun bir nesnesi BufferedReader sınıfına gömülüyor. Böylece, BufferedReader sınıfının
readLine() metodunu kullanabilme olanağı yaratılıyor. Bu metot, giriş akımından gelen bütün
satırı bir seferde okuyor. Ayrıca, int tipinden char tipine dönüştürme deyimlerine de gerekseme
kalmıyor; çünkü readLine() metodu geliş akımından gelenleri int olarak değil, char olarak
veriyor.
package inputStreamReader;
import java.io.*;
public class Demo {
public static void main(String arg[]) {
/**
* System.in std input stream akımı öntanımlı olarak açıktır.
* InputStreamReader nesnesi 16-bitlik karekterleri okuyabilir.
* System.in onun bir parametresi oluyor.
*/
System.out.println("Lütfenbir metin giriniz. ");
InputStreamReader isr = new InputStreamReader(System.in);
// isr değişkeni BufferedReader sınıfına gömülüyor.
BufferedReader br = new BufferedReader(isr);
/**
* System.out değişkeni OutputStreamWriter sınıfına gömülerek 16-bitlik
* karekterleri yazması sağlanıyor.
*/
OutputStreamWriter osw = new OutputStreamWriter(System.out);
PrintWriter pw = new PrintWriter(osw, true);
String str = "q";
/**
* Bu blok bir seferde bir satır okur.
*/
try {
do {
// Klavyeden text oku
str = br.readLine();
// Okunanı ekrana yaz.
pw.println("okunan: " + str);
} while (!str.toLowerCase().equals("q"));
} catch (IOException e) {
System.out.println("IO exception = " + e);
}
}
}
/**
a 1 b 2 c 3 79488 slkglk j7h89 12.3
okunan: a 1 b 2 c 3 79488 slkglk j7h89 12.3
*/
import java.io.*;
public class Demo {
public static void main(String args[]) {
int ch = 0;
int[] numbers = { 17, 5, 14, 23, 70 };
try {
System.out.println("1. Veri yaz");
System.out.println("2. Veri Oku");
System.out.println("Lütfen seçiminizi yapınız ");
BufferedReader br = new BufferedReader(new InputStreamReader(
System.in));
ch = Integer.parseInt(br.readLine());
switch (ch) {
case 1:
FileOutputStream fos = new FileOutputStream("datafile.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
DataOutputStream out = new DataOutputStream(bos);
for (int i = 0; i < numbers.length; i++) {
out.writeInt(numbers[i]);
}
System.out.println("yazma başarılı");
out.close();
case 2:
FileInputStream fis = new FileInputStream("datafile.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
DataInputStream in = new DataInputStream(bis);
while (true) {
System.out.println(in.readInt());
}
default:
System.out.println("Geçersiz seçim");
}
} catch (Exception e) {
System.err.println("Veriyi dosyaya yazarken read/write hatası: "
+ e);
}
}
}