Hướng dẫn sử dụng nền tảng tập hợp trong Java (Java Collection Framework)

package org.o7planning.tutorial.javacollection.helloworld;

import java.util.LinkedList;

public class HelloLinkedList {

	public static void main(String[] args) {
		// Tạo một đối tượng LinkedList.
		LinkedList<String> list = new LinkedList<String>();

		// Thêm một số phần tử vào danh sách.
		list.add("F");
		list.add("B");
		list.add("D");
		list.add("E");
		list.add("C");

		// Thêm phần tử vào cuối danh sách.
		list.addLast("Z");

		// Thêm phần tử vào vị trí đầu tiên của danh sách.
		list.addFirst("A");

		// Trèn một phần tử vào ví trí có chỉ số 1.
		list.add(1, "A2");

		// Ghi ra tất cả các phần tử của danh sách:
		System.out.println("Original contents of list: " + list);

		// Loại bỏ một phần tử khỏi danh sách
		list.remove("F");

		// Loại bỏ phần tử tại vị trí có chỉ số 2.
		list.remove(2);

		// In ra danh sách sau khi đã xóa 2 phần tử.
		System.out.println("Contents of list after deletion: " + list);

		// Loại bỏ phần tử đầu tiên và cuối cùng trong danh sách.
		list.removeFirst();
		list.removeLast();

		// In ra danh sách sau khi đã xóa.
		System.out.println("List after deleting first and last: " + list);

		// Lấy ra phần tử tại chỉ số 2.
		Object val = list.get(2);

		// Sét đặt lại phần tử tại vị trí có chỉ số 2.
		list.set(2, (String) val + " Changed");
		System.out.println("List after change: " + list);
	}

}

package org.o7planning.tutorial.javacollection.helloworld;

import java.util.HashMap;

public class HelloHashMap {

	public static void main(String[] args) {

		// Tạo một đối tượng HashMap lữu trữ các cặp, mã số nhân viên và tiền lương.
		// String key: Mã số nhân viên
		// Float value: Tiền lương.
		HashMap<String, Float> salaryMap = new HashMap<String, Float>();
	 

		salaryMap.put("E01", 1000f);
		salaryMap.put("E02", 12000f);
		salaryMap.put("E03", 12300f);
		salaryMap.put("E04", 1000f);
		salaryMap.put("E05", 300.5f);
		
		// Lấy ra tiền lương của nhân viên 'E02'
		Float salary= salaryMap.get("E01");
		System.out.println("Salary of employee E01 = "+ salary);
		
		// Cập nhập tiền lương cho nhân viên 'E05'
		salaryMap.put("E05", 400f);
		
		System.out.println("Salary of employee E05 = "+ salaryMap.get("E05"));
		 
	}

}

public class HashMap<K,V> extends AbstractMap<K,V>
                           implements Map<K,V>, Cloneable, Serializable

public class Vector<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, Serializable

Collection<String> c=new ArrayList<String>();
// Thêm phần tử vào tập hợp.
c.add("One");


Map<Integer,String> m=new LinkedHashMap<Integer,String>();
Integer key=new Integer(123);
String value="One two three";

// Thêm một cặp 'key/value' vào Map m.
// Nếu 'key' đã tồn tại, 'value' sẽ được thay bởi giá trị mới.
m.put(key,value);

