14.集合框架

14.集合框架 14.集合框架

      集合框架是java做好的用来管理一堆各种类型数据的java类库

 

1.集合框架结构

         集合框架分为2大部分，Collection接口和Map接口。

        第一部分Collection接口是用来处理单列数据的集合，最大接口是Collection。Collection接口之下又有两个子接口：List接口和Set接口。List接口下子类ArrayList类和linkedList类。Set接口下子类HashSet类，再下linkedHashSet类。

       第二部分Map接口是用来处理键值对数据的集合，最大接口是Map接口。Map接口下有HashMap类和Hashtable类。

1.1 Collection接口

       用来处理单列数据的集合

1.1.1 List接口

       List接口是用来处理有序的单列数据，可以有重复的元素

1.1.1.1 ArrayList类

1. 用来处理有序的单列数据，可以有重复的元素
2. 添加的元素会自动扩展
3. 动态数组结构，查询速度快，添加删除速度慢

1.1.1.2 linkedList类

1. 用来处理有序的单列数据，可以有重复的元素
2. 添加的元素会自动扩展
3. 双向链表结构，查询速度慢，添加删除速度快

1.1.2 Set接口

      Set接口是用来处理无序的单列数据，没有重复的元素，重复的元素算一个。

1.1.2.1 Hashset类

      是用来处理无序的单列数据，没有重复的元素，重复的元素算一个

1.1.2.1.1 linkedHashSet

      是用来处理无序的单列数据，没有重复的元素，重复的元素算一个

1.2 Map接口

      用来处理键值对数据的集合，例如: name[键]=zhangsan[值]  

1.2.1 HashMap类

1. 用来处理键值对数据的集合
2. 允许有null，键和值都可以为null

1.2.2 Hashtable类

1. 用来处理键值对数据的集合
2. 不允许有null

1.2.3 TreeMap类

      红黑树基于NavigableMap实现【有序】

1.按照键的字母顺序排列

            2.键不能为null

            3.重复的键被算作是一个数据。

            4.非线程安全

1.2.4 ConcurrentHashMap

      支持检索的完全并发性和更新的高预期并发性的哈希表。 这个类服从相同功能规范如Hashtable ，并且包括对应于每个方法的方法版本Hashtable 。

2.ArrayList类

      1.用来处理有序的单列数据，可以有重复的元素。

      2.添加的元素会自动扩展。

      3.动态数组结构，查询速度快，添加删除速度慢

      构造方法：

ArrayList()

构造一个初始容量为10的空列表

ArrayList(Collection c)

通过实现Collection 接口的子类/子接口对象创建一个列表

ArrayList(int initialCapacity)

构造具有指定初始容量的空列表

      实例方法：

Boolean  add(Object o)

将指定的元素追加到此列表的末尾

Boolean  contains(Object o)

如果此列表包含指定的元素，则返回 true

Object    get(int index)

返回此列表中指定位置的元素

int  indexOf(Object o)

返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。

int  lastIndexOf(Object o)

返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。

Object  remove(int index)

删除该列表中指定位置的元素

boolean     remove(Object o)

从列表中删除指定元素的第一个出现（如果存在）【如果删数字，需要把数字封装】

Object  set(int index,Object  element)

用指定的元素替换此列表中指定

int  size()

返回此列表中的元素数

boolean     isEmpty()

如果此列表不包含元素，则返回 true

void     clear()

从列表中删除所有元素

Iterator      iterator()

以正确的顺序返回该列表中的元素的迭代器

最后一个迭代器方法

Iterator iterator() 以正确的顺序返回该列表中的元素的迭代器。

            Iterator it=list1.iterator();

            while (it.hasNext()) {

                  Object  obj=it.next();

                  System.out.println("Iterator迭代器---"+obj);

            }

hasNext()是有下一个，判断是否有下一个，为true执行next（），拿出下一个的值。

例：

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

public class ArrayListTest {

