集合类学习一

package com.jihe.mytest;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

/*
* Java容器类类库分类:
Collection:一组独立的元素,通常这些元素都符合某种规则。(例如List必须保持元素特定的顺序,Set不能有重复元素)
Map:一组成对的“键值对”对象。

Collection – 对象之间没有指定的顺序,允许重复元素。
Set –  对象之间没有指定的顺序,不允许重复元素
List–  对象之间有指定的顺序,允许重复元素,并引入位置下标。
Map –  接口用于保存关键字(Key)和数值(Value)的集合,集合中的每个对象加入时 都提供数值和关键字。Map 接口既不继承 Set 也不继承 Collection。

List、Set、Map共同的实现基础是Object数组。

接口      实现               历史集合类
Set  HashSet     
     TreeSet     
List ArrayList   Vector   
     LinkedList  Stack 
Map  HashMap     Hashtable    
     TreeMap     Properties

*/

public class CollectionTest {
public static void main(String[] args){
//Collection
/*
集合(Collection): 
        Collection<String> collection1=new ArrayList<String>();//创建一个集合对象
    collection1.add("000");//添加对象到Collection集合中
    collection1.add("111");
    collection1.add("222");
    System.out.println("集合collection1的大小:"+collection1.size());
    System.out.println("集合collection1的内容:"+collection1);
    collection1.remove("000");//从集合collection1中移除掉 "000" 这个对象
    System.out.println("集合collection1移除 000 后的内容:"+collection1);
    System.out.println("集合collection1中是否包含000 :"+collection1.contains("000"));
    System.out.println("集合collection1中是否包含111 :"+collection1.contains("111"));
    Collection  collection2=new ArrayList();
    collection2.addAll(collection1);//将collection1 集合中的元素全部都加到collection2中
    System.out.println("集合collection2的大小:"+collection2.size());
    System.out.println("集合collection2的内容:"+collection2);
    collection2.clear();//清空集合 collection1 中的元素
    System.out.println("集合collection2是否为空 :"+collection2.isEmpty());
    //将集合collection1转化为数组
    Object s[]= collection1.toArray();
    for(int i=0;i<s.length;i++){
            System.out.println(s[i]);
            }
*/
Collection<String> collection1=new ArrayList<String>();//创建一个集合对象
    collection1.add("000");//添加对象到Collection集合中
    collection1.add("111");
    collection1.add("222");
    System.out.println("集合collection1的大小:"+collection1.size());
    System.out.println("集合collection1的内容:"+collection1);
    collection1.remove("000");//从集合collection1中移除掉 "000" 这个对象
    System.out.println("集合collection1移除 000 后的内容:"+collection1);
    System.out.println("集合collection1中是否包含000 :"+collection1.contains("000"));
    System.out.println("集合collection1中是否包含111 :"+collection1.contains("111"));
    Collection<String>  collection2=new ArrayList<String>();
    collection2.addAll(collection1);//将collection1 集合中的元素全部都加到collection2中
    System.out.println("集合collection2的大小:"+collection2.size());
    System.out.println("集合collection2的内容:"+collection2);
    collection2.clear();//清空集合 collection1 中的元素
    System.out.println("集合collection2是否为空 :"+collection2.isEmpty());
    //将集合collection1转化为数组
    Object s[]= collection1.toArray();
    for(int i=0;i<s.length;i++){
            System.out.println(s[i]);
        }

    //Iterator
/*
迭代器(Iterator)本身就是一个对象,它的工作就是遍历并选择集合序列中的对象,而客户端的程序员不必知道或关心该序列底层的结构
*/
    Collection<String> coll = new ArrayList<String>();
        coll.add("s1");
        coll.add("s2");
        coll.add("s3");
        Iterator iterator = coll.iterator();//得到一个迭代器
        while (iterator.hasNext()) {//遍历
            Object element = iterator.next();
            System.out.println("iterator = " + element);
        }
        if(coll.isEmpty())
            System.out.println("collection is Empty!");
        else
        System.out.println("collection is not empty!");
        

//List
/*
List:是容器的一种,表示列表的意思。对象之间有指定的顺序,允许重复元素,并引入位置下标。
  void add(int index, Object element) :添加对象element到位置index上
  boolean addAll(int index, Collection collection) :在index位置后添加容器collection中所有 的元素
  Object get(int index) :取出下标为index的位置的元素
  int indexOf(Object element) :查找对象element 在List中第一次出现的位置
  int lastIndexOf(Object element) :查找对象element 在List中最后出现的位置
  Object remove(int index) :删除index位置上的元素
  Object set(int index, Object element) :将index位置上的对象替换为element 并返回老的元素
List的实现有两种方式:ArrayList和LinkedList
ArrayList提示快速的基于索引的成员访问,对尾部成员的增加和删除支持较好,成员可为任意Object子类的对象
LinkedList对列表中任何位置的成员的增加和删除支持较好,但对于索引的成员访问支持性能较差,成员可为任意Object子类的对象
因此,如果要支持随机访问,而不必在除尾部的任何位置插入或除去元素,那么,ArrayList 提供了可选的集合。但如果,您要频繁的从列表的中间位置添加和除去元素,而只要顺序的访问列表元素,那么,LinkedList 实现更好。

List接口处理集合的子集:
  ListIterator listIterator() :返回一个ListIterator 跌代器,默认开始位置为0
  ListIterator listIterator(int startIndex) :返回一个ListIterator 跌代器,开始位置为startIndex
  List subList(int fromIndex, int toIndex) :返回一个子列表List ,元素存放为从 fromIndex 到 toIndex之前的一个元素
*/
        List<String> ll = new ArrayList<String>();
    ll.add("aaa");
    ll.add("bbb");
    ll.add("ccc");
    ll.add("ddd"); 
     System.out.println("下标0开始:"+ll.listIterator(0).next());//next()
     System.out.println("下标1开始:"+ll.listIterator(1).next());
    System.out.println("子List 1-3:"+ll.subList(1,3));//子列表
    ListIterator<String> it = ll.listIterator();//默认从下标0开始
    //隐式光标属性add操作 ,插入到当前的下标的前面
    it.add("sss");
    while(it.hasNext()){
    System.out.println("next Index="+it.nextIndex()+",Object="+it.next());
    }  
   
    //set属性
        ListIterator<String> it1 = ll.listIterator();
    it1.next();
    it1.set("ooo");  //将上面设置的sss元素改成ooo
    ListIterator<String> it2 = ll.listIterator(ll.size());//下标
        while(it2.hasPrevious()){
        System.out.println("previous  Index="+it2.previousIndex()+",Object="+it2.previous());
        }
       
    //Map
/*
Map:不是 Collection 接口的继承,而是从自己的用于维护键-值关联的接口层次结构入手。按定义,该接口描述了从不重复的键到值的映射。
  Object put(Object key,Object value):用来存放一个键-值对Map中
  Object remove(Object key):根据key(键),移除一个键-值对,并将值返回
  void putAll(Map mapping) :将另外一个Map中的元素存入当前的Map中
  void clear() :清空当前Map中的元素
  Object get(Object key) :根据key(键)取得对应的值
  boolean containsKey(Object key) :判断Map中是否存在某键(key)
  boolean containsValue(Object value):判断Map中是否存在某值(value)
  int size():返回Map中 键-值对的个数
  boolean isEmpty() :判断当前Map是否为空
  public Set keySet() :返回所有的键(key),并使用Set容器存放。因为映射中键的集合必须是唯一的,就使用 Set 来支持。
  public Collection values() :返回所有的值(Value),并使用Collection存放。因为映射中值的集合可能不唯一,就使用 Collection 来支持。
  public Set entrySet() :返回一个实现 Map.Entry 接口的元素 Set

Map的实现:
HashMap:能满足用户对map的通用需求。键成员可以为任意的Object子类的对象,但如果覆盖了equals方法,同时注意修改hashCode方法。
TreeMap:支持对键有序的遍历,使用时建议先用HashMap增加和删除成员,最后从HashMap生成TreeMap;附加实现了SortedMap接口,支持子Map等要求顺序的操作。键成员要求实现Compareble接口,或者使用Comparator构造TreeMap,键成员一般为同一类型。
LinkedHashMap:保留键的插入顺序,用equals方法检查键和值的相等性。成员可为任意的Object子类对象,但如果覆盖了equals方法,同时注意修改hashCode方法。
*/
        Map<String,String> map1 = new HashMap<String,String>();
        Map<String,String> map2 = new HashMap<String,String>();
        map1.put("1","aaa1");
        map1.put("2","bbb2");   
        map2.put("10","aaaa10");
        map2.put("11","bbbb11");
        //根据键 "1" 取得值:"aaa1"
        System.out.println("map1.get(1)="+map1.get("1"));
        // 根据键 "1" 移除键值对"1"-"aaa1"
        System.out.println("map1.remove(1)="+map1.remove("1"));
        System.out.println("map1中键值对的个数:"+map1.size());
        System.out.println("map1.get(1)="+map1.get("1"));
        map1.putAll(map2);//将map2全部元素放入map1中
        map2.clear();//清空map2
        System.out.println("map1 IsEmpty?="+map1.isEmpty());
        System.out.println("map2 IsEmpty?="+map2.isEmpty());
        System.out.println("map1 中的键值对的个数size = "+map1.size());
        System.out.println("KeySet="+map1.keySet());//set
        System.out.println("values="+map1.values());//Collection
        System.out.println("entrySet="+map1.entrySet());    
        System.out.println("map1 是否包含键:11 = "+map1.containsKey("11"));
        System.out.println("map1 是否包含值:aaa1 = "+map1.containsValue("aaa1"));
   
        //Map的排序

        Map<Integer,String> m1 = new HashMap<Integer,String>();
        Map m2 = new LinkedHashMap();
        for(int i=0;i<3;i++){
        double sr=Math.random()*100;//产生一个随机数,并将其放入Map中
        m1.put(new Integer((int) sr),"第 "+i+" 个放入的元素:"+sr+"¥n");
            m2.put(new Integer((int) sr),"第 "+i+" 个放入的元素:"+sr+"¥n");
        }
        System.out.println("未排序前HashMap:"+m1);   //HashMap的存入顺序和输出顺序无关
        System.out.println("未排序前LinkedHashMap:"+m2);   //LinkedHashMap的输出顺序与存入顺序相同
        //使用TreeMap来对另外的Map进行重构和排序
        Map sortedMap = new TreeMap(m1);  //TreeMap是对Map中元素进行排序
        System.out.println("排序后:"+sortedMap);
        System.out.println("排序后:"+new TreeMap(m2));
       
       
        //Set
/*
* Set:继承 Collection 接口,而且它不允许集合中存在重复项。
     public int size() :返回set中元素的数目,如果set包含的元素数大于Integer.MAX_VALUE,返回Integer.MAX_VALUE
  public boolean isEmpty() :如果set中不含元素,返回true
  public boolean contains(Object o) :如果set包含指定元素,返回true
  public Iterator iterator() :返回set中元素的迭代器;元素返回没有特定的顺序,除非set是提高了该保证的某些类的实例
  public Object[] toArray() :返回包含set中所有元素的数组
  public Object[] toArray(Object[] a) :返回包含set中所有元素的数组,返回数组的运行时类型是指定数组的运行时类型
  public boolean add(Object o) :如果set中不存在指定元素,则向set加入     
  public boolean remove(Object o) :如果set中存在指定元素,则从set中删除        
  public boolean removeAll(Collection c) :如果set包含指定集合,则从set中删除指定集合的所有元素      
  public boolean containsAll(Collection c) :如果set包含指定集合的所有元素,返回true。如果指定集合也是一个set,只有是当前set的子集时,方法返回true     
  public boolean addAll(Collection c) :如果set中中不存在指定集合的元素,则向set中加入 所有元素
  public boolean retainAll(Collection c) :只保留set中所含的指定集合的元素(可选操作)。 换言之,从set中删除所有指定集合不包含的元素。 如果指定集合也是一个set,那么该操作修改set的效果是使它的值为两个set的交集
  public void clear() :从set中删除所有元素

Set的常用实现类:
HashSet:外部无序地遍历成员。成员可为任意Object子类 的对象,但如果覆盖了equals方法,同时注意修改hashCode方法
TreeSet:外部有序地遍历成员;附加实现了SortedSet,支持子集等要求顺序的操作。成员要求实现 Comparable接口,或者使用Comparator构造 TreeSet。成员一般为同一类型。
LinkedHashSet:外部按成员的插入顺序遍历成员。成员与HashSet成员类似。
*/
        Set set1 = new HashSet();
        if (set1.add("a")) {//添加成功            
        System.out.println("1 add true");
        }
        if (set1.add("a")) {//添加失败
            System.out.println("2 add true");
        }else{
        System.out.println("2 add failed");
        }
        set1.add("000");//添加对象到Set集合中
        set1.add("111");
        set1.add("222");
        System.out.println("集合set1的大小:"+set1.size());
        System.out.println("集合set1的内容:"+set1);
        set1.remove("000");//从集合set1中移除掉 "000" 这个对象
        System.out.println("集合set1移除 000 后的内容:"+set1);
        System.out.println("集合set1中是否包含000 :"+set1.contains("000"));
        System.out.println("集合set1中是否包含111 :"+set1.contains("111"));
        Set set2=new HashSet();
        set2.add("111");
        set2.addAll(set1);//将set1 集合中的元素全部都加到set2中
        System.out.println("集合set2的内容:"+set2);
        set2.clear();//清空集合 set1 中的元素
        System.out.println("集合set2是否为空 :"+set2.isEmpty());
        Iterator iterator1 = set1.iterator();//得到一个迭代器
        while (iterator1.hasNext()) {//遍历
            Object element = iterator1.next();
            System.out.println("iterator = " + element);
        }
        //将集合set1转化为数组
        Object ss[]= set1.toArray();
        for(int i=0;i<ss.length;i++){
            System.out.println(ss[i]);
        }
        //Set排序
        Set<Integer> s1 = new HashSet<Integer>();
        Set<Integer> s2 = new LinkedHashSet<Integer>();
        for(int i=0;i<5;i++){
        int ssss=(int) (Math.random()*100);  //产生一个随机数,并将其放入Set中
        s1.add(new Integer(ssss));
        s2.add(new Integer(ssss));
        System.out.println("第 "+i+" 次随机数产生为:"+ssss);
        }
        System.out.println("未排序前HashSet:"+s1);
        System.out.println("未排序前LinkedHashSet:"+s2);
        //使用TreeSet来对另外的Set进行重构和排序
        Set<Integer> sortedSet = new TreeSet<Integer>(s1);
        System.out.println("排序后的HashSet :"+sortedSet);
        System.out.println("排序后的LinkedHashSet :"+new TreeSet(s2));
    }
}

你可能感兴趣的:(list,set,map,Collection)