Java集合

 

 

List、Map、Set的区别与联系
一、结构特点
     1.List和Set是存储单列数据的集合，Map是存储键值对这样的双列数据的集合；
     2.List中存储的数据是有顺序的，并且值允许重复；Map中存储的数据是无序的，它的键是不允许重复的，但是值是允许重复            的；Set中存储的数据是无顺序的，并且不允许重复，但元素在集合中的位置是由元素的hashcode决定，即位置是固定的            （Set集合是根据hashcode来进行数据存储的，所以位置是固定的，但是这个位置不是用户可以控制的，所以对于用户来说             set中的元素还是无序的）。
二、实现类
List接口有三个实现类： 
       1.1 LinkedList 
             基于链表实现，链表内存是散列的，增删快，查找慢； 
      1.2 ArrayList 
           基于数组实现，非线程安全，效率高，增删慢，查找快； 
      1.3 Vector 
           基于数组实现，线程安全，效率低，增删慢，查找慢；
Map接口有四个实现类： 
      2.1 HashMap 
         基于 hash 表的 Map 接口实现，非线程安全，高效，支持 null 值和 null 
          键； 
     2.2 HashTable 
         线程安全，低效，不支持 null 值和 null 键； 
     2.3 LinkedHashMap 
        是 HashMap 的一个子类，保存了记录的插入顺序； 
     2.4 SortMap 接口 
         TreeMap，能够把它保存的记录根据键排序，默认是键值的升序排序

Set接口有两个实现类： 
      3.1 HashSet 
            底层是由 Hash Map 实现，不允许集合中有重复的值，使用该方式时需要重写 equals()和 hash Code()方法； 
     3.2 LinkedHashSet 
           继承于 HashSet，同时又基于 LinkedHashMap 来进行实现，底层使用的是 LinkedHashMap

三. 区别
       1. List 集合中对象按照索引位置排序，可以有重复对象，允许按照对象在集合中的索引位置检索对象，例如通过list.get(i)方                 法来获取集合中的元素；
      2. Map 中的每一个元素包含一个键和一个值，成对出现，键对象不可以重复，值对象可以重复；
      3. Set 集合中的对象不按照特定的方式排序，并且没有重复对象，但它的实现类能对集合中的对象按照特定的方式排序， 例            如 Tree Set 类，可以按照默认顺序，也可以通过实现 Java.util.Comparator< Type >接口来自定义排序方式。

   

---

List
1.可以允许重复的对象。

2.可以插入多个null元素。

3.是一个有序容器，保持了每个元素的插入顺序，输出的顺序就是插入的顺序。

4.常用的实现类有 ArrayList、LinkedList 和 Vector。ArrayList 最为流行，它提供了使用索引的随意访问，而 LinkedList 则对于经常需要从 List 中添加或删除元素的场合更为合适。

---

Set
1.不允许重复对象
2. 无序容器，你无法保证每个元素的存储顺序，TreeSet通过 Comparator  或者 Comparable 维护了一个排序顺序。
3. 只允许一个 null 元素
4.Set 接口最流行的几个实现类是 HashSet、LinkedHashSet 以及 TreeSet。最流行的是基于 HashMap 实现的 HashSet；TreeSet 还实现了 SortedSet 接口，因此 TreeSet 是一个根据其 compare() 和 compareTo() 的定义进行排序的有序容器。
 

---

map
1.Map不是collection的子接口或者实现类。Map是一个接口。
2.Map 的 每个 Entry 都持有两个对象，也就是一个键一个值，Map 可能会持有相同的值对象但键对象必须是唯一的。
3. TreeMap 也通过 Comparator  或者 Comparable 维护了一个排序顺序。
4. Map 里你可以拥有随意个 null 值但最多只能有一个 null 键。
5.Map 接口最流行的几个实现类是 HashMap、LinkedHashMap、Hashtable 和 TreeMap。（HashMap、TreeMap最常用）
 

---

