Java dilini öğrenmek için çıkmış olduğumuz bu bilgi serüvenindeki yeni macera konumuz dosya işlemleri nam-ı diğer I/O kavramlarına giriş yapacağız.

Giriş yapmadan önce bu serüven içerisinde bizleri neler beklediğini daha yakından anlayabilmek için sizlere konu işleyişinin nasıl gerçekleşeceği hakkında ufak bir bilgi vermek istiyorum. Öncelikle “Java Dosya İşlemleri Nedir” sorusuna cevap arayarak teorik olarak yapıyı tanımaya çalışacağız, daha sonra dosya işlemlerinin içerisinde yer alan temel metotları tanıyarak basit birkaç uygulamalı örnek oluşturacağız.

Kendinizi hazır hissediyorsanız, uzun bir rehber serisi olacak “Java Dosya İşlemleri” konumuzun ilk adımını atarak “Java Dosya İşlemleri Nedir” sorusuna cevap aramaya başlayalım.👨🏻‍🏫👨🏻‍🎓

Java Dosya İşlemleri Nedir?

Java dosya işlemleri, projelerimizde bir dosyadan verileri okumak veya herhangi bir dosyaya verileri yazdırmak için kullanacağımız özel bir kütüphane yapısıdır. Genellikle I/O olarak da bilinen dosya işlemleri yapısı input ve output kavramlarının baş harflerinden oluşmaktadır. Bu yüzdende kullanacağımız kütüphane yapısı java.io ön eki ile başlar ve içerisinde kullanacağımız özelliklere göre şekillenir. 👨🏻‍💻

Java’da dosyalarımız üzerinde gerçekleştireceğimiz giriş çıkış işlemlerini “Stream” mantığı ile gerçekleştiririz. Türkçe karşılığı olarak Akım anlamına gelen Stream, programımız üzerindeki veriler ile dosya arasında bir köprü görevi görür. Yani bir nevi programımız ile dosya arasındaki damar sistemidir.

Projemizde veri aktarımı yapmak istediğimiz zaman önümüze iki seçenek çıkar, bunlardan ilki karakter bazlı, diğeri ise byte bazlı olarak aktarma seçenekleridir.

Karakter bazlı veri aktarımı gerçekleştirmek istediğimiz zaman verilerimizi karakter halinde taşır. Bu taşıma şeklinde Unicode desteği bulunur. Yani birçok alfabeyi desteklemektedir. Byte bazlı olarak aktarım işlemlerinde ise karakter toplulukları şeklinde aktarım gerçekleştirilir. Bu aktarım yöntemi karakter bazlı aktarımdan daha performanslıdır. 👨🏻‍🔧🧰

Teorik olarak “Java Dosya İşlemleri Nedir” sorusuna cevap verdiğimize göre artık bu yapının içerisindeki veri taşıma işlemini gerçekleştiren yapıları daha yakından tanımaya çalışalım. 👀

Karakter Tabanlı Veri Taşıma İşlemi

Java’da dosya işlemlerini kullanırken verilerimizi karakter tabanlı olarak taşımak istediğimiz zaman, Writer ve Reader sınıfları ile çalışmamız gerekir. Bu bahsetmiş olduğum iki yapınında kendi arasında çeşitli alt sınıfları bulunur.

Reader sınıfını ele alacak olursak içerisinde kullanacağımız popüler alt sınıflarını şu şekilde sıralayabilirim:

• FileReader
• InputStreamReader
• FilterReader
• StringReader
• BufferedReader

Eğer, Writer sınıfını ele alacak olursak içerisindeki popüler alt sınıfları şu şekilde sıralamamız mümkün olacaktır.

• FileWriter
• OutputStreamWriter
• FilterWriter
• StringWriter
• BufferedWriter
• PrintWriter

Bu sınıf yapılarını projelerimizde kullanmak istediğimiz zaman projelerimizin ilgili sınıf yapılarına import işlemleri gerçekleştirmemiz gerekmektedir.

Hadi gelin birlikte, basit birkaç import yapısını aşağıdaki kod bloğu üzerinde inceleyerek bir fikir sahibi olmaya çalışalım.👨🏻‍💻

