-- Java SE

Path Class and Path Operations

Path sınıfı pathler hakkında bilgi edinmek,path elementlerine erişmek, path’i diğer formlara dönüştürmek gibi işlemler için metodlar içerir.  Path metodları syntactic işlemler yapar, yani path değişkeninin kendisi üzerinde işlem yapılır, dosya sistemine erişim olmaz.

Path Oluşturma

Bir Path değişkeni file veya directory yerini belirtmek için kullanılır. Aşağıdaki get metodları ile Path değişkeni oluşturuabilir.

Path p1 = Paths.get("/tmp/foo");
  Path p2 = Paths.get(args[0]);
  Path p3 = Paths.get(URI.create("file:///Users/joe/FileTest.java"));


Bilgi Edinme

Bir Path elementleri dizi şeklinde tutar diyebiliriz. N elemanlı bir Directory yapısındaki en yüksek seviyedeki element 0. indexte tutulur, en düşük seviyedeki element ise [n-1]. indextedir. Bu indexler kullanılarak belirli bir element veya directorynin bir kısmı hakkında bilgi edinilebilir.

Bu yazıdaki metodlar aşağıdaki Directory yapısı üzerinde çalışacaktır.

Aşağıdaki kod parçacığı bir Path değişkeni tanımlar ve bu path hakkında bilgi edinebilmek için birkaç metod çağırır.

Dosya sisteminde bu Path'in olması gerekmez. Aşağıdaki metodlar path d
eğişkeni üzerinde işlem yapar.

Path path = Paths.get("C:\\home\\joe\\foo");

System.out.format("toString: %s%n", path.toString());
// Path'in string karşılığı ( C:\home\joe\foo )

System.out.format("getFileName: %s%n", path.getFileName()); 
//Son elementin dosya adı ( foo)

System.out.format("getName(0): %s%n", path.getName(0));
//Belirtilen indexteki elementin dosya adı ( home )

System.out.format("getNameCount: %d%n", path.getNameCount());
//Element sayısı (3)

System.out.format("subpath(0,2): %s%n", path.subpath(0,2));
//Path'in belirtilen başlangıç ve son indexi arasındaki kısım.)(root element yazılmaz) ( home\joe)

System.out.format("getParent: %s%n", path.getParent());
//Bir üst directory ( \home\joe )

System.out.format("getRoot: %s%n", path.getRoot());
//Path'in root(kök) elementi ( C:\ )

Gereksiz Notasyonları Silme

Birçok dosya sistemi “.” notasyonunu şuanki directory’i ve “..” notasyonunu da parent directory’i belirtmek için kullanır. Bu notasyonları içeren bir Path ile karşı karşıya kaldığımızda normalize metodu kullanılabilir.

Aşağıdaki iki Path de gereksiz ayrıntılar içeriyor.

/home/./joe/foo
/home/sally/../joe/foo

normalize metodu gereksiz elementleri siler ve yukardaki iki örnek de /home/joe/foo şeklinde normalleştirilir.

Path Dönüştürme

Path dönüştürmek için kullanılabilecek metodlar var. Eğer bir path’i browserda açılabilecek formda bir stringe çevirmek istiyorsak, toUri metodu kullanılabilir. Örneğin;

Path p1 = Paths.get("/home/logfile");

System.out.format("%s%n", p1.toUri());

// Sonuç : file:///home/logfile

toAbsolutePath metodu bir pathi absolute path’e çevirir. Eğer ki metoda geçilen path zaten absolute ise, aynı Path nesnesini dönderir. toAbsolutePath metodu, kullanıcıdan path girilmesini istenildiğinde kullanışlıdır. Örneğin;

public class FileTest {
    public static void main(String[] args) {

        if (args.length < 1) {
            System.out.println("usage: FileTest file");
            System.exit(-1);
        }

        // Girilen Stringi path'e çevir.
        Path inputPath = Paths.get(args[0]);

Path Birleştirme

İki pathi resolve metodu ile kombine edebiliriz. Örneğin;

// Microsoft Windows
Path p1 = Paths.get("C:\\home\\joe\\foo");

System.out.format("%s%n", p1.resolve("bar"));

// Sonuç = C:\home\joe\foo\bar

İki Path Arasında Path Oluşturma

File I/O kodu yazarken bir dosyadan diğer dosyaya geçebilecek bir path oluşturmak isteyebiliriz. Burada devreye relativize metodu girer. Bu metod orjinal path kökenli ve belirtilen path ile biten bir path oluşturur. Bu oluşan path orjinal pathe göredir.

Örneğin şu şekilde iki path olsun :

Path p1 = Paths.get("joe");
Path p2 = Paths.get("sally");

Pathlerde belirtilen joe ve sally dosyaları aynı dosya içerisinde ve dosya ağacında aynı seviyede olsun(siblings). Joe’den sally’e gitmek için, ağaç yapısında bir seviye üste çıktıktan sonra, tekrardan sally’e girerek bir seviye aşağı inilir.

// Sonuç = ../sally
Path p1_to_p2 = p1.relativize(p2);

// Sonuç =../joe
Path p2_to_p1 = p2.relativize(p1);

Örneği biraz zorlaştıralım ve şöyle yapalım :

Path p1 = Paths.get("home");
Path p3 = Paths.get("home/sally/bar");

// Sonuç = sally/bar
Path p1_to_p3 = p1.relativize(p3);

// Sonuç = ../..
Path p3_to_p1 = p3.relativize(p1);

Bu örnekte iki path home adlı node’u paylaşıyor. Home‘dan bar‘a gitmek için öncelikle bir seviye aşağıda sally‘e ardından tekrar bir seviye aşağı bar‘a gidilmelidir. Bar‘dan home‘a gitmek için iki seviye yukarı gidilmelidir.

Eğer pathlerden sadece biri root elementi içeriyorsa relative path oluşturulamaz. Eğer iki path de root element içeriyorsa, relative path’in oluşturalabilirliği sisteme bağlıdır.

Pathleri Kıyaslama

Pathlerin eşitliğini kontrol etmek için equals metodu kullanılabilir. startsWith/endsWith metodları pathin belirtilen string ile başlayıp/bittiğini kontrol etmek için kullanılabilir. Örneğin;

Path path = ...;
Path otherPath = ...;
Path beginning = Paths.get("/home");
Path ending = Paths.get("foo");

if (path.equals(otherPath)) {
    // eşitse yapılacaklar...
} else if (path.startsWith(beginning)) {
    // "/home" ile başlıyorsa yapılacaklar..
} else if (path.endsWith(ending)) {
    // "foo" ile bitiyorsa...
}

Ayrıca Path sınıfı Iterable interfaceini implement eder. iterator metodu ile path içerisindeki elementlerin isimleri dönderilebilir. Dönderilen ilk element root’a en yakın olandır. Aşağıdaki kod parçacığı bir path’i iterate eder ve her elementin ismini yazdırır.

Path path = ...;
for (Path name: path) {
    System.out.println(name);
}

Path sınıfı ayrıca Comperable interfaceini implement eder. Path nesnelerini compareTo metodu ile kıyaslayabiliriz. Ayrıca Path nesneleri bir Collection içine koyulabilir ve iki Path nesnesinin aynı dosyada olup olumadığını kontrol etmek için isSameFile metodu kullanılabilir.

 

 

Yorum bırak

Yorum