java笔记—List、Set、Map集合

第六章：集合框架

第一：理解： 集合可想象为一个动态数组。
集合类型主要有3种：set(集）、list(列表）、map(映射)。

第二：Collection 接口：

1、List 接口：任意存放数据、而且内容可以是重复的。

List的子类：

1、ArrayList 类 ： 同Vector一样是一个基于Array上的链表，但是不同的是ArrayList不是同步的。每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。

实例化： List list = new ArrayList(); 或者 List<String> list = new ArrayList<String>();

例如：

package list_arraylist;

import java.util.*;

/*
 * ArrayList<泛型>
 * 添加数据
 * 获取单个元素
 * 迭代器遍历全部元素
 */
public class AddDom {
	public static void main(String[] args){
		

       List<String> list = new ArrayList<String>();
       list.add("tianjia");
       list.add("manman");
       list.add("buyaoji");
       list.set(2, "改过了");
       
       //获取单个元素
       String li = (String) list.get(2);
       System.out.println(li);
       System.out.println("\n");
       //遍历全部元素
       Iterator<String> iterator = list.iterator();
       while(iterator.hasNext()){
    	   String str = (String) iterator.next();
    	   System.out.println(str);
       }
	}
}

2、 Vector 类 ： 基于Array的List，其实就是封装了Array所不具备的一些功能方便我们使用，它不可能走出Array的限制。Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。

实例化： Vector vector = new Vector();

例如：

package list_vector;


import java.util.*;
/*
 * ArrayList会比Vector快，他是非同步的，
 * 如果设计涉及到多线程，还是用Vector比较好一些 
 * 演示Vector的使用。包括Vector的创建、向Vector中添加元素、从Vector中删除元素、 
 * 统计Vector中元素的个数和遍历Vector中的元素。 
*/ 

public class VectorDom {
	public static void main(String [] args){
		
        Vector<String> vector = new Vector<String>(10);
        vector.add("test1");
        vector.add("test2");
        vector.add("test3");
        vector.add("test4");
        vector.add("test5");
        vector.add("test6");
        
        int in = vector.size();
        System.out.println("size:" + in + "\n");       
        vector.remove(3);
        vector.removeElementAt(0);

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

3、LinkedList 类： 不同于前面两种List，它不是基于Array的，所以不受Array性能的限制。它每一个节点（Node）都包含两方面的内容：

1. 节点本身的数据（data）；

2. 下一个节点的信息（nextNode）。所以当对LinkedList做添加，删除动作的时候就不用像基于Array的List一样，必须进行大量的数据移动。只要更改nextNode的相关信息就可以实现了。这就是LinkedList的优势。

实例化： LinkedList linkedlist = new LinkdList();

例如：

package list_linked;

import java.util.*;

/*
 * LinkedList<String>
 * iterate遍历
 * 添加元素
 * */
public class List_linked {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
        LinkedList<String> linked = new LinkedList<String>();
        
        linked.add("linked");
        linked.addFirst("添加到第一个");
        linked.add("艾玛");
        linked.add("li5");
        linked.removeLast();
        linked.remove("艾玛");
        
        Iterator<String> iterator = linked.listIterator();
        while(iterator.hasNext()){
        	String string = (String)iterator.next();
        	System.out.println(string);
        }
	}

}

List总结：

1. 所有的List中只能容纳单个不同类型的对象组成的表，而不是Key－Value键值对。
2. 所有的List中可以有相同的元素。
3. 所有的List中可以有null元素。

4. 基于Array的List（Vector，ArrayList）适合查询，而LinkedList（链表）适合添加，删除操作。

2、Set 接口： 不可以加入重复元素、但是可以排序。

Set子类：

HashSet：散列存放 HashSet hs = new HashSet();

TreeSet ：有序存放 TreeSet hs = new TreeSet(); 

例如：

package set_hashset;

import java.util.*;

/*
 * 不可以加入重复元素。
 * 
 * */
public class HashSet_dom {
public static void main(String[] args) {	
		Set<Comparable> hs = new HashSet<Comparable>(6);
		
		hs.add("abc");
		hs.add(new Date());//在HashSet里增加日期对象
		hs.add(new Integer(12));
		
		Iterator<Comparable> it = hs.iterator();
		while(it.hasNext()){ 
			System.out.println(it.next()); 
		} 
	}
}

Set总结：

1. Set实现的基础是Map（HashMap）；

2. Set中的元素是不能重复的，如果使用add(Object obj)方法添加已经存在的对象，则会覆盖前面的对象为什么要使用集合类当你事先不知道要存放数据的个数，

或者你需要一种比数组下标存取机制更灵活的方法时，你就需要用到集合类。

第三：Map 接口：映射与集或列表有明显区别，映射中每个项都是成对的。

子类：

HashMap ：无序存放，Key不许重复。基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

实例化：Map<String,String> map = new HashMap<String, String>();

Hashtable：无序存放，Key不许重复。

实例化：Map<String,String> map = new Hashtable<String, String>();

例如：

package map;
import java.util.*;

/*
 * Key－Value
 * 成对存在
 * */
public class Map_hashmap {
	public static void main(String[] args) {

	Map<String,String> map = new HashMap<String, String>(); 
		// 添加对象
        map.put("学号：01", "陈游游同学"); 
        map.put("学号：02", "陈君道同学");
        map.put("学号：03", "null");
        
        // 构建Map集合中所有key对象的集合
        Set<String> set = map.keySet(); 
        // 创建迭代器 遍历集合
        Iterator<String> it = set.iterator();                
        while(it.hasNext()){
        	System.out.println(" key:集合中的元素是:" + it.next());
        }
        
        // 构建Map集合中所有value对象的集合
        Collection<String> coll = map.values();  
        it=coll.iterator();        
        while(it.hasNext()){
        	System.out.println(" values:集合中的元素是:" +it.next());
        }
	}

}

第四：迭代器的创建和遍历：

Iterator iterator = list.iterator();

while(iterator.hasNext()){
     String str = (String) iterator.next();
     System.out.println(str);

}

转载于:https://my.oschina.net/czyandy/blog/692275