   public static void main(String[] args) {

      

      List list1 = new ArrayList();// 这是接口回调对象

      // 或者

      ArrayList alist1 = new ArrayList();

      // ArrayList(Collection c) 通过实现Collection 接口的子类/子接口对象创建一个列表

      ArrayList alist2 = new ArrayList(list1);

      List list2 = new ArrayList(list1);

      // ArrayList(int initialCapacity) 构造具有指定初始容量的空列表

      ArrayList alist3 = new ArrayList(30);

      List list3 = new ArrayList(30);

      // 实例方法

      // Boolean add(Object o) 将指定的元素追加到此列表的末尾

      list1.add("zhangjing");

      list1.add(666);

      list1.add(true);

      list1.add("zhangsan");

      list1.add("zhangjing");

      list1.add(56.98);

      // int size() 返回此列表中的元素数

      System.out.println(list1.size());

      // Boolean contains(Object o) 如果此列表包含指定的元素，则返回 true

      System.out.println(list1.contains(56.98));

      // Object get(int index) 返回此列表中指定位置的元素

      System.out.println(list1.get(4));

      // int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。

      System.out.println(list1.indexOf(666));

      System.out.println(list1.indexOf("weiwei"));// -1

      // int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。

   System.out.println(list1.lastIndexOf("zhangjing"));

      // Object remove(int index) 删除该列表中指定位置的元素

      System.out.println(list1.remove(2));

      System.out.println(list1.size());

      // boolean remove(Object o)从列表中删除指定元素的第一个出现（如果存在）

      System.out.println(list1.remove("zhangjing"));

      // Object set(int index,Object element) 用指定的元素替换此列表中指定

      System.out.println(list1.size());

      // boolean isEmpty() 如果此列表不包含元素，则返回 true

      System.out.println(list1.isEmpty());// false

      // void clear() 从列表中删除所有元素

      list1.clear();

      System.out.println(list1.size());



      list2.add("zhangjing");

      list2.add(666);

      list2.add(true);

      list2.add("zhangsan");

      list2.add("zhangjing");

      list2.add(56.98);

      // 遍历集合for循环，增强for循环，迭代器

      // Iterator iterator() 以正确的顺序返回该列表中的元素的c

      Iterator diedai = list2.iterator();

      while (diedai.hasNext()) {

          Object obj = diedai.next();

          System.out.println("iterator迭代器----" + obj);

      }

      // for循环，因为是有序的，所以可以用

      for (int i = 0; i < list2.size(); i++) {

          System.out.println("for循环---"+list2.get(i));

      }

      //增强for循环

      for(Object jihe:list2){

          System.out.println("增强for循环---"+jihe);

      }

   }

}

遍历输出结果：

iterator迭代器----zhangjing

iterator迭代器----666

iterator迭代器----true

iterator迭代器----zhangsan

iterator迭代器----zhangjing

iterator迭代器----56.98

for循环---zhangjing

for循环---666

for循环---true

for循环---zhangsan

for循环---zhangjing

for循环---56.98

增强for循环---zhangjing

增强for循环---666

增强for循环---true

增强for循环---zhangsan

增强for循环---zhangjing

增强for循环---56.98

3.linkedList类

      1.用来处理有序的单列数据，可以有重复的元素。

      2.添加的元素会自动扩展。

      3.双向链表结构，查询速度慢，添加删除速度快

  构造方法：

linkedList()

构造一个空列表

linkedList (Collection c)

通过实现Collection 接口的子类/子接口对象创建一个列表

      第2行意思是可以转换，比如把ArrayList转换为linkedList

 实例方法：

Boolean  add(Object o)

将指定的元素追加到此列表的末尾

Boolean  contains(Object o)

如果此列表包含指定的元素，则返回 true

Object    get(int index)

返回此列表中指定位置的元素

int  indexOf(Object o)

返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。

int  lastIndexOf(Object o)

返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。

Object  remove(int index)

删除该列表中指定位置的元素

boolean     remove(Object o)

从列表中删除指定元素的第一个出现（如果存在）

Object  set(int index,Object  element)

用指定的元素替换此列表中指定

int  size()

返回此列表中的元素数

boolean     isEmpty()

如果此列表不包含元素，则返回 true

void     clear()