4 补充：HashMap 和 HashTable
HashMap 是线程不安全的,HashMap 是一个接口,是 Map的一个子接口,是将键映射到值得对象,不允许键值重复,允许空键和空值;由于非线程安全, HashMap的效率要较 HashTable 的效率高一些. 
HashTable 是线程安全的一个集合,不允许 null 值作为一个 key 值或者 Value 值; 
HashTable 是 sychronize(同步化),多个线程访问时不需要自己为它的方法实现同步,而 HashMap 在被多个线程访问的时候需要自己为它的方法实现同步;

 

 

java中List、Set、Map集合的遍历方法总结

package cn.gts.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.junit.Test;

/**
 * 测试set、List、map的遍历方式
 * @author gts
 */

public class BianLiCollection { 
        /*
         * 第一种方式遍历Set
         * 迭代器Iterator
         */
        @Test
        public void testIteratorSet(){
            Set<String> set1 = new HashSet<String>();
            set1.add("aaaa");
            set1.add("bbbb");
            set1.add("cccc");
            System.out.println("iterator迭代器遍历set集合");
            Iterator<String> itr = set1.iterator();
            while(itr.hasNext()){
                String str = itr.next();
                System.out.println(str);
            }
        }   
        /*
         * 第二种方式遍历set
         *增强for遍历 （set中不存在下标）
         */
        @Test
        public void testForeachSet(){
            Set<String> set2 = new HashSet<String>();
            set2.add("dddd");
            set2.add("ffff");
            set2.add("gggg");
            System.out.println("增强for遍历set集合");
            for (String string : set2) {
                System.out.println(string);
            }
        }       
        /**
         * 遍历List集合
         * 1、通过下标遍历（简单for循环）
         */
        @Test
        public void testList1(){
            List<String> list = new ArrayList<String>();
            list.add("dsadsa");
            list.add("wdesds");
            list.add("sdsfsa");
            System.out.println("通过下标遍历list");
            for(int i = 0;i<list.size();i++){
                System.out.println(list.get(i));
            }
        }
        /**
         * 遍历List集合
         * 2、通过iterator迭代器遍历
         */
        @Test
        public void testList2(){
            List<String> list = new ArrayList<String>();
            list.add("dsadsa");
            list.add("wdesds");
            list.add("sdsfsa");
            System.out.println("通过iterator迭代器遍历list");
            Iterator<String> itr = list.iterator();
            while(itr.hasNext()){
                System.out.println(itr.next());
            }
        }

        /**
         * 遍历List集合
         * 3、通过增强for遍历
         */
        @Test
        public void testList3(){
            List<String> list = new ArrayList<String>();
            list.add("dsadsa");
            list.add("wdesds");
            list.add("sdsfsa");
            System.out.println("通过foreach迭代器遍历list");
            for (String string : list) {
                System.out.println(string);
            }
        }


        /**
         * 遍历map
         */
        @Test
        public void testMap(){
            Map<String, String> map = new HashMap<String, String>();
            map.put("zhanSan", "学习Java");
            map.put("liSi", "学习.net");
            map.put("Lucy", "学习c#");
            map.put("Mary", "学习数据库");

            //1、通过Map.keySet遍历
            System.out.println("通过Map.keySet遍历key和value：");
            for (String key : map.keySet()) {
             System.out.println("name= "+ key +">>>"+ "简介= " + map.get(key));
            }

            //2、通过map.entrySet遍历,foreach
            System.out.println("通过map.entrySet遍历");
            for (Entry<String, String> entry : map.entrySet()) {
                System.out.println("name="+entry.getKey()+">>>"+"简介="+entry.getValue() );
            }
            //3、使用Iterator遍历（不使用使用泛型）（不常用）
            System.out.println("使用Iterator遍历不使用泛型");
            Iterator iterator = map.entrySet().iterator();
            while(iterator.hasNext()){
                Entry entry = (Entry) iterator.next();
                String name = (String) entry.getKey();
                String msg = (String) entry.getValue();
                System.out.println("name="+name+">>>"+"简介="+msg);
            }
            //4、使用Iterator遍历（使用泛型）（常用）
            System.out.println("使用Iterator遍历使用泛型");
            Iterator<Entry<String, String>> itr = map.entrySet().iterator();
            while(itr.hasNext()){
                Entry<String, String> entry = itr.next();
                System.out.println("name="+entry.getKey()+">>>"+"简介="+entry.getValue());
            }   
        }   
}