///---> Reader Sınıfından Tanımlamalar <---\\\
import java.io.InputStreamReader; 
import java.io.FileReader;
import java.io.StringReader;

///---> Writer Sınıfından Tanımlamalar <---\\\
import java.io.OutputStreamWriter;
import java.io.FileWriter;
import java.io.StringWriter;

///---> Tüm java.io Yapısını Kullanmak İstersek <---\\\
import java.io.*;

Gördüğünüz gibi projemizin içerisine dosya işlemlerini dahil etmek istediğimiz zaman birçok tanımlama yapısını gerçekleştirmemiz gerekir. Eğer, projemizin içerisinde birçok java.io sınıf yapısına ihtiyaç duyuyorsak direkt ana yapıyı projemize import ederek tanımlama sürecini hızlandırabiliriz.

“Karakter Tabanlı Veri Taşıma İşlemi” konu başlığını teorik olarak öğrendiğimize göre artık rehber içeriğimizin bir sonraki aşaması olan “Byte Tabanlı Veri Taşıma İşlemi” başlığına geçiş yaparak serüvenimizde bir adım daha atalım.

Byte Tabanlı Veri Taşıma İşlemi

Java’da projelerimizde dosya işlemlerinde veri aktarımı yapacağımız zaman Byte tabanlı veri taşıma işlemi gerçekleştirebiliriz. Byte Tabanlı veri taşıma işlemi, InputStream ve OutputStream sınıflarının sahip olduğu özellikleri kullanarak işlemleri gerçekleştirir.

Java üzerinde tüm sınıf yapıları Object sınıfından türetilerek oluştuğu için bu bahsetmiş olduğum iki sınıfta Object sınıfından türemiştir. Karakter tabanlı veri taşıma işleminin aksine Unicode desteği bulunmamaktadır.

Hazırsanız, teorik olarak tanımaya çalıştığımız “Byte Tabanlı Veri Taşıma” konusunun sahip olduğu sınıfları daha yakından tanımaya çalışalım. 🧑🏻‍🎓👨🏻‍🎓

Öncelikle InputStream sınıf yapısından türeyen alt yapılarının ismen tanımak için aşağıdaki maddelere göz atalım.

• DataInputStream
• FilterInputStream
• BufferedInputStream
• RandomAccessFile
• FileInputStream
• PrintStream

InputStream sınıf yapısından türeyen yapıların isimlerini tanıdığımıza göre artık OutputStream yapısından türeyen sınıf yapılarına da göz atabiliriz.

• DataOutputStream
• FileOutputStream
• BufferedOutputStream
• FilterOutputStream

Tüm bu teorik öğrenme aşamalarından sonra, projelerimizde Byte tabanlı veri taşıma işlemi uygulayacağımız zaman nasıl tanımlama işlemleri yapacağımızı inceleyebiliriz.

///---> InputStream Sınıfından Türeyen Tanımlamalar <---\\\
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.BufferedInputStream;

///---> OutputStream Sınıfından Türeyen Tanımlamalar <---\\\
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.BufferedOutputStream;

Rehber içeriğimizin en sancılı ve belki de en sıkıldığınız kısmı geride bırakarak eğleneceğimiz, daha kolay öğrenebileceğimiz ve “Java Dosya İşlemleri” başlığının ana iskeletini oluşturan “Java File Sınıfı Kullanımı” başlığına geçiş yapabiliriz. 👨🏻‍🏫👌🏻

Java File Sınıfı Kullanımı

Java File Sınıfı, bilgisayarımız üzerinde bulunan herhangi bir dosyanın bilgilerine erişmemize imkan sağlar. File sınıfı ile bilgisayarımız üzerindeki herhangi bir dosyayı ilişkilendirmemiz sonucunda, bu dosyaya ait birçok bilgiye erişebiliriz.

File sınıf yapısını projelerimize dahil edeceğimiz zaman, işlem gerçekleştireceğimiz dosya veya klasörün sahip olduğu dizin yolunu almamız ve daha sonra File sınıfının constructor (kurucu) metot yapısına bu dizin yolunun tanımlamasını gerçekleştirmeliyiz.