从列表中删除所有元素

Iterator      iterator()

以正确的顺序返回该列表中的元素的迭代器

        多出一组对第一个元素和最后一个元素的 *** 作方法。因为ArrayList是动态数组结构，他在查找第一个元素和最后一个元素的时很麻烦，而linkedList采用的是双向链表结构，这种结构在查找第一个元素和最后一个元素的时候是最快的。就像一列火车我们眼前驶过，我们可能不知道这列火车由几节车厢组成，但是我们一定会在第一时间看清第一节与最后一节车厢位置。

void     addFirst(Object e)

在该列表开头插入指定的元素

void     addLast(Object  e)

将指定的元素追加到此列表的末尾

Object  getFirst()

返回此列表中的第一个元素

Object  getLast()

返回此列表中的最后一个元素

Object  removeFirst()

从此列表中删除并返回第一个元素

Object  removeLast()

从此列表中删除并返回最后一个元素

代码演示：

import java.util.Iterator;

import java.util.linkedList;

import java.util.List;



public class linkedListTest {



   public static void main(String[] args) {

      // linkedList() 构造一个空列表

      linkedList list1 = new linkedList();

      List list2=new linkedList();//或者接口回调，因为上一级是List

      // linkedList (Collection c) 通过实现Collection 接口的子类/子接口对象创建一个列表

      // 假设把ArrayList转换为linkedList

      

      //Boolean  add(Object o)  将指定的元素追加到此列表的末尾

      list1.add("zhangjing");

      list1.add(666);

      list1.add(true);

      list1.add("zhangsan");

      list1.add("zhangjing");

      list1.add(56.98);

      // int size() 返回此列表中的元素数

      System.out.println(list1.size());

      // Boolean contains(Object o) 如果此列表包含指定的元素，则返回 true

      System.out.println(list1.contains(56.98));

      // Object get(int index) 返回此列表中指定位置的元素

      System.out.println(list1.get(4));

      // int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。

      System.out.println(list1.indexOf(666));

      System.out.println(list1.indexOf("weiwei"));// -1

      // int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。

      System.out.println(list1.lastIndexOf("zhangjing"));

      // Object remove(int index) 删除该列表中指定位置的元素

      System.out.println(list1.remove(2));

      System.out.println(list1.size());

      // boolean remove(Object o)从列表中删除指定元素的第一个出现（如果存在）

      System.out.println(list1.remove("zhangjing"));

      // Object set(int index,Object element) 用指定的元素替换此列表中指定

      System.out.println(list1.size());

      // boolean isEmpty() 如果此列表不包含元素，则返回 true

      System.out.println(list1.isEmpty());// false

      // void clear() 从列表中删除所有元素

      list1.clear();

      System.out.println(list1.size());



      list2.add("zhangjing");

      list2.add(666);

      list2.add(true);

      list2.add("zhangsan");

      list2.add("zhangjing");

      list2.add(56.98);

      // 遍历集合for循环，增强for循环，迭代器

      // Iterator iterator() 以正确的顺序返回该列表中的元素的c

      Iterator diedai = list2.iterator();

      while (diedai.hasNext()) {

          Object obj = diedai.next();

          System.out.println("iterator迭代器----" + obj);

      }

      // for循环，因为是有序的，所以可以用

      for (int i = 0; i < list2.size(); i++) {

          System.out.println("for循环---"+list2.get(i));

      }

      //增强for循环

      for(Object jihe:list2){

          System.out.println("增强for循环---"+jihe);

      }

      

      //list2.addFirst();//报错，list2是父类的，而这个方法是它独有的，因此必须用linkedList的构造

      linkedList list3 = new linkedList();

      list3.add("zhangjing");

      list3.add(666);

      list3.add(true);

      list3.add("zhangsan");

      list3.add("zhangjing");

      list3.add(56.98);

      list3.addFirst(1717);

      list3.addLast("一起呀");

      System.out.println(list3.getFirst());//1717

      System.out.println(list3.getLast());//一起呀

      list3.removeFirst();

      list3.removeLast();

      System.out.println(list3.size());//6 

   }

}

