java_list,set,map集合

一、集合定义

集合就是讲诺干用途相同、近似的“数据”结合成一个整体

集合从体系上分为三种

1、列表（List）：List集合区分元素的顺序，允许包含相同的元素

2、集（set）：Set集合不区分元素的顺序，不允许包含相同的元素

3、映射（Map）：Map集合保存的“键”-“值”对“键”不能重复，而且一个“键”只能对应一个“值”

　　1）list 序列特点

　　有序的，可添加重复元素

　　ArrayList：顺序结构，容量动态扩充，线程不安全。（不同步）

　　LinkedList：离散

　　方法：pop:弹出置顶元素

　　　　　peek：获取连接的第一个元素

　　　　　addFirst：给链表头添加元素

　　　　　addLast：给链表尾添加元素

　　　　使用next()获得序列中的下一个元素，使用hasNext()检查序列中是否还有元素。

import java.util.Iterator;
import java.util.LinkedList;
public class s1 {
 
   public  static void main(String[] args)
   {
       LinkedList list = new LinkedList();
       list.add(100);
       list.add("beijing");
       list.add(123);
       list.add("zhongguo");
       for (int i = 0 ; i< list.size();i++)
       {
           System.out.println(list.get(i));
       }
       System.out.println("==================");
       list.addFirst("lcj"); //给链表头添加元素
       list.addLast("haha");//给链表末添加元素
       Iterator it = list.iterator();//迭代器
       while (it.hasNext())//　　2)使用next()获得序列中的下一个元素。3)使用hasNext()检查序列中是否还有元素。
       {
           System.out.println(it.next());
       }
//       System.out.println("---------------------------");
//       System.out.println(list.peek());  //获取第一个迭代器中第一个元素
        System.out.println("------------------");
       System.out.println(list.pop()); //弹出置顶元素
       System.out.println("弹出之后元素》》");
       System.out.println("------------------");
       it = list.iterator();  //重新获取迭代器
       while (it.hasNext())
       {
           System.out.println(it.next());
       }
   }
}

　　二、set集合

　　没有重复元素的集合

　　HashSet特点：顺序结构，无重复元素，允许null值，无序的，线程不安全（不同步）

import java.util.HashSet;
import java.util.Iterator;
 
public class set01 {
    public static void main(String[] args)
    {
        HashSet set = new HashSet();
        set.add(100);
        set.add("lcj");
        set.add(true);
        set.add(2.34);
        set.add(2.34); //不可添加重复元素：
        set.add(null);//可添加null值
          //无法使用for循环遍历set集合
//        for (int i = 0 ;i<set.size();i++)
//        {
//            System.out.println(set.);//无法获取列表下标
//        }
        Iterator it = set.iterator();  //Iterator迭代器
        while (it.hasNext())  //hasNext:检查序列中是否还有元素
        {
            System.out.println(it.next());//使用next()获得序列中的下一个元素
        }
    }
}

　　TreeSet 特点：无重复元素，允许null值，有排序，线程不安全的（不同步）　　

import java.util.Iterator;
import java.util.TreeSet;
 
public class set02 {
    public static void main(String[] args)
    {
        TreeSet set = new TreeSet();//TreeSet:有序排序
        set.add("chain");
        set.add("lcj");
        set.add("aw");
        set.add("haha");
        set.add("beijing");
        Iterator it = set.iterator();
        while (it.hasNext())  //hasNext:检查序列中是否还有元素
        {
            System.out.println(it.next());  //使用next()获得序列中的下一个元素
        }
    }
}
//输出：按照字母排序
//aw
// beijing
//chain
//haha
//lcj

　　LinkedSed 特点

　　离散结构，通过链表实现，无重复元素，允许Null值，有序，线程不安全的（不同步）

import java.util.Iterator;
import java.util.LinkedHashSet;
public class set03 {
    public static void main(String[] args)
    {
        LinkedHashSet set = new LinkedHashSet();//无序，链表结果
        set.add("chain");
        set.add("lcj");
        set.add("aw");
        set.add(null); //允许添加null值
        set.add("beijing");
        Iterator it = set.iterator();  //遍历结果是有序：即按照写入的顺序排序
        while (it.hasNext())
        {
            System.out.println(it.next());
        }
    }  //chain    lcj    aw  null   beijing
}

　　　三、map集合

