集合、遍历、Collections排序

package test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 集合
 * @author houst
 *
 */
public class CollectionsTest {



    public static void main(String[] args) {
        new CollectionsTest().CollectionsFn();
    }

    /*
     * Collection接口，是最基本的集合接口。List、Set接口都继承于Collection接口。
     * 
     * List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，
     * 能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，
     * 第一个元素的索引为 0，而且允许有相同的元素。采用线性链表的存储方式。
     * 
     * List接口的实现类主要是ArrayList以及LinkedList。
     * 
     * ArrayList该类是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，
     * 提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，
     * ArrayList插入删除效率低。
     * 
     * LinkedList该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，
     * 如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。
     * 例如：List list=Collections.synchronizedList(newLinkedList(...));
     * LinkedList查找效率低。
     * 
     * Set接口不保存重复的元素。其接口的实现类主要是HashSet以及TreeSet
     * 
     * HashSet类实现了Set接口，但是其不能保证元素的顺序，不允许出现重复的元素，并且允许有null元素，
     * 但是null元素必须是一个
     * 
     * TreeSet类也实现了Set接口，并且其可以对其中的元素进行排序。
     * 
     * Map接口是采用键值对的形式进行存储。其主要的实现类是HashMap以及TreeMap
     * 
     * HashMap是一个散列表的形式，根据键的hashCode值存储数据，具有很快的访问速度，
     * 最终只允许一条键的值为null，不支持线程同步。
     * TreeMap继承了AbstractMap，并且使用一颗树。
     * 
     * Collections是一个类，主要用于对集合的排序。
     * 
     */

    public void CollectionFn () {

        //ArrayList不是线程安全的，所以在多线程必须构造同步List, 单线程中就不需要
        List<String> list = Collections.synchronizedList(new ArrayList<String>());
        Set<String> set = new HashSet<>(); 
        Collection<String> c = new LinkedList<>();


        list.add("56");
        list.add("23");
        list.add("14");
        list.add("14");
        set.addAll(list);
        c.addAll(list);
        //遍历集合
        //迭代器：就是提供一种方法，该方法用于对容器中的各个元素进行访问，而又不暴露该容器的底层细节。
        Iterator<?> it = list.iterator();
        while (it.hasNext()) {
            String temp = (String) it.next();
            System.out.println(temp);
            //it.remove();
        }
        System.out.println(list.size());

        it = set.iterator();
        while (it.hasNext()) {
            String temp = (String) it.next();
            System.out.println(temp);
            //it.remove();
        }
        System.out.println(set.size());

        //对集合进行排序
        Collections.sort(list);

        //for循环遍历
        for (String str : list) {
            System.out.println(str);
        }

        Map<String, Integer> map = new HashMap<>(); 

        map.put("one", 1);
        map.put("two", 2);
        map.put("three", 3);

        //遍历
        //普遍使用，二次取值
        for(String str : map.keySet()) {
            System.out.println(str + "," + map.get(str));
        }

        //推荐，尤其是容量大时
        for (Map.Entry<String, Integer> mapEntry : map.entrySet()) {
            System.out.println(mapEntry.getKey() + "," + mapEntry.getValue());
        }

    }

    /*
     * 如果集合中的是对象，如本例的Persion类,要采用Collections对其进行排序。
     * 那么要对该类的对象进行比较，则该类必须实现Comparable接口。或者创建一个比较器类，该类必须实现
     * Comparator接口。
     * 
     * 两种方法各有优劣, 用Comparable 简单, 只要实现Comparable接口的对象直接就成为一个可以比较的对象,
     * 但是需要修改源代码, 用Comparator 的好处是不需要修改源代码, 而是另外实现一个比较器, 当某个自定义
     * 的对象需要作比较的时候,把比较器和对象一起传递过去就可以比大小了, 并且在Comparator 里面用户可以自
     * 己实现复杂的可以通用的逻辑,使其可以匹配一些比较简单的对象,那样就可以节省很多重复劳动了。
     * 
     */

    public void CollectionsFn () {
        Persion p1 = new Persion(11, "p1");
        Persion p2 = new Persion(12, "p2");
        Persion p3 = new Persion(13, "p3");

        List<Persion> linkedList = new LinkedList<>();
        linkedList.add(p2);
        linkedList.add(p3);
        linkedList.add(p1);

        Iterator<?> it = linkedList.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println(linkedList.size());

        //Persion 实现 Comparable接口
        //Collections.sort(linkedList);

        //创建PersonComparator比较器
        Collections.sort(linkedList, new PersonComparator());

        it = linkedList.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println(linkedList.size());
    }

}

//Persion类实现Comparable
class Persion implements Comparable<Persion>{

    private int age;
    private String name;


    public Persion(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return this.name + "," + age;
    }

    @Override
    public int compareTo(Persion persion) {
        if (this.age > persion.getAge()) {
            return 1;
        } else {
            return this.name.compareTo(persion.getName());
        }

    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

//构造比较器类
class PersonComparator implements Comparator<Persion> {
    @Override
    public int compare(Persion p1, Persion p2) {
        if (p1.getAge() > p2.getAge()) {
            return 1;
        } else {
            return p1.getName().compareTo(p2.getName());
        }
    }
}

1. ArrayList 一种可以动态增长和缩减的索引序列
2. LinkedList 一种可以在任意位置进行高效地插入和删除操作 的有序序列
3. ArrayDeque 一种用循数组实现的双端队列
4. HashSet 一种没有重复元素的无序集合
5. TreeSet 一种有序集
6. EnumSet 一种包含枚举类型的集
7. LinkedHahSet 一种可以记住元素插入次序的集
8. PriorityQueue 一种允许高效删除最小元素的集合
9. HashMap 一种存储键/值关联的数据结构
10. TreeMap 一种键值有序排列的映射表
11. EnumMap 一种键值属于枚举类型的映射表
12. LinkedHashMap 一种可以记住键值项添加次序的映射表
13. WeakHshMap 一种其值无用武之地后可以被垃圾回收器回收的映射表
14. IdentityHashMap 一种用==而不是用equals比较值得映射表

参考文章
Java 中Collection和Collections 、Comparable 和Comparator的区别
Java 集合框架