4. HashSet类

       用来处理无序的单列数据，没有重复的元素，重复的元素算一个。

构造方法：

HashSet（）

构造一个新的空集合；默认初始容量（16）和负载因子（0.75）

HashSet (Collection c)

构造一个包含指定集合中的元素的新集合

HashSet（int initialCapacity）

构造一个新的空集合；具有指定的初始容量和默认负载因子

HashSet（int initialCapacity，float loadFactor）

构造一个具有指定的初始容量和指定的负载因子

实例方法：因为无序，因此没有有序的 *** 作方法

boolean  add(Object o)

将指定的元素追加到此集合中（如果尚未存在）

void     clear()

从列表中删除所有元素

boolean     isEmpty()

如果此列表不包含元素，则返回 true

Boolean contains(Object o)

如果此集合包含指定的元素，则返回 true

Iterator      iterator()

返回该列表中的元素的迭代器

int  size()

返回此列表中的元素数（重复的算一个）

boolean     remove(Object o)

如果存在，则从该集合中删除指定的元素

例：

import java.util.HashSet;

import java.util.Iterator;



public class HashSetTest {



   public static void main(String[] args) {

      // 构造一个默认初始容量16的空集合

      HashSet hashset = new HashSet();

      hashset.add("吴");

      hashset.add(66);

      hashset.add(true);

      hashset.add(98.9);

      hashset.add(66);

      hashset.add("吴");

      hashset.add('K');

      // int size()返回此列表中的元素数（重复的算一个）

      System.out.println(hashset.size());// 5

      // boolean isEmpty()如果此列表不包含元素，则返回 true

      System.out.println(hashset.isEmpty());// false

      // Boolean contains(Object o)如果此集合包含指定的元素，则返回 true

      System.out.println(hashset.contains("吴"));// true

      System.out.println(hashset.contains("张"));// false

      

      //boolean remove(Object o) 如果存在，则从该集合中删除指定的元素

      System.out.println(hashset.remove("吴"));

      System.out.println(hashset.size());//4

      //Iterator   iterator()   返回该列表中的元素的迭代器

      Iterator iterator=hashset.iterator();

      while(iterator.hasNext()){

          Object obj = iterator.next();

          System.out.println("iterator迭代器----"+obj);

      }

      //for循环不能使用，因为无序

      //增强for循环

      for(Object obj: hashset){

          System.out.println("增强for循环=="+obj);

      }

      System.out.println(hashset);

   }

}

5.linkedHashSet类

      哈希表和链表实现了Set接口，具有可预测的迭代次序。这种实现不同于HashSet，它维持于所有条目的运行双向链表。因为linkedHashSet类是HashSet类的子类，因此会从父类继承集合数据的 *** 作方法，所以只要我们会HashSet类使用，那么linkedHashSet类不用学也会用

构造方法：

LikedHashSet（）

构造一个新的空集合；默认初始容量（16）和负载因子（0.75）

LikedHashSet (Collection c)

构造一个包含指定集合中的元素的新集合

LikedHashSet（int initialCapacity）

构造一个新的空集合；具有指定的初始容量和默认负载因子

LikedHashSet（int initialCapacity，float loadFactor）

构造一个具有指定的初始容量和指定的负载因子

实例方法：因为无序，因此没有有序的 *** 作方法

boolean  add(Object o)

将指定的元素追加到此集合中（如果尚未存在）

void     clear()

从列表中删除所有元素

boolean     isEmpty()

如果此列表不包含元素，则返回 true

Boolean contains(Object o)

如果此集合包含指定的元素，则返回 true

Iterator      iterator()

返回该列表中的元素的迭代器

int  size()

返回此列表中的元素数（重复的算一个）

boolean     remove(Object o)

如果存在，则从该集合中删除指定的元素

例：

import java.util.Iterator;

import java.util.linkedHashSet;



public class linkedHashSetTest {



