Tanım: İçerisinde index'li ve sıralı veri tutan, gerektiğinde kendiliğinden büyüyebilen class

Tanım: Bir class'ın içindeki liste şeklindeki objelere sıra ile erişimi sağlayan yapı. Bunu sağlamak için Enumeration interface'si kullanılır.

Tanım: Bir class'ın içindeki liste şeklindeki objelere sıra ile erişimi sağlayan yapı. Bunu sağlamak için Iterator interface'si kullanılır. Enumaration'dan farklı olarak elde edilen eleman listeden kaldırılabilmektedir.

Aşağıdaki örnekte bir listeye eklenen elemanlar Iterator ile alınmakta ve ekrana basılmaktadır :

import java.util.*;
public class IteratorTest {
        public static void main(String[] args) {
                List<Integer> list=new ArrayList<Integer>();
                list.add(1);
                list.add(2);
                list.add(3); 
                Iterator<Integer> iterator=list.iterator();
                while(iterator.hasNext()){
                        Integer item=iterator.next();
                        System.out.println(item);
                }                
        }
}

Aşağıdaki örnekte bir vector'e eklenen elemanlar Enumeration ile alınmakta ve ekrana basılmaktadır :

import java.util.*;
public class EnumerationTest {
	public static void main(String[] args) {
		Vector<Integer> vector=new Vector<Integer>();
		vector.add(1);
		vector.add(2);
		vector.add(3);
		Enumeration<Integer> enumeration=vector.elements();
		while(enumeration.hasMoreElements()){
			Integer item=enumeration.nextElement();
			System.out.println(item);
		}
	}
}

Elinizde bir listenin belirli sayıda eleman sayılarına göre bölünüp verilmesi için aşağıdaki gibi bir kod yazılabilir. Aşağıdaki örnek bir listeyi 3'lü gruplar halinde vermekte ve ekrana basmaktadır :

List> groupList=new ArrayList>();
ArrayList list=new ArrayList();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
list.add("6");
list.add("7");
list.add("8");
list.add("9");
list.add("10");
for (int i=0;i3) {
	if((i+3)<=(list.size()-1)){
		groupList.add(list.subList(i, i+3));	
	}else{
		groupList.add(list.subList(i,list.size()));
	}
}
for (List sublist : groupList) {
	System.out.println("grup:");
	for (String item : sublist) {
		System.out.println(item);
	}
}

Örnek listeye 10 madde ekledik (farklı eleman sayılı listelerle deneyebilirsiniz). Bir sonraki bölümde 3 sayısına göre listeyi parçaladık. En son bölümde ise parçaladığımız liste grubunu ekrana bastırdık.

Java'da Enumeration interfacesini (arayüzünü) implements etmiş (arayüzü sağlamış) bir class (sınıf) içindeki bir nesne dizisine aşağıdaki gibi sırasıyla erişilebilinir :

     for (Enumeration e = v.elements() ; e.hasMoreElements() ;) {
         Object obj=e.nextElement();
     }

v değişkeni Vector sınıfından yaratılmış bir değişkendir. Vector sınıfı Enumeration interfaces'ini implements (arayüzü sağlamış) bir sınıftır.

X tipinde değerleri saklayan bir map'iniz (örneğin HashMap) var ise değerleri bir List şeklinde (Örneğin ArrayList) aşağıdaki gibi alabilirsiniz:

Map map=new HashMap();
ArrayList list= new ArrayList(map.values());

ArrayList kurucusunda Collection alabilmektedir. Map class'ının values() yöntemi Map'teki değerlerden oluşan bir Collection döndürmektedir. Bu nedenle values() ile dönen değerler ArrayList'e kurucuda verilerek değerlerden bir ArrayList listesi yaratılmış olur.

Bir List nesnesini Set nesnesine aşağıdaki gibi çevirebilirsiniz :

Set set = new HashSet(list);

Bir Set nesnesini ise aşağıdaki gibi bir List nesnesine çevirebilirsiniz :

List list = new ArrayList(set);

Bir Enum'un değerlerini alfabetik sıralamak için aşağıdaki gibi bir Comparator yaratılabilir : code:/java public class ElementComparator implements java.util.Comparator { public int compare(TestEnum left, TestEnum right){ return left.toString().compareTo(right.toString()); } } code/: Bu comparator aşağıdaki kullanılarak TestEnum adındaki Enum'un değerleri sıralanabilir : code:/java TestEnum[] values=TestEnum.values(); Arrays.sort(values, new ElementComparator()); code/: code/:

Java'da Enum sadece String'den oluşmak zorunda değildir. Her enum maddesinin kendisine özel property(özellik)leri olabilir. Bu tür bir örnek aşağıdaki gibi verilebilir :

