JAVA-集合類型List(ArrayList、LinkedList)常用操作例子（基礎必備）

package com.net.xinfang.reflect;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.LinkedList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/***
 * 集合類（List-LinkedList/ArrayList/Vector,Set,Map-HashTable/HashMap）
 * 
 * @author xinfang
 *
 */
public class collect004 {
	public void map() {
		Map map = new HashMap();
		map.put("key1", "lisi1");
		map.put("key2", "lisi2");
		// 先獲取map集合的所有鍵的set集合，keyset（）
		Iterator it = map.keySet().iterator();
		// 獲取迭代器
		// 第一種遍歷Iterator-keySet
		while (it.hasNext()) {
			Object key = it.next();
			System.out.println(map.get(key));
		}
		// 第二種遍歷(推薦，效率高)-entrySet
		// 將map集合中的映射關系取出，存入到set集合
		Iterator it1 = map.entrySet().iterator();// 創建迭代對象
		while (it1.hasNext()) {// hasNext判斷是否還有下一個元素
			Entry e = (Entry) it1.next();
			System.out.println("鍵" + e.getKey() + "的值為" + e.getValue());
		}
		// foreach遍歷方式-keySet
		Map<String, Integer> ma = new HashMap<String, Integer>();
		ma.put("二陽", 23);
		ma.put("二崢", 24);
		Set<String> keys = ma.keySet(); // 把鍵其中起來,存入到set集合中.
		for (String key : keys) { // 遍歷鍵集合，獲取每一個鍵
			Integer value = ma.get(key); // 讓鍵去找值 get(Object key)
			System.out.println(key + "***" + value);
		}
		// entrySet
		Set<Map.Entry<String, Integer>> set = ma.entrySet();
		for (Map.Entry<String, Integer> me : set) { // 遍歷鍵值對集合，獲取到每一個鍵值對。增強for，迭代器
			String key = me.getKey(); // 通過鍵值對獲取鍵getKey()
			Integer value = me.getValue(); // 通過鍵值對獲取值getValue()
			System.out.println(key + "***" + value);
		}
	}

	public void List() {
		List<String> strList = new ArrayList<>();// 動態數組-get/set快
		List<String> linkList = new LinkedList<>();// 鏈表-插入/刪除快
		//ArrayList<String> ast=new ArrayList<>();
		//LinkedList<String> list=new LinkedList<>();
		linkList.add("2");
		linkList.add("1");
		linkList.add("1");
		strList.add("1");// 添加元素
		strList.add("2");
		strList.toString();// 轉換字符串
		strList.size();// 獲取長度
		strList.get(0);// 獲取索引為0的值
		strList.remove(0);// 移除索引為0的值
		Collections.sort(linkList);// 排序
		removeDuplicate(linkList);// 去重
		strList.contains("1");// 判斷是否包含1
		strList.set(0, "1");// 替換索引為0的值
		strList.add(1, "2");// 添加索引為1的值
		strList.indexOf("1");// 獲取第一個出現1的索引位置
		strList.lastIndexOf("2");// 獲取最后一個出現2的索引位置
		strList.subList(0, 1);// 截取0<=index<1的值作為新的List
		// equals值比較相等，hashcode相等的對象就不一定是相等的對象
		strList.isEmpty();// 空為true,非空為false
		strList.iterator();// 返回iterator集合對象
		// for循環方式遍歷
		for (int i = 0; i < strList.size(); i++) {
			System.out.println(strList.get(i));
		}
		// foreach遍歷list
		for (String obj : strList) {
			System.out.println(obj);
		}
		for (String obj : linkList) {
			System.out.println(obj);
		}
		// Iterator接口迭代遍歷
		Iterator<String> it = strList.iterator();
		while (it.hasNext()) {
			String obj = it.next();
			System.out.println(obj);
		}
		// List轉換為數組
		// 第一種for循環轉換
		String string[] = new String[strList.size()];
		for (int i = 0, j = strList.size(); i < j; i++) {
			string[i] = strList.get(i);
		}
		// 第二種調用toArray函數轉換
		String[] strings = new String[strList.size()];
		strList.toArray(strings);
		for (String str : strings) {
			System.out.println(str);
		}
		// 數組轉換為List
		String[] s = { "a", "b", "c" };
		List<String> list = new ArrayList<>(Arrays.asList(s));
		for (String st : list) {
			System.out.println(st);
		}
	}

	// 利用HashSet特性去重
	public static void removeDuplicate(List list) {
		HashSet h = new HashSet(list);
		list.clear();
		list.addAll(h);
		System.out.println(list);
	}

	// 前者與后者比較去重
	public static void removeDuplicate1(List list) {
		for (int i = 0; i < list.size() - 1; i++) {
			for (int j = list.size() - 1; j > i; j--) {
				if (list.get(j).equals(list.get(i))) {
					list.remove(j);
				}
			}
		}
		System.out.println(list);
	}

	public void list1() {
		String a = "A", b = "B", c = "C", d = "D", e = "E";// 定義要插入集合的字符串對象
		List<String> list = new LinkedList<String>();// 創建List集合
		list.add(a);// 向集合中添加元素
		list.add(b);
		list.add(c);
		Iterator<String> iter = list.iterator();// 創建集合的迭代器
		System.out.println("修改后 前集合 中的元素是：");
		while (iter.hasNext()) {
			System.out.print(iter.next() + " ");
		}
		list.set(0, e);// 將索引位置為0的對象修改為對象e
		list.set(2, d);// 將索引位置為2的對象修改為對象d
		Iterator<String> it = list.iterator();// 創建將集合對象修改后的迭代器對象
		System.out.println();
		System.out.println("修改后的集合中的元素是：");
		while (it.hasNext()) {// 循環獲取集合中的元素
			System.out.print(it.next() + " ");
		}
		List list1 = new ArrayList();// 創建集合對象
		int i = (int) (Math.random() * (list.size() - 1));// 獲得0-2之間的隨機數
		list1.add("a");// 向集合中添加元素
		list1.add("b");
		list1.add("c");
		System.out.println("隨機獲取數組中的元素：" + list1.get(i));//
		list1.remove(2);// 將指定索引位置的元素從集合中移除
		System.out.println("將索引是'2'的元素從數組中移除后，數組中的元素是：");
		for (int j = 0; j < list1.size(); j++) {// 循環遍歷數組
			System.out.print(list1.get(j) + " ");
		}
	}

	public static void main(String args[]) {
		collect004 c1 = new collect004();
		c1.map();
		c1.List();
		c1.list1();
		// 冒泡排序
		/***
		 * 基本思想：在要排序的一組數中，對當前還未排好序的范圍內的全部數，自上而下對相鄰的兩個數依次進行比較和調整，讓較大的數往下沉，較小的往上冒。
		 * 即：每當兩相鄰的數比較后發現它們的排序與排序要求相反時，就將它們互換。
		 */
		int[] a = { 1, 3, 2 };
		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a.length - 1 - i; j++) {
				if (a[j] > a[j + 1]) {
					int temp = a[j + 1];
					a[j + 1] = a[j];
					a[j] = temp;
				}
			}
		}
		for (int k : a) {
			System.out.println(k);
		}
		int arr[] = { 23, 12, 6 };
		// 冒泡排序(比較相鄰的兩個元素，大的往后排，小的往前移動，第一層循環避免漏排，第二層循環比較排序)
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					int t = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = t;
				}
			}
		}
		for (int k : arr) {
			System.out.println(k);
		}
		/***
		 * 選擇排序-比較第一個與第二個，以此類推，大的往后移，小的往前移 冒泡排序-相鄰的比較，大的往后移，小的往前移
		 * 快速排序-選擇第一個或最后一個元素作為基准元素， 第一趟掃描分為兩部分（一部分為比基准元素小的，一部分比基准元素大的），然后分別遞歸排序
		 * 插入排序-選擇一個記錄元素，比較后排序插入新的數組
		 */
		//插入排序
		int brr[] = {2, 3, 1, 5};
		int i, j, insertNote;// 要插入的數據
		for (i = 1; i < brr.length; i++) {// 從數組的第二個元素開始循環將數組中的元素插入
			insertNote = brr[i];// 設置數組中的第2個元素為第一次循環要插入的數據
			j = i - 1;
			while (j >= 0 && insertNote < brr[j]) {
				brr[j + 1] = brr[j];// 如果要插入的元素小於第j個元素,就將第j個元素向后移動
				j--;
			}
			brr[j + 1] = insertNote;// 直到要插入的元素不小於第j個元素,將insertNote插入到數組中
		}
		for (int k : brr) {
			System.out.println(k);
		}
	}
}