Hazırsanız, Java’da File sınıf yapısının nasıl tanımlanacağını ve kullanılacağını incelemek için gerekli adımımızı atalım.

• Projemiz içerisinde dosya oluşturma, dosya içeriğini okuma gibi çeşitli işlemleri yürütebilmek için java.io.File yapısını projemizin içerisine import ederek ilk adımızı atalım.
• Daha sonra projemizin içerisine File sınıfından bir nesne türetelim. Türetmiş olduğumuz bu nesnenin kurucu metot yapısına dosyamızın konumunu belirtelim.
Not: Dosya konumunu belirtirken tek “\” işareti kullanırsak hata ile karşılaşabiliriz. Böyle bir durumla karşılaşmamak için dosya yolunu belirtirken söz konusu işareti (\\) iki kez kullanabiliriz veya bu işaret yerine / işaretini de kullanabiliriz.
• Tüm bu işlemlerden sonra belirlemiş olduğumuz dosya yolunda bir klasörün olup olmadığını kontrol etmek için gerekli if-else yapısını oluşturalım.
• Bu if-else kontrol yapımızda dosya bulunmuyorsa dosyanın oluşmasını sağlayacak tanımlamalarımızı gerçekleştirelim.
• Son olarak oluşturmuş olduğumuz dosyanın çeşitli bilgilerine erişmek için özel metot yapılarını kullanarak konsol ekranımıza çıktı verelim.

Tüm bu yukarıdaki aşamaları takip ederek uyguladıktan sonra oluşturmuş olduğumuz kod yapısını aşağıdaki kod bloğundan inceleyebilirsiniz.

import java.io.File;
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", "-");
        File file = new File("C:\\Users\\winem\\Desktop\\emrecelen.txt");

        ///---> Belirlediğimiz Dizin Yolunda İlgili Dosyanın Bulunup Bulunmadığını Kontrol Ediyor <---\\\
        System.out.println(ayrac+"\n< Java Dosya İşlemleri >\n"+ayrac);

        if(file.exists()){
            ///---> Dosyanın Dizin Üzerinde Bulunup Bulunmadığını Kontrol Ediyoruz <---\\\
            System.out.println("-> Belirlemiş Olduğunuz Dizin Üzerinde İlgili Dosya Bulunuyor.\n"+ayrac);
        }
        else{
            ///---> Dosya Belirlemiş Olduğumuz Dizin Üzerinde Bulunmuyorsa Dosyanın Oluşmasını Sağlayacak Kodu Yazıyoruz <---\\\
            try{
                file.createNewFile();
                System.out.println("-> Dizin Üzerinde Dosya Oluşturuldu !!!\n"+ayrac);
            }
            catch (IOException e){
                System.out.println("-> Dosya Oluşturulurken Hata Oluştu !!!\n-> Hata Mesajı: "+ e.getMessage()+"\n"+ayrac);
            }
        }
        System.out.println("-> Dosyanın Adı: " + file.getName());
        System.out.println("-> Dosyanın Dizin Yolu: "+ file.getPath()+"\n"+ayrac);
    }
}

Kod Çıktısı:

Teorik olarak öğrenmiş olduğumuz “Java Dosya İşlemleri” kavramının kod içerisindeki pratik tanımlama yapısını da öğrendiğimize göre artık rehberimizin bu bölümünün son aşaması olarak “File” sınıfının içerisinde yer alan metot yapılarını tanımaya çalışalım.

File Sınıfının İçerisindeki Metotlar

Projemizin ilgili sınıf yapısına File kavramını başarılı bir şekilde tanımladıktan sonra bazı çeşitli metotları kullanabilir hale geliriz. Bu bahsetmiş olduğum metot yapılarından sıklıkla kullanacaklarımızı aşağıdaki maddelerden inceleyebilirsiniz.

