Java 集合类

一、Collection 接口

方法：

1. add(E e)
2. remove(Object o)
3. isEmpty()
4. iterator()
5. size()

子接口：List 和 Set

二、List 接口

继承：Collection接口，可使用其中搜友方法

自定义的重要方法：

1. get(int index)
2. set(int index,Object obj)

特点：

1. 有序，可通过索引访问
2. 可重复，可以添加重复的元素

实现类：

1. ArrayList 可变的数组，允许null，访问快，增删慢，线程不安全。
2. LinkedList 双向链表，访问慢，增删快，线程不安全 手写LinkedList
3. Vector 线程安全

List<String> a = new ArrayList<>();
a.add("a");
a.add("b");
a.set(1,"b1");
System.out.println(a);
// [a,b1]

三、Map接口

• 存储“键(key)-值(value) 对”,一一对应的关系，因此键不能重复，若重复，新的值会替代旧的值
• 哈希算法实现，查找、删除、修改效率高

方法：

1. put(K key,V value)
2. containsKey(Object key)
3. containsValue(Object value)
4. get(Object key)
5. keySet()
6. values()

实现类：

1. HashMap 允许使用null值和null键 不保证映射顺序
2. TreeMap 不允许null键 但集合映射具有一定顺序

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Vector;


public class testMap {
	void test1() {
		Map<Integer,String> m1 = new HashMap<>();
		
		m1.put(31,"1");
		m1.put(13,"3");
		m1.put(211,"2");
		m1.put(42,"4");
		m1.put(34,"5");
		m1.put(101,"6");
		
		Map<Integer,String> m2 = new TreeMap<>();
		m2.put(31,"1");
		m2.put(13,"3");
		m2.put(211,"2");
		m2.put(42,"4");
		m2.put(34,"5");
		m2.put(101,"6");
		
		System.out.println(m1);
		System.out.println(m2);
	}
    public static void main(String[] args) {
    	new testMap().test1();
	}
}

结果：

{34=5, 211=2, 101=6, 42=4, 13=3, 31=1} //无序
{13=3, 31=1, 34=5, 42=4, 101=6, 211=2}  //有序

• HashMap效率高于TreeMap;在需要排序的Map时才选用TreeMap。

四、Set接口

继承：Collection接口
方法：与Collection完全一致
特点：无序（没有索引，只能遍历查找）、不可重复（不能出现重复元素）
实现类：

1. HashSet 允许null元素 不保证迭代顺序
2. TreeSet 不允许使用null元素 通过实现Comparable接口做到内部的排序

HashSet例子：

public class Test {
    public static void main(String[] args) {
        Set<String> s = new HashSet<String>();
        s.add("hello");
        s.add("-");
        s.add("world");
        System.out.println(s);
        s.add("hello"); //相同的元素不会被加入
        System.out.println(s);
        s.add(null);
        System.out.println(s);
        s.add(null);
        System.out.println(s);
    }
}

结果：

[world, hello, -]
[world, hello, -]
[null, world, hello, -]
[null, world, hello, -]

• 打印出来每个元素的位置与添加的位置无关（不保证迭代顺序）
• 允许添加null元素，但最多添加一个，因为Set不允许重复。

TreeSet例子：

package Gaoqi300;

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class Test1 {
    public static void main(String[] args) {
        User u1 = new User(1001, "高淇", 18);
        User u2 = new User(2001, "高希希", 5);
        User u3 = new User(1599,"xxx",12);
        Set<User> set = new TreeSet<User>();
        set.add(u1);
        set.add(u2);
        set.add(u3);
        System.out.println(set);
        
        Iterator  iter =set.iterator();
        while(iter.hasNext()){
            Object  obj =  iter.next();
            System.out.println(obj);
        }
    }
}
 
class User implements Comparable<User> {
    int id;
    String uname;
    int age;
 
    public User(int id, String uname, int age) {
        this.id = id;
        this.uname = uname;
        this.age = age;
    }
    /**
     * 返回0 表示 this == obj 返回正数表示 this > obj 返回负数表示 this < obj
     */
    @Override
    public int compareTo(User o) {
        if (this.id > o.id) {
            return 1;
        } else if (this.id < o.id) {
            return -1;
        } else {
            return 0;
        }
    }
    
    public String toString() {
		return id+" "+age+" "+uname;
    }
}

运行结果：

[1001 18 高淇, 1599 12 xxx, 2001 5 高希希]
1001 18 高淇
1599 12 xxx
2001 5 高希希

• Set < User > set = new TreeSet< User >(); 尖括号里面的类必须实现Comparable接口，这样才能实现内部排序。

五、遍历集合

对于Set、List和Map都可使用Iterator迭代器

public class testSet {

     public static void main(String[] args) {
    	        Set<String> s = new HashSet<String>();
    	        s.add("hello");
    	        s.add("-");
    	        s.add("world");
    	        s.add("hello"); //相同的元素不会被加入
    	        s.add(null);
    	        s.add(null);
    	    
    	        for(Iterator iter= s.iterator();iter.hasNext();){
    	            String temp = (String)iter.next();
    	            System.out.println(temp);
    	        }
    	        
    	        Iterator iter = s.iterator();
    	        while(iter.hasNext()) {
    	        	String temp = (String)iter.next();
    	        	System.out.println(temp);
    	        }
    	    }
}

• 对于List，操作与以上类似
• 对于Map，如下：

根据Key值获取Value：

Map<Integer, Man> maps = new HashMap<Integer, Man>();
Set<Integer>  keySet =  maps.keySet();  //获取键
for(Integer id : keySet){
System.out.println(maps.get(id).name);
}

或 entrySet：

Set<Entry<Integer, Man>>  ss = maps.entrySet();
for (Iterator iterator = ss.iterator(); iterator.hasNext();) {
    Entry e = (Entry) iterator.next(); 
    System.out.println(e.getKey()+"--"+e.getValue());

除此之外，对于List，也可以结合循环和List的get()方法遍历集合：

for(int i=0;i<list.size();i++){//list为集合的对象名
    String temp = (String)list.get(i);
    System.out.println(temp);
}