集合

---

title: 集合

集合

Collection集合体系

1. List：只能存储Object类型的对象 有序，有下标(0~size()-1)，元素可重复
2. Set：

List（Collection的子接口）

1. 特点：只能存储Object类型的对象 有序，有下标(0~size()-1)，元素可重复

2. 实现类

   • ArrayList JDK1.2 数组实现 查询快，增删慢 线程不安全 效率高

   • LinkedList JDK1.2 链表实现 查询慢，增删快 线程不安全 效率高

   • Vector JDK1.0 数组实现 查询快，增删慢 线程安全 效率低

     

3. 遍历方法

   • 下标遍历

     for(int i=0;i<list.size();i++) {
     	 System.out.println(list.get(i));
     }
     

   • 迭代器遍历

     //迭代器遍历
     //首先获取迭代器对象
     Iterator itr = list.iterator();
     //hasNext();作用：判断集合中是否还有元素，有元素则返回true，否则返回false
     //next();作用：获取下一个集合元素
     while(itr.hasNext()) {
     	Object object = itr.next();
     	String string = (String)object;
     	System.out.println(string.toUpperCase());
     }
     

   • foreach遍历

     for(Object o:list) {
     	//System.out.println(o);
     	String str = (String)o;
     	System.out.println(str.toUpperCase());
     }
     

   • forEach方法遍历

     集合引用.forEach(Consumer c);
     调用forEach()方法需要传入一个实参-Consumer接口的实现类对象
     list.forEach(new Consumer() {
     	public void accept(Object t) {
     		System.out.println(t);
     	}
     });
     //Lambda形式
     list.forEach(t->System.out.println(t));
     

   • 遍历时删除元素，只能采用迭代器遍历，不能用foreach，但是最好不要再遍历时删除集合中的元素。集合删除元素后，后边元素会自动往前

   • 对集合中的元素进行排序，可以采用list.sort()方法，自己传入比较器

Set（Collection的子接口）

1. 特点：只能存储Object类型的数据，无序、无下标、元素不能重复

2. 实现类：

   • HashSet：数组+链表/红黑树 查询增删都快 JDK1.2 线程不安全 效率高
     • 注意：为了过滤掉重复元素，必须重写hashCode()方法和equals()方法
       • 重写hashCode()方法的要求：相同对象必须返回相同哈希码；不同对象尽量返回不同哈希码！

   

   • LinkedHashSet 数组+链表/红黑树 是HashSet的子类 查询快，增删慢 JDK1.2 线程不安全 效率高
   • 特点：可以维持添加顺序（集合内元素的获取顺序与添加顺序一致）

• 注意：集合元素类型若是自定义类型，必须重写hashCode()方法和equals()方法

• TreeSet 红黑树 SortedSet接口的实现类 JDK1.2 线程不安全 效率高

  • 特点：可以自动对集合内元素做排序，默认升序；自定义类型，需要实现Comparable接口，重写compareTo（）方法（排序规则）；或者，在创建TreeSet时，传入一个比较器Comparator实现类

3. 遍历方法

   • 迭代器遍历
   • forEach遍历
   • ForEach方法遍历

4. Set的底层是Map

Map集合

Map接口

1. 特点：存储任意的键值对(key-value),就是说集合中的每个元素都是有键（key）和值（value）组成

   • 键(key) 无序、无下标、不能重复 （若key为自定义类型，必须重写hashCode和equals方法）
   • 值(value) 无序、无下标、可以重复

2. 实现类

   • HashMap 哈希表 JDK1.2 线程不安全 效率高 允许键或值为null注意：键最多只有一个null,值可以有多个null
   • LinkedHashMap 哈希表+链表 HashMap的子类 JDK1.2 线程不安全 效率高 允许键或值为null
     • 特点：保证集合元素的获取顺序与添加顺序一致
   • TreeMap 红黑树 SortedMap接口的实现类 JDK1.2 线程不安全 效率高 不允许键值为null
     • 特点：可以自动根据key对集合键值对排序
     • key若是自定义类型，需要实现Comparable接口，重写compareTo()方法
   • Hashtable 哈希表 JDK1.0 线程安全 效率低 不允许键值为null
   • Properties HashTable的子类 JDK1.0 键和值只能为String类型，通常用于配置文件的读取

3. 遍历方式

   • 键遍历（将键放入一个Set集合中）

     //键遍历
     //1. 通过keySet()方法获取键的Set集合
     Set<String> keSet = map.keySet();
     //2. 对Set集合进行遍历
     for(String s:keSet) {
     	//3. 根据key获取value
     	String value = map.get(s);
     	System.out.println("key="+s+", value="+value);
     }
     

   • 值遍历

     //值遍历
     //1. 通过values()方法获取值的Collection集合
     Collection<String> values = map.values();
     //2. 对Collection集合遍历
     for(String s:values) {
     	System.out.println(s);
     }
     

   • 键值对遍历（将键和值看成一个整体，整体也是无序无下标不能重复，所以也可以放入一个Set集合）

     //键值对遍历
     //1. 通过entrySet()获取键值对的Set集合  
     //注意：此Set集合中元素的数据类型是  Map.Entry;也就意味着，Set中存的是一个又一个的Map.Entry对象
     Set<Map.Entry<String, String>> entrySet = map.entrySet();
     //2 遍历Set集合
     for(Map.Entry<String, String> o:entrySet) {
     	//3 根据getKey方法从o中获取key
     	String key = o.getKey();
     	//4 根据getValue方法从o中获取value
     	String value = o.getValue();
     	System.out.println("key="+key+", value="+value);
     }
     

   • forEach（）遍历

     //自遍历
     System.out.println("========自遍历=========");
     map.forEach(new BiConsumer<String, String>() {
     	@Override
     	public void accept(String t, String u) {
     		// TODO Auto-generated method stub
     		System.out.println("key="+t+", value="+u);
     	}
     });
     System.out.println("===========Lambda==============");
     //Lambda表达式
     map.forEach((a,b)->System.out.println("key="+a+", value="+b));
     

     }
     });
     System.out.println("=Lambda====");
     //Lambda表达式
     map.forEach((a,b)->System.out.println(“key=”+a+", value="+b));