// In ra giá trị ứng với 'key' (khóa).
System.out.println(m.get(new Integer(123));

public class Vector<E> extends AbstractList<E>
               implements List<E>, RandomAccess, Cloneable, Serializable

public interface Collection<E> extends java.lang.Iterable<E> {

   //
   // Thêm một phần tử vào Collection trả về true nếu Collection thay đổi sau
   // khi gọi method và trả về false nếu Collection này không cho phép trùng
   // lặp và E o đã có trong Collection rồi (optional operation).
   //
   boolean add(E o);

   //
   // Thêm tập hợp vào Collection ,trả về true nếu thực sự Collection thay đổi
   // sau khi gọi method (optional operation).
   //
   boolean addAll(Collection<? extends E> c);

   // Xóa tất cả các phần tử ra khỏi Collection .(optional operation).
   void clear();

   // Kiểm tra xem Collection có chứa Object o không
   boolean contains(Object o);

   // Kiểm tra xem Collection có chứa tất cả các phần tử trong Collection c
   // không.
   boolean containsAll(Collection<?> c);

   // So sánh Collection này với Object o
   boolean equals(Object o);

   int hashCode();

   // Trả về true nếu Collection này không chứa phần tử nào
   boolean isEmpty();

   //
   // Xóa đối tượng o ra khỏi Collection trả về true nếu thực sự có một phần tử
   // bị xóa khỏi (optional operation).
   //
   boolean remove(Object o);

   //
   // Xóa các phần tử trong Collection này giống với các phần tử của Collection c
   //
   boolean removeAll(Collection<?> c);

   //
   // Kiểm tra xem Collection này chứa mọi phần tử mà Collection c chứa
   // (optional operation).
   ///
   boolean retainAll(Collection<?> c);

   // Trả về số phần tử trong Collection.
   int size();

   // Chuyển Collection thành mảng các đối tượng
   Object[] toArray();

   <T> T[] toArray(T[] a);

   // Trả về một bộ lặp để duyệt trên các phần tử của tập hợp.
   Iterator<E> iterator();
}

package org.o7planning.tutorial.javacollection.collection;

import java.util.Collection;
import java.util.Iterator;
import java.util.Vector;

public class CollectionAndIterator {

	public static void main(String[] args) {

		// Tạo một đối tượng Collection rỗng.
		// Một tập hợp chỉ chứa các String.
		Collection<String> coll = new Vector<String>();
		coll.add("Collection");
		coll.add("Queue");
		coll.add("List");
		coll.add("Map");

		// In ra số phần tử của tập hợp (collection) này.
		System.out.println("Size:" + coll.size());

		// Lấy ra đối tượng Iterator để truy cập vào các phần tử của tập hợp.
		// Đối tượng Iterator này chỉ chứa các String.
		Iterator<String> ite = coll.iterator();

		// Kiểm tra xem Iteractor còn phần tử tiếp theo hay không?
		while (ite.hasNext()) {
			// Lấy ra phần tử tại vị trí con trỏ đang đứng
			// Sau đó di chuyển con trỏ thêm 1 bước.
			String s = ite.next();
			System.out.println("Element:" + s);
		}
	}

}

// Trả về đối tượng ListIterator, để duyệt các phần tử của danh sách.
public ListIterator<E> listIterator()  
 
// Trả về đối tượng ListIterator, 
// để duyệt các phần tử từ vị trí có chỉ số 'index' đến cuối danh sách.
public ListIterator<E> listIterator(int index)

package org.o7planning.tutorial.javacollection.list;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListAndListIterator {

	public static void main(String[] args) {

		// Tạo một đối tượng List (Chỉ chứa các String).
		List<String> list = new ArrayList<String>();
		list.add("One");
		list.add("Two");
		list.add("Three");
		list.add("Four");

		// Lấy ra đối tượng ListIterator để duyệt các phần tử của danh sách.
		// (Theo đúng trình tự).
		// Returns a list iterator over the elements in this list
		// (in proper sequence)
		ListIterator<String> listIterator = list.listIterator();

		// Hiện tại con trỏ đang đứng tại ví trí đầu tiên của Iterator.
		// Đứng tại vị trí có chỉ số 0.
		// Lấy ra phần tử đầu tiên trong Iterator, con trỏ tiến thêm một bước.
		String first = listIterator.next();
		System.out.println("first:" + first);// -->"One"

		// Hiện tại con trỏ đang đứng tại vị trí có chỉ số 1.
		// Lấy ra phần tử tiếp theo.
		String second = listIterator.next();
		System.out.println("second:" + second);// -->"Two"

		// Kiểm tra xem con trỏ có thể nhẩy lùi trở lại 1 vị trí hay không.
		if (listIterator.hasPrevious()) {
			// Nhẩy trở lại 1 bước.
			String value = listIterator.previous();
			System.out.println("value:" + value);// -->"Two"
		}

		System.out.println(" ----- ");

		while (listIterator.hasNext()) {
			String value = listIterator.next();
			System.out.println("value:" + value);
		}
	}

}

package org.o7planning.tutorial.javacollection.set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class HashSetExample {

	public static void main(String[] args) {

		// Tạo một đối tượng Set có sức chứa (capacity) ban đầu 10 phần tử.
		// Nếu số lượng phần tử thêm vào vượt quá sức chứa hiện tại
		// nó sẽ tự tăng sức chứa lên 80%.
		// Đặc điểm của HashSet là phần tử thêm vào sau sẽ đứng ở phía trước.
		Set<String> set = new HashSet<String>(10, (float) 0.8);

		set.add("One");
		set.add("Two");

		// Khi trùng lặp xẩy ra.
		// Với HashSet: Nó sẽ thêm vào phần tử mới và loại bỏ phần tử cũ.
		set.add("One");
		set.add("Three");

		Iterator<String> it = set.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
	}

}

package org.o7planning.tutorial.javacollection.queue;

import java.util.LinkedList;
import java.util.Queue;

public class QueueDemo {

	public static void main(String[] args) {

		Queue<String> names = new LinkedList<String>();

		// offer(E): Trèn thêm phần tử vào hàng đợi (queue).
		// Với hàng đợi LinkedList phần tử sẽ được trèn vào cuối hàng đợi.
		// Trả về true nếu trèn thành công.
		// Trả về false nếu hàng đợi không còn chỗ.
		names.offer("E");
		names.offer("A");
		names.offer("M");

		// add(E): Trèn thêm phần tử vào hàng đợi.
		// Với hàng đợi LinkedList phần tử sẽ trèn vào cuối hàng đợi.
		// Trả về true nếu thêm thành công
		// Ném ra ngoại lệ nếu hàng đợi không còn chỗ.
		names.add("G");
		names.add("B");

		while (true) {
			// Lấy ra và loại bỏ phần tử đầu tiên ra khỏi hàng đợi.
			// Trả về null nếu không còn phần tử nào trong hàng đợi.
			String name = names.poll();
			if (name == null) {
				break;
			}
			System.out.println("Name=" + name);
		}

	}

}

package org.o7planning.tutorial.javacollection.queue;

import java.util.PriorityQueue;
import java.util.Queue;

public class PriorityQueueDemo {

	public static void main(String[] args) {

		// Với hàng đợi (queue) PriorityQueue phần tử sẽ được sắp xếp vị trí
		// theo trật tự tự nhiên của chúng.
		Queue<String> names = new PriorityQueue<String>();

		// offer(E): Trèn thêm phần tử vào hàng đợi (queue).
		// Trả về true nếu thêm thành công.
		// Trả về false nếu hàng đợi không còn chỗ.
		names.offer("E");
		names.offer("A");
		names.offer("M");

		// add(E): Trèn một phần tử vào hàng đợi (queue).
		// Trả về true nếu thành công.
		// Ném ra một Exception nếu hàng đợi đã đầy.
		names.add("G");
		names.add("B");

		while (true) {
			// poll(): Lấy ra và loại bỏ phần tử đầu tiên ra khỏi hàng đợi.
			// Trả về null nếu không còn phần tử nào trong hàng đợi.
			String name = names.poll();
			if (name == null) {
				break;
			}
			System.out.println("Name=" + name);
		}

	}

}

package org.o7planning.tutorial.javacollection.list;

import java.util.ArrayList;

public class ArrayListDemo {

	public static void main(String[] args) {

		// Khai báo một đối tượng ArrayList chứa các phần tử có kiểu Integer.
		ArrayList<Integer> list = new ArrayList<Integer>(10);

		// Thêm vào các phần tử.
		list.add(123);
		list.add(245);
		list.add(new Integer(345));

		// ArrayList cho phép thêm vào phần tử null .
		// (Đặc tính của List)
		list.add(null);

		// In ra số phần tử trong ArrayList.
		System.out.println("Size:" + list.size());// =4

		// Truy cập ngẫu nhiên vào phần tử tại chỉ số 1.
		Integer i = list.get(1);
		System.out.println("Element index 1 =" + i);// =245
		Integer newInt = 1000;

		// Thay thế phần tử tại vị trí có chỉ số 1.
		// Phương thức này trả về phần tử cũ.
		Integer old = list.set(1, newInt);
		// 
		System.out.println("Old value:" + old);// =245 .
		System.out.println("New value:" + list.get(1));// =1000 .
	}

}

// Method di sản từ 1.0 , lấy ra phần tử tại vị trí index
// elementAt(int) giống với method get(int)
public E elementAt(int index)

// Method thừa kế từ interface List, lấy ra phần tử tại vị trí index.
public E get(int index)

// Thay thế phần tử tại vị trí index bởi phần tử mới, và trả về phần tử cũ.
// setElementAt(int,E) giống với set(int,E)
public void setElementAt(int index, E element);

// Thay thế phần tử tại vị trí index bởi phần tử mới, và trả về phần tử cũ.
public E set(int index, E element)

package org.o7planning.tutorial.javacollection.list;

import java.util.Vector;

public class VectorDemo {

	public static void main(String[] args) {
		// Khởi tạo một đối tượng Vector.
		// Với sức chứa (capacity) ban đầu là 10 phần tử.
		// Tự động tăng sức chứa thêm 5 nếu số phần tử nhiều hơn
		// sức chứa hiện tại.
		Vector<Integer> v = new Vector<Integer>(10, 5);

		v.add(123);
		v.add(245);
		v.add(new Integer(345));
		v.add(null);

		// In ra số phần tử thực sự có trong Vecter (Không phải là sức chứa)
		System.out.println("Size:" + v.size());// =4

		// Lấy ra phần tử tại chỉ số 1.
		// Giống với phương thức get(int).
		Integer i = v.elementAt(1);
		System.out.println("v.elementAt(1)=" + i);// 245

		// Thay thế phần tử tại chỉ số 1.
		// Replace element at index 1.
		v.setElementAt(1000, 1);
		// 
		System.out.println("New value:" + v.get(1));// =1000 .
	}
}

package org.o7planning.tutorial.javacollection.sortedset;

public class Player implements Comparable<Player> {

	private String name;

	private int goldMedal;
	private int silverMedal;
	private int bronzeMedal;

	public Player(String name, int goldMedal, int silverMedal, int bronzeMedal) {
		this.name = name;
		this.goldMedal = goldMedal;
		this.silverMedal = silverMedal;
		this.bronzeMedal = bronzeMedal;
	}

	// So sánh Player này với Player khác (other).
	// Giá trị trả về < 0 nghĩa là Player này < Player other.
	// Nếu giá trị trả về > 0 nghĩa là Player này > Player other
	// Nếu giá trị trả về = 0 nghĩa là Player này = Player other.
	@Override
	public int compareTo(Player other) {
		// So sánh số huy chương vàng.
		int value = this.goldMedal - other.goldMedal;
		if (value != 0) {
			return value;
		}
		// So sánh số huy chương bạc.
		value = this.silverMedal - other.silverMedal;
		if (value != 0) {
			return value;
		}
		// So sánh số huy chương đồng.
		value = this.bronzeMedal - other.bronzeMedal;
		return value;
	}

	@Override
	public String toString() {
		return "[" + this.name + ", Gold: " + this.goldMedal //
				+ ", Silver: " + this.silverMedal + ", Bronze: " //
				+ this.bronzeMedal + "]";
	}

}

package org.o7planning.tutorial.javacollection.sortedset;

import java.util.SortedSet;
import java.util.TreeSet;

public class SortedSetDemo {

	public static void main(String[] args) {

		// Tạo một đối tượng SortedSet thông qua lớp con TreeSet
		SortedSet<Player> players = new TreeSet<Player>();

		Player tom = new Player("Tom", 1, 3, 5);
		Player jerry = new Player("Jerry", 3, 1, 3);
		Player donald = new Player("Donal", 2, 10, 0);

		// Thêm các phần tử vào tập hợp.
		// Chúng sẽ tự động được sắp xếp (Tăng dần).
		players.add(tom);
		players.add(jerry);
		players.add(donald);

		// In ra các phần tử.
		for (Player player : players) {
			System.out.println("Player: " + player);
		}
	}

}

import java.util.Collection;
import java.util.Map;
import java.util.Set;

public class MyMap<K,V> implements Map<K,V>{

   .....
     
     // Nếu bạn gọi phương thức này, một ngoại lệ sẽ được ném ra vô điều kiện.
    @Override
    public void clear() {
        throw new java.lang.UnsupportedOperationException();        
    }  

}

package org.o7planning.tutorial.javacollection.map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo {

	public static void main(String[] args) {

		Map<String, String> map = new HashMap<String, String>();

		map.put("01000005", "Tom");
		map.put("01000002", "Jerry");
		map.put("01000003", "Tom");
		map.put("01000004", "Donald");

		// Lấy ra một tập hợp chứa các khóa (key).
		// Tập hợp này không được sắp xếp.
		Set<String> phones = map.keySet();

		for (String phone : phones) {
			System.out.println("Phone: " + phone + " : " + map.get(phone));
		}

	}

}

package org.o7planning.tutorial.javacollection.map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

public class MapEntryDemo {

	public static void main(String[] args) {

		Map<String, String> map = new HashMap<String, String>();

		map.put("01000005", "Tom");
		map.put("01000002", "Jerry");
		map.put("01000003", "Tom");
		map.put("01000004", "Donald");

		// Lấy ra một tập hợp của các entry.
		// Các entry này có thể không được sắp xếp theo khóa (key).
		Set<Entry<String, String>> entries = map.entrySet();

		for (Entry<String, String> entry : entries) {
			System.out.println("Phone: " + entry.getKey() + " : " + entry.getValue());
		}

	}
}

package org.o7planning.tutorial.javacollection.sortedmap;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class SortedMapDemo {

	public static void main(String[] args) {

		Map<String, String> map = new TreeMap<String, String>();

		map.put("01000005", "Tom");
		map.put("01000002", "Jerry");
		map.put("01000003", "Tom");
		map.put("01000004", "Donald");

		// Tập hợp này đã được sắp xếp tăng dần.
		Set<String> keys = map.keySet();
		for (String key : keys) {
			System.out.println("Phone: " + key);
		}

		System.out.println("-----");

		// Tập hợp này cũng đã được sắp xếp theo key.
		Set<Map.Entry<String, String>> entries = map.entrySet();
		for (Map.Entry<String, String> entry : entries) {
			System.out.println("Phone: " + entry.getKey());
		}
	}

}