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）[b]Hashtable：[b]无序、[/b]基于哈希表的Map接口实现，顺序结构，键和值都不容许是null，值可重复，线程安全，同步，[/b]　　

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）[b][b]LinkeHasdMap：离散结构，有序，基于哈希表的Map接口实现，键和值都允许为Null，值可以重复，线程不安全（不同步）[/b][/b]

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变量
　　　　　//遍历出来结果是有序的
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：获取某一个键对应的值
}
}
}