public enum Test {
	ITEM1(1,"Madde 1"),
	ITEM2(2,"Madde 2"),
	ITEM3(3,"Madde 3"),
	ITEM4(4,"Madde 4"),
	ITEM5(5,"Madde 5");
	private Test(int no,String title) {
		setNo(no);
		setTitle(title);
	}
	private int no;
	private String title;
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}

Yukarıda Test enum'unun no ve title özelliği bulunmaktadır. Her maddenin bu iki özelliği olacaktır. Örneğin üçüncü maddenin değerine Test.ITEM3.no , title değerine Test.ITEM3.title ile erişilebilir

Bir listeden null'lanmış değerleri kaldırma işlemi Java 8 ve sonraki versiyonlar için aşağıdaki gibi bir kod ile yapılabilir: list.removeIf(Objects::isNull); Java 8 öncesi için list.removeAll(Collections.singleton(null)); şeklinde yapılabilir

Eğer içeriğinde null bir değer olan liste veya dizi sıralanırsa aşağıdaki gibi bir hata oluşur:

Exception in thread "main" java.lang.NullPointerException
	at java.util.ComparableTimSort.countRunAndMakeAscending(ComparableTimSort.java:321)
	at java.util.ComparableTimSort.sort(ComparableTimSort.java:188)

Bu hatayı üretmek için aşağıdaki gibi bir kod kullanılabilir :

import java.util.*;
public class SortNullTest {
	public static void main(String[] args) {
	    List<String> list = Arrays.asList("HI", "BYE", null, "MERHABA", ":)");
	    Collections.sort(list);
	}
}

Bu kod çalıştırıldığında aşağıdaki exception oluşacaktır :

Exception in thread "main" java.lang.NullPointerException
	at java.util.ComparableTimSort.countRunAndMakeAscending(ComparableTimSort.java:321)
	at java.util.ComparableTimSort.sort(ComparableTimSort.java:188)
	at java.util.Arrays.sort(Arrays.java:1246)
	at java.util.Arrays.sort(Arrays.java:1433)
	at java.util.Arrays$ArrayList.sort(Arrays.java:3895)
	at java.util.Collections.sort(Collections.java:141)
	at com.test.SortNullTest.main(SortNullTest.java:13)

Liste içindeki null değerini kaldırırsanız hata oluşmayacağını görebilirsiniz.

Queue arayüzünün yöntemleri aşağıdaki gibidir:

• add : Verilen elemanı kuyruğa ekler. Eğer kapasite aşılması gibi sorun oluşursa IllegalStateException fırlatılır.
• offer : Verilen elemanı kuyruğa ekler. Eğer kapasite aşılması ve buna benzer bir sorun oluşursa false dönülür
• remove : Kuyruğun başında elamanı verir ve ardından kuyruktan kaldırır. Kuyruk boş ise NoSuchElementException fırlatılır.
• poll : Kuyruğun başında elamanı vÿJ­ u aûerir ve ardından kuyruktan kaldırır. Kuyruk boş ise null dönülür
• element : Kuyruğun başında elamanı verir ancak kuyruktan kaldırmaz. Kuyruk boş ise NoSuchElementException fırlatılır.
• peek : Kuyruğun başında elamanı verir ancak kuyruktan kaldırmaz. Kuyruk boş ise null dönülür

Yukarıdaki bilgiler bir tablo şeklinde aşağıdaki gibi gösterilebilir:

Yöntem	Exception Oluşur	Null Dönülür
Ekle	add()	offer()
Al ve Kaldır	remove()	poll()

Queue arayüzünde kuyruğa elaman eklemeyi sağlayan add() ve offer() adında iki yöntem bulunur. add() yöntemi Collections arayüzünden gelir. offer() ise Queue arayüzünün bir yöntemidir. Kapasitesini aşmış bir kuyruğa add() ile eklenirse IllegalStateException fırlatılır. offer() ile eklenirse Exception fırlamaz ve yöntem false döner.

Boş bir kuyruktan remove() ile eleman alınmaya çalışılırsa NoSuchElementException fırlatılır. poll() ile alınmaya çalışılırsa Exception fırlamaz ve yöntem null döner.

BlockingQueue'da kuyruğa eleman ekleme ve kuyruktan elaman alma yöntemleri aşağıdaki gibidir:

