Java 集合框架

//集合框架
public static void main(String[] args) {
    //集合框架下 分 Collection map
    // Collection  3 种子类型，List、Set 和 Queue
    //List代表了有序可重复集合，可直接根据元素的索引来访问；
    //常用的list实现类 LinkedList ArrayList Vector
    //LinkedList  内部以链表的形式保存集合中的元素，所以随机访问集合中的元素性能较差，但在插入删除元素时有较好的性能。
    // 链表 是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。
    LinkedList<String> linkedList = new LinkedList();
    linkedList.add("Google");
    linkedList.add("Runoob");
    linkedList.add("Taobao");
    linkedList.add("Weibo");
    System.out.println(linkedList);
    //使用LinkedList 的场景
    //头部添加元素
    linkedList.addFirst("头部");
    linkedList.add(2,"中间");
    linkedList.addLast("wei部");
    System.out.println(linkedList);
    linkedList.removeFirst();
    linkedList.remove(1);
    linkedList.removeLast();
    System.out.println(linkedList);
    for (String i : linkedList) {
        System.out.println(i);
    }
    System.out.println("-----------------------------------ArrayList--------------------------------");
    //ArrayList  是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制
    ArrayList<String> arrayList = new ArrayList();
    arrayList.add("Google");
    arrayList.add("Runoob");
    arrayList.add("Taobao");
    arrayList.add("Weibo");
    System.out.println(arrayList);
    arrayList.remove(1);
    System.out.println(arrayList);
    arrayList.set(0,"修改");
    for (String i : arrayList) {
        System.out.println(i);
    }
    //按照字母排序
    Collections.sort(arrayList);
    System.out.println(arrayList);
    System.out.println("------------------------------------Vector-------------------------------");
    //Vector 类实现了一个动态数组 线程安全（同步访问) 与arraylist 类似
    Vector<Integer> vector = new Vector();
    vector.add(3);
    vector.add(1);
    vector.add(2);
    System.out.println(vector);
    Collections.sort(vector);
    System.out.println(vector);

    // Set代表无序不可重复集合，只能根据元素本身来访问；
    //set 的实现类常用的有     HashSet TreeSet LinkedHashSet
    //HashSet 是一个不允许有重复元素的集合。
    System.out.println("---------------------------------------TreeSet----------------------------------");
    HashSet<Integer> hashSet = new HashSet();
    hashSet.add(1);
    hashSet.add(3);
    hashSet.add(2);
    //该元素不会被添加
    hashSet.add(1);
    //HashSet 允许有 null 值。
    hashSet.add(null);
    System.out.println(hashSet);
    //HashSet 是无序的，即不会记录插入的顺序。
    //HashSet 不是线程安全的， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。 您必须在多线程访问时显式同步对 HashSet 的并发访问。
    System.out.println(hashSet.contains(1));
    System.out.println(hashSet.remove(1));
    hashSet.clear();
    System.out.println(hashSet);
    //LinkedHashSet
    //LinkedHashSet是HashSet的一个子类，具有HashSet的特性，也是根据元素的hashCode值来决定元素的存储位置。但它使用链表维护元素的次序，元素的顺序与添加顺序一致。
    // 由于LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet，但在迭代访问Set里的全部元素时由很好的性能。
    System.out.println("---------------------------------------TreeSet----------------------------------");
    //TreeSet
    //TreeSet可以保证元素处于排序状态，它采用红黑树的数据结构来存储集合元素。TreeSet支持两种排序方法：自然排序和定制排序，默认采用自然排序。
    //自然排序
    Set<Integer> s = new TreeSet<Integer>();
    s.add(1);
    s.add(192);
    s.add(123);
    s.add(56);
    s.add(13);
    s.add(96);
    System.out.println(s);
    Set<Student> students = new TreeSet<Student>();
    students.add(new Student(13));
    students.add(new Student(21));
    students.add(new Student(2));
    System.out.println(students);
    //定制排序
    Comparator comparator = new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            if(o1 instanceof Student1 && o2 instanceof Student1 ){
                Student1 s1 = (Student1)o1;
                Student1 s2 = (Student1)o2;
                return s1.getAge().compareTo(s2.getAge());
            }
            return 0;
        }
    };
    TreeSet set = new TreeSet(comparator);
    set.add(new Student1(13));
    set.add(new Student1(33));
    set.add(new Student1(23));
    System.out.println(set);
    // Queue是队列集合；
    //队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。
    //LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。
    System.out.println("---------------------------------------Queue----------------------------------");
    Queue<String> queue = new LinkedList<String>();
    //add()和remove()方法在失败的时候会抛出异常(不推荐)
    queue.offer("a");
    queue.offer("b");
    queue.offer("c");
    queue.offer("d");
    for (String q:queue) {
        System.out.println(q);
    }
    System.out.println("poll="+queue.poll()); //返回第一个元素，并在队列中删除
    for(String q : queue){
        System.out.println(q);
    }
    System.out.println("===");
    System.out.println("element="+queue.element()); //返回第一个元素
    for(String q : queue){
        System.out.println(q);
    }
    System.out.println("===");
    System.out.println("peek="+queue.peek()); //返回第一个元素
    for(String q : queue){
        System.out.println(q);
    }
    // Map代表的是存储key-value对的集合，可根据元素的key来访问value。
    System.out.println("---------------------------------------HashMap----------------------------------");
    //HashMap 是一个散列表，它存储的内容是键值对(key-value)映射,无序。
    //该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。
    HashMap<Integer, String> Sites = new HashMap<Integer, String>();
    Sites.put(1,"小鸡");
    Sites.put(2,"小e");
    Sites.put(3,"小ya");
    Sites.put(4,"小zhu");
    System.out.println(Sites);
    System.out.println("3是："+Sites.get(3));
    System.out.println("移除："+Sites.remove(3));
    System.out.println("size："+Sites.size());
    for (Integer key: Sites.keySet()) {
        System.out.println("key:"+Sites.get(key));
    }
    for (String value: Sites.values()) {
        System.out.println("value:"+value);
    }
    Sites.clear();
    System.out.println("删除所有"+Sites);
    //TreeMap
    //LinkedHashMap
}