　　1）Hashtable：无序、基于哈希表的Map接口实现，顺序结构，键和值都不容许是null，值可重复，线程安全，同步，　　

import java.util.Hashtable;
import java.util.Iterator;
import java.util.Set;
 
public class hashtable04 {
    public static  void main(String[] args)
    {
        Hashtable map = new Hashtable();
        map.put(1,"北京");
        map.put(2,"武汉");
        map.put(3,"天津");
        map.put(6,"山西");
      //  map.put(null,"山西");键不能为null
     //   map.put(4,null);//值不允许为null
       // map.put(null,null);//键值都不允许为null
        Set keys = map.keySet();  //返回是一个set集合
        Iterator it = keys.iterator();  //迭代器：将keys中元素赋值给it变量
        //遍历出来结果是无序的
        while (it.hasNext())  ////hasNext:检查序列中是否还有元素
        {
            Object obj = it.next(); //使用next()获得序列中的下一个元素，即获取键
            System.out.println(obj+"="+map.get(obj));//get：获取某一个键对应的值
        }
    }
}

　　2）LinkeHasdMap：离散结构，有序，基于哈希表的Map接口实现，键和值都允许为Null，值可以重复，线程不安全（不同步）

public class hash02 {
    public static void main(String[] args)
    {
        //LinkeHasdMap：离散结构，有序，基于哈希表的Map接口实现，键和值都允许为Null，值可以重复，线程不安全（不同步）
        LinkedHashMap map = new LinkedHashMap();
        map.put(1,"北京");
        map.put(2,"武汉");
        map.put(3,"天津");
        map.put(6,"山西");
        map.put(null,"山西");
        map.put(4,null);//键允许为null
        map.put(null,null);//键值为null,替换前面的null，山西
        Set keys = map.keySet();  //返回是一个set集合
        Iterator it = keys.iterator();  //迭代器：将keys中元素赋值给it变量<br>　　　　　//遍历出来结果是有序的
        while (it.hasNext())  ////hasNext:检查序列中是否还有元素
        {
            Object obj = it.next(); //使用next()获得序列中的下一个元素，即获取键
            System.out.println(obj+"="+map.get(obj));//get：获取某一个键对应的值
 
        }
    }
}

　　HashMap：　　基于数组实现，无序，键和值可以为null

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
 
public class hash01 {
    public static void main(String[] args)
    {
        HashMap map = new HashMap();
        map.put(1,"北京");
        map.put(2,"武汉");
        map.put(3,"天津");
        map.put(6,"山西");
        map.put(null,"山西");
        map.put(4,null);//键允许为null
        map.put(null,null);//键值为null,替换前面的null，山西
        Set keys = map.keySet();  //返回是一个set集合
        Iterator it = keys.iterator();  //迭代器：将keys中元素赋值给it变量
        //遍历出来结果是无序的
        while (it.hasNext())  ////hasNext:检查序列中是否还有元素
        {
            Object obj = it.next(); //使用next()获得序列中的下一个元素，即获取键
            System.out.println(obj+"="+map.get(obj));//get：获取某一个键对应的值
        }
    }
}

　　3）TreeMap

　　基于红黑树（Red-Back tree）的NavigableMap实现，该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的Comparator进行排序，具体取决于使用的构造方法

　　特点：

　　键不允许为null，并且数据类型一致，值允许是null

　　实现自然排序

　　线程不安全（不同步）

import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
 
/**
 * Created by luochengjia on 2016/7/15.
 */
public class treemap05 {
    public static void main(String[] agrs)
    {
        TreeMap map = new TreeMap();
        map.put(1,"北京");
        map.put(2,"武汉");
        map.put(3,"天津");  //数据类型为：int
//        map.put(null,"天津"); 键不允许为null
        map.put(6,"山西");
//        map.put("6","山西");  键数据类型一致：字符串 String
        map.put(6,null);
        Set keys = map.keySet();  //返回是一个set集合
        Iterator it = keys.iterator();  //迭代器：将keys中元素赋值给it变量
        //遍历出来结果是按照输入时顺序进行排序
        while (it.hasNext())  ////hasNext:检查序列中是否还有元素
        {
            Object obj = it.next(); //使用next()获得序列中的下一个元素，即获取键
            System.out.println(obj+"="+map.get(obj));//get：获取某一个键对应的值
        }
    }
}