   public static void main(String[] args) {

      // 构造一个默认初始容量16的空集合

      linkedHashSet linkedhashset = new linkedHashSet();

      linkedhashset.add("吴");

      linkedhashset.add(66);

      linkedhashset.add(true);

      linkedhashset.add(98.9);

      linkedhashset.add(66);

      linkedhashset.add("吴");

      linkedhashset.add('K');

      // int size()返回此列表中的元素数（重复的算一个）

      System.out.println(linkedhashset.size());// 5

      // boolean isEmpty()如果此列表不包含元素，则返回 true

      System.out.println(linkedhashset.isEmpty());// false

      // Boolean contains(Object o)如果此集合包含指定的元素，则返回 true

      System.out.println(linkedhashset.contains("吴"));// true

      System.out.println(linkedhashset.contains("张"));// false

      

      //boolean remove(Object o) 如果存在，则从该集合中删除指定的元素

      System.out.println(linkedhashset.remove("吴"));

      System.out.println(linkedhashset.size());//4

      //Iterator   iterator()   返回该列表中的元素的迭代器

      Iterator iterator=linkedhashset.iterator();

      while(iterator.hasNext()){

          Object obj = iterator.next();

          System.out.println("iterator迭代器----"+obj);

      }

      //for循环不能使用，因为无序

      //增强for循环

      for(Object obj:linkedhashset){

          System.out.println("增强for循环=="+obj);

      }

      System.out.println(linkedhashset);

     

   }

}

           

6.HashMap类

（1）允许null值和null键

（2）数据的保存是无序的

（3）重复的键被算作是一个数据

（4）线程不安全

构造方法：

HashMap（）

构造一个新HashMap,默认初始容量（16）和负载因子（0.75）

HashMap (Map m)

构造一个新的 HashMap与指定的相同的映射 Map

HashMap（int initialCapacity）

构造一个新的空HashMap，具有指定的初始容量和默认负载因子

HashMap（int initialCapacity，float loadFactor）

构造一个HashMap具有指定的初始容量和指定的负载因子

实例方法：

void   clear()

清空集合

Object  put(Object key,Object value)

向集合中添加键值对数据

boolean     containsKey(Object key)

判断集合中是否包含指定的键

Boolean  containsValue(Object value)

判断集合中是否包含指定的值

Object  get(Object key)

根据指定的键得到该键对应的值

boolean     isEmpty()

判断集合是否为空

int  size()

得到集合中键值对元素的个数

V    remove(Object key)

根据指定的键删除对应的键值对数据值

Set keySet()

得到集合中所有的键保存到Set集合中

Collection   values()

得到集合中所有的值保存到Collection集合中

Set> entrySet()

得到集合中所有的键值对数据保存到Set集合中

例：

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;



public class HashMapTest {