• exists(): Bu metot yapımızda “File” yapısının içerisinde belirtilen dizin adresinde dosyanın var olup olmadığının karşılığını boolean veri tipinde bizlere verir.
• getName(): Oluşturmuş olduğumuz dosyanın mevcut adını bizlere geri döndürür.
• length(): Proje içerisinde belirtilen dosyanın sahip olduğu boyutu bizlere verir.
• renameTo(): Projemizin içerisinde belirtilen dosyanın mevcut ismini değiştirmeye yarar.
• delete(): Belirlemiş olduğumuz dosyayı, bilgisayarımızdan kaldırma işlemini gerçekleştirir.
• canRead(): Dosyamızın içeriğinin okunabilir olup olmadığını boolean türünde bizlere gösterir.

Yukarıdaki popüler metot yapılarını kullanarak basit bir uygulama geliştirerek kod içerisinde bu metot yapılarının kullanılma şekillerini gözlemleyelim.

import java.io.File;
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", "-");
        File  dosya = new File("C:\\Users\\winem\\Desktop\\java-dosya-islemleri.txt");

        System.out.println(ayrac+"\n < Java Dosya İşlemlerinin Metot Yapıları >\n"+ayrac);
        if(dosya.exists()){
            System.out.println("-> Belirtilen dizin yolunda, belirtmiş olduğunuz dosya zaten mevcut.\n"+ayrac);
        }
        else{
            try{
                dosya.createNewFile();
                System.out.println("-> Başarılı bir şekilde, dizin üzerinde belirtmiş olduğunuz isimde dosya oluşturuldu.\n"+ayrac);
            }
            catch (IOException e){
                System.out.println("-> Dosya oluşturulurken hata oluştu !!!\n-> Hatanın Mesajı: "+ e.getMessage()+"\n"+ayrac);
            }
        }
        System.out.println("-> Dosyanın Adı: " + dosya.getName()+"\n-> Dosyanın Dizin Yolu: "+ dosya.getPath());
        System.out.println("-> Dosyanın Boyutu: " + dosya.length()+"\n-> Dosyanın Okunabilirlik Durumu: " + dosya.canRead());
        System.out.println("-> Dosyanın Mevcut Adını [\""+dosya.getName()+"\"] Değiştirerek [\"dosya-metotlari.txt\"] Yapalım.");
        File degistir = new File("C:\\Users\\winem\\Desktop\\dosya-metotlari.txt");
        dosya.renameTo(degistir); ///---> Dosyamızın İsmi Değiştirildi <---\\\
        System.out.println("-> Dosyayı Silelim: " + dosya.delete()+"\n-> Dosya Mevcut Mu: " + dosya.exists()+"\n"+ayrac);
    }
}

Kod Çıktısı:

Bu rehber içeriğimizin içerisinde “Java Dosya İşlemleri Nedir” ve “Veri Taşıma İşlemleri Nedir” başlıklarına teorik bir cevap verdik. Daha sonra edinmiş olduğumuz bu bilgiyi kullanarak “File Sınıfının Kullanımı” konusunda teorik ve pratik uygulamalar geliştirdik. Böylelikle “Java Dosya İşlemleri” konusunun ilk aşamasını tamamlamış olduk.

Bir sonraki içeriğimizde oluşturmuş olduğumuz dosyaların içerisine çeşitli verilerin eklenmesini, eklenen verilerin çekilmesini, işlenmesini ve silinmesinin nasıl gerçekleşeceğini öğreneceğiz. Bu taşıma işlemlerini “Karakter Tabanlı” ve “Byte Tabanlı” olarak ele alacağımız rehber içeriğini kaçırmak istemiyorsanız sağ tarafta yer alan “Mail Bültenine” katılım sağlayabilirsiniz.

Eğer, “Java Dosya İşlemleri Nedir” sorusuna farklı kaynaklardan cevap aramak isterseniz sizlere Oracle tarafından hazırlanmış dokümantasyon dosyasını tavsiye ederim. Bahsetmiş olduğum dokümantasyon içeriğine buraya tıklayarak ulaşabilirsiniz.

Unutmayın, aklınıza takılan herhangi bir soruyu, konu işleyişi ile alakalı önerilerinizi ya da eleştirilerinizi aşağıda yer alan yorum yap kısmından bana iletebilirsiniz. 👋🏻