Java集合Collection使用(Map，List，Set)和迭代器Iterator

Collection接口

Java不提供直接继承自Conllection，只提供继承于的子接口

Map

Map存储的是一组键值对象，提供key到value的映射，而且是无序的。相同的key只能对应一个value，一个value可以对应多个key。

使用例子和遍历Map的四种方法(例子中涉及到迭代器，如有不懂往下滚先看迭代器)

public class MapTest {

    public static void main(String[] args) {

        //HashMap是无序的
        Map<String,Double> map = new HashMap<String,Double>();
        map.put("One",1000.0);
        map.put("Two",2000.0);
        map.put("Three",3000.0);
        map.put("Four",1000.0);

        //根据key获取value
        map.get("One");
        //判断key是否存在
        map.containsKey("Key");
        //判断有没有该value存在
        map.containsValue(1000.0);
        //将map中的所有key以数组形式输出
        map.keySet();
        //将map中的所有value以数组形式输出
        map.values();

        /**
         * 遍历Map方法，有四种
         */
        //一：此遍历方法需要判断map是否为空。
        if (map.size() != 0 ||  map != null){
            Set<Map.Entry<String, Double>> entries = map.entrySet();
            for (Map.Entry<String, Double> entry : entries) {
                System.out.println(entry.getKey()+":"+entry.getValue());
            }
        }else {
            System.out.println("Map为空");
        }

        //二：如果只需要map中的key或value 直接遍历即可。
        for (Double value : map.values()) {
            System.out.println("Values:"+value);
        }

        for (String s : map.keySet()) {
            System.out.println("Keys:"+s);
        }

        //三：使用迭代器Iterator遍历（效率最高）且能够使用迭代器的.remove方法循环进行删除。 使用泛型
        Iterator<Map.Entry<String,Double>> entryIterator = map.entrySet().iterator();
        while (entryIterator.hasNext()){
            Map.Entry<String,Double> entry = entryIterator.next();
            System.out.println("Key:"+entry.getKey()+",Value:"+entry.getValue());
        }

        //四：不使用泛型
        Iterator entries = map.entrySet().iterator();
        while (entries.hasNext()){
            Map.Entry entry = (Map.Entry)entries.next();

            String key = (String) entry.getKey();
            Double value = (Double)entry.getValue();
            System.out.println("key="+key+",value="+value);

        }


    }
}

Set

set不保存重复的元素

set使用例子

public class SetTest {

    public static void main(String[] args) {
        //set是无序集合 数据不能重复添加
        Set<Date> set = new HashSet<Date>();

        Date a = new Date(1568185516330L);
        Date b = new Date(1568185616330L);
        Date c = new Date(1568185716330L);
        Date d = new Date(1568185816330L);

        set.add(a);
        set.add(b);
        set.add(c);
        //使用add方法，返回值是一个布尔值，如果插入的值是已经存在的，则会返回false
        boolean b1 = set.add(d);
        //移除
        set.remove(a);
        //判断是否为空
        set.isEmpty();

        //循环遍历
        for (Date date : set) {
            System.out.println(date);
        }

    }
}

List

List存储的是一组不唯一，有序(插入顺序)的对象，因此能够通过索引对list进行操作

使用例子：

public class ListTest {

    public static void main(String[] args) {

        //声明一个集合，里面全是字符串--------
        List<String> list = new ArrayList<String>();
        list.add("String1");//0
        list.add("String2");//1
        list.add("String3");//2
        list.add("String4");//3


        //list.for --快捷健循环
        for (String s : list){
            System.out.println(s);
        }

        //通过索引进行移除
        list.remove(1);
        //查看list集合大小
        list.size();
        //通过索引获取值
        list.get(1);
        //清空list
        list.clear();
        System.out.println(list.size());
    }
}

迭代器Iterator

该类主要用于遍历集合对象

使用迭代器进行遍历

public static void main(String[] args) {
		ArrayList list = new ArrayList();
		// 增加：add() 将指定对象存储到容器中
		list.add("String1");
		list.add("String2");
		list.add("String3");
		list.add("String4");
		list.add("String5");
		System.out.println(list);
		Iterator it = list.iterator();
        //使用while进行循环
		while (it.hasNext()) {
			String next = (String) it.next();
			System.out.println(next);
		}
        //使用for循环
        for (Iterator it1 = list.iterator(); it1.hasNext();) {
			String next = (String) it1.next();
			System.out.println(next);
		}
        
        //使用迭代器清空集合
        while (it.hasNext()) {
			it.next();
			it.remove();
		}
		System.out.println(it);
        
	}

在调用remove之前需要调用next，否则会出现异常。