   public static void main(String[] args) {

      // HashMap（） 构造一个新HashMap,默认初始容量（16）和负载因子（0.75）

      HashMap map1 = new HashMap();

      Map map11 = new HashMap();

      // HashMap（int initialCapacity） 构造一个新的空HashMap，具有指定的初始容量和默认负载因子

      HashMap map2 = new HashMap(30);

      Map map22 = new HashMap(30);

      // HashMap（int initialCapacity，float loadFactor）

      // 构造一个HashMap具有指定的初始容量和指定的负载因子

      HashMap map3 = new HashMap(30, 0.8f);

      Map map33 = new HashMap(30, 0.8f);

      // HashMap (Map m) 构造一个新的 HashMap与指定的相同的映射 Map

      HashMap map4 = new HashMap(map1);

      Map map44 = new HashMap(map1);

      

      // Object put(Object key,Object value) 向集合中添加键值对数据

      map1.put("name", "zhangsan");

      map1.put(true, 9.9);

      map1.put('B', 88);

      map1.put(null, false);

      map1.put(true, null);// 重复的键算作一个数据

      // 上面说明HashMap键值对，键和值可以任意类型

      System.out.println(map1);// {null=false, B=88, name=zhangsan, true=null}

      System.out.println(map1.size());// 4

      // boolean containsKey(Object key) 判断集合中是否包含指定的键

      // Boolean containsValue(Object value) 判断集合中是否包含指定的值

      System.out.println("key--hello存在---" + map1.containsKey("hello"));

      System.out.println("key--true存在---" + map1.containsKey(true));

      System.out.println("value--true存在---" + map1.containsValue(true));

      System.out.println("value--88存在---" + map1.containsValue(88));

      // Object get(Object key)根据指定的键得到该键对应的值

      System.out.println("name===" + map1.get("name"));// 只能根据键得到值

      // remove(Object key) 根据指定的键删除对应的键值对数据值

      map1.remove(true);

      System.out.println(map1);// {null=false, B=88, true=null}



      // Set keySet() 得到集合中所有的键保存到Set集合中

      Set setkey=map1.keySet();

      System.out.println(setkey);//[null, B, name]

      //遍历一下键的集合

      for(Object obj:setkey){

          System.out.println("增强for循环遍历键==="+obj);

      }

      //也可以迭代器，Set接口有迭代器

      Iterator iterator1 = setkey.iterator();

      while(iterator1.hasNext()){

          Object obj1 = iterator1.next();

          System.out.println("迭代器键==="+obj1);

      }

     

      // Collection values() 得到集合中所有的值保存到

      Collection values = map1.values();

      //遍历一下值的集合

          for(Object obj1:values){

             System.out.println("增强for循环遍历值==="+obj1);

          }

         

          Iterator iterator2 = values.iterator();

          while(iterator2.hasNext()){

             Object obj2 = iterator2.next();

             System.out.println("迭代器值==="+obj2);

          }

      // Collection集合中 Set> entrySet() 得到集合中所有的键值对数据保存到Set集合中

      //此方法遍历键值对

          Set> set1 = map1.entrySet();

          for(Map.Entry entry:set1){

             System.out.println("键值对"+entry.getKey()+":"+entry.getValue());

          }

  

          Set set2 = map1.entrySet();

          for(Object entry:set2){

             System.out.println("键值对"+entry);

          } 

      }

}

7.Hashtable类

（1）不允许null值和null键

（2）数据的保存是无序的

（3）重复的键被算作是一个数据

（4）用作键的对象必须实现hashCode方法和equals方法

（5）线程安全

构造方法：

Hashtable（）

构造一个新的，空的散列表，默认初始容量（11）和负载因子（0.75）

Hashtable (Map m)

构造一个与给定地图相同的映射的新哈希表

Hashtable（int initialCapacity）

构造一个新的,空的哈希表,具有指定的初始容量和默认负载因子0.75

Hashtable（int initialCapacity，float loadFactor）

构造一个新的，空的哈希表，具有指定的初始容量和指定的负载因子。

实例方法：

void   clear()

清空集合

Object  put(Object key,Object value)

向集合中添加键值对数据

boolean     containsKey(Object key)

判断集合中是否包含指定的键

Boolean  containsValue(Object value)

判断集合中是否包含指定的值

Object  get(Object key)

根据指定的键得到该键对应的值

boolean     isEmpty()

判断集合是否为空

int  size()

得到集合中键值对元素的个数

V    remove(Object key)

根据指定的键删除对应的键值对数据值

Set keySet()

得到集合中所有的键保存到Set集合中

Collection   values()

得到集合中所有的值保存到Collection集合中

Set> entrySet()

得到集合中所有的键值对数据保存到Set集合中

Enumeration   keys()

返回此散列表中键的枚举

Enumeration   elements()

返回此散列表中值的枚举

例：

import java.util.Collection;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;



public class HashtableTest {



