JAVA集合

Collection 类结构：

Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set

Map
├Hashtable
├HashMap
└WeakHashMap

 Collection简介：

 Collection接口：继承它的接口类有List和Set

             List特点：元素有放入顺序，元素可重复 

            Set 特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的）

(1)List简介：

List是有序的，List类能定位索引到每个元素位置，List集合中允许有相同元素而不覆盖。

List接口有三个实现类：LinkedList，ArrayList，Vector ，Set接口有两个实现类：HashSet(底层由HashMap实现)，LinkedHashSet

ArrayList：

ArrayList它允许所有元素，包括null。ArrayList没有同步。依赖于数组实现的,初始长度为10的Object[],并且可随需要而增加的动态数组，当元素超过10,那么ArrayList底层会新生成一个数组,然后将原数组内容复制到新数组中,并且后续增加的内容会放到新数组中, 当新数组无法容纳增加的元素,重复该过程，ArrayList对随机访问性能很好,但进行大量插入,删除操作,性能很差,因为操作之后后续元素需要移动。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

ArrayList基础常用：

void ListTest(){
		
		 List<String> list = new ArrayList<String>();  
	        // 向列表的尾部追加指定的元素  
	        list.add("lmx");  
	        // 在列表的指定位置插入指定元素  
	        list.add(1, "lmx");  
	        // 追加指定 collection 中的所有元素到此列表的结尾  
	        list.addAll(new ArrayList<String>());  
	        // 从列表中移除所有元素  
	        list.clear();  
	        // 如果列表包含指定的元素,则返回true  
	        list.contains("lmx");  
	        // 如果列表包含指定 collection 的所有元素,则返回 true  
	        list.containsAll(new ArrayList<Object>());  
	        // 比较指定的对象与列表是否相等  
	        list.equals(new ArrayList<Object>());  
	        // 返回列表中指定位置的元素  
	        list.get(0);  
	        // 返回列表的哈希码值  
	        //a.hashCode()==b.hashCode() &&a.equals(b)。
	        list.hashCode();  
	        // 返回列表中首次出现指定元素的索引,如果列表不包含此元素,则返回 -1  
	        list.indexOf("lmx");  
	        // 返回列表中最后出现指定元素的索引,如果列表不包含此元素,则返回 -1  
	        list.lastIndexOf("lmx");  
	        // 如果列表不包含元素,则返回 true  
	        list.isEmpty();  
	        // 移除列表中指定位置的元素  
	        list.remove(0);  
	        // 移除列表中出现的首个指定元素  
	        list.remove("lmx");  
	        // 从列表中移除指定 collection 中包含的所有元素  
	        list.removeAll(new ArrayList<Object>());  
	        // 用指定元素替换列表中指定位置的元素  
	        list.set(0, "lmx");  
	        // 返回列表中的元素数  
	        list.size();  
	        // 返回列表中指定的fromIndex(包括)和toIndex(不包括)之间的部分视图  
	        list.subList(1, 2);  
	        // 返回以正确顺序包含列表中的所有元素的数组  
	        list.toArray();  
	        // 返回以正确顺序包含列表中所有元素的数组  
	        list.toArray(new String[] { "l", "m" });  
		
	}
	
	
	void ListIteratorTests(){
		
		
        List<String> list = new ArrayList<String>();  
        list.add("lmx");  
        list.add("xml");  
        // 遍历一  
        Iterator<String> ite1 = list.iterator();  
        while (ite1.hasNext()) {  
            String str = ite1.next();  
            System.out.println(str);  
        }  
    
        // 遍历二 
        for (Iterator<String> ite2 = list.iterator(); ite2.hasNext();) {  
            String str = ite2.next();  
            System.out.println(str);  
        }  

        // 遍历三  
        for(String s : list){  
            System.out.println(s);  
        } 
	}
	

Vector：

 Vector特点与ArrayList相同, 不同的是Vector操作元素的方法是同步的,同一时刻只能有一个线程访问,没有特殊需求都一般使用ArrayList 代替。

Vector基础常用：

void VectorTest(){
	    Vector v = new Vector();  
        v.add("lmx");  
        v.add("hello");  
        v.add("world");  
        // Vector转换为枚举  
        Enumeration e = v.elements();  
        while (e.hasMoreElements()) {  
            System.out.println(e.nextElement());  
        }  
	}

Stack:

stack特点:栈结构

stack基础常用：

void StackTest() {
		Stack stack = new Stack();
		// 向栈里面压一个整数
		stack.push(new Integer(100));
		stack.push("lmx");
		stack.push(new Double(99.99));
		// 遍历
		Enumeration items = stack.elements();
		while (items.hasMoreElements()) {
			System.out.print(items.nextElement() + " ");
		}
		System.out.println();
		// 出栈  先进后出
		while (stack.size() != 0) {
			System.out.print(stack.pop() + " ");
		}
	}

