4. Yaygın Olarak Kullanılan Sınıflar
Bu bölümde, yaygın olarak kullanılan bazı Java sınıflarını tanıtıyoruz. Bu sınıfların çok sayıda özniteliği, yöntemi ve oluşturucusu vardır. Her seferinde, sınıfların sadece küçük bir kısmını ele alıyoruz. Bunların ayrıntıları, şimdi tanıtacağımız Java yardımında mevcuttur.
4.1. Belgeler
Sun'ın JDK paketini <jdk> klasörüne kurduysanız, belgelere <jdk>\docs klasöründen ulaşabilirsiniz:
Bazen jdk dosyası bulunur, ancak dokümantasyon yoktur. Dokümantasyon, Sun'ın http://www.sun.com adresindeki web sitesinde bulunabilir. docs klasöründe, JDK yardım dosyasının başlangıç noktası olan index.html dosyası bulunur:
Yukarıdaki API & Language bağlantısı, Java sınıflarına erişim sağlar. Demos/Tutorials bağlantısı, Java program örneklerine ulaşmak için özellikle yararlıdır. API & Language bağlantısını takip edelim:
Java 2 Platformu bağlantısını (API) takip edelim:
Bu sayfa, sınıflarla ilgili belgelerin asıl başlangıç noktasıdır. Hızlı erişim için bu sayfaya bir kısayol oluşturulabilir. URL, <jdk>\docs\api\index.html konumundadır. Burada, JDK'teki yüzlerce Java sınıfına ilişkin bağlantılar bulunur. Başlangıçta karşılaşılan en büyük zorluk, bu farklı sınıfların ne işe yaradığını bilmektir. Dolayısıyla ilk etapta, bu yardım ancak bilgi almak istediğiniz sınıfın adını biliyorsanız anlamlıdır. Ayrıca, genellikle sınıfın işlevini belirten sınıf adlarından da yol gösterici olarak yararlanabilirsiniz.
Bir örnek verelim ve dinamik bir dizi uygulayan Vector sınıfı hakkında bilgi arayalım. Sol taraftaki çerçeve içindeki sınıflar listesinde Vector sınıfının bağlantısını aramak yeterlidir:
ve sınıfın tanımını görmek için bu bağlantıya tıklamak yeterlidir:
Burada
- sınıfın bulunduğu hiyerarşi, bu örnekte java.util.Vector
- sınıfın alan (öznitelik) listesi
- yapıcıların listesi
- yöntemlerin listesi
Bundan sonra çeşitli sınıfları tanıtacağız. Okuyucuyu, kullanılan sınıfların tam tanımlarını sistematik olarak kontrol etmeye davet ediyoruz.
4.2. Test sınıfları
Aşağıdaki örneklerde zaman zaman personne ve enseignant sınıfları kullanılmaktadır. Bu sınıfların tanımlarını burada tekrar hatırlatıyoruz.
public class personne{
// soyadı, adı, yaşı
private String prenom;
private String nom;
private int age;
// yapıcı 1
public personne(String P, String N, int age){
this.prenom=P;
this.nom=N;
this.age=age;
}
// yapıcı 2
public personne(personne P){
this.prenom=P.prenom;
this.nom=P.nom;
this.age=P.age;
}
// toString
public String toString(){
return "personne("+prenom+","+nom+","+age+")";
}
// yardımcılar
public String getPrenom(){
return prenom;
}
public String getNom(){
return nom;
}
public int getAge(){
return age;
}
//değiştiriciler
public void setPrenom(String P){
this.prenom=P;
}
public void setNom(String N){
this.nom=N;
}
public void setAge(int age){
this.age=age;
}
}
enseignant sınıfı, personne sınıfından türetilmiştir ve şu şekilde tanımlanmıştır:
class enseignant extends personne{
// öznitelikler
private int section;
// oluşturucu
public enseignant(String P, String N, int age,int section){
super(P,N,age);
this.section=section;
}
// toString
public String toString(){
return "etudiant("+super.toString()+","+section+")";
}
}
Ayrıca, personne sınıfından türetilen ve aşağıdaki gibi tanımlanan etudiant sınıfını da kullanacağız:
class etudiant extends personne{
String numero;
public etudiant(String P, String N, int age,String numero){
super(P,N,age);
this.numero=numero;
}
public String toString(){
return "etudiant("+super.toString()+","+numero+")";
}
}
4.3. String sınıfı
String sınıfı, karakter dizilerini temsil eder. nom bir karakter dizisi değişkeni olsun:
String isim;
nom, henüz başlatılmamış bir nesneye ait bir referanstır. Bu değişkeni iki şekilde başlatabiliriz:
nom="at" veya nom=new String("at")
Her iki yöntem de eşdeğerdir. Daha sonra nom="balık" yazılırsa, nom yeni bir nesneye referans verir. Eski nesne String("cheval") kaybolur ve işgal ettiği bellek alanı geri kazanılır.
String sınıfı, birçok öznitelik ve yönteme sahiptir. İşte bunlardan bazıları:
public char charAt(int i) | dizgedeki i karakterini verir; ilk karakterin indeksi 0'dır. Dolayısıyla String("at").charAt(3) 'v' karakterine eşittir |
public int compareTo(dize2) | chaine1.compareTo(dize2), dize1 ile dize2'yi karşılaştırır ve dize1 = dize2 ise 0, dize1 > dize2 ise 1, dize1 < dize2 ise -1 değerini döndürür |
public boolean equals(Object anObject) | chaine1.equals(dize2), dize1 = dize2 ise true, aksi takdirde false değerini döndürür |
public String toLowerCase() | chaine1.toLowerCase() dizge1'i küçük harfe dönüştürür |
public String toUpperCase() | chaine1.toUpperCase() string1'i büyük harflerle döndürür |
public String trim() | chaine1.trim(), chaine1'in başındaki ve sonundaki boşlukları temizler |
public String substring(int beginIndex, int endIndex) | String("chapeau").subString(2,4), "ape" dizesini döndürür |
public char[] toCharArray() | dizgideki karakterleri bir karakter dizisine yerleştirir |
int length() | dizenin karakter sayısı |
int indexOf(String chaine2) | geçerli dizede chaine2'in ilk konumunu döndürür; chaine2 mevcut değilse -1 döndürür |
int indexOf(String chaine2, int startIndex) | geçerli dizede chaine2'in ilk konumunu döndürür; chaine2 mevcut değilse -1 döndürür. Arama, startIndex numaralı karakterden başlar. |
int lastIndexOf(String chaine2) | geçerli dizede chaine2'in son konumunu döndürür; chaine2 mevcut değilse -1 döndürür |
boolean startsWith(String chaine2) | geçerli dize chaine2 ile başlıyorsa true değerini döndürür |
boolean endsWith(String chaine2) | Geçerli olur, eğer geçerli dize chaine2 ile bitiyorsa |
boolean matches(String regex) | Geçerli dize, regex düzenli ifadesine uyuyorsa true değerini döndürür. |
String[] split(String regex) | Geçerli dize, regex düzenli ifadesiyle modellenen bir karakter dizisiyle ayrılmış alanlardan oluşur. split yöntemi, alanları bir dizide geri almayı sağlar. |
String replace(char oldChar, char newChar) | geçerli dizgedeki oldChar karakterini newChar karakteriyle değiştirir. |
İşte bir örnek program:
// ithalatlar
import java.io.*;
public class string1{
// bir örnek sınıf
public static void main(String[] args){
String uneChaine="l'oiseau vole au-dessus des nuages";
affiche("uneChaine="+uneChaine);
affiche("uneChaine.Length="+uneChaine.length());
affiche("chaine[10]="+uneChaine.charAt(10));
affiche("uneChaine.IndexOf(\"vole\")="+uneChaine.indexOf("vole"));
affiche("uneChaine.IndexOf(\"x\")="+uneChaine.indexOf("x"));
affiche("uneChaine.LastIndexOf('a')="+uneChaine.lastIndexOf('a'));
affiche("uneChaine.LastIndexOf('x')="+uneChaine.lastIndexOf('x'));
affiche("uneChaine.substring(4,7)="+uneChaine.substring(4,7));
affiche("uneChaine.ToUpper()="+uneChaine.toUpperCase());
affiche("uneChaine.ToLower()="+uneChaine.toLowerCase());
affiche("uneChaine.Replace('a','A')="+uneChaine.replace('a','A'));
String[] champs=uneChaine.split("\\s+");
for (int i=0;i<champs.length;i++){
affiche("champs["+i+"]=["+champs[i]+"]");
}//for
affiche("(\" abc \").trim()=["+" abc ".trim()+"]");
}//Ana
// görüntüler
public static void affiche(String msg){
// msg'yi görüntüler
System.out.println(msg);
}//görüntüle
}//sınıf
ve elde edilen sonuçlar:
uneChaine=l'oiseau vole au-dessus des nuages
uneChaine.Length=34
chaine[10]=o
uneChaine.IndexOf("vole")=9
uneChaine.IndexOf("x")=-1
uneChaine.LastIndexOf('a')=30
uneChaine.LastIndexOf('x')=-1
uneChaine.substring(4,7)=sea
uneChaine.ToUpper()=L'OISEAU VOLE AU-DESSUS DES NUAGES
uneChaine.ToLower()=l'oiseau vole au-dessus des nuages
uneChaine.Replace('a','A')=l'oiseAu vole Au-dessus des nuAges
champs[0]=[l'oiseau]
champs[1]=[vole]
champs[2]=[au-dessus]
champs[3]=[des]
champs[4]=[nuages]
(" abc ").trim()=[abc]
4.4. Vector sınıfı
Vektör, elemanları nesne referansları olan dinamik bir dizidir. Dolayısıyla, boyutu zaman içinde değişebilen bir nesne dizisidir; bu, şimdiye kadar karşılaştığımız statik dizilerde mümkün olmayan bir özelliktir. İşte bu sınıfın bazı alanları, oluşturucuları ve yöntemleri:
public Vector() | boş bir vektör oluşturur |
public final int size() | vektördeki eleman sayısı |
public final void addElement(Object obj) | obj tarafından referans verilen nesneyi vektöre ekler |
public final Object elementAt(int index) | vektördeki index numaralı nesneye referans verir - indeksler 0'dan başlar |
public final Enumeration elements() | vektördeki tüm elemanları bir enumerasyon olarak döndürür |
public final Object firstElement() | vektörün ilk elemanına referans |
public final Object lastElement() | vektörün son elemanının referansı |
public final boolean isEmpty() | vektör boşsa true değerini döndürür |
public final void removeElementAt(int index) | index indeksindeki öğeyi kaldırır |
public final void removeAllElements() | vektördeki tüm elemanları siler |
public final String toString() | vektörün kimlik dizesini döndürür |
İşte bir test programı:
// ithal edilen sınıflar
import java.util.*;
public class test1{
// ana program main - static - sınıf yöntemi
public static void main(String arg[]){
// sınıf örneklerinin oluşturulması
personne p=new personne("Jean","Dupont",30);
enseignant en=new enseignant("Paula","Hanson",56,27);
etudiant et=new etudiant("Chris","Garot",22,"19980405");
System.out.println("p="+p.toString());
System.out.println("en="+en.toString());
System.out.println("et="+et.toString());
// polimorfizm
personne p2=(personne)en;
System.out.println("p2="+p2.toString());
personne p3=(personne)et;
System.out.println("p3="+p3.toString());
// bir vektör
Vector V=new Vector();
V.addElement(p);V.addElement(en);V.addElement(et);
System.out.println("Taille du vecteur V = "+V.size());
for(int i=0;i<V.size();i++){
p2=(personne) V.elementAt(i);
System.out.println("V["+i+"]="+p2.toString());
}
} // main sonu
}// sınıf sonu
Bu programı derleyelim:
E:\data\serge\JAVA\poly juin 2002\Chapitre 3\vector>dir
10/06/2002 10:41 1 134 personne.class
10/06/2002 10:41 619 enseignant.class
10/06/2002 10:41 610 etudiant.class
10/06/2002 10:42 1 035 test1.java
E:\data\serge\JAVA\poly juin 2002\Chapitre 3\vector>javac test1.java
E:\data\serge\JAVA\poly juin 2002\Chapitre 3\vector>dir
10/06/2002 10:41 1 134 personne.class
10/06/2002 10:41 619 enseignant.class
10/06/2002 10:41 610 etudiant.class
10/06/2002 10:42 1 035 test1.java
10/06/2002 10:43 1 506 test1.class
test1.class dosyasını çalıştıralım:
E:\data\serge\JAVA\poly juin 2002\Chapitre 3\vector>java test1
p=personne(Jean,Dupont,30)
en=etudiant(personne(Paula,Hanson,56),27)
et=etudiant(personne(Chris,Garot,22),19980405)
p2=etudiant(personne(Paula,Hanson,56),27)
p3=etudiant(personne(Chris,Garot,22),19980405)
Taille du vecteur V = 3
V[0]=personne(Jean,Dupont,30)
V[1]=etudiant(personne(Paula,Hanson,56),27)
V[2]=etudiant(personne(Chris,Garot,22),19980405)
Bundan sonra, test programlarının derlenmesi ve çalıştırılması sürecini tekrarlamayacağız. Yukarıda yapılanları tekrarlamak yeterlidir.
4.5. ArrayList sınıfı
ArrayList sınıfı, Vector sınıfına benzerdir. Temel olarak, yalnızca birden fazla yürütme iş parçacığı tarafından aynı anda kullanıldığında farklılık gösterir. Bir Vector veya bir ArrayList'e erişim için iş parçacıklarını senkronize etme yöntemleri farklıdır. Bu durum dışında, ikisinden herhangi biri aynı şekilde kullanılabilir. İşte bu sınıfın bazı alanları, oluşturucuları veya yöntemleri:
ArrayList() | boş bir dizi oluşturur |
int size() | dizideki öğe sayısı |
void add(Object obj) | obj tarafından referans verilen nesneyi diziye ekler |
void add(int index, Object obj) | obj tarafından referans verilen nesneyi, index konumunda diziye ekler |
Object get(int index) | dizideki index numaralı nesnenin referansı - indeksler 0'dan başlar |
boolean isEmpty() | dizi boşsa true değerini döndürür |
void remove(int index) | index indeksindeki öğeyi kaldırır |
void clear() | dizideki tüm öğeleri siler |
Object[] toArray() | dinamik diziyi klasik bir diziye dönüştürür |
String toString() | dizinin kimlik dizesini döndürür |
İşte bir test programı:
// ithal edilen sınıflar
import java.util.*;
public class test1{
// ana program main - static - sınıf yöntemi
public static void main(String arg[]){
// sınıf örneklerinin oluşturulması
personne p=new personne("Jean","Dupont",30);
enseignant en=new enseignant("Paula","Hanson",56,27);
etudiant et=new etudiant("Chris","Garot",22,"19980405");
System.out.println("p="+p);
System.out.println("en="+en);
System.out.println("et="+et);
// polimorfizm
personne p2=(personne)en;
System.out.println("p2="+p2);
personne p3=(personne)et;
System.out.println("p3="+p3);
// bir vektör
ArrayList personnes=new ArrayList();
personnes.add(p);personnes.add(en);personnes.add(et);
System.out.println("Nombre de personnes = "+personnes.size());
for(int i=0;i<personnes.size();i++){
p2=(personne) personnes.get(i);
System.out.println("personnes["+i+"]="+p2);
}
} // main sonu
}// sınıf sonu
Elde edilen sonuçlar öncekilerle aynıdır.
4.6. Arrays sınıfı
java.util.Arrays sınıfı, diziler üzerinde çeşitli işlemler, özellikle sıralama ve eleman arama işlemlerini gerçekleştirmeye olanak tanıyan statik yöntemlere erişim sağlar. İşte bu yöntemlerden bazıları:
static void sort(dizi) | tableau dizisini, dizi veri türünün (sayı veya karakter dizileri) örtük sıralamasını kullanarak sıralar. |
static void sort (Object[] dizi, Comparator C) | tableau dizisini, elemanları karşılaştırmak için C karşılaştırma işlevini kullanarak sıralar |
static int binarySearch(dizi, eleman) | élément'in tableau içindeki konumunu döndürür; aksi takdirde <0 değerini döndürür. Dizi önceden sıralanmış olmalıdır. |
static int binarySearch(Object[] dizi, Object eleman, Comparator C) | Aynı işlevi yerine getirir, ancak dizideki iki öğeyi karşılaştırmak için C karşılaştırma işlevini kullanır. |
İşte ilk örnek:
import java.util.*;
public class sort2 implements Comparator{
// iç özel sınıf
private class personne{
private String nom;
private int age;
public personne(String nom, int age){
this.nom=nom; // kişinin adı
this.age=age; // yaşı
}
// yaşı al
public int getAge(){
return age;
}
// kişinin kimliği
public String toString(){
return ("["+nom+","+age+"]");
}
}; // kişi sınıfı
// üretici
public sort2() {
// kişi tablosu
personne[] amis=new personne[]{new personne("tintin",100),new personne("milou",80),
new personne("tournesol",40)};
// kişi tablosunun sıralanması
Arrays.sort(amis,this);
// doğrulama
for(int i=0;i<3;i++)
System.out.println(amis[i]);
}//oluşturucu
// kişileri karşılaştıran işlev
public int compare(Object o1, Object o2){
// şunu döndürmelidir
// -1, eğer o1 "o2'den küçükse"
// o1 "o2'ye eş" ise 0
// o1, o2'den "büyükse" +1
personne p1=(personne)o1;
personne p2=(personne)o2;
int age1=p1.getAge();
int age2=p2.getAge();
if(age1<age2) return (-1);
else if (age1==age2) return (0);
else return +1;
}//karşılaştırır
// test fonksiyonu
public static void main(String[] arg){
new sort2();
}//ana
}//sınıf
Bu programı inceleyelim. main işlevi, bir sort2 nesnesi oluşturur. sort2 sınıfının oluşturucusu şöyledir:
// üretici
public sort2() {
// kişi tablosu
personne[] amis=new personne[]{new personne("tintin",100),new personne("milou",80),
new personne("tournesol",40)};
// kişi tablosunun sıralanması
Arrays.sort(amis,this);
// doğrulama
for(int i=0;i<3;i++)
System.out.println(amis[i]);
}//üretici
Sıralanacak dizi, personne nesnelerinden oluşan bir dizidir. personne sınıfı, sort2 sınıfının içinde özel olarak (private) tanımlanmıştır. Arrays sınıfının sort statik yöntemi, personne nesnelerinden oluşan bir diziyi nasıl sıralayacağını bilmediğinden, burada void sort(Object[] obj, Comparator C) biçimini kullanmak zorundayız. Comparator, yalnızca bir yöntem tanımlayan bir arayüzdür:
ve bu yöntem 0 değerini döndürmelidir: o1=o2 ise, -1: o1 < o2 ise, +1: o1 > o2 ise. void sort(Object[] obj, Comparator C) prototipinde ikinci argüman C, Comparator arayüzünü uygulayan bir nesne olmalıdır. sort2 yapıcıda, mevcut this nesnesi seçilmiştir:
Bu durum iki şey yapmamızı gerektirir:
- sort2 sınıfının Comparator arayüzünü uyguladığını belirtmek
- compare işlevini sort2 sınıfına yazın.
İşlev şu şekildedir:
// kişileri karşılaştıran işlev
public int compare(Object o1, Object o2){
// şunu döndürmelidir
// o1 "o2'den küçükse" -1
// o1 "o2'ye eş" ise 0
// o1, o2'den "büyükse" +1
personne p1=(personne)o1;
personne p2=(personne)o2;
int age1=p1.getAge();
int age2=p2.getAge();
if(age1<age2) return (-1);
else if (age1==age2) return (0);
else return +1;
}//karşılaştırır
İki nesneyi (personne) karşılaştırmak için burada yaş kullanılıyor (ad da kullanılabilirdi).
Çalıştırma sonuçları şöyledir:
Comparator arayüzünü uygulamak için farklı bir yol da izlenebilirdi:
import java.util.*;
public class sort2 {
// özel bir iç sınıf
private class personne{
…….
}; // kişi sınıfı
// yapıcı
public sort2() {
// kişi dizisi
personne[] amis=new personne[]{new personne("tintin",100),new personne("milou",80),
new personne("tournesol",40)};
// kişi dizisinin sıralanması
Arrays.sort(amis,
new java.util.Comparator(){
public int compare(Object o1, Object o2){
return compare1(o1,o2);
}//karşılaştırma
}//sınıflandırma
);
// doğrulama
for(int i=0;i<3;i++)
System.out.println(amis[i]);
}//oluşturucu
// kişileri karşılaştıran işlev
public int compare1(Object o1, Object o2){
// şunu döndürmelidir
// -1, eğer o1 "o2'den küçükse"
// o1 "o2'ye eş" ise 0
// o1, o2'den "büyükse" +1
personne p1=(personne)o1;
personne p2=(personne)o2;
int age1=p1.getAge();
int age2=p2.getAge();
if(age1<age2) return (-1);
else if (age1==age2) return (0);
else return +1;
}//karşılaştırma1
// ana
public static void main(String[] arg){
new sort2();
}//ana
}//sınıf
Sıralama komutu şu şekilde oldu:
// kişi tablosunu sıralama
Arrays.sort(amis,
new java.util.Comparator(){
public int compare(Object o1, Object o2){
return compare1(o1,o2);
}//karşılaştırma
}//sınıf
);
sort yönteminin ikinci parametresi, Comparator arayüzünü uygulayan bir nesne olmalıdır. Burada new java.util.Comparator() ile böyle bir nesne oluşturuyoruz ve {….} işaretinden sonraki metin, nesnesini oluşturduğumuz sınıfı tanımlar. Buna isimsiz sınıf denir, çünkü bir adı yoktur. Comparator arayüzünü uygulaması gereken bu isimsiz sınıfta, söz konusu arayüzün compare yöntemini tanımlıyoruz. Bu yöntem, sort2 sınıfının compare1 yöntemini çağırmakla yetinir. Böylece önceki duruma geri dönülür.
sort2 sınıfı artık Comparator arayüzünü uygulamamaktadır. Dolayısıyla bu sınıfın tanımlaması şu şekilde olur:
Şimdi, aşağıdaki örnekte Arrays sınıfının binarySearch yöntemini test ediyoruz:
import java.util.*;
public class sort4 {
// özel bir iç sınıf
private class personne{
// özellikler
private String nom;
private int age;
// yapıcı
public personne(String nom, int age){
this.nom=nom; // kişinin adı
this.age=age; // yaşı
}
// adı almayı
public String getNom(){
return nom;
}
// yaşı al
public int getAge(){
return age;
}
// kişinin kimliği
public String toString(){
return ("["+nom+","+age+"]");
}
}; // kişi sınıfı
// oluşturucu
public sort4() {
// kişi tablosu
personne[] amis=new personne[]{new personne("tintin",100),new personne("milou",80),
new personne("tournesol",40)};
// karşılaştırıcılar
java.util.Comparator comparateur1=
new java.util.Comparator(){
public int compare(Object o1, Object o2){
return compare1(o1,o2);
}//karşılaştırma
}//sınıf
;
java.util.Comparator comparateur2=
new java.util.Comparator(){
public int compare(Object o1, Object o2){
return compare2(o1,o2);
}//karşılaştırma
}//sınıflandırma
;
// kişi tablosunu sıralama
Arrays.sort(amis,comparateur1);
// doğrulama
for(int i=0;i<3;i++)
System.out.println(amis[i]);
// arama
cherche("milou",amis,comparateur2);
cherche("xx",amis,comparateur2);
}//oluşturucu
// kişileri karşılaştıran işlev
public int compare1(Object o1, Object o2){
// sonuç olarak
// -1, eğer o1 "o2'den küçükse"
// o1 "o2'ye eş" ise 0
// o1, o2'den "büyükse" +1
personne p1=(personne)o1;
personne p2=(personne)o2;
int age1=p1.getAge();
int age2=p2.getAge();
if(age1<age2) return (-1);
else if (age1==age2) return (0);
else return +1;
}//compare1
// bir kişiyi bir isimle karşılaştıran işlev
public int compare2(Object o1, Object o2){
// o1 bir kişidir
// o2 bir String'dir, bir kişinin nom2 adlı adı
// şunu döndürmelidir
// o1.nom "nom2'den küçükse" -1
// o1.nom, nom2'ye "eşitse" 0
//, o1.nom "nom2'den büyükse" +1
personne p1=(personne)o1;
String nom1=p1.getNom();
String nom2=(String)o2;
return nom1.compareTo(nom2);
}//karşılaştırma2
public void cherche(String ami,personne[] amis, Comparator comparateur){
// arkadaşlar tablosunda arkadaş arar
int position=Arrays.binarySearch(amis,ami,comparateur);
// bulundu mu?
if(position>=0)
System.out.println(ami + " a " + amis[position].getAge() + " ans");
else System.out.println(ami + " n'existe pas dans le tableau");
}//arıyor
// ana sayfa
public static void main(String[] arg){
new sort4();
}//el
}//sınıf
Burada, önceki örneklerden biraz farklı bir yol izledik. sort ve binarySearch yöntemleri için gerekli olan iki Comparator nesnesi oluşturuldu ve comparateur1 ile comparateur2 değişkenlerine atandı.
// karşılaştırıcılar
java.util.Comparator comparateur1=
new java.util.Comparator(){
public int compare(Object o1, Object o2){
return compare1(o1,o2);
}//karşılaştır
}//sınıf
;
java.util.Comparator comparateur2=
new java.util.Comparator(){
public int compare(Object o1, Object o2){
return compare2(o1,o2);
}//karşılaştırma
}//sınıf
;
amis tablosunda ikili arama, sort4 oluşturucusunda iki kez yapılır:
cherche yöntemi, binarySearch yöntemini çağırmak için ihtiyaç duyduğu tüm parametreleri alır:
public void cherche(String ami,personne[] amis, Comparator comparateur){
// arkadaşlar tablosunda arkadaş arama
int position=Arrays.binarySearch(amis,ami,comparateur);
// bulundu mu?
if(position>=0)
System.out.println(ami + " a " + amis[position].getAge() + " ans");
else System.out.println(ami + " n'existe pas dans le tableau");
}//arıyor
binarySearch yöntemi, comparateur2 karşılaştırıcıyla çalışır; bu karşılaştırıcı ise sort4 sınıfının compare2 yöntemini çağırır. rend yöntemi, aranan adın tabloda mevcutsa konumunu, yoksa <0 değerinde bir sayı döndürür. compare2 yöntemi, bir personne nesnesini String türündeki bir adla karşılaştırmak için kullanılır.
// bir kişiyi bir isimle karşılaştıran işlev
public int compare2(Object o1, Object o2){
// o1 bir kişidir
// o2 bir String'dir, bir kişinin nom2 adlı adı
// şunu döndürmelidir
// -1 ise o1.nom "nom2'den küçükse"
// 0 ise o1.nom "eşittir" isim2
// +1 eğer o1.nom "nom2'den büyükse"
personne p1=(personne)o1;
String nom1=p1.getNom();
String nom2=(String)o2;
return nom1.compareTo(nom2);
}//karşılaştırma2
sort yönteminin aksine, binarySearch yöntemi iki adet personne nesnesi almaz, bunun yerine sırasıyla bir adet personne nesnesi ve bir adet String nesnesi alır. İlk parametre, amis dizisinin bir elemanıdır; ikincisi ise aranan kişinin adıdır.
4.7. Enumeration sınıfı
Enumeration bir arayüzdür, sınıf değildir. Aşağıdaki yöntemlere sahiptir:
public abstract boolean hasMoreElements() | enumerasyonun hala elemanları varsa true değerini döndürür |
public abstract Object nextElement() | enumerasyonun bir sonraki elemanının referansını döndürür |
Bir enum nasıl kullanılır? Genellikle şu şekilde:
Enumeration e=… // bir enumerasyon nesnesi alınır
while(e.hasMoreElements()){
// e.nextElement() öğesini kullanır
}
İşte bir örnek:
// ithal edilen sınıflar
import java.util.*;
public class test1{
// ana program main - static - sınıf yöntemi
public static void main(String arg[]){
// sınıf örneklerinin oluşturulması
personne p=new personne("Jean","Dupont",30);
enseignant en=new enseignant("Paula","Hanson",56,27);
etudiant et=new etudiant("Chris","Garot",22,"19980405");
System.out.println("p="+p.toString());
System.out.println("en="+en.toString());
System.out.println("et="+et.toString());
// polimorfizm
personne p2=(personne)en;
System.out.println("p2="+p2.toString());
personne p3=(personne)et;
System.out.println("p3="+p3.toString());
// bir vektör
Vector V=new Vector();
V.addElement(p);V.addElement(en);V.addElement(et);
System.out.println("Taille du vecteur V = "+V.size());
int i;
for(i=0;i<V.size();i++){
p2=(personne) V.elementAt(i);
System.out.println("V["+i+"]="+p2.toString());
}
// bir enum
Enumeration E=V.elements();
i=0;
while(E.hasMoreElements()){
p2=(personne) E.nextElement();
System.out.println("V["+i+"]="+p2.toString());
i++;
}
}// main sonu
}//sınıf sonu
Şu sonuçlar elde edilir:
p=personne(Jean,Dupont,30)
en=enseignant(personne(Paula,Hanson,56),27)
et=etudiant(personne(Chris,Garot,22),19980405)
p2=enseignant(personne(Paula,Hanson,56),27)
p3=etudiant(personne(Chris,Garot,22),19980405)
Taille du vecteur V = 3
V[0]=personne(Jean,Dupont,30)
V[1]=enseignant(personne(Paula,Hanson,56),27)
V[2]=etudiant(personne(Chris,Garot,22),19980405)
V[0]=personne(Jean,Dupont,30)
V[1]=enseignant(personne(Paula,Hanson,56),27)
V[2]=etudiant(personne(Chris,Garot,22),19980405)
4.8. Hashtable sınıfı
Hashtable sınıfı, bir sözlükün uygulanmasına olanak tanır. Bir sözlük, iki sütunlu bir tablo olarak düşünülebilir:
anahtar | değer |
anahtar1 | değer1 |
anahtar2 | değer2 |
.. | ... |
Anahtarlar benzersizdir, c.a.d. Yani iki anahtarın aynı olması mümkün değildir. Hashtable sınıfının başlıca yöntemleri ve özellikleri şunlardır:
public Hashtable() | yapıcı - boş bir sözlük oluşturur |
public int size() | sözlükteki öğe sayısı - bir öğe, (anahtar, değer) çiftinden oluşur |
public Object put(Object key, Object value) | (anahtar, değer) çiftini sözlüğe ekler |
public Object get(Object key) | key anahtarına bağlı nesneyi alır; key anahtarı yoksa null nesnesini alır |
public boolean containsKey(Object key) | key anahtarı sözlükte varsa true |
public boolean contains(Object value) | value değeri sözlükte varsa true |
public Enumeration keys() | sözlüğün anahtarlarını bir enum olarak döndürür |
public Object remove(Object key) | (anahtar, değer) çiftini siler; burada anahtar=key |
public String toString() | sözlüğü tanımlar |
İşte bir örnek:
// ithal edilen sınıflar
import java.util.*;
public class test1{
// ana program main - static - sınıf yöntemi
public static void main(String arg[]){
// sınıf örneklerinin oluşturulması
personne p=new personne("Jean","Dupont",30);
enseignant en=new enseignant("Paula","Hanson",56,27);
etudiant et=new etudiant("Chris","Garot",22,"19980405");
System.out.println("p="+p.toString());
System.out.println("en="+en.toString());
System.out.println("et="+et.toString());
// polimorfizm
personne p2=(personne)en;
System.out.println("p2="+p2.toString());
personne p3=(personne)et;
System.out.println("p3="+p3.toString());
// bir sözlük
Hashtable H=new Hashtable();
H.put("personne1",p);
H.put("personne2",en);
H.put("personne3",et);
Enumeration E=H.keys();
int i=0;
String cle;
while(E.hasMoreElements()){
cle=(String) E.nextElement();
p2=(personne) H.get(cle);
System.out.println("clé "+i+"="+cle+" valeur="+p2.toString());
i++;
}
}//main sonu
}//sınıf sonu
Elde edilen sonuçlar şunlardır:
p=personne(Jean,Dupont,30)
en=enseignant(personne(Paula,Hanson,56),27)
et=etudiant(personne(Chris,Garot,22),19980405)
p2=enseignant(personne(Paula,Hanson,56),27)
p3=etudiant(personne(Chris,Garot,22),19980405)
clé 0=personne3 valeur=etudiant(personne(Chris,Garot,22),19980405)
clé 1=personne2 valeur=enseignant(personne(Paula,Hanson,56),27)
clé 2=personne1 valeur=personne(Jean,Dupont,30)
4.9. Metin dosyaları
4.9.1. Yazma
Bir dosyaya yazmak için bir yazma akışına sahip olmak gerekir. Bunun için FileWriter sınıfı kullanılabilir. Sıkça kullanılan oluşturucular şunlardır:
FileWriter(String fileName) | fileName adlı dosyayı oluşturur - daha sonra bu dosyaya yazılabilir - aynı adlı bir dosya varsa üzerine yazılır |
FileWriter(String fileName, boolean append) | aynı işlem - aynı isimde bir dosya varsa, ekleme modunda açarak kullanılabilir (append=true) |
FileWriter sınıfı, bir dosyaya yazmak için Writer sınıfından miras alınan bir dizi yöntem sunar. Bir metin dosyasına yazmak için, sık kullanılan oluşturucuları aşağıdaki gibi olan PrintWriter sınıfını kullanmak daha uygundur:
PrintWriter(Writer out) | Argüman, Writer veya c.a.d türündedir. Bir yazma akışı (dosyaya, ağa, …) |
PrintWriter(Writer out, boolean autoflush) | Aynı şekilde. İkinci argüman, satırların tamponlanmasını yönetir. Değeri false olduğunda (varsayılan ayar), dosyaya yazılan satırlar bellekteki bir tampondan geçer. Tampon dolduğunda, dosya üzerine yazılır. Bu, disk erişimini iyileştirir. Bununla birlikte, özellikle ağa yazarken bu davranış bazen istenmeyen sonuçlara yol açabilir. |
PrintWriter sınıfının kullanışlı yöntemleri şunlardır:
void print(Type T) | T verisini (String, int, …) yazar |
void println(Type T) | aynı işlemi, satır sonu işaretiyle bitirerek yapar |
void flush() | otomatik boşaltma modunda değilse tamponu boşaltır |
void close() | yazma akışını kapatır |
İşte bir metin dosyasına birkaç satır yazan bir program:
// ithalatlar
import java.io.*;
public class ecrire{
public static void main(String[] arg){
// dosyanın açılması
PrintWriter fic=null;
try{
fic=new PrintWriter(new FileWriter("out"));
} catch (Exception e){
Erreur(e,1);
}
// dosyaya yazma
try{
fic.println("Jean,Dupont,27");
fic.println("Pauline,Garcia,24");
fic.println("Gilles,Dumond,56");
} catch (Exception e){
Erreur(e,3);
}
// dosyayı kapatma
try{
fic.close();
} catch (Exception e){
Erreur(e,2);
}
}// main sonu
private static void Erreur(Exception e, int code){
System.err.println("Erreur : "+e);
System.exit(code);
}//Hata
}//sınıf
Çalıştırma sonucunda elde edilen out dosyası şöyledir:
4.9.2. Okuma
Bir dosyanın içeriğini okumak için, dosyaya ait bir okuma akışına sahip olmak gerekir. Bunun için FileReader sınıfı ve aşağıdaki oluşturucu kullanılabilir:
FileReader(String dosyaAdı) | belirtilen dosyadan bir okuma akışı açar. İşlem başarısız olursa bir istisna oluşturur. |
FileReader sınıfı, bir dosyadan okuma yapmak için Reader sınıfından miras alınan bir dizi yönteme sahiptir. Bir metin dosyasındaki satırları okumak için, BufferedReader sınıfını aşağıdaki oluşturucu ile kullanmak tercih edilir:
BufferedReader(Reader in) | bir in giriş akışından tamponlu bir okuma akışı açar. Bu Reader türündeki akış, klavyeden, bir dosyadan, ağdan vb. gelebilir. |
BufferedReader sınıfının kullanışlı yöntemleri şunlardır:
int read() | bir karakter okur |
String readLine() | bir satır metin okur |
int read(char[] buffer, int offset, int taille) | dosyadan taille karakter okur ve bunları buffer dizisine offset konumundan itibaren yerleştirir. |
void close() | okuma akışını kapatır |
İşte daha önce oluşturulan dosyanın içeriğini okuyan bir program:
// ithal edilen sınıflar
import java.util.*;
import java.io.*;
public class lire{
public static void main(String[] arg){
personne p=null;
// dosya açılıyor
BufferedReader IN=null;
try{
IN=new BufferedReader(new FileReader("out"));
} catch (Exception e){
Erreur(e,1);
}
// veriler
String ligne=null;
String[] champs=null;
String prenom=null;
String nom=null;
int age=0;
// olası hataların yönetimi
try{
while((ligne=IN.readLine())!=null){
champs=ligne.split(",");
prenom=champs[0];
nom=champs[1];
age=Integer.parseInt(champs[2]);
System.out.println(""+new personne(prenom,nom,age));
}// while döngüsünün sonu
} catch (Exception e){
Erreur(e,2);
}
// dosya kapatma
try{
IN.close();
} catch (Exception e){
Erreur(e,3);
}
}// main sonu
// Hata
public static void Erreur(Exception e, int code){
System.err.println("Erreur : "+e);
System.exit(code);
}
}// sınıf sonu
Programın çalıştırılması sonucunda şu sonuçlar elde edilir:
4.9.3. Bir kişi nesnesinin kaydedilmesi
Az önce gördüklerimizi uygulayarak, personne sınıfına bir kişinin özniteliklerini bir dosyaya kaydetmeye yarayan bir yöntem ekliyoruz. personne sınıfının tanımına sauveAttributs yöntemini ekliyoruz:
// ------------------------------
// metin dosyasına kaydet
// ------------------------------
public void sauveAttributs(PrintWriter P){
P.println(""+this);
}
personne sınıfının tanımlanmasından önce, java.io paketini içe aktarmayı unutmayalım:
sauveAttributs yöntemi, yazması gereken PrintWriter akışını tek parametre olarak alır. Bir test programı şu şekilde olabilir:
// içe aktarma
import java.io.*;
// kişi içe aktarma;
public class sauver{
public static void main(String[] arg){
// dosya açma
PrintWriter fic=null;
try{
fic=new PrintWriter(new FileWriter("out"));
} catch (Exception e){
Erreur(e,1);
}
// dosyaya yazma
try{
new personne("Jean","Dupont",27).sauveAttributs(fic);
new personne("Pauline","Garcia",24).sauveAttributs(fic);
new personne("Gilles","Dumond",56).sauveAttributs(fic);
} catch (Exception e){
Erreur(e,3);
}
// dosyayı kapatma
try{
fic.close();
} catch (Exception e){
Erreur(e,2);
}
}// main sonu
// Hata
private static void Erreur(Exception e, int code){
System.err.println("Erreur : "+e);
System.exit(code);
}//Hata
}//sınıf
Bu programı derleyip çalıştıralım:
E:\data\serge\JAVA\poly juin 2002\Chapitre 3\sauveAttributs>javac sauver.java
E:\data\serge\JAVA\poly juin 2002\Chapitre 3\sauveAttributs>dir
10/06/2002 10:52 1 352 personne.class
10/06/2002 10:53 842 sauver.java
10/06/2002 10:53 1 258 sauver.class
E:\data\serge\JAVA\poly juin 2002\Chapitre 3\sauveAttributs>java sauver
E:\data\serge\JAVA\poly juin 2002\Chapitre 3\sauveAttributs>dir
10/06/2002 10:52 1 352 personne.class
10/06/2002 10:53 842 sauver.java
10/06/2002 10:53 1 258 sauver.class
10/06/2002 10:53 83 out
E:\data\serge\JAVA\poly juin 2002\Chapitre 3\sauveAttributs>more out
personne(Jean,Dupont,27)
personne(Pauline,Garcia,24)
personne(Gilles,Dumond,56)
4.10. İkili dosyalar
4.10.1. RandomAccessFile sınıfı
RandomAccessFile sınıfı, özellikle C/C++ dilinde bilinen sabit yapılı ikili dosyaları yönetmeye olanak tanır. İşte bazı yararlı yöntemler ve oluşturucular:
RandomAccessFile(String dosyaAdı, String mod) | yapıcı - belirtilen dosyayı belirtilen modda açar. Modun değerleri şunlardır: r: okuma modunda açma rw: okuma ve yazma modunda açma |
void writeTTT(TTT değer) | değer'i dosyaya yazar. TTT, değer'in türünü temsil eder. Değer'in bellekteki temsili olduğu gibi dosyaya yazılır. Böylece writeBoolean, writeByte, writeInt, writeDouble, writeLong, writeFloat,... gibi değerler bulunur. Bir dize yazmak için writeBytes(String dize) kullanılır. |
TTT readTTT() | TTT türünde bir değeri okur ve döndürür. Böylece readBoolean, readByte, readInt, readDouble, readLong, readFloat,... gibi değerler bulunur. read() yöntemi bir bayt okur. |
long length() | dosya boyutu (bayt cinsinden) |
long getFilePointer() | dosya işaretçisinin geçerli konumu |
void seek(long pos) | dosya imlecini pos baytına konumlandırır |
4.10.2. article sınıfı
Aşağıdaki tüm örneklerde şu article sınıfı kullanılacaktır:
// makale yapısı
private static class article{
// yapı tanımlanıyor
public String code;
public String nom;
public double prix;
public int stockActuel;
public int stockMinimum;
}//ürün sınıfı
Yukarıdaki java sınıfı article, C dilindeki aşağıdaki article yapısına eşdeğer olacaktır
Böylece kodu 4 karakterle, adı ise 20 karakterle sınırlayacağız.
4.10.3. Bir kayıt yazma
Aşağıdaki program, "data" adlı bir dosyaya bir giriş yazar:
// ithal edilen sınıflar
import java.io.*;
public class test1{
// bir yapının (C dilinde olduğu gibi) ikili bir dosyaya yazılmasını test eder
// makale yapısı
private static class article{
// yapıyı tanımlıyoruz
public String code;
public String nom;
public double prix;
public int stockActuel;
public int stockMinimum;
}//"article" sınıfı
public static void main(String arg[]){
// makalelerin depolanacağı ikili dosya tanımlanıyor
RandomAccessFile fic=null;
// bir makale tanımlanır
article art=new article();
art.code="a100";
art.nom="velo";
art.prix=1000.80;
art.stockActuel=100;
art.stockMinimum=10;
// dosya tanımlanıyor
try{
fic=new RandomAccessFile("data","rw");
} catch (Exception E){
erreur("Impossible d'ouvrir le fichier data",1);
}//try-catch
// yazılır
try{
ecrire(fic,art);
} catch (IOException E){
erreur("Erreur lors de l'écriture de l'enregistrement",2);
}//try-catch
// bitti
try{
fic.close();
} catch (Exception E){
erreur("Impossible de fermer le fichier data",2);
}//try-catch
}//main
// yazma yöntemi
public static void ecrire(RandomAccessFile fic, article art) throws IOException{
// kod
fic.writeBytes(art.code);
// 20 karakterle sınırlı ad
art.nom=art.nom.trim();
int l=art.nom.length();
int nbBlancs=20-l;
if(nbBlancs>0){
String blancs="";
for(int i=0;i<nbBlancs;i++) blancs+=" ";
art.nom+=blancs;
} else art.nom=art.nom.substring(0,20);
fic.writeBytes(art.nom);
// fiyat
fic.writeDouble(art.prix);
// stoklar
fic.writeInt(art.stockActuel);
fic.writeInt(art.stockMinimum);
}// yazma sonu
// ------------------------hata
public static void erreur(String msg, int exitCode){
System.err.println(msg);
System.exit(exitCode);
}// hata sonu
}// sınıf sonu
Aşağıdaki program, işlemin doğru bir şekilde gerçekleştirildiğini doğrulamamızı sağlar.
4.10.4. Bir kaydı okumak
// ithal edilen sınıflar
import java.io.*;
public class test2{
// bir yapının (C dilinde olduğu gibi) ikili bir dosyaya yazılmasını test eder
// article yapısı
private static class article{
// yapıyı tanımlıyoruz
public String code;
public String nom;
public double prix;
public int stockActuel;
public int stockMinimum;
}//"article" sınıfı
public static void main(String arg[]){
// makalelerin depolanacağı ikili dosya tanımlanıyor
RandomAccessFile fic=null;
// dosyayı okuma modunda açıyoruz
try{
fic=new RandomAccessFile("data","r");
} catch (Exception E){
erreur("Impossible d'ouvrir le fichier data",1);
}//try-catch
// dosyadaki tek ürünü okunur
article art=new article();
try{
lire(fic,art);
} catch (IOException E){
erreur("Erreur lors de la lecture de l'enregistrement",2);
}//try-catch
// Okunan kaydı görüntülüyoruz
affiche(art);
// işlem tamamlandı
try{
fic.close();
} catch (Exception E){
erreur("Impossible de fermer le fichier data",2);
}//try-catch
}// elle sonlandırma
// okuma yöntemi
public static void lire(RandomAccessFile fic, article art) throws IOException{
// kod okuma
art.code="";
for(int i=0;i<4;i++) art.code+=(char)fic.readByte();
// ad
art.nom="";
for(int i=0;i<20;i++) art.nom+=(char)fic.readByte();
art.nom=art.nom.trim();
// fiyat
art.prix=fic.readDouble();
// stoklar
art.stockActuel=fic.readInt();
art.stockMinimum=fic.readInt();
}// yazma sonu
// ---------------------görüntüle
public static void affiche(article art){
System.out.println("code : "+art.code);
System.out.println("nom : "+art.nom);
System.out.println("prix : "+art.prix);
System.out.println("Stock actuel : "+art.stockActuel);
System.out.println("Stock minimum : "+art.stockMinimum);
}// görüntüleme sonu
// ------------------------hata
public static void erreur(String msg, int exitCode){
System.err.println(msg);
System.exit(exitCode);
}// hata sonu
}// sınıf sonu
Çalıştırma sonuçları şöyledir:
E:\data\serge\JAVA\random>java test2
code : a100
nom : velo
prix : 1000.8
Stock actuel : 100
Stock minimum : 10
Yazma programı tarafından yazılan kayıt başarıyla geri alınmıştır.
4.10.5. Metin --> ikili dönüştürme
Aşağıdaki program, bir kayıt yazma programının bir uzantısıdır. Şimdi, data.bin adlı bir ikili dosyaya birden fazla kayıt yazıyoruz. Veriler, aşağıdaki data.txt dosyasından alınmaktadır:
E:\data\serge\JAVA\random>more data.txt
a100:velo:1000:100:10
b100:pompe:65:6:2
c100:arc:867:10:5
d100:fleches - lot de 6:450:12:8
e100:jouet:10:2:3
// ithal edilen sınıflar
import java.io.*;
import java.util.*;
public class test3{
// metin dosyası --> ikili dosya
// makale yapısı
private static class article{
// yapı tanımlanıyor
public String code;
public String nom;
public double prix;
public int stockActuel;
public int stockMinimum;
}//ürün sınıfı
public static void main(String arg[]){
// makalelerin depolanacağı ikili dosya tanımlanıyor
RandomAccessFile dataBin=null;
try{
dataBin=new RandomAccessFile("data.bin","rw");
} catch (Exception E){
erreur("Impossible d'ouvrir le fichier data.bin",1);
}
// veriler bir metin dosyasından alınır
BufferedReader dataTxt=null;
try{
dataTxt=new BufferedReader(new FileReader("data.txt"));
} catch (IOException E){
erreur("Impossible d'ouvrir le fichier data.txt",2);
}
// .txt dosyası --> .bin dosyası
String ligne=null;
String[] champs=null;
int numLigne=0;
String champ=null;
article art=new article(); // oluşturulacak ürün
try{
while((ligne=dataTxt.readLine())!=null){
// bir satır +
numLigne++;
// alanlara ayrıştırma
champs=ligne.split(":");
// 5 alan gereklidir
if(champs.length!=5)
erreur("Ligne "+numLigne+" erronée dans data.txt",3);
//kod
art.code=champs[0];
if(art.code.length()!=4)
erreur("Code erroné en ligne "+numLigne+" du fichier data.txt",12);
// soyadı, adı
art.nom=champs[1];
// fiyat
try{
art.prix=Double.parseDouble(champs[2]);
} catch (Exception E){
erreur("Prix erroné en ligne "+numLigne+" du fichier data.txt",4);
}
// mevcut stok
try{
art.stockActuel=Integer.parseInt(champs[3]);
} catch (Exception E){
erreur("Stock actuel erroné en ligne "+ numLigne + " du fichier data.txt",5);
}
// mevcut stok
try{
art.stockActuel=Integer.parseInt(champs[3]);
} catch (Exception E){
erreur("Stock actuel erroné en ligne "+ numLigne + " du fichier data.txt",5);
}
// kayıt yazılır
try{
ecrire(dataBin,art);
} catch (IOException E){
erreur("Erreur lors de l'écriture de l'enregistrement "+numLigne,7);
}
// bir sonraki satıra geçiliyor
}// while döngüsü sonu
} catch (IOException E){
erreur("Erreur lors de la lecture du fichier data.txt après la ligne "+numLigne,8);
}
// işlem tamamlandı
try{
dataBin.close();
} catch (Exception E){
erreur("Impossible de fermer le fichier data.bin",10);
}
try{
dataTxt.close();
} catch (Exception E){
erreur("Impossible de fermer le fichier data.txt",11);
}
}// main sonu
// yazma yöntemi
public static void ecrire(RandomAccessFile fic, article art) throws IOException{
// kod
fic.writeBytes(art.code);
// 20 karakterle sınırlı ad
art.nom=art.nom.trim();
int l=art.nom.length();
int nbBlancs=20-l;
if(nbBlancs>0){
String blancs="";
for(int i=0;i<nbBlancs;i++) blancs+=" ";
art.nom+=blancs;
} else art.nom=art.nom.substring(0,20);
fic.writeBytes(art.nom);
// fiyat
fic.writeDouble(art.prix);
// stoklar
fic.writeInt(art.stockActuel);
fic.writeInt(art.stockMinimum);
}// yazma sonu
// ------------------------hata
public static void erreur(String msg, int exitCode){
System.err.println(msg);
System.exit(exitCode);
}// hata sonu
}// sınıf sonu
Aşağıdaki program, bu programın doğru çalıştığını doğrulamaya yarar.
4.10.6. İkili --> metin dönüştürme
Aşağıdaki program, daha önce oluşturulan data.bin adlı ikili dosyanın içeriğini okur ve bu içeriği data.text adlı metin dosyasına aktarır. Her şey yolunda giderse, data.text dosyası, orijinal data.txt dosyasıyla aynı olmalıdır.
// ithal edilen sınıflar
import java.io.*;
import java.util.*;
public class test5{
// metin dosyası --> ikili dosya
// makale yapısı
private static class article{
// yapı tanımlanıyor
public String code;
public String nom;
public double prix;
public int stockActuel;
public int stockMinimum;
}//ürün sınıfı
// ana fonksiyon
public static void main(String arg[]){
// makalelerin depolanacağı ikili dosya tanımlanıyor
RandomAccessFile dataBin=null;
try{
dataBin=new RandomAccessFile("data.bin","r");
} catch (Exception E){
erreur("Impossible d'ouvrir le fichier data.bin en lecture",1);
}
// veriler bir metin dosyasına yazılır
PrintWriter dataTxt=null;
try{
dataTxt=new PrintWriter(new FileWriter("data.text"));
} catch (IOException E){
erreur("Impossible d'ouvrir le fichier data.text en écriture",2);
}
// .bin dosyası --> .text dosyası
article art=new article(); // oluşturulacak ürün
// ikili dosya işlenir
int numRecord=0;
long l=0; // dosya boyutu
try{
l=dataBin.length();
} catch (IOException e){
erreur("Erreur lors du calcul de la longueur du fichier data.bin",2);
}
long pos=0; // dosyadaki geçerli konum
try{
pos=dataBin.getFilePointer();
} catch (IOException e){
erreur("Erreur lors de la lecture de la position courante dans data.bin",2);
}
// dosyanın sonuna ulaşılana kadar
while(pos<l){
// geçerli kaydı oku ve işleme al
numRecord++;
try{
lire(dataBin,art);
} catch (Exception e){
erreur("Erreur lors de la lecture de l'enregistrement "+numRecord,2);
}
affiche(art);
// ilgili metin satırını dataTxt dosyasına yazma
dataTxt.println(art.code.trim()+":"+art.nom.trim()+":"+art.prix+":"+art.stockActuel+":"+art.stockMinimum);
// devam edelim mi?
try{
pos=dataBin.getFilePointer();
} catch (IOException e){
erreur("Erreur lors de la lecture de la position courante dans data.bin",2);
}
}// while döngüsünün sonu
// bitti
try{
dataBin.close();
} catch (Exception E){
erreur("Impossible de fermer le fichier data.bin",2);
}
try{
dataTxt.close();
} catch (Exception E){
erreur("Impossible de fermer le fichier data.text",2);
}
}// main sonu
// okuma yöntemi
public static void lire(RandomAccessFile fic, article art) throws IOException{
// kod okuma
art.code="";
for(int i=0;i<4;i++) art.code+=(char)fic.readByte();
// ad
art.nom="";
for(int i=0;i<20;i++) art.nom+=(char)fic.readByte();
art.nom=art.nom.trim();
// fiyat
art.prix=fic.readDouble();
// stoklar
art.stockActuel=fic.readInt();
art.stockMinimum=fic.readInt();
}// yazma sonu
// ---------------------görüntüle
public static void affiche(article art){
System.out.println("code : "+art.code);
System.out.println("nom : "+art.nom);
System.out.println("prix : "+art.prix);
System.out.println("Stock actuel : "+art.stockActuel);
System.out.println("Stock minimum : "+art.stockMinimum);
}// ilan sonu
// ------------------------hata
public static void erreur(String msg, int exitCode){
System.err.println(msg);
System.exit(exitCode);
}// hata sonu
}// sınıf sonu
İşte bir çalışma örneği:
E:\data\serge\JAVA\random>java test5
code : a100
nom : velo
prix : 1000.0
Stock actuel : 100
Stock minimum : 0
code : b100
nom : pompe
prix : 65.0
Stock actuel : 6
Stock minimum : 0
code : c100
nom : arc
prix : 867.0
Stock actuel : 10
Stock minimum : 0
code : d100
nom : fleches - lot de 6
prix : 450.0
Stock actuel : 12
Stock minimum : 0
code : e100
nom : jouet
prix : 10.0
Stock actuel : 2
Stock minimum : 0
E:\data\serge\JAVA\random>more data.text
a100:velo:1000.0:100:0
b100:pompe:65.0:6:0
c100:arc:867.0:10:0
d100:fleches - lot de 6:450.0:12:0
e100:jouet:10.0:2:0
4.10.7. Kayıtlara doğrudan erişim
Bu son program, bir ikili dosyanın kayıtlarına doğrudan erişme olanağını göstermektedir. Programa parametre olarak verilen data.bin dosyasının kaydını görüntüler; 1 numaralı kayıt, 1 numaralıdır.
// ithal edilen sınıflar
import java.io.*;
import java.util.*;
public class test6{
// metin dosyası --> ikili dosya
// makale yapısı
private static class article{
// yapı tanımlanıyor
public String code;
public String nom;
public double prix;
public int stockActuel;
public int stockMinimum;
}//ürün sınıfı
// ana işlev
public static void main(String[] args){
// argümanları kontrol ediyoruz
int nbArguments=args.length;
String syntaxe="syntaxe : pg numéro_de_fiche";
if(nbArguments!=1)
erreur(syntaxe,20);
// kayıt numarası kontrolü
int numRecord=0;
try{
numRecord=Integer.parseInt(args[0]);
} catch(Exception e){
erreur(syntaxe+"\nNuméro de fiche incorrect",21);
}
// ikili dosyayı okuma modunda açılıyor
RandomAccessFile dataBin=null;
try{
dataBin=new RandomAccessFile("data.bin","r");
} catch (Exception E){
erreur("Impossible d'ouvrir le fichier data.bin en lecture",1);
}
// istenen kayda konumlanılıyor
try{
dataBin.seek((numRecord-1)*40);
} catch (Exception e){
erreur("La fiche "+numRecord+" n'existe pas",23);
}
// dosya okunuyor
article art=new article();
try{
lire(dataBin,art);
} catch (Exception e){
erreur("Erreur lors de la lecture de l'enregistrement "+numRecord,2);
}
// dosya görüntülenir
affiche(art);
// işlem tamamlandı
try{
dataBin.close();
} catch (Exception E){
erreur("Impossible de fermer le fichier data.bin",2);
}//try-catch
}// main sonu
// okuma yöntemi
public static void lire(RandomAccessFile fic, article art) throws IOException{
// kod okuma
art.code="";
for(int i=0;i<4;i++) art.code+=(char)fic.readByte();
// ad
art.nom="";
for(int i=0;i<20;i++) art.nom+=(char)fic.readByte();
art.nom=art.nom.trim();
// fiyat
art.prix=fic.readDouble();
// stoklar
art.stockActuel=fic.readInt();
art.stockMinimum=fic.readInt();
}// yazma sonu
// ---------------------görüntüle
public static void affiche(article art){
System.out.println("code : "+art.code);
System.out.println("nom : "+art.nom);
System.out.println("prix : "+art.prix);
System.out.println("Stock actuel : "+art.stockActuel);
System.out.println("Stock minimum : "+art.stockMinimum);
}// ilan sonu
// ------------------------hata
public static void erreur(String msg, int exitCode){
System.err.println(msg);
System.exit(exitCode);
}// hata sonu
}// sınıf sonu
İşte bazı çalışma örnekleri:
E:\data\serge\JAVA\random>java test6 2
code : b100
nom : pompe
prix : 65.0
Stock actuel : 6
Stock minimum : 0
E:\data\serge\JAVA\random>java.bat test6 20
Erreur lors de la lecture de l'enregistrement 20
4.11. Düzenli ifadeleri kullanma
4.11.1. java.util.regex paketi
java.util.regex paketi, düzenli ifadelerin kullanımına olanak tanır. Düzenli ifadeler, bir karakter dizisinin biçimini test etmeye yarar. Böylece, bir tarihi temsil eden karakter dizisinin gerçekten gg/aa/yy biçiminde olup olmadığını kontrol edebiliriz. Bunun için bir şablon kullanılır ve karakter dizisi bu şablonla karşılaştırılır. Dolayısıyla bu örnekte, j, m ve a rakamlar olmalıdır. Geçerli bir tarih biçiminin şablonu "\d\d/\d\d/\d\d" şeklindedir; burada \d sembolü bir rakamı ifade eder. Şablonda kullanılabilecek semboller şunlardır (Microsoft belgeleri):
Karakter | Açıklama |
\ | Aşağıdaki karakteri özel karakter veya sabit karakter olarak işaretler. Örneğin, "n" karakteri "n" karakterine karşılık gelir. "\n" karakteri yeni satır karakterine karşılık gelir. "\\" dizisi "\" karakterine karşılık gelirken, "\(" karakteri "(" karakterine karşılık gelir. |
^ | Girişin başlangıcına karşılık gelir. |
$ | Girişin sonuna karşılık gelir. |
* | Önceki karakteri sıfır kez veya birden fazla kez ifade eder. Dolayısıyla, "zo*" hem "z" hem de "zoo" anlamına gelir. |
+ | Önceki karakteri bir veya daha fazla kez eşleştirir. Dolayısıyla, "zo+" "zoo" ile eşleşir, ancak "z" ile eşleşmez. |
? | Önceki karakterle sıfır veya bir kez eşleşir. Örneğin, "a?ve?" "lever" kelimesindeki "ve" ile eşleşir. |
. | Satır başı karakteri hariç, herhangi bir tek karakterle eşleşir. |
(örnek) | modèle'i arar ve eşleşmeyi kaydeder. Eşleşen alt dize, elde edilen Matches koleksiyonundan Item [0]...[n] kullanılarak çıkarılabilir. Parantez ( ) içindeki karakterlerle eşleşmeleri bulmak için "\(" veya "\)" kullanın. |
x|y | x veya y ile eşleşir. Örneğin, "z|foot" correspond à "z" ou à "foot". "(z|f)oo" "zoo" veya "foo" ile eşleşir. |
{n} | n, negatif olmayan bir tamsayıdır. Tam olarak n çarpı karakter değerine karşılık gelir. Örneğin, "o{2}", "Bob," içindeki "o" harfine değil, "fooooot" içindeki ilk iki "o" harfine karşılık gelir. |
{n,} | n, negatif olmayan bir tamsayıdır. Karakterin en az n katına karşılık gelir. Örneğin, "o{2,}" "Bob" kelimesindeki "o" harfine değil, "fooooot" kelimesindeki tüm "o" harflerine karşılık gelir. "o{1,}" "o+" ile eşdeğerdir ve "o{0,}" "o*" ile eşdeğerdir. |
{n,m} | m ve n, negatif olmayan tamsayılardır. Karakterin en az n ve en fazla m kez tekrarlandığı durumlara karşılık gelir. Örneğin, "o{1,3}", "foooooot" kelimesindeki ilk üç "o" karakterine karşılık gelir ve "o{0,1}", "o?" ile eşdeğerdir. |
[xyz] | Karakter kümesi. Belirtilen karakterlerden birine karşılık gelir. Örneğin, "[abc]", "plat" kelimesindeki "a" harfine karşılık gelir. |
[^xyz] | Negatif karakter kümesi. Belirtilmeyen tüm karakterlere karşılık gelir. Örneğin, "[^abc]", "plat" kelimesindeki "p" harfine karşılık gelir. |
[a-z] | Karakter aralığı. Belirtilen dizideki tüm karakterlere karşılık gelir. Örneğin, "[a-z]", "a" ile "z" arasındaki tüm küçük harf karakterlerine karşılık gelir. |
[^m-z] | Negatif karakter aralığı. Belirtilen dizide bulunmayan tüm karakterlere karşılık gelir. Örneğin, "[^m-z]", "m" ile "z" arasında bulunmayan tüm karakterlere karşılık gelir. |
\b | Bir kelimeyi temsil eden sınırla, başka bir deyişle bir kelime ile boşluk arasındaki konuma karşılık gelir. Örneğin, "er\b", "lever" kelimesindeki "er"e karşılık gelir, ancak "verbe" kelimesindeki "er"e karşılık gelmez. |
\B | Bir kelimeyi temsil etmeyen bir sınırla eşleşir. "en*t\B", "bien entendu" kelimesindeki "ent" ile eşleşir. |
\d | Bir rakamı temsil eden bir karaktere karşılık gelir. [0-9] ile eşdeğerdir. |
\D | Rakam olmayan bir karaktere karşılık gelir. [^0-9] ile eşdeğerdir. |
\f | Sayfa sonu karakterine karşılık gelir. |
\n | Satır sonu karakterine karşılık gelir. |
\r | Satır başı karakterine karşılık gelir. |
\s | Boşluk, sekme, sayfa sonu vb. dahil olmak üzere tüm boşluk karakterlerine karşılık gelir. "[ \f\n\r\t\v]" ile eşdeğerdir. |
\S | Beyaz olmayan tüm boşluk karakterlerine karşılık gelir. "[^ \f\n\r\t\v]" ile eşdeğerdir. |
\t | Bir sekme karakterine karşılık gelir. |
\v | Dikey sekme karakterine karşılık gelir. |
\w | Bir kelimeyi temsil eden ve alt çizgi içeren herhangi bir karaktere karşılık gelir. "[A-Za-z0-9_]" ile eşdeğerdir. |
\W | Bir kelimeyi temsil etmeyen herhangi bir karaktere karşılık gelir. "[^A-Za-z0-9_]" ile eşdeğerdir. |
\num | num’e karşılık gelir; burada num pozitif bir tamsayıdır. Kaydedilmiş eşleşmelere atıfta bulunur. Örneğin, "(.)\1" iki ardışık aynı karaktere karşılık gelir. |
|
Bir şablondaki öğe, 1 veya daha fazla kopya halinde bulunabilir. 1 rakamı temsil eden \d sembolüyle ilgili birkaç örneği ele alalım:
şablon | anlam |
\d | bir rakam |
\d? | 0 veya 1 rakam |
\d* | 0 veya daha fazla rakam |
\d+ | 1 veya daha fazla rakam |
\d{2} | 2 rakam |
\d{3,} | en az 3 rakam |
\d{5,7} | 5 ile 7 arasında rakam |
Şimdi, bir karakter dizisi için beklenen biçimi tanımlayabilen bir model düşünelim:
aranan dize | model |
gg/aa/yy formatında bir tarih | \d{2}/\d{2}/\d{2} |
hh:mm:ss biçiminde bir saat | \d{2}:\d{2}:\d{2} |
işaretsiz bir tamsayı | \d+ |
boş olabilir bir boşluk dizisi | \s* |
önünde veya arkasında boşluk bulunabilen işaretsiz bir tamsayı | \s*\d+\s* |
önünde veya arkasında boşluklar bulunabilen, işaretli veya işaretsiz bir tamsayı | \s*[+|-]?\s*\d+\s* |
önünde veya arkasında boşluk bulunabilen işaretsiz bir gerçek sayı | \s*\d+(.\d*)?\s* |
işareti olan veya olmayan bir gerçek sayı; başında veya sonunda boşluk olabilir | \s*[+|]?\s*\d+(.\d*)?\s* |
"juste" kelimesini içeren bir dize | \bjuste\b |
Dizgide kalıbın nerede aranacağını belirtebiliriz:
desen | anlam |
^örnek | model, dizginin başında yer alır |
model$ | şablon dizgiyi sonlandırır |
^desen$ | şablon dizgiyi başlatır ve bitirir |
desen | desen, dizgenin başından başlayarak her yerinde aranır. |
aranan dize | desen |
ünlem işaretiyle biten bir dize | !$ |
nokta ile biten bir dize | \.$ |
// dizisiyle başlayan bir dize | ^// |
yalnızca bir kelimeden oluşan ve isteğe bağlı olarak öncesinde veya sonrasında boşluklar bulunan bir dize | ^\s*\w+\s*$ |
önünde veya arkasında boşluk olabilecek iki kelimeden oluşan bir dize | ^\s*\w+\s*\w+\s*$ |
"secret" kelimesini içeren bir dize | \bsecret\b |
Bir şablonun alt kümeleri "çıkarılabilir". Böylece, bir dizgenin belirli bir şablona uyup uymadığını kontrol etmekle kalmaz, aynı zamanda bu dizgede parantezlerle çevrelenmiş şablonun alt kümelerine karşılık gelen öğeleri de çıkarabiliriz. Örneğin, gg/aa/yyyy tarihini içeren bir dizgiyi analiz ediyorsak ve bu tarihin gg, aa, yyyy öğelerini de ayıklamak istiyorsak, (\d\d)/(\d\d)/(\d\d) kalıbını kullanırız.
4.11.2. Bir dizgenin belirli bir şablona uyup uymadığını kontrol etme
Pattern sınıfı, bir dizgenin belirli bir şablona uyup uymadığını kontrol etmemizi sağlar. Bunun için statik yöntem kullanılır
şu şekilde: modèle: doğrulanacak şablon, chaine: şablonla karşılaştırılacak dize. Dize şablona uyuyorsa sonuç true boole değeri olur, aksi takdirde false olur.
İşte bir örnek:
import java.io.*;
import java.util.regex.*;
// düzenli ifadelerin yönetimi
public class regex1 {
public static void main(String[] args){
// bir düzenli ifade şablonu
String modèle1="^\\s*\\d+\\s*$";
// bir örneği şablonla karşılaştırma
String exemplaire1=" 123 ";
if (Pattern.matches(modèle1,exemplaire1)){
affiche("["+exemplaire1 + "] correspond au modèle ["+modèle1+"]");
}else{
affiche("["+exemplaire1 + "] ne correspond pas au modèle ["+modèle1+"]");
}//if
String exemplaire2=" 123a ";
if (Pattern.matches(modèle1,exemplaire2)){
affiche("["+exemplaire2 + "] correspond au modèle ["+modèle1+"]");
}else{
affiche("["+exemplaire2 + "] ne correspond pas au modèle ["+modèle1+"]");
}//if
}//ana işlev
public static void affiche(String msg){
System.out.println(msg);
}//görüntüle
}//sınıf
ve yürütme sonuçları:
"^\s*\d+\s*$" deseninde, Java'nın bu karakteri özel bir şekilde yorumlaması nedeniyle \ karakterinin iki kez yazılması gerektiğine dikkat edilmelidir. Dolayısıyla şöyle yazılır: String desen1="^\\s*\\d+\\s*$";
4.11.3. Bir dizede bir desene uyan tüm öğeleri bulma
"\d+" desenini ve " 123 456 789 " dizesini ele alalım. Desen, dizede üç farklı yerde bulunur. Pattern ve Matcher sınıfları, bir dizede bir desenin farklı örneklerini bulmaya olanak tanır. Pattern sınıfı, düzenli ifadeleri yöneten sınıftır. Birden fazla kez kullanılan bir düzenli ifadenin "derlenmesi" gerekir. Bu, dizgilerde desen aramalarını hızlandırır. Statik compile yöntemi bu işi yapar:
Bu yöntem, parametre olarak desen dizesini alır ve bir Pattern nesnesi döndürür. Bir Pattern nesnesinin desenini bir karakter dizesiyle karşılaştırmak için Matcher sınıfı kullanılır. Bu sınıf, bir desenin bir karakter dizesiyle karşılaştırılmasını sağlar. Bir Pattern nesnesinden, matcher yöntemi kullanılarak Matcher türünde bir nesne elde edilebilir:
input, şablonla karşılaştırılması gereken karakter dizisidir.
Dolayısıyla, "\d+" şablonunu " 123 456 789 " dizesiyle karşılaştırmak için, aşağıdaki şekilde bir Matcher nesnesi oluşturulabilir:
Yukarıdaki résultats nesnesinden, dizgedeki kalıbın farklı örneklerini alabiliriz. Bunun için, Matcher sınıfının suivantes yöntemlerini kullanırız:
find yöntemi, taranan dizede şablonun ilk örneğini arar. find yöntemine ikinci bir çağrı, bir sonraki örneği arar. Ve bu şekilde devam eder. Yöntem, deseni bulursa true değerini, bulamazsa false değerini döndürür. find tarafından bulunan son örneğe karşılık gelen dize parçası, group yöntemi ile elde edilir; konumu ise start yöntemi ile elde edilir. Dolayısıyla, önceki örneği devam ettirirsek ve " 123 456 789 " dizesindeki "\d+" deseninin tüm örneklerini görüntülemek istersek, şunu yazacağız:
while(résultats.find()){
System.out.println("séquence " + résultats.group() + " trouvée en position " + résultats.start());
}//while
reset yöntemi, Matcher nesnesini, desenle karşılaştırılan dizgenin başına sıfırlamaya olanak tanır. Böylece find yöntemi, daha sonra desenin ilk örneğini yeniden bulacaktır.
İşte tam bir örnek:
import java.io.*;
import java.util.regex.*;
// düzenli ifadelerin yönetimi
public class regex2 {
public static void main(String[] args){
// örnekteki şablonun birden fazla örneği
String modèle2="\\d+";
Pattern regex2=Pattern.compile(modèle2);
String exemplaire3=" 123 456 789";
// örnekteki şablon örneklerinin aranması
Matcher matcher2=regex2.matcher(exemplaire3);
while(matcher2.find()){
affiche("séquence " + matcher2.group() + " trouvée en position " + matcher2.start());
}//while
}//Ana Sayfa
public static void affiche(String msg){
System.out.println(msg);
}//görüntüler
}//sınıf
Çalıştırma sonuçları:
Modèle=[\d+],exemplaire=[ 123 456 789 ]
Il y a 3 occurrences du modèle dans l'exemplaire
123 en position 2
456 en position 7
789 en position 12
4.11.4. Bir şablonun parçalarını ayıklama
Bir şablonun alt kümeleri "çıkarılabilir". Böylece, bir dizgenin belirli bir şablona uyup uymadığını kontrol etmekle kalmaz, aynı zamanda bu dizgede parantez içine alınmış şablonun alt kümelerine karşılık gelen öğeleri de çıkarabiliriz. Örneğin, gg/aa/yyyy tarihini içeren bir dizgiyi analiz ediyorsak ve bu tarihin gg, aa, yyyy öğelerini de ayıklamak istiyorsak, (\d\d)/(\d\d)/(\d\d) şablonunu kullanırız.
Şu örneği inceleyelim:
import java.io.*;
import java.util.regex.*;
// düzenli ifadelerin yönetimi
public class regex3 {
public static void main(String[] args){
// şablondaki öğeleri yakalama
String modèle3="(\\d\\d):(\\d\\d):(\\d\\d)";
Pattern regex3=Pattern.compile(modèle3);
String exemplaire4="Il est 18:05:49";
// şablon doğrulama
Matcher résultat=regex3.matcher(exemplaire4);
if (résultat.find()){
// örnek, şablona uyuyor
affiche("L'exemplaire ["+exemplaire4+"] correspond au modèle ["+modèle3+"]");
// gruplar görüntülenir
for (int i=0;i<=résultat.groupCount();i++){
affiche("groupes["+i+"]=["+résultat.group(i)+"] en position "+résultat.start(i));
}//for
}else{
// örnek, modele uymuyor
affiche("L'exemplaire["+exemplaire4+" ne correspond pas au modèle ["+modèle3+"]");
}
}//Ana Sayfa
public static void affiche(String msg){
System.out.println(msg);
}//görüntüleniyor
}//sınıflandırma
Bu programın çalıştırılması sonucunda aşağıdaki çıktılar elde edilir:
L'exemplaire [Il est 18:05:49] correspond au modèle [(\d\d):(\d\d):(\d\d)]
groupes[0]=[18:05:49] en position 7
groupes[1]=[18] en position 7
groupes[2]=[05] en position 10
groupes[3]=[49] en position 13
Yenilik, aşağıdaki kod bölümünde yer almaktadır:
// şablon doğrulama
Matcher résultat=regex3.matcher(exemplaire4);
if (résultat.find()){
// örnek, modele uyuyor
affiche("L'exemplaire ["+exemplaire4+"] correspond au modèle ["+modèle3+"]");
// gruplar görüntüleniyor
for (int i=0;i<=résultat.groupCount();i++){
affiche("groupes["+i+"]=["+résultat.group(i)+"] en position "+résultat.start(i));
}//for
}else{
// örnek, modele uymuyor
affiche("L'exemplaire["+exemplaire4+" ne correspond pas au modèle ["+modèle3+"]");
}
exemplaire4 dizesi, find yöntemi aracılığıyla regex3 şablonuyla karşılaştırılır. Böylece, exemplaire4 dizesinde regex3 şablonuna ait bir örnek bulunur. Şablon, parantezlerle çevrili alt kümeler içeriyorsa, bunlar Matcher sınıfının çeşitli yöntemleri aracılığıyla erişilebilir:
public int groupCount()
public String group(int group)
public int start(int group)
groupCount yöntemi, şablonda bulunan alt kümelerin sayısını verir; group(i) ise i numaralı alt kümeyi verir. Bu alt küme, start(i) tarafından belirtilen konumda dizgide bulunur. Örnekte olduğu gibi:
L'exemplaire [Il est 18:05:49] correspond au modèle [(\d\d):(\d\d):(\d\d)]
groupes[0]=[18:05:49] en position 7
groupes[1]=[18] en position 7
groupes[2]=[05] en position 10
groupes[3]=[49] en position 13
find yöntemine yapılan ilk çağrı, 18:05:49 dizesini bulacak ve şablondaki parantezlerle tanımlanan üç alt kümeyi, sırasıyla 18, 05 ve 49 olarak otomatik olarak oluşturacaktır.
4.11.5. Bir alıştırma programı
Bir dizenin belirli bir şablona uyup uymadığını kontrol etmemizi sağlayan düzenli ifadeyi bulmak bazen gerçek bir zorluktur. Aşağıdaki program bu konuda alıştırma yapmanıza olanak tanır. Program, bir şablon ve bir dize ister ve ardından dizenin şablona uyup uymadığını belirtir.
import java.io.*;
import java.util.regex.*;
// düzenli ifadelerin yönetimi
public class regex4 {
public static void main(String[] args){
// veriler
String modèle=null,chaine=null;
Pattern regex=null;
BufferedReader IN=null;
Matcher résultats=null;
int nbOccurrences=0;
// hata yönetimi
try{
// kullanıcıdan, bu örnekle karşılaştırılacak şablonlar ve örnekler istenir
while(true){
// giriş akışı
IN=new BufferedReader(new InputStreamReader(System.in));
// şablon istenir
System.out.print("Tapez le modèle à tester ou fin pour arrêter :");
modèle=IN.readLine();
// bitti mi?
if(modèle.trim().toLowerCase().equals("fin")) break;
// düzenli ifade oluşturulur
regex=Pattern.compile(modèle);
// kullanıcıdan şablonla karşılaştırılacak örnekler isteniyor
while(true){
System.out.print("Tapez la chaîne à comparer au modèle ["+modèle+"] ou fin pour arrêter :");
chaine=IN.readLine();
// bitti mi?
if(chaine.trim().toLowerCase().equals("fin")) break;
// eşleştirici nesnesi oluşturulur
résultats=regex.matcher(chaine);
// şablonun örnekleri aranır
nbOccurrences=0;
while(résultats.find()){
// bir eşleşme bulunur
nbOccurrences++;
// bu örnek görüntülenir
System.out.println("J'ai trouvé la correspondance ["+résultats.group()
+"] en position "+résultats.start());
// alt öğeler görüntüleniyor
if(résultats.groupCount()!=1){
for(int j=1;j<=résultats.groupCount();j++){
System.out.println("\tsous-élément ["+résultats.group(j)+"] en position "+
résultats.start(j));
}//for j
}//if
// sonraki dize
}//while(résultats.find())
// en az bir örnek bulundu mu?
if(nbOccurrences==0){
System.out.println("Je n'ai pas trouvé de correspondance au modèle ["+modèle+"]");
}//if
// sonraki şablon
}//while(true)
}//while(true)
}catch(Exception ex){
// hata
System.err.println("Erreur : "+ex.getMessage());
// hata ile sonlandırma
System.exit(1);
}//try-catch
// son
System.exit(0);
}//Main
}//sınıf
İşte bir çalışma örneği:
Tapez le modèle à tester ou fin pour arrêter :\d+
Tapez la chaîne à comparer au modèle [\d+] ou fin pour arrêter :123 456 789
J'ai trouvé la correspondance [123] en position 0
J'ai trouvé la correspondance [456] en position 4
J'ai trouvé la correspondance [789] en position 8
Tapez la chaîne à comparer au modèle [\d+] ou fin pour arrêter :fin
Tapez le modèle à tester ou fin pour arrêter :(\d\d):(\d\d)
Tapez la chaîne à comparer au modèle [(\d\d):(\d\d)] ou fin pour arrêter :14:15
abcd 17:18 xyzt
J'ai trouvé la correspondance [14:15] en position 0
sous-élément [14] en position 0
sous-élément [15] en position 3
J'ai trouvé la correspondance [17:18] en position 11
sous-élément [17] en position 11
sous-élément [18] en position 14
Tapez la chaîne à comparer au modèle [(\d\d):(\d\d)] ou fin pour arrêter :fin
Tapez le modèle à tester ou fin pour arrêter :^\s*\d+\s*$
Tapez la chaîne à comparer au modèle [^\s*\d+\s*$] ou fin pour arrêter : 1456
J'ai trouvé la correspondance [ 1456] en position 0
Tapez la chaîne à comparer au modèle [^\s*\d+\s*$] ou fin pour arrêter :fin
Tapez le modèle à tester ou fin pour arrêter :^\s*(\d+)\s*$
Tapez la chaîne à comparer au modèle [^\s*(\d+)\s*$] ou fin pour arrêter :1456
J'ai trouvé la correspondance [1456] en position 0
sous-élément [1456] en position 0
Tapez la chaîne à comparer au modèle [^\s*(\d+)\s*$] ou fin pour arrêter :abcd 1
456
Je n'ai pas trouvé de correspondances
Tapez la chaîne à comparer au modèle [^\s*(\d+)\s*$] ou fin pour arrêter :fin
Tapez le modèle à tester ou fin pour arrêter :fin
4.11.6. Pattern sınıfının split yöntemi
Bir düzenli ifade kullanılarak ifade edilen bir ayırıcı dizgiyle ayrılmış alanlardan oluşan bir karakter dizisini ele alalım. Örneğin, alanlar herhangi bir sayıda boşluğun önünde veya arkasında bulunan karakteriyle ayrılıyorsa, alanları ayıran dizgiyi modelleyen düzenli ifade "\s*,\s*" olur. Pattern sınıfının split yöntemi, alanları bir diziye aktarmamızı sağlar:
public String[] split(CharSequence input)
input dizesi, geçerli Pattern nesnesinin şablonuna uygun bir ayırıcıyla ayrılmış alanlara bölünür. Alan ayırıcısı virgül olan ve virgülün önünde veya arkasında herhangi bir sayıda boşluk bulunan bir satırın alanlarını almak için şu komutu yazacağız:
// bir satır
String ligne="abc ,, def , ghi";
// bir şablon
Pattern modèle=Pattern.compile("\\s*,\\s*");
// satırı alanlara ayırma
String[] champs=modèle.split(ligne);
Aynı sonuç, String sınıfındaki split yöntemi ile de elde edilebilir:
public String[] split(String regex)
İşte bir test programı:
import java.io.*;
import java.util.regex.*;
// düzenli ifadelerin yönetimi
public class split1 {
public static void main(String[] args){
// bir satır
String ligne="abc ,, def , ghi";
// bir şablon
Pattern modèle=Pattern.compile("\\s*,\\s*");
// satırı alanlara ayırma
String[] champs=modèle.split(ligne);
// görüntüleme
for(int i=0;i<champs.length;i++){
System.out.println("champs["+i+"]=["+champs[i]+"]");
}//for
// başka bir yöntem
champs=ligne.split("\\s*,\\s*");
// görüntüleme
for(int i=0;i<champs.length;i++){
System.out.println("champs["+i+"]=["+champs[i]+"]");
}//for
}//Ana Sayfa
}//sınıf
Çalıştırma sonuçları:
champs[0]=[abc]
champs[1]=[]
champs[2]=[def]
champs[3]=[ghi]
champs[0]=[abc]
champs[1]=[]
champs[2]=[def]
champs[3]=[ghi]
4.12. Alıştırmalar
4.12.1. Alıştırma 1
Unix'te programlar genellikle şu şekilde çağrılır:
$ pg -o1 v1 v2 ... -o2 v3 v4 …
burada -oi bir seçeneği, vi ise bu seçeneğe ait bir değeri temsil eder. -o1 v1 v2 ... -o2 v3 v4 … argüman dizesini analiz ederek aşağıdaki öğeleri oluşturabilen bir options sınıfı oluşturmak istiyoruz:
optionsValides | Anahtarları geçerli oi seçenekleri olan bir sözlük (Hashtable). oi anahtarına atanan değer, -oi seçeneğine atanan v1 v2 … değerlerinden oluşan bir vektördür (Vector) |
optionsInvalides | Anahtarları geçersiz oi seçenekleri olan bir sözlük (Hashtable). oi anahtarına atanan değer, elemanları -oi seçeneğiyle ilişkili v1, v2 … değerlerinden oluşan bir vektördür (Vector) |
optionsSans | bir seçeneğe atanmamış vi değerlerinin listesini veren dize (String) |
erreur | argüman satırında hata yoksa 0 değerinde, aksi takdirde başka bir değer: 1: geçersiz çağrı parametreleri var 2: geçersiz seçenekler var 4: seçeneklerle eşleştirilmemiş değerler var Birden fazla hata türü varsa, bu değerler toplanır. |
Bir options nesnesi 4 farklı şekilde oluşturulabilir:
public options (String arguments, String optionsAcceptables)
arguments | analiz edilecek -o1 v1 v2 ... -o2 v3 v4 … argüman satırı |
optionsAcceptables | kabul edilebilir oi seçeneklerinin listesi |
Çağırma örneği: options opt=new options("-u u1 u2 u3 -g g1 g2 -x","-u -g");
Burada her iki argüman da karakter dizileridir. Bu dizilerin kelimelere bölünerek bir karakter dizisi dizisine yerleştirildiği durumlar da kabul edilir. Bunun için üç ayrı oluşturucu gereklidir:
public options (String[] arguments, String optionsAcceptables)
public options (String arguments, String[] optionsAcceptables)
public options (String[] arguments, String[] optionsAcceptables)
Options sınıfı aşağıdaki arayüze (erişim yöntemleri) sahip olacaktır:
seçenekler nesnesinin oluşturulması sırasında oluşturulan optionsValides tablosunun referansını döndürür
seçenekler nesnesinin oluşturulması sırasında oluşturulan optionsInvalides tablosunun referansını döndürür
seçenekler nesnesinin oluşturulması sırasında oluşturulan optionsSans dizesinin referansını döndürür
seçenek nesnesinin oluşturulması sırasında oluşturulan hata özniteliğinin değerini döndürür
Hata yoksa optionsValides, optionsInvalides, optionsSans özniteliklerinin değerlerini gösterir; aksi takdirde hata numarasını gösterir.
İşte bir örnek program:
import java.io.*;
//içe aktarma seçenekleri;
public class test1{
public static void main (String[] arg){
// giriş akışının açılması
String ligne;
BufferedReader IN=null;
try{
IN=new BufferedReader(new InputStreamReader(System.in));
} catch (Exception e){
affiche(e);
System.exit(1);
}
// options(String, string) yapıcı argümanlarının okunması
String options=null;
String optionsAcceptables=null;
while(true){
System.out.print("Options : ");
try{
options=IN.readLine();
} catch (Exception e){
affiche(e);
System.exit(2);
}
if(options.length()==0) break;
System.out.print("Options acceptables: ");
try{
optionsAcceptables=IN.readLine();
} catch (Exception e){
affiche(e);
System.exit(2);
}
System.out.println(new options(options,optionsAcceptables));
}// while döngüsünün sonu
}//main'in sonu
public static void affiche(Exception e){
System.err.println("Erreur : "+e);
}
}//sınıf sonu
Bazı sonuçlar:
C:\Serge\java\options>java test1
Options : 1 2 3 -a a1 a2 -b b1 -c c1 c2 c3 -b b2 b3
Options acceptables: -a -b
Erreur 6
Options valides :(-b,b1,b2,b3) (-a,a1,a2)
Options invalides : (-c,c1,c2,c3)
Sans options : 1 2 3
4.12.2. Alıştırma 2
Bir String nesnesinin içeriğini bir Vector nesnesine aktarmayı sağlayan bir stringtovector sınıfı oluşturmak istiyoruz. Bu sınıf, Vector sınıfından türetilecektir:
ve şu yapıya sahip olurdu:
private void stringtovector(String S, String separateur, int[] tChampsVoulus,
boolean strict){
// S dizesinin alanlarını içeren bir vektör oluşturur
// bu dize, ayırıcı ile ayrılmış alanlardan oluşur
// ayırıcı=null ise, dize tek bir alan oluşturur
// yalnızca indeksleri tChampsVoulus
// dizisinde yer alanlar istenir. İndeksler 1'den başlar
// tChampsvoulus=null veya boyutu sıfırsa, tüm alanlar alınır
// strict=true ise, istenen tüm alanlar mevcut olmalıdır
Sınıfın şu özel özniteliği olacaktır:
Bu öznitelik, önceki oluşturucu tarafından aşağıdaki değerlerle ayarlanır:
0: oluşturma işlemi başarıyla tamamlandı
4: strict=true ayarlıyken istenen bazı alanlar eksik
Sınıf ayrıca iki yönteme sahip olacaktır:
bu yöntem, özel özniteliğin değerini döndürür erreur.
nesnenin değerini (hata, eleman 1, eleman 2, …) biçiminde görüntüler; burada i elemanları, dizeden oluşturulan vektörün elemanlarıdır.
Bir test programı şu şekilde olabilir:
import java.io.*;
//import stringtovector;
public class essai2{
public static void main(String arg[]){
int[] T1={1,3};
System.out.println(new stringtovector("a : b : c :d:e",":",T1,true).identite());
int[] T2={1,3,7};
System.out.println(new stringtovector("a : b : c :d:e",":",T2,true).identite());
int [] T3={1,4,7};
System.out.println(new stringtovector("a : b : c :d:e",":",T3,false).identite());
System.out.println(new stringtovector("a : b : c :d:e","",T1,false).identite());
System.out.println(new stringtovector("a : b : c :d:e",null,T1,false).identite());
int[] T4={1};
System.out.println(new stringtovector("a : b : c :d:e","!",T4,true).identite());
int[] T5=null;
System.out.println(new stringtovector("a : b : c :d:e",":",T5,true).identite());
System.out.println(new stringtovector("a : b : c :d:e",null,T5,true).identite());
int[] T6=new int[0];
System.out.println(new stringtovector("a : b : c :d:e","",T6,true).identite());
int[] T7={1,3,4};
System.out.println(new stringtovector("a b c d e"," ",T6,true).identite());
}
}
Sonuçlar:
(0,a,c)
(4,a,c)
(0,a,d)
(0,a : b : c :d:e)
(0,a : b : c :d:e)
(0,a : b : c :d:e)
(0,a,b,c,d,e)
(0,a : b : c :d:e)
(0,a : b : c :d:e)
(0,a,b,c,d,e)
Bazı ipuçları:
- S dizesini alanlara ayırmak için, String sınıfındaki split yöntemini kullanın.
- S'deki alanları, alan numarasına göre indekslenmiş D sözlüğüne yerleştirin
- D sözlüğünden, anahtarı (indeksi) tChampsVoulus tablosunda bulunan alanları alın.
4.12.3. Alıştırma 3
stringtovector sınıfına aşağıdaki oluşturucuyu eklemek istiyoruz:
public stringtovector(String S, String separateur, String sChampsVoulus,boolean strict){
// S dizgesindeki alanları içeren bir vektör oluşturur
// bu dize, ayırıcı ile ayrılmış alanlardan oluşur
// separator=null ise, dize tek bir alan oluşturur
// yalnızca indeksleri sChampsVoulus içinde bulunan alanlar istenmektedir
// indeksler 1'den başlar
// sChampsvoulus=null veya "" ise, tüm alanlar alınır
// strict=true ise, istenen tüm alanlar mevcut olmalıdır
Dolayısıyla, istenen alanların listesi bir tamsayı dizisi (int[]) yerine bir dize (String) içinde yer almaktadır. Sınıfın özel özniteliği erreur'e yeni bir değer atanabilir:
2: İstenen alanların dizin dizisi hatalı
İşte bir örnek program:
import java.io.*;
//stringtovector'ı içe aktar;
public class essai1{
public static void main(String arg[]){
String champs=null;
System.out.println(new stringtovector("a: b :c :d:e ",":","1 3",true).identite());
System.out.println(new stringtovector("a: b :c :d:e ",":","1 3 7",true).identite());
System.out.println(new stringtovector("a: b :c :d:e ",":","1 4 7",false).identite());
System.out.println(new stringtovector("a: b :c :d:e ","","1 3",false).identite());
System.out.println(new stringtovector("a: b :c :d:e ",null,"1 3",false).identite());
System.out.println(new stringtovector("a: b :c :d:e ","!","1",true).identite());
System.out.println(new stringtovector("a: b :c :d:e ",":","",true).identite());
System.out.println(new stringtovector("a: b :c :d:e ",":",champs,true).identite());
System.out.println(new stringtovector("a: b :c :d:e ",null,champs,true).identite());
System.out.println(new stringtovector("a: b :c :d:e ","","",true).identite());
System.out.println(new stringtovector("a: b :c :d:e ",":","1 !",true).identite());
System.out.println(new stringtovector("a b c d e "," ","1 3",false).identite());
}
}
Bazı sonuçlar:
(0,a,c)
(4,a,c)
(0,a,d)
(0,a: b :c :d:e)
(0,a: b :c :d:e)
(0,a: b :c :d:e)
(0,a,b,c,d,e)
(0,a,b,c,d,e)
(0,a: b :c :d:e)
(0,a: b :c :d:e)
(2)
(0,a,c)
Birkaç ipucu:
- sChampsVoulus dizisindeki alanları bir tamsayı dizisine aktararak önceki örneğe geri dönmeliyiz. Bunun için, sChampsVoulus dizesini bir StringTokenizer nesnesi kullanarak alanlara ayırın; bu nesnenin countTokens özniteliği, elde edilen alan sayısını verecektir. Ardından, uygun boyutta bir tamsayı dizisi oluşturulabilir ve elde edilen alanlarla doldurulabilir.
- Bir alanın tamsayı olup olmadığını öğrenmek için, Integer.parseInt yöntemini kullanarak alanı tamsayıya dönüştürün ve bu dönüştürme işlemi mümkün olmadığında ortaya çıkacak istisnayı işleyin.
4.12.4. Alıştırma 4
Bir metin dosyasının içeriğini bir Vector nesnesine aktarmayı sağlayan filetovector sınıfı oluşturmak istiyoruz. Bu sınıf, Vector sınıfından türetilecektir:
ve aşağıdaki oluşturucuya sahip olacaktır:
// --------------------- oluşturucu
public filetovector(String nomFichier, String separateur, int [] tChampsVoulus,boolean strict, String tagCommentaire){
// metin dosyasındaki satırlarla bir vektör oluşturur nomFichier
// satırlar, ayırıcı ile ayrılmış alanlardan oluşur
// ayırıcı=null ise, satır tek bir alandan oluşur
// Yalnızca indeksleri tChampsVoulus içinde bulunan alanlar istenmektedir
// indeksler 1'den başlar
// tChampsvoulus=null veya boşsa, tüm alanlar alınır
// strict=true ise, istenen tüm alanlar mevcut olmalıdır
// Aksi takdirde, satır kaydedilmez ve indeksi
// lignesErronees vektörüne yerleştirilir
// boş satırlar göz ardı edilir
// ayrıca, tagCommentaire != null ise, tagCommentaire ile başlayan satırlar da göz ardı edilir
Sınıfın aşağıdaki özel özellikleri olacaktır:
erreur özniteliği, önceki oluşturucu tarafından aşağıdaki değerlerle ayarlanır:
0: oluşturma işlemi başarıyla tamamlandı
1: işlenecek dosya açılamadı
4: strict=true ayarında olmasına rağmen istenen bazı alanlar eksik
8: Dosya işlenirken bir G/Ç hatası meydana geldi
lignesErronees özniteliği, hatalı satırların numaralarını karakter dizesi biçiminde içeren bir vektördür. Bir satır, strict=true ayarlıyken istenen alanları sağlayamıyorsa hatalı sayılır.
Sınıf ayrıca iki yönteme sahip olacaktır:
erreur özel özniteliğinin değerini döndüren.
Bu komut, nesnenin değerini (hata, eleman 1, eleman 2 …,(l1,l2,…)) biçiminde görüntüler; burada i elemanları, dosyadan oluşturulan vektörün elemanlarıdır ve li ise hatalı satırların numaralarıdır.
İşte bir test örneği:
import java.io.*;
//import filetovector;
public class test2{
public static void main(String arg[]){
int[] T1={1,3};
System.out.println(new filetovector("data.txt",":",T1,false,"#").identite());
System.out.println(new filetovector("data.txt",":",T1,true,"#").identite());
System.out.println(new filetovector("data.txt","",T1,false,"#").identite());
System.out.println(new filetovector("data.txt",null,T1,false,"#").identite());
int[] T2=null;
System.out.println(new filetovector("data.txt",":",T2,false,"#").identite());
System.out.println(new filetovector("data.txt",":",T2,false,"").identite());
int[] T3=new int[0];
System.out.println(new filetovector("data.txt",":",T3,false,null).identite());
}
}
Çalıştırma sonuçları:
[0,(0,a,c) (0,1,3) (0,azerty,cvf) (0,s)]
[4,(0,a,c) (0,1,3) (0,azerty,cvf),[5]]
[0,(0,a:b:c:d:e) (0,1 :2 : 3: 4: 5) (0,azerty : 1 : cvf : fff: qqqq) (0,s)]
[0,(0,a:b:c:d:e) (0,1 :2 : 3: 4: 5) (0,azerty : 1 : cvf : fff: qqqq) (0,s)]
[0,(0,a,b,c,d,e) (0,1,2,3,4,5) (0,azerty,1,cvf,fff,qqqq) (0,s)]
[0,(0,a,b,c,d,e) (0,1,2,3,4,5) (0,# yorum) (0,azerty,1,cvf,fff,qqqq) (0,s)]
[0,(0,a,b,c,d,e) (0,1,2,3,4,5) (0,# yorum) (0,azerty,1,cvf,fff,qqqq) (0,s)]
Birkaç ipucu
-
Metin dosyası satır satır işlenir. Satır, daha önce incelenen stringtovector sınıfı kullanılarak alanlara bölünür.
-
Dolayısıyla, metin dosyasından oluşturulan vektörün elemanları stringtovector türünde nesnelerdir.
-
filetovector sınıfının identite yöntemi, öğelerini görüntülemek için stringtovector.identite() yöntemini ve olası hatalı satırların numaralarını görüntülemek için Vector.toString() yöntemini kullanabilir.
4.12.5. Alıştırma 5
filetovector sınıfına aşağıdaki oluşturucuyu eklemek istiyoruz:
public filetovector(String nomFichier, String separateur, String sChampsVoulus,
boolean strict, String tagCommentaire){
// nomFichier metin dosyasındaki satırları içeren bir vektör oluşturur
// satırlar, ayırıcı ile ayrılmış alanlardan oluşur
// ayırıcı=null ise, satır tek bir alandan oluşur
// Yalnızca indeksleri tChampsVoulus içinde bulunan alanlar istenmektedir
// indeksler 1'den başlar
// sChampsvoulus=null veya boşsa, tüm alanlar alınır
// strict=true ise, istenen tüm alanlar mevcut olmalıdır
// Aksi takdirde, satır kaydedilmez ve indeksi
// lignesErronees vektörüne eklenir
// boş satırlar göz ardı edilir
// ayrıca, tagCommentaire != null ise, tagCommentaire ile başlayan satırlar da göz ardı edilir
İstenen alanların dizin listesi artık bir tamsayı dizisi yerine bir karakter dizisi (String) içinde yer almaktadır.
Özel öznitelik erreur ek bir değer alabilir:
2: istenen alanların dizin dizesi hatalı
İşte bir test örneği:
import java.io.*;
//import filetovector;
public class test1{
public static void main(String arg[]){
System.out.println(new filetovector("data.txt",":","1 3",false,"#").identite());
System.out.println(new filetovector("data.txt",":","1 3",true,"#").identite());
System.out.println(new filetovector("data.txt","","1 3",false,"#").identite());
System.out.println(new filetovector("data.txt",null," 1 3",false,"#").identite());
String S2=null;
System.out.println(new filetovector("data.txt",":",S2,false,"#").identite());
System.out.println(new filetovector("data.txt",":",S2,false,"").identite());
String S3="";
System.out.println(new filetovector("data.txt",":",S3,false,null).identite());
}
}
Sonuçlar:
[0,(0,a,c) (0,1,3) (0,azerty,cvf) (0,s)][4,(0,a,c) (0,1,3) (0,azerty,cvf),[5]]
[0,(0,a:b:c:d:e) (0,1 :2 : 3: 4: 5) (0,azerty : 1 : cvf : fff: qqqq) (0,s)]
[0,(0,a:b:c:d:e) (0,1 :2 : 3: 4: 5) (0,azerty : 1 : cvf : fff: qqqq) (0,s)]
[0,(0,a,b,c,d,e) (0,1,2,3,4,5) (0,azerty,1,cvf,fff,qqqq) (0,s)]
[0,(0,a,b,c,d,e) (0,1,2,3,4,5) (0,# yorum) (0,azerty,1,cvf,fff,qqqq) (0,s)]
[0,(0,a,b,c,d,e) (0,1,2,3,4,5) (0,# yorum) (0,azerty,1,cvf,fff,qqqq) (0,s)]
Birkaç ipucu
- sChampsVoulus dizisini, önceki oluşturucudaki duruma dönmek için tChampVoulus tamsayı tablosuna dönüştüreceğiz.