   public static void main(String[] args) {

      Hashtable table1 = new Hashtable();

      

      table1.put("name", "zhangsan");

      table1.put(true, 9.9);

      table1.put('B', 88);

      // table1.put(null, false);不能有null

      // table1.put(true, null);不能有null

      table1.put('B', 66);

      System.out.println(table1.size());// 3

      System.out.println(table1);// {true=9.9, name=zhangsan, B=66}

      // 遍历

      // Set keySet() 得到集合中所有的键保存到Set集合中

      Set setkey = table1.keySet();

      System.out.println(setkey);//

      // 遍历一下键的集合

      for (Object obj : setkey) {

          System.out.println("增强for循环遍历键===" + obj);

      }

      // 也可以迭代器，Set接口有迭代器

      Iterator iterator1 = setkey.iterator();

      while (iterator1.hasNext()) {

          Object obj1 = iterator1.next();

          System.out.println("迭代器键===" + obj1);

      }



      // Collection values() 得到集合中所有的值保存到

      Collection values = table1.values();

      // 遍历一下值的集合

      for (Object obj1 : values) {

          System.out.println("增强for循环遍历值===" + obj1);

      }



      Iterator iterator2 = values.iterator();

      while (iterator2.hasNext()) {

          Object obj2 = iterator2.next();

          System.out.println("迭代器值===" + obj2);

      }

      // Collection集合中 Set> entrySet() 得到集合中所有的键值对数据保存到Set集合中

      // 此方法遍历键值对

      Set> set1 = table1.entrySet();

      for (Map.Entry entry : set1) {

          System.out.println("键值对" + entry.getKey() + ":" + entry.getValue());

      }

      Set set2 = table1.entrySet();

      for (Object entry : set2) {

          System.out.println("键值对" + entry);

      }

   }

}

8.TreeMap类

            1.输出是按照键的字母顺序排列                

            2.键不能为null

            3.重复的键被算作是一个数据。

            4.非线程安全

      构造方法：

      TreeMap() 使用其键的自然排序构造一个新的空树状图。

      TreeMap(Map m) 构造一个新的树状图，其中包含与给定地图相同的映射，根                  据其键的自然顺序进行排序 。

      实例方法:

      void     clear() 清空集合。

      Object put(Object key, Object value) 向集合中添加键值对数据

      boolean      containsKey(Object key) 判断集合中是否包含指定的键

      boolean      containsValue(Object value) 判断集合中是否包含指定的值

      Object  get(Object key) 根据指定的键得到该键对应的值

      boolean      isEmpty() 判断集合是否为空。

      int  size() 得到集合中键值对元素的个数

      V    remove(Object key)  根基指定的键删除对应的键值对数据值

      Set  keySet() 得到集合中所有的键保存到Set集合中

      Collection   values() 得到集合中所有的值保存到Collection集合中

      Set> entrySet() 得到集合中所有的键值对数据Set集合中      HashMap的方法TreeMap都可以

9.区别 9.1 ArrayList类与数组的区别

ArrayList类

数组

元素类型没有限制

都是同一种类型

存储空间会自动扩展

数组的存储空间设置后是固定的

9.2 ArrayList类与linkedList类的区别

ArrayList类

linkedList类

动态数组结构

双向链表结构

添加删除速度慢，查询速度快

添加删除速度快，查询速度慢

没有提供对第一个元素和最后一个元素的 *** 作

提供对第一个元素和最后一个元素的 *** 作

适合大量查询 *** 作

适合大量添加删除 *** 作

有初始容量为10

没有初始容量

每次扩容后的大小为之前的1.5倍

没有扩容机制

9.3 HashSet和linkedHashSet区别

      HashSet在遍历输出的时候无序（不是按插入的顺序输出的），而linkedHashSet在遍历输出的时候按照插入顺序输出。

9.4 List接口与Set接口区别

List接口

Set接口

有序

无序

可以有重复数据

重复的数据算一个

9.5 Collection接口与Map接口区别

Collection接口

Map接口

处理单列数据的顶级接口

处理键值对数据的顶级接口

可以使用迭代器接口iterator遍历

没有迭代器iterator接口

9.6 HashMap类和Hashtable类区别

HashMap类

Hashtable类

可以有null键和null值

不可以有null

默认初始容量16

默认初始容量11

线程不安全

线程安全

9.7 HashMap类和Hashtable类、TreeMap类、ConcurrentHashMap类区别

HashMap类

Hashtable类

TreeMap类

ConcurrentHashMap类

无序

无序

输出是按字母顺序

线程不安全

线程安全

线程不安全

线程安全

访问速度快

访问速度慢

访问速度快

访问速度慢

并发，分布式