• add : Verilen elemanı kuyruğa ekler. Eğer kapasite aşılması gibi sorun oluşursa IllegalStateException fırlatılır
• offer : Verilen elemanı kuyruğa ekler. Eğer kapasite aşılması oluşursa false dönülür. Timeout verilirse verilen süre kuyruğun boşalmasını bekler
• put : Verilen elemanı kuyruğa ekler. Eğer kuyruk kapasitesi dolu ise boşalana kadar bekler.
• remove : Kuyruğun başında elamanı verir ve ardından kuyruktan kaldırır. Kuyruk boş ise NoSuchElementException fırlatılır.
• poll : Kuyruğun başında elamanı verir ve ardından kuyruktan kaldırır. Kuyruk boş ise null dönülür. Timeout verilirse verilen süre kuyruğun dolmasını bekler.
• take : Kuyruğun başında elamanı verir ve ardından kuyruktan kaldırır. Kuyruk boş ise bir eleman eklenene kadar bekler.
• element : Kuyruğun başında elamanı verir ancak kuyruktan kaldırmaz. Kuyruk boş ise NoSuchElementException fırlatılır.
• peek : Kuyruğun başında elamanı verir ancak kuyruktan kaldırmaz. Kuyruk boş ise null dönülür

add, offer, remove, poll, element, peek yöntemleri Queue interface'sinden gelir. Bloklamayı sağlayan take() ve put() yöntemi BlockingQueue arayüzüne aittir.
Yukarıdaki yöntemler bir tablo şeklinde aşağıdaki gibi gösterilebilir:

Yöntem	Exception Oluşur	Null Dönülür	Bloklar/Bekler	Belirli Süre Bloklar/Bekler
Ekle	add()	offer()	put()	offer()
Al ve Kaldır	remove()	poll()	take()	poll()
Sadece Al	element()	peek()	-	-

Bir BlockingQueue'e girilen elemanları alan en basit tüketici (consumer) aşağıdaki gibi yapılabilir:

import java.util.concurrent.BlockingQueue;

public class SimpleConsumer implements Runnable{

	private final BlockingQueue<Integer> queue;
	
	public SimpleConsumer(BlockingQueue<Integer> queue) {
		this.queue=queue;
	}
	
	@Override
	public void run() {
		
		while (true) {
				
			try {
				
				System.out.println("element bekleniyor ");
				
				int element=queue.take();
				
				System.out.println("element alindi : "+element);
				
			} catch (InterruptedException e) {
				e.printStackTrace();
			}			
		}
	}
}

SimpleConsumer sınıfı bir Thread'dir ve kurucu ile Integer değerleri tutan bir BlockingQueue almaktadır. Sonsuz döngü içinde queue.take() yöntemi ile kuyruğa girilen elemanları beklemektedir. take() yöntemi thread'i kuyruğa yeni bir eleman gelene kadar bekletir. Yeni bir eleman geldiğinde sayıyı alır ve ekrana basar. Sonrasında kuyrukta başka elamanları sırayla alır. Eğer kuyrukta eleman kalmaz ise beklemeye devam eder. SimpleConsumer dışarıdan sonlanmadığı sürece devam edecektir. SimpleConsumer sınıfı test etmek için aşağıdaki gibi bir uygulama yapılabilir:

import java.util.Scanner;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ConsumerBlockingQueueTest {

	public static void main(String[] args) {

		BlockingQueue<Integer> queue = new ArrayBlockingQueue(1000);

		SimpleConsumer consumerTest = new SimpleConsumer(queue);
		Thread t = new Thread(consumerTest);
		t.start();

		boolean exit=false;
		
		try (Scanner scanner = new Scanner(System.in)) {
			
			while(!exit) { // sayi disinda herhangi bir sey girilirse uygulamadan cikilir				
				String input = scanner.next();
				try {
					int number=Integer.parseInt(input);
					queue.add(number);
				} catch (NumberFormatException e) {
					exit=true;
				}				
			}		
		}
		System.out.println("exit");
		
		System.exit(0);
	}
}

İlk olarak en fazla 1000 elemanın olabileceği bir BlockingQueue yaratılır. Ardından SimpleConsumer thread'i başlatılır. Kullanıcıdan sürekli sayı almak için scanner sonsuz döngüye alınır. Alınan sayı queue.add(number) ile kuyruğa eklenir. Kullanıcı sayı dışında bir değer girdiğinde döngü sonlanır ve uygulama kapatılır. Uygulama aşağıdaki gibi test edilebilir :

element bekleniyor 
10
element alindi : 10
element bekleniyor 
25
element alindi : 25
element bekleniyor 
35
element alindi : 35
element bekleniyor 
E
exit

Uygulama ilk açıldığında SimpleConsumer element bekleniyor mesajını yazar ve int element=queue.take(); satırında bekler. 10 değerini girdiğinizde değer kuyruğa eklenir ve SimpleConsumer kuyruktan alır ve element alindi : 10 mesajını basar ve yeni değeri beklemeye başlar. Diğer sayılar içinde aynı durum devam eder. E yazıldığında uygulama sonlanır.