LinkedList:

LinkedList特点: LinkedList功能与ArrayList,Vector相同,内部是依赖双链表实现的,  因此有很好的插入和删除性能,但随机访问元素的性能很差, 插入和删除操作时,采用LinkedList好,搜索时,采用ArrayList好  

LinkedList 基础常用：

 private static void printList(List link) {  
        System.out.println("正序链表中的元素");  
        // 的到链表的迭代器,位置指向链头  
        ListIterator li = link.listIterator();  
        // 判断迭代器中是否有下一个元素  
        while (li.hasNext()) {  
            // 返回下个元素  
            System.out.print(li.next() + " ");  
        }  
        System.out.println();  
    }  
  
    private static void printReversedList(List link) {  
        System.out.println("逆向链表中的元素");  
        // 的到链表的迭代器,位置指向link.size()结尾  
        ListIterator li = link.listIterator(link.size());  
        // 判断迭代器中是否有前一个元素  
        while (li.hasPrevious()) {  
            // 返回前一个元素  
            System.out.print(li.previous() + " ");  
        }  
 
    } 
    
    
    public static void main(String[] args) {  
    	
        List link = new LinkedList();  
        link.add(100);  
        link.add("lmx");  
        link.add(9.9);  
        link.add("jqy");  
        link.add(520);  
        printList(link);  
        printReversedList(link); 
        
    }

List<Map>:

void ListMap(){
		
		Map<Integer, String> map1 = new HashMap<Integer, String>();
		map1.put(new Integer(1), "lmx");
		map1.put(new Integer(2), "jqy");
		Map<Integer, String> map2 = new HashMap<Integer, String>();
		map2.put(new Integer(3), "zcm");
		map2.put(new Integer(4), "zl");
		List<Map<Integer, String>> list = new ArrayList<Map<Integer, String>>();
		list.add(map1);
		list.add(map2);
		
		// 遍历一
		Iterator<Map<Integer, String>> ite1 = list.iterator();
		while (ite1.hasNext()) {
			Map<Integer, String> m = ite1.next();
			System.out.println(m);
		}
		
		// 遍历二
		for (Iterator<Map<Integer, String>> ite2 = list.iterator(); ite2
				.hasNext();) {
			Map<Integer, String> m = ite2.next();
			System.out.println(m);
		}
	
		// 遍历三:
		for (Map<Integer, String> m : list) {
			System.out.println(m);
		}
	}

(1)Sst简介：

不包含重复元素,最多包含一个null,元素没有顺序  

HashSet:

package com.collection;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;

public class HashSetTest {

	void RunHashSet() {

		HashSet hs = new HashSet();

		// 添加第一个元素
		hs.add(new String("lmx"));

		// 创建一个ArrayList对象，添加多个个元素
		ArrayList list = new ArrayList();
		list.add("one");
		list.add("two");

		// 把ArrayList对象添加到HashSet中
		hs.addAll(list);

		// 在HashSet中添加一个元素
		hs.add("three");

		// 添加一个null元素
		hs.add(null);

		// 通过转换成数组遍历的结果
		this.toForeachList2(hs);

		// 通过得到Iterator遍历的结果
		hs.remove("one");
		// "删除one元素之后
		this.toForeachList1(hs);

		System.out.println("HashSet中元素的个数为：" + hs.size());

		if (hs.isEmpty()) {
			System.out.println("HashSet是空的");
		} else {
			System.out.println("HashSet不是空的");
		}

		System.out.println("清空所有的元素：");

		hs.clear();

		if (hs.isEmpty()) {
			System.out.println("HashSet是空的");
		} else {
			System.out.println("HashSet不是空的");
		}

	}

	/*
	 * 得到Iterator，然后遍历输出
	 */
	public void toForeachList1(HashSet hs) {
		Iterator i = hs.iterator();
		while (i.hasNext()) {
			String temp = (String) i.next();
			System.out.println(temp);
		}
	}

	/*
	 * 转换成数组，遍历并输出HashSet中的元素
	 */
	public void toForeachList2(HashSet hs) {
		Object o[] = hs.toArray();
		for (int i = 0; i < o.length; i++) {
			System.out.println((String) o[i]);
		}
	}

	public static void main(String[] args) {

		new HashSetTest().RunHashSet();

	}

}




/*输出结果
null
two
one
three
lmx
null
two
three
lmx
HashSet中元素的个数为：4
HashSet不是空的
清空所有的元素：
HashSet是空的*/

LinkedHashSet:

几个set的比较  

• HashSet：哈希表是通过使用称为散列法的机制来存储信息的，元素并没有以某种特定顺序来存放；  
• LinkedHashSet：以元素插入的顺序来维护集合的链接表，允许以插入的顺序在集合中迭代；  
• TreeSet：提供一个使用树结构存储Set接口的实现，对象以升序顺序存储，访问和遍历的时间很快。 

Collections:

操作Collection类的工具类,类中方法都是静态的 

package com.collection;

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

public class CollectionTest {

	public void RunCollection() {

		List<String> list1 = new ArrayList<String>();
		list1.add("A");
		list1.add("B");
		list1.add("C");
		list1.add("5");

		List<String> list2 = new ArrayList<String>();
		list1.add("1");
		list1.add("2");
		list2.add("3");

		/**
		 * copy 将所有元素从一个列表复制到另一个列表
		 */
		Collections.copy(list1, list2);

		System.out.print("结果：");
		for (String string : list1) {
			System.out.print(string);
		}
		System.out.println("");
		// 输出：A B C 1 2 3

		/**
		 * disjoint 如果两个指定collection中没有相同的元素,则返回 true
		 */
		boolean istrue = Collections.disjoint(list1, list2);

		System.out.print("结果：" + istrue);
		System.out.println("");
		// 输出：true

		List<bean> list3 = new ArrayList<bean>();
		bean b = new bean();
		b.setId("10");
		b.setName("lmx");
		b.setPw("123456");
		list3.add(b);

		bean b2 = new bean();
		b2.setId("10");
		b2.setName("lmx123");
		b2.setPw("123456123");

		/**
		 * fill 使用指定元素替换指定列表中的所有元素
		 */
		Collections.fill(list3, b2);
		for (bean bean : list3) {
			System.out.println(bean.getName());
		}
		System.out.println("");
		// 输出：lmx123

		/**
		 * frequency 返回指定 collection 中等于指定对象的元素数
		 */
		int cnt = Collections.frequency(list3, b);
		System.out.println(cnt);
		System.out.println("");
		// 输出：1 //需全等,对象是同一对象才返回

		/**
		 * indexOfSubList 返回指定源列表中第一次出现指定目标列表的起始位置,如果没有出现这样的列表,则返回 -1
		 */
		int cnt1 = Collections.indexOfSubList(list1, list2);
		System.out.print(cnt1);
		System.out.println("");
		// 输出：2 list1 为ABC，list2为 C

		/**
		 * max 根据元素的自然顺序，返回给定 collection 的最大元素
		 */
		String maxValue = Collections.max(list1);
		System.out.print(maxValue);
		System.out.println("");
		// 输出：C ASCII大小比较

		/**
		 * min 根据元素的自然顺序，返回给定 collection 的最大元素
		 */
		String minValue = Collections.min(list1);
		System.out.print(minValue);
		System.out.println("");
		// 输出：A ASCII大小比较

		/**
		 * replaceAll 使用另一个值替换列表中出现的所有某一指定值
		 */
		Collections.replaceAll(list1, "5", "6");
		for (String string : list1) {
			System.out.println(string);
		}
		System.out.println("");
		// 输出：ABC612 5被替换成6

		/**
		 * reverse 反转指定列表中元素的顺序
		 */
		Collections.reverse(list1);
		for (String string : list1) {
			System.out.println(string);
		}
		System.out.println("");
		// 输出：216CBA

		/**
		 * shuffle 使用默认随机源随机更改指定列表的序列
		 */
		Collections.shuffle(list1);
		for (String string : list1) {
			System.out.println(string);
		}
		System.out.println("");
		// 输出：62BCA1 随机刷出

		/**
		 * sort 根据元素的自然顺序对指定列表按升序进行排序
		 */

		Collections.sort(list1);
		for (String string : list1) {
			System.out.println(string);
		}
		System.out.println("");
		// 输出：125ABC ASCII升序

		/**
		 * swap 在指定列表的指定位置处交换元素
		 */
		Collections.swap(list1, 1, 2);
		for (String string : list1) {
			System.out.println(string);
		}
		System.out.println("");
		// 输出：ACB512 1位置和2换
	}

	public static void main(String[] args) {
		new CollectionTest().RunCollection();
	}
}

class bean {
	String id;
	String name;
	String pw;

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getPw() {
		return pw;
	}

	public void setPw(String pw) {
		this.pw = pw;
	}

}

还在编写中···

总结不好多多担待，文章只单纯个人总结，如不好勿喷，技术有限，有错漏麻烦指正提出。本人QQ:373965070