Pure Java – 71 Generics & Collections – Sort & Searching

Merhaba Arkadaslar,
Bu yazida java.util.Collections ve java.util.Arrays utility siniflari yardimi ile sorting/siralama konusuna deginecegiz. Hatirlayacagimiz gibi Collection bir arabirimdir , Collections ise bir siniftir. Bunlari birbirine karistirmayalim.
Daha sonrasinda java.util.Comparable ve java.util.Comparator arabirimlerini inceleyecegiz.
Son olarak searching Arrays ve Collections konusunu inceleyegiz.
Son olarak binarySearch metodunu inceleyecegiz.

Ilk olarak java.util.Arrays sinifini kullanarak dizileri siralayalim. Dizinin elemanlari sayi ise kucukten buyuge siralama yapacaktir. Dizinin elemanlari String ise unicode degerine gore siralama yapacaktir. Tabi bizim icin faydali olacak konu sozluk mantiginda harf/kelime siralamasi yapacagidir. Burada dikkat etmemiz gereken nokta buyuk harflerin unicode degerleri kucuk harflerin unicode degerlerinden daha kucuktur.

import java.util.Arrays;

public class ArraysSortTest {

	public static void main(String[] args) {
		Integer[] numbers = { 10, 20, 50, 25, 35, 80, -20, -30, 0, 10 };

		for (int n : numbers) {
			System.out.print(n + " ");
		}
		System.out.println();

		System.out.println("Sorting Numbers");
		Arrays.sort(numbers);

		for (int n : numbers) {
			System.out.print(n + " ");
		}
		System.out.println("\n");

		String[] stringArray = { "de", "", "da", "De", "DE", "a", "A", "1", "Z" };

		for (String str : stringArray) {
			System.out.print(str + " ");
		}
		System.out.println();

		System.out.println("Sorting Strings");

		Arrays.sort(stringArray);

		for (String str : stringArray) {
			System.out.print(str + " ");
		}
	}
}

Collections sinifini kullanalim , benzer sekilde int veya String elemana sahip List’leri siralayabiliriz.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CollectionsSortTest {

	public static void main(String[] args) {
		List <Integer> numberList = new ArrayList<Integer>();

		numberList.add(20);
		numberList.add(10);
		numberList.add(50);
		numberList.add(40);
		numberList.add(-20);
		numberList.add(-5);

		for (int i : numberList) {
			System.out.print(i + " ");
		}
		System.out.println();

		Collections.sort(numberList);

		System.out.println("Sorting Numbers");
		for (int i : numberList) {
			System.out.print(i + " ");
		}
		System.out.println();

	}

}

Sayi veya String elemanlara sahip dizi ve List’leri natural ordering/dogal siralama kuralan gore siraladik. Peki elemanlarimiz Car sinifinda olsa bu durumda ne yapmaliyiz ?

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class Car {

	public Car(String hp, String brand, Integer price) {
		super();
		this.hp = hp;
		this.brand = brand;
		this.price = price;
	}

	private String hp;
	private String brand;
	private Integer price;

	public String getHp() {
		return hp;
	}

	public void setHp(String hp) {
		this.hp = hp;
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public Integer getPrice() {
		return price;
	}

	public void setPrice(Integer price) {
		this.price = price;
	}

	@Override
	public String toString() {
		return "Car [hp=" + hp + ", brand=" + brand + ", price=" + price + "]";
	}

}

public class CollectionCarSort {

	public static void main(String[] args) {
		Car ford = new Car("50", "ford", 100);
		Car fiat = new Car("20", "fiat", 50);
		Car subaru = new Car("500", "subaru", 5000);
		Car bmw = new Car("200", "bmv", 1000);

		List <Car> carList = new ArrayList <Car> ();
		carList.add(ford);
		carList.add(fiat);
		carList.add(subaru);
		carList.add(bmw);

		// Collections.sort(carList);
		// Derleme hatasi verecektir! Siralama islemini neye gore kime gore
		// yapacak ?
	}
}

Siralama islemini neye gore kime gore nasil yapacaginin bilgisi olmadigi icin Collections.sort metodu derleme hatasi verecektir. Ornegin price(fiyat) gore siralama yapalim. Bu durumda Comparable arabirimini su sekilde kullanabiliriz.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class Car implements Comparable <Car>{

	public Car(String hp, String brand, Integer price) {
		super();
		this.hp = hp;
		this.brand = brand;
		this.price = price;
	}

	private String hp;
	private String brand;
	private Integer price;

	public String getHp() {
		return hp;
	}

	public void setHp(String hp) {
		this.hp = hp;
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public Integer getPrice() {
		return price;
	}

	public void setPrice(Integer price) {
		this.price = price;
	}

	@Override
	public int compareTo(Car car) {
		return price.compareTo(car.getPrice());
	}

	@Override
	public String toString() {
		return "Car [hp=" + hp + ", brand=" + brand + ", price=" + price + "]";
	}

}

public class ComparableTest {

	public static void main(String[] args) {
		Car ford = new Car("50", "ford", 100);
		Car fiat = new Car("20", "fiat", 50);
		Car subaru = new Car("500", "subaru", 5000);
		Car bmw = new Car("200", "bmv", 1000);


		List <Car> carList = new ArrayList <Car>();
		carList.add(ford);
		carList.add(fiat);
		carList.add(subaru);
		carList.add(bmw);
		

		for (Car c : carList) {
			System.out.println(c);
		}
		System.out.println();
		
		Collections.sort(carList);

		System.out.println("Comparable Sorting");
		for (Car c : carList) {
			System.out.println(c);
		}

	}
}

java.util.Comparable arabirimini implement ettigimizde compareTo metodunu override etmemiz gerekir. Sonrasinda return ifadesi icerisinde Integer.compareTo metodunu cagiriyoruz. Hatirlayacagimiz gibi compareTo metodu degerleri dondurebilir;

thisObject.compareTo(anotherObject);

negative If thisObject < anotherObject 
zero If thisObject == anotherObject 
positive If thisObject > anotherObject

Comparable arabimini kullanarak bu sekilde diledigimiz state(instance variable)e gore siralama yapabiliriz. Ornegin brand’a gore siralama yapmak istersek compareTo metodunu su sekilde yazabiliriz ;

	public int compareTo(Car car) {
		return brand.compareTo(car.getBrand());
	}

Eger buyukten-kucuge olacak sekilde siralamak istersek compareTo metodunda yer degisikligi yapmamiz yeterli olacaktir;

	@Override
	public int compareTo(Car car) {
		return car.getPrice().compareTo(price);
	}

Eger Comparable arabirimi implement edilirken Generics yapisi kullanilmazsa bu durumda compareTo metodumuz parametre olarak Car degil Object sinifi tipinde olacaktir.

class Car implements Comparable {

	// ....

	@Override
	public int compareTo(Object o) {
		Car car = (Car) o;
		return price.compareTo(car.getPrice());
	}
//....
}

Comparable arabirimini inceledik simdi de Comparator arabirimini inceleyelim.Comparator arabirimi de Comparable arabirimine benzer mantikta calismaktadir. Aralarindaki temel fark sudur ; Ornegin yukaridaki ornekte elemanlari Car olan bir List’i siralamak istedik bu nedenle Car sinifi Comparable arabimini uyguladi yani List’te hangi eleman varsa o sinif Comparable arabirimini uygulamalidir. Comparator arabirimini ise baska bir sinif uygulayabilir ve bu ayri sinifta ilgili sinifa ait siralama kurali yazilabilir.

Ornegimizi inceleyelim , aciklamalari kod icerisinde bulabilirsiniz;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class Car {

	public Car() {
	}

	public Car(String hp, String brand, Integer price) {
		super();
		this.hp = hp;
		this.brand = brand;
		this.price = price;
	}

	private String hp;
	private String brand;
	private Integer price;

	public String getHp() {
		return hp;
	}

	public void setHp(String hp) {
		this.hp = hp;
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public Integer getPrice() {
		return price;
	}

	public void setPrice(Integer price) {
		this.price = price;
	}

	@Override
	public String toString() {
		return "Car [hp=" + hp + ", brand=" + brand + ", price=" + price + "]";
	}
}

public class ComparatorTest implements Comparator<Car> {
	// Comparable arabirimini kullanmak icin eger Car sinifini tipinde
	// elemanlardan olusan bir List'i siralama istiyorsak bu durumda mutlaka Car
	// sinifi Comparable arabirimini uygulamalidir.
	// Fakat Comparator arabirimi bu sekilde baska bir sinif ile kullanilabilir.
	// Dilersek Car sinifinda Comparator seklinde uygulayabiliriz.
	public static void main(String[] args) {
		Car ford = new Car("50", "ford", 100);
		Car fiat = new Car("20", "fiat", 50);
		Car subaru = new Car("500", "subaru", 5000);
		Car bmw = new Car("200", "bmv", 1000);

		List<Car> carList = new ArrayList <Car>();
		carList.add(ford);
		carList.add(fiat);
		carList.add(subaru);
		carList.add(bmw);

		for (Car c : carList) {
			System.out.println(c);
		}
		System.out.println();

		ComparatorTest comparatorTest = new ComparatorTest();
		// overloaded sort metodunu kullanabiliriz.
		// burada 1.arguman siralamak istedigimiz List
		// 2.arguman ise Comparator arabirimini uygulayan sinifimiz olacaktir.
		Collections.sort(carList, comparatorTest);

		System.out.println("Comparator Sorting");
		for (Car c : carList) {
			System.out.println(c);
		}
	}

	// Comparator arabirimini uyguladigimiz zaman compare metodunu override
	// etmemiz gerekir!
	// Comparable arabiriminde ise bu metot compareTo metoduydu.
	@Override
	public int compare(Car car1, Car car2) {
		return car1.getPrice().compareTo(car2.getPrice());
	}

}

Eger buyuken-kucuge siralamak istersek compare metodunda su sekilde yer degistirmemiz yeterli olacaktir ;

	public int compare(Car car1, Car car2) {
		return car2.getPrice().compareTo(car1.getPrice());
	}

Arrays.sort metodu ile natural order’a uygun dizileri siralama yaptik. Benzer sekilde java.util.Comparator arabirimini kullanabiliriz. Arrays.sort metodunun overloaded versiyonu mevcuttur.

import java.util.Arrays;
import java.util.Comparator;

class Car {
	private String hp;
	private String brand;
	private Integer price;

	public Car(String hp, String brand, Integer price) {
		super();
		this.hp = hp;
		this.brand = brand;
		this.price = price;
	}

	public String getHp() {
		return hp;
	}

	public void setHp(String hp) {
		this.hp = hp;
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public Integer getPrice() {
		return price;
	}

	public void setPrice(Integer price) {
		this.price = price;
	}

	@Override
	public String toString() {
		return "Car [hp=" + hp + ", brand=" + brand + ", price=" + price + "]";
	}

}

public class ArraysComparator implements Comparator <Car>{

	public static void main(String[] args) {
		Car ford = new Car("50", "ford", 100);
		Car fiat = new Car("20", "fiat", 50);
		Car subaru = new Car("500", "subaru", 5000);
		Car bmw = new Car("200", "bmv", 1000);

		Car[] carArray = { ford, fiat, subaru, bmw };

		// Arrays.sort(carArray);
		// Car cannot be cast to java.lang.Comparable
		ArraysComparator arrayComparator = new ArraysComparator();
		Arrays.sort(carArray, arrayComparator);

		for (Car c : carArray) {
			System.out.println(c);
		}
	}

	@Override
	public int compare(Car car1, Car car2) {
		return car1.getPrice().compareTo(car2.getPrice());
	}
}

Arrays.binarySearch metodu ile search/arama yapabiliriz. binarySearch metodunun dogru calisabilmesi icin oncelikle Arrays.sort metodu ile sort islemi yapilmalidir.

import java.util.Arrays;

public class ArraysBinarySearch {

	public static void main(String[] args) {
		String[] names = { "name2", "name1", "name6", "name4", "name3", "name5" };

		Arrays.sort(names);

		for (String s : names) {
			System.out.println(s);
		}

		int index = Arrays.binarySearch(names, "name3");

		System.out.println("name3 index:" + index);

	}
}

binarySearch metodunun overloaded hali bulunmaktadir. Onceki ornegimize binarySearch metodunu ekleyelim. Unutmayalim oncesinde Arrays.sort kullanilmazsa , binarySearch metodu dogru calismayacaktir.

...
public class ArraysComparator implements Comparator <Car> {

	public static void main(String[] args) {
		Car ford = new Car("50", "ford", 100);
		Car fiat = new Car("20", "fiat", 50);
		Car subaru = new Car("500", "subaru", 5000);
		Car bmw = new Car("200", "bmv", 1000);

		Car[] carArray = { ford, fiat, subaru, bmw };

		// Arrays.sort(carArray);
		// Car cannot be cast to java.lang.Comparable
		ArraysComparator arrayComparator = new ArraysComparator();
		Arrays.sort(carArray, arrayComparator);

		for (Car c : carArray) {
			System.out.println(c);
		}

		int index = Arrays.binarySearch(carArray, bmw, arrayComparator);
		System.out.println("index:" + index);

	}

	@Override
	public int compare(Car car1, Car car2) {
		return car1.getPrice().compareTo(car2.getPrice());
	}
}

binarySearch metodunu Collections sinifinda da mevcuttur.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CollectionBinarySearch {

	public static void main(String[] args) {
		List names = new ArrayList();
		names.add("name2");
		names.add("name1");
		names.add("name6");
		names.add("name4");
		names.add("name3");
		names.add("name5");

		Collections.sort(names);

		for (String name : names) {
			System.out.println(name);
		}

		int index = Collections.binarySearch(names, "name3");
		System.out.println("index name3:" + index);

	}
}

binarySearch metodunun benzer sekilde Comparator tipinde parametre de alan overloaded hali vardir.

...
public class ComparatorTest implements Comparator <Car>{
	// Comparable arabirimini kullanmak icin eger Car sinifini tipinde
	// elemanlardan olusan bir List'i siralama istiyorsak bu durumda mutlaka Car
	// sinifi Comparable arabirimini uygulamalidir.
	// Fakat Comparator arabirimi bu sekilde baska bir sinif ile kullanilabilir.
	// Dilersek Car sinifinda Comparator seklinde uygulayabiliriz.
	public static void main(String[] args) {
		Car ford = new Car("50", "ford", 100);
		Car fiat = new Car("20", "fiat", 50);
		Car subaru = new Car("500", "subaru", 5000);
		Car bmw = new Car("200", "bmv", 1000);

		List carList = new ArrayList();
		carList.add(ford);
		carList.add(fiat);
		carList.add(subaru);
		carList.add(bmw);

		for (Car c : carList) {
			System.out.println(c);
		}
		System.out.println();

		ComparatorTest comparatorTest = new ComparatorTest();
		// overloaded sort metodunu kullanabiliriz.
		// burada 1.arguman siralamak istedigimiz List
		// 2.arguman ise Comparator arabirimini uygulayan sinifimiz olacaktir.
		Collections.sort(carList, comparatorTest);

		System.out.println("Comparator Sorting");
		for (Car c : carList) {
			System.out.println(c);
		}

		int index = Collections.binarySearch(carList, bmw, comparatorTest);

		System.out.println("index:" + index);

	}

	// Comparator arabirimini uyguladigimiz zaman compare metodunu override
	// etmemiz gerekir!
	// Comparable arabiriminde ise bu metot compareTo metoduydu.
	@Override
	public int compare(Car car1, Car car2) {
		return car2.getPrice().compareTo(car1.getPrice());
	}

}

...

Yazimi burada sonlandiriyorum.
Herkese Bol Javali Gunler dilerim.
Be an oracle man , import java.*;
Levent Erguder
OCP, Java SE 6 Programmer
OCE, Java EE 6 Web Component Developer

Print Friendly, PDF & Email

Leave a Reply

Your email address will not be published. Required fields are marked *