Java’da çıkmış olduğumuz uçsuz bucaksız bilgi serüveninde dosya işlemleri yani I/O kavramlarına bir önceki yazımızın içerisinde değinerek “Java Dosya İşlemleri Nedir” sorusuna cevap aradık.
Eğer, henüz teorik olarak “dosya işlemleri” kavramı hakkında bir fikriniz yoksa ilgili içeriğe emrecelen.com.tr/java-dosya-islemleri-nedir/ bu bağlantı adresini takip ederek ulaşabilirsiniz.
Bu rehber içeriğimiz, yukarıda bahsetmiş olduğum içeriğin devam konusu niteliğinde olup çeşitli sorulara cevaplar arayacağımız detaylı bir rehber içeriği olacaktır. Bahsetmiş olduğum bu sorulardan bazıları Java Dosya Okuma İşlemi Nasıl Yapılır, Java Dosya Yazma İşlemi Nasıl Yapılır gibi projelerimizde ihtiyaç duyacağımız yapıları öğrenmeye yönelik başlıklar olacaktır.
Kendinizi hazır hissediyorsanız rehber içeriğimizin ilk adımını atarak “Java Dosya İşlemleri” yapısını daha yakından tanımaya başlayalım.📁📝
Java Dosya İşlemleri
Java Dosya İşlemleri, geliştireceğimiz projeler içerisinde çeşitli bilgilerin kayıt altına alınması, okunması ve işlenmesi gibi işlemleri uygulamamıza imkan veren özel bir sınıf (java.io) yapısına sahip, programımız ile dosya arasındaki damar sisteminin genel adıdır.
Bir damar sisteminin içerisinde atar damarlar ve toplar damarlar bulunur. Aynı şekilde dosya işlemleri içinde kullanabileceğimiz iki damar yöntemi bulunur. Bunları konunu ilerleyen kısımlarında şu şekilde tanıyacağız:
- Java Dosya Okuma İşlemi
- Java Dosya Yazma İşlemi
Tabii, bu başlıkların içerisinde projemizin kullandığı, ihtiyaç duyduğu veri yapılarına göre işlemleri yürütebilecek çeşitli alt başlıklar yer almaktadır. Bu alt başlıkları daha iyi anlayabilmek ve projelerimize sıkıntısız bir şekilde tanımlama gerçekleştirerek kullanabilmek için sizlere öncelikle teorik bilgiler daha sonra bu öğrendiğimiz teorik bilgileri pratiğe dökerek çeşitli uygulamalar sunmak istiyorum.
Eğer, kendinizi hazır hissediyorsanız ve “Java Dosya İşlemleri” konusunda çıkmış olduğumuz bilgi serüveninde ileriye doğru bir adım daha atarak “Java Dosya Okuma İşlemi Nasıl Yapılır” sorusuna cevap aramaya başlayalım.📂🔍
Java Dosya Okuma İşlemi
Projelerimizde ihtiyaç duyacağımız bazı bilgileri çeşitli klasörlerin içerisinde yer alan dosyaların içerisinde tutabiliriz. Bu bilgilere daha sonra erişmek ve mevcut verileri okumak için çeşitli yapılardan yardım alırız. Bu “Java Dosya Okuma İşlemi” yapılarını daha yakından tanıyabilmek için gelin birlikte çeşitli teorik bilgiler edinelim.👨🏻🏫👨🏻💻
1- FileReader ile Dosya Okuma İşlemi
Java dosya okuma işlemi için kullanabileceğimiz bir yapı olan “FileReader” sınıfı ile dosya içerisindeki verilerimizi karakter bazlı bir şekilde ele alarak okuyabiliriz. Karakter bazlı işlem yürüttüğü için encoding kavramına göre çalışır fakat göstermiş olduğu performans düşük bir seviyede kalmaktadır.
Karakter tabanlı işlem yürüttüğü için okuyacağımız verileri “char” veri tipine ait bir diziye aktarmalıdır. Fakat kullanacağımız yazma işlemlerinde ihtiyaç duymamaktadır.
Java’da FileReader ile dosya okuma işleminin nasıl gerçekleşeceği konusunda pratik bir bilgiye sahip olmak için basit bir uygulama geliştirelim. Böylelikle yukarıda öğrenmiş olduğumuz teorik bilgiler aklımızda daha rahat bir şekilde canlanacaktır.
- Java dosya okuma işlemi yaparak “FileReader” sınıfını kullanmak için öncelikle içerisinde çeşitli verilerin yer alacağı bir txt dosyası oluşturalım.
- Dosyamızı oluşturduktan sonra içerisine çeşitli veri girişleri yapalım.
- Daha sonra bu dosya yapısını oluşturmuş olduğumuz proje yapısına tanıtmak için File sınıfından bir nesne oluşturalım.
- Oluşturduktan sonra bizim için dosya okuma işlemi görevini üstlenecek “FileReader” yapısından bir nesne tanımlayalım.
- Okunan verilerin program tarafından kayıt altına alınabilmesi için char veri tipine ait bir dizi tanımlayalım.
- FileReader sınıfına ait özel “read” metodu sayesinde okuyacağımız verileri oluşturmuş olduğumuz dizinin içerisine aktaralım.
- Dizi içeriğine verileri aktardıktan sonra ekrana çıktımızı vermek için gerekli işlemleri yapalım.
Bu uygulamanın devamında benim kullanacağım txt dosyasının içerisinde yer alan veriler şu şekildedir:
Merhaba, FileReader yapısı ile içimdeki verilere ulaşabilirsiniz. Blog Adresim: https://emrecelen.com.tr Mail Adresim: [email protected]
Tüm bu bahsetmiş olduğum aşamaları izledikten sonra oluşturmuş olduğum kod bloğuna aşağıdan göz atabilirsiniz.
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class Main {
public static void main(String[] args) {
///---> Değişken ve File Sınıfının Tanımlanma İşlemleri <---\\\
String ayrac = new String(new char[15]).replace("\0", "-");
String okunanVeri = null;
File dosya = new File("C:\\Users\\winem\\Desktop\\fileReader-dosya-okuma.txt");
///---> FileReader ile Dosya Okuma İşlemi İçin Gerekli Tanımlamalar <---\\\
FileReader fileReader;
char veriler [] = new char [(int) dosya.length()];
///---> Dosya Okuma İşlemini Gerçekleştirelim <---\\\
System.out.println(ayrac+"\n< Java FileReader Dosya Okuma İşlemi >\n"+ayrac);
try {
fileReader = new FileReader(dosya);
fileReader.read(veriler);
okunanVeri = new String(veriler);
System.out.println(veriler);
}
catch (FileNotFoundException e){
System.out.println("-> Aradığınız Dosyaya Ulaşamadım.\n-> Hata Mesajım: "+ e.getMessage());
}
catch (IOException e){
System.out.println("-> Aradığınız Dosya Üzerinde Veri Okuyamıyorum.\n-> Hata Mesajım: "+ e.getMessage());
}
finally {
System.out.println(ayrac);
}
}
}Kod Çıktısı:
2- FileInputStream ile Dosya Okuma İşlemi
FileInputStream sınıf yapısı ile java projelerimizde dosya okumak istersek byte bazlı bir okuma işlemi gerçekleştiririz. Byte tabanlı okuma işlemini gerçekleştirdiğimiz zaman karakter encoding işlemi gerçekleşmez ve okuduğumuz veriler byte veri tipinde veriler olur.
Edinmiş olduğumuz teorik bilginin aklımızda daha kalıcı bir yer edinebilmesi için basit bir uygulama geliştirerek oluşan işleme birlikte göz atalım.
- Öncelikle uygulama içerisinde yapacağımız dosya okuma işlemi için ihtiyaç duyacağımız içerisinde çeşitli verilerin yer alacağı bir txt uzantılı dosya oluşturuyoruz.
- Daha sonra oluşturmuş olduğumuz bu dosyanın içerisine çeşitli veri girişleri yaparak içeriğini kayıt ediyoruz.
- Daha sonra dosya yapımızı projemize tanıtmak için File sınıfından bir nesne oluşturuyoruz.
- Dosya yapımızın tanıtımını gerçekleştirdikten sonra okunan verilerin kayıt altına alınması için byte veri tipinde bir dizi tanımlıyoruz.
- Tüm bu tanımlamalardan sonra dosya okuma işlemini gerçekleştirmek için FileInputStream sınıfından bir nesne oluşturarak işlemimize başlıyoruz.
Kayıt işlemini gerçekleştirdikten sonra txt uzantılı dosyamın içeriği aşağıdaki gibi oldu.
--------------- -> Merhaba, -> Byte Tabanlı Veri Okuma işlemi için kullanmış olduğum "FileInputStream" sınıfını kullanarak -> çekeceğim veriler şu şekildedir: --------------- -> Instagram Hesabım: @emrcelen -> LinkedIN Hesabım: @emrecelen ---------------
Tüm bu adımları eksiksiz bir şekilde takip ettikten sonra ilgili kod dizilimi aşağıdaki halini almış oldu.
import java.io.*;
public class Main {
public static void main(String[] args) {
///---> Değişken ve File Sınıfının Tanımlanma İşlemleri <---\\\
String ayrac = new String(new char[15]).replace("\0", "-");
String okunanVeri = null;
File dosya = new File("C:\\Users\\winem\\Desktop\\byte-tabanli-dosya.txt");
///---> Byte Tabanlı Dosya Okumak İçin Gerekli Tanımlamaları Gerçekleştirelim <---\\\
FileInputStream fileInputStream;
byte veriler [] = new byte[(int) dosya.length()];
System.out.println(ayrac+"\n< Java FileInputStream Dosya Okuma İşlemi >");
try{
fileInputStream = new FileInputStream(dosya);
fileInputStream.read(veriler);
okunanVeri = new String(veriler);
System.out.println(okunanVeri);
}
catch (FileNotFoundException e){
System.out.println("-> Hata Mesajım: "+ e.getMessage()+"\n-> Hata Kodum: "+ e.hashCode());
}
catch (IOException e){
System.out.println("-> Hata Mesajım: "+ e.getMessage()+"\n-> Hata Kodum: "+ e.hashCode());
}
}
}Kod Çıktısı:
3- BufferedReader ile Dosya Okuma İşlemi
Java’da Reader sınıf yapısından türeyen “BufferedReader” sınıfı dosya içerisindeki verileri karakter tabanlı işlemler uygulayarak okur. Aynı zamanda okuma işlemi esnasında buffer kullanır, böylelikle program içerisindeki performansı oldukça yüksektir. Diğer okuma işlemlerinden farklı kullanım yapısına sahip olmasından dolayı aşağıda yer alan örnek uygulamadaki aşamaları dikkatli bir şekilde incelemelisiniz. 👀
- Okuyacağımız dosya yapısını programımız içerisinde tanıtmak için “File” sınıf yapısından bir nesne tanımlayarak projemize dosyanın dizin adresini tanıtıyoruz.
- Tanıtım işlemini gerçekleştirdikten sonra dosyamızın içerisindeki verileri okuyabilmek için FileReader yapısından bir nesne tanımladık.
- Bu tanımlamayı gerçekleştirdikten sonra okuma işleminin daha performanslı bir şekilde oluşması ve “buffer” yapısının kullanılması için BufferedReader yapısının da nesnesini tanımladık.
- Tüm bu tanımlamalardan sonra BufferedReader yapısının özel bir metodu olan readLine() metodunu kullanarak dosyamızın içerisindeki verileri satır satır okumaya başladım.
- Boş satır bulunana kadar verilerin okunmasını istediğim için bir while döngüsü tanımlayarak gerekli tanımlamaları gerçekleştirdim.
- Okuma işlemimin bitmesinden sonra programımın içerisinde BufferedReader yapısını kapatmak için close() metodunu kullandım.
Tüm bu aşamaları eksiksiz bir şekilde takip ettikten sonra oluşturmuş olduğum kod blokları aşağıdaki gibidir:
import java.io.*;
public class Main {
public static void main(String[] args) {
///---> Değişken ve File Sınıfının Tanımlanma İşlemleri <---\\\
String ayrac = new String(new char[15]).replace("\0", "-");
String okunanVeri = null;
File bufferDosya = new File("C:\\Users\\winem\\Desktop\\buffered-reader-dosya-okuma.txt");
///---> BufferedReader Kullanarak Dosya Okumak İçin Gerekli Tanımlamalar <---\\\
FileReader reader;
BufferedReader bufferedReader;
System.out.println(ayrac+"\n< Java BufferedReader Dosya Okuma İşlemi >");
try{
reader = new FileReader(bufferDosya);
bufferedReader = new BufferedReader(reader);
okunanVeri = bufferedReader.readLine();
while(okunanVeri != null){
System.out.println(okunanVeri);
okunanVeri = bufferedReader.readLine();
}
bufferedReader.close();
}
catch (IOException e){
System.out.println("-> Hata Mesajım: "+ e.getMessage()+"\n-> Hata Kodum: "+ e.hashCode());
}
}
}
Kod Çıktısı:
4- BufferedInputStream ile Dosya Okuma İşlemi
BufferedInputStream sınıf yapısı, Java’da somut bir sınıf olan “FilterInputStream” sınıf yapısından türeyerek ortaya çıkmıştır. Buffer yapısını kullanarak dosya içerisinde byte tabanlı veri okuma işlemi gerçekleştirir. Buffer yapısı kullandığı için “FileInputStream” yapısına göre daha performanslıdır.
Basit bir örnek uygulama geliştirerek kod içeriğinde nasıl kullanıldığı hakkında fikir sahibi olarak kod çıktısına birlikte göz atabiliriz.
import java.io.*;
public class Main {
public static void main(String[] args) {
///---> Değişken ve File Sınıfının Tanımlanma İşlemleri <---\\\
String ayrac = new String(new char[15]).replace("\0", "-");
String okunanVeri = null;
File bufferByteDosya = new File("C:\\Users\\winem\\Desktop\\byte-tabanli-dosya.txt");
///---> BufferedInputStream Yapısını Kullanmak İçin Gerekli Tanımlamalar <---\\\
byte veriDizisi [] = new byte[(int)bufferByteDosya.length()];
int okumaSayisi = 0;
FileInputStream fileInputStream;
BufferedInputStream bufferedInputStream;
System.out.println(ayrac+"\n< Java BufferedInputStream Dosya Okuma İşlemi >");
try{
fileInputStream = new FileInputStream(bufferByteDosya);
bufferedInputStream = new BufferedInputStream(fileInputStream);
while((okumaSayisi = bufferedInputStream.read(veriDizisi)) != -1){
okunanVeri = new String(veriDizisi, 0, okumaSayisi);
System.out.println(okunanVeri);
}
bufferedInputStream.close();
}
catch (IOException e){
System.out.println("-> Hata Mesajım: "+ e.getMessage()+"\n-> Hata Kodum: "+ e.hashCode());
}
}
}
Kod Çıktısı:
Popüler olarak kullanılan tüm dosya okuma işlemleri hakkında fikir sahibi olduğumuza göre artık çıkmış olduğumuz bilgi serüveninde ileriye doğru bir adım daha atarak sonraki aşamamıza geçiş yapabiliriz. Böylelikle “Java Dosya Yazma İşlemleri” hakkında detaylı bir bilgi edinimi kazanabiliriz.
Java Dosya Yazma İşlemi
Geliştirdiğimiz proje içerisinde çeşitli veri yapılarının dosyalara kayıt edilmesini isteyebiliriz. Bu isteğimiz karşılamak için Java içerisinde yer alan dosya yazma sınıflarından yardım alırız. Bu “Java Dosya Yazma İşlemi” sınıf yapılarını daha yakından tanımak için rehberimiz içerisinde bir aşama daha ilerleyelim.🕵🏻♂️👨🏻💻
1- FileWriter ile Dosya Yazma İşlemi
Java dosya yazma işlemi için kullanabileceğimiz sınıf yapılarından birisi olarak karşımıza çıkan “FileWriter” sınıfı ile dosya içerisine çeşitli verilerin aktarımını gerçekleştirebiliriz. Karakter bazlı işlem yürütür ve veri aktarımı sırasında encoding kavramına bağlı bir şekilde çalışır.
Projelerimizde kullanım yapısı olarak şu şekilde tanımlama yapabiliriz:
FileWriter fileWriter = new FileWriter ("Dosya Yolu", true or false);
Tanımlama yaparken tanımlayacağımız ilk parametre alanı zorunludur. Bu alanda dosya yazma işleminin çalışacağı dosyanın, bilgisayarımızdaki bulunduğu konumu programımıza tanıtıyoruz. Daha sonra girdiğimiz ikinci parametre değeri “true” olursa dosya içerisindeki verilerin devamına eklemenin gerçekleşmesini söyler, bu alanın doldurulması zorunlu değildir. Eğer bu alan doldurulmazsa veya “false” değeri girilirse dosya içerisindeki veriler silinerek yazma işlemine başlanılır.
FileWriter yapısını daha iyi anlayabilmek için basit bir tanımlama gerçekleştirerek örnek uygulama oluşturalım.
import java.io.*;
public class Main {
public static void main(String[] args) {
///---> Değişken ve File Sınıfının Tanımlanma İşlemleri <---\\\
String ayrac = new String(new char[15]).replace("\0", "-");
String okunanVeri = null;
File yazDosya = new File("C:\\Users\\winem\\Desktop\\dosya-yazma-islemi.txt");
///---> Dosya İçerisine Veri Yazma Ve Yazdırdığımız Veriyi Okumak İçin Gerekli Tanımlamalar <---\\\
FileWriter yazdir;
FileReader oku;
char okunanVeriler[];
System.out.println(ayrac+"\n< Java FileWriter Dosya Yazma İşlemi >\n"+ayrac);
try{
///---> Dosya İçerisine Değer Ekleme Adımları <---\\\
yazdir = new FileWriter(yazDosya);
yazdir.write("Merhaba Dünya,\nBu verileri FileWriter yapısını kullanarak ekledim.\nwww.emrecelen.com.tr");
yazdir.close();
///---> Dosya Okuma İşlemleri İçin Gerekli Adımlar <---\\\
oku = new FileReader(yazDosya);
okunanVeriler = new char[(int)yazDosya.length()];
oku.read(okunanVeriler);
okunanVeri = new String(okunanVeriler);
System.out.println(okunanVeri+"\n"+ayrac);
}
catch (IOException e){
System.out.println("-> Hata Mesajım: "+ e.getMessage()+"\n-> Hata Kodum: "+ e.hashCode());
}
}
}
Kod Çıktısı:
2- FileOutputStream ile Dosya Yazma İşlemi
FileOutputStream sınıf yapısı kullanarak verileri dosya üzerine yazdırmanın FileWriter sınıf yapısından bir farkı, byte tabanlı işlemler gerçekleştirdiği dosya yazma işlemi için byte veri tipine ait bir dizi tanımlayarak işlemlerini gerçekleştirmesi gerekmektedir. Aklımızda daha kalıcı bir yer edebilmesi için basit bir tanımlama örneği oluşturarak ekran çıktısına göz atalım.
import java.io.*;
public class Main {
public static void main(String[] args) {
///---> Değişken ve File Sınıfının Tanımlanma İşlemleri <---\\\
String ayrac = new String(new char[15]).replace("\0", "-");
String okunanVeri = null;
File byteYazDosya = new File("C:\\Users\\winem\\Desktop\\dosya-yazma-islemi.txt");
///---> Dosya İçerisine Veriyi Yazmak ve Okumak İçin Gerekli Tanımlamalar <---\\\
FileOutputStream fileOutputStream;
FileReader fileReader;
System.out.println(ayrac+"\n< Java FileOutputStream Dosya Yazma İşlemi >\n"+ayrac);
try{
///---> Dosya Yazma İşlemleri <---\\\
fileOutputStream = new FileOutputStream(byteYazDosya);
String yazMetin = "Merhaba,\nByte tabanlı veri yazma işlemi için kullanacağımız FileOutputStream sınıf yapısını tanıyoruz.\nEmre ÇELEN";
byte byteVeriler[] = yazMetin.getBytes();
fileOutputStream.write(byteVeriler);
fileOutputStream.close();
///---> Dosya Okuma İşlemleri <---\\\
char okunacakVeriler [] = new char [(int) byteYazDosya.length()];
fileReader = new FileReader(byteYazDosya);
fileReader.read(okunacakVeriler);
okunanVeri = new String(okunacakVeriler);
System.out.println(okunanVeri+"\n"+ayrac);
}
catch (IOException e){
System.out.println("-> Hata Mesajım: "+ e.getMessage()+"\n-> Hata Kodum: "+ e.hashCode());
}
}
}
Kod Çıktısı:
3- BufferedWriter ile Dosya Yazma İşlemi
Writer sınıf yapısı altından türeyen BufferedWriter sınıfı, karakter bazlı veri yazma işlemi gerçekleştirir. Buffer yapısını kullandığı için flush() metodunu kullanır. Böylelikle veri yazma işlemini gerçekleştirir.
İsterseniz, basit bir örnek tanımlama uygulaması oluşturarak “BufferedWriter” yapısını daha yakından tanıyalım.
import java.io.*;
public class Main {
public static void main(String[] args) {
///---> Değişken ve File Sınıfının Tanımlanma İşlemleri <---\\\
String ayrac = new String(new char[15]).replace("\0", "-");
String okunanVeri = null;
File bufferedWriterDosya = new File("C:\\Users\\winem\\Desktop\\dosya-yazma-islemi.txt");
///---> Dosya Yazma İşlemleri İçin Gerekli Tanımlamalar <---\\\
try{
FileWriter fw = new FileWriter(bufferedWriterDosya);
BufferedWriter bufferedWriter = new BufferedWriter(fw);
bufferedWriter.write("BufferedWriter kullanarak dosya içerisine veri yazma işlemi gerçekleştirdik.");
bufferedWriter.flush();
bufferedWriter.close();
}
catch (IOException e){
System.out.println("-> Hata Mesajım: "+ e.getMessage()+"\n-> Hata Kodum: "+ e.hashCode());
}
}
}Benimle birlikte uzun, yorucu ve zorluklarla dolu bu bilgi serüvenine çıkarak “Java Dosya İşlemleri” kavramının derinliklerine inerek ilgili sınıf yapılarını tanımak için zaman ayırdığınız için sizlere sonsuz teşekkürlerimi sunuyorum. Eğer, konu ile alakalı farklı kaynaklara göz atmak ve “Java Dosya İşlemleri” konusunda devam etmek istiyorsanız sizlere Oracle tarafından hazırlanmış rehber içeriğini tavsiye ederim. Bahsetmiş olduğum rehber içeriğine buraya tıklayarak ulaşabilirsiniz.
Unutmayın, aklınıza takılan herhangi bir soru ya da konu işleyişi ile ilgili önerilerinizi veya eleştirilerinizi aşağıda yer alan yorum yap kısmından bana iletebilirsiniz. 👋🏻💬👍🏻
