Java中集合类（API）

接口

1. Collection：这是集合框架的根接口。它定义了集合的基本操作，如添加、删除、检查元素是否存在等。
2. List：一个有序的集合（也称为序列）。它允许存储重复的元素，并且可以通过索引访问元素。
3. Set：一个不包含重复元素的集合。
4. Queue：一个特殊的集合，用于存储等待处理的元素。
5. Deque：一个双端队列，支持在两端插入和删除元素。
6. Map：存储键值对（key-value pairs）的集合。键是唯一的，每个键最多映射到一个值。

实现类

1. ArrayList：实现了List接口，基于动态数组实现，因此随机访问元素很快，但插入和删除元素可能较慢（尤其是在列表的中间位置）。
2. LinkedList：实现了List和Deque接口，基于链表实现，因此插入和删除元素很快，但随机访问元素可能较慢。
3. HashSet：实现了Set接口，基于哈希表实现，因此不包含重复元素，且添加、删除和查找操作通常很快。
4. TreeSet：实现了Set接口，基于红黑树实现，因此元素自然排序或根据提供的Comparator进行排序。
5. PriorityQueue：实现了Queue接口，基于优先级堆实现，元素按照其自然顺序或比较器的顺序进行排序。
6. ArrayDeque：实现了Deque接口，基于数组实现，因此提供了在两端快速插入和删除元素的能力。
7. HashMap：实现了Map接口，基于哈希表实现，因此提供了快速的键值对存储和查找。
8. TreeMap：实现了Map接口，基于红黑树实现，因此键自然排序或根据提供的Comparator进行排序。

迭代器

• Iterator：用于遍历集合中的元素。它提供了基本的遍历操作，如hasNext()和next()。
• ListIterator：是Iterator的子接口，专门用于遍历List。它提供了额外的操作，如添加、替换和获取列表中元素的索引。

package com.the_finals.javaoop.hashmap.demo;

import java.util.HashMap;

public class Hashmap_test {
    public static void main(String[] args) {
        HashMap<String,String> hashMap = new<String,String> HashMap();
        hashMap.put("a","sd");
        hashMap.put("b","ad");
        hashMap.put("c","df");
        hashMap.put("s","vv");
        System.out.println(hashMap.isEmpty());
        System.out.println(hashMap.get("s"));
        System.out.println(hashMap.containsValue("vv"));
        System.out.println(hashMap.containsKey("a"));
        System.out.println(hashMap);
    }
}

package com.the_finals.javaoop.hashmap.demo;

import java.util.Hashtable;
import java.util.Map;
import java.util.Set;

public class Hashtable_Procase {
    /*
        Hashtable
        方法上都添加了synchronized锁
        不允许key为null，也不允许值为null
        但是Hashmap允许一个为null的key，null被默认为0
     */
    public static void main(String[] args) {
        Hashtable<String,String> hashtable =new Hashtable<>();
        hashtable.put("a","bb");
        hashtable.put("d","ba");
        //hashtable.put("c",null);
        hashtable.put("x","sb");
        //hashtable.put(null,"bb");
    /*
        map遍历
        方式1：先拿到所有的key，遍历key，根据key找值
        方式2：EntrySet会备份一份数据，直接把备份数据返回
    */
        Set<String> keyset = hashtable.keySet();
        for (String key : keyset){
            System.out.println(hashtable.get(key));
        }

        Set<Map.Entry<String,String>> entries = hashtable.entrySet();
        for (Map.Entry entry : entries){
            System.out.println(entry);
        }
    }
}

package com.the_finals.javaoop.compator.demo;

import java.sql.Connection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Compator_test {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        ArrayList<Integer> arrayList1 = new ArrayList<>();
        Collections.addAll(arrayList,2,3,4,1);
        Collections.sort(arrayList);
        System.out.println(arrayList);
        Collections.sort(arrayList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.intValue()-o1.intValue();
            }
        });
        System.out.println(arrayList);
        System.out.println(Collections.binarySearch(arrayList, 2));
        System.out.println(Collections.replaceAll(arrayList, 4, 1));
        Collections.shuffle(arrayList);
        System.out.println(arrayList);
        Collections.copy(arrayList,arrayList1);
    }
}

package com.the_finals.javaoop.testarratlist;

import java.util.ArrayList;
import java.util.HashSet;

public class String_ArrayList {
    public static void main(String[] args) {
        ArrayList<String> stringArrayList = new ArrayList<>();
        stringArrayList.add("a");
        stringArrayList.add("b");
        stringArrayList.add("a");
        stringArrayList.add("c");
        stringArrayList.add("d");
        HashSet<String> stringHashSet = new HashSet<>(stringArrayList);
        System.out.println(stringHashSet);
    }
}

package com.the_finals.javaoop.testtime;

import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedList;

public class TTest_demo {
    public static void main(String[] args) {
        Use_for use_for = new Use_for();

        Date date1 = new Date();
        use_for.Cutime1();
        Date date2 = new Date();
        System.out.println("ArrayList的效率是：" + (date2.getTime()-date1.getTime()));

        Date date3 = new Date();
        use_for.Cutime2();
        Date date4 = new Date();
        System.out.println("LinkedList的效率是：" + (date4.getTime()-date3.getTime()));

        Date date5 = new Date();
        use_for.Cutime3();
        Date date6 = new Date();
        System.out.println("ArrayList的效率是：" + (date6.getTime()-date5.getTime()));

        Date date7 = new Date();
        use_for.Cutime4();
        Date date8 = new Date();
        System.out.println("LinkedList的效率是：" + (date8.getTime()-date7.getTime()));
    }
}

package com.the_finals.javaoop.treeset.demo;

public class Student implements Comparable<Student>{
    private int number;
    private String name;

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public int compareTo(Student o) {
        return this.number-o.number;
    }

    @Override
    public String toString() {
        return "Student{" +
                "number=" + number +
                ", name='" + name + '\'' +
                '}';
    }
}

package com.the_finals.javaoop.treeset.demo;

import sun.reflect.generics.tree.Tree;

import java.util.TreeSet;

public class TreeSet_test {
    /*
        TreeSet
        不能存储重复元素
        可以直接对数据排序，底层采用树形结构存储，树形结构本身就是有序的
        向TreeSet中添加的元素类型必须实现Comparable接口，重写compareTo(),
        每次添加元素时
     */


    public static void main(String[] args) {
        TreeSet<Student> treeSet = new<Student> TreeSet();
        Student student1 = new Student();
        student1.setNumber(16);
        student1.setName("dou");

        Student student2 = new Student();
        student2.setNumber(11);
        student2.setName("zhu");
        treeSet.add(student1);
        treeSet.add(student2);
        System.out.println(treeSet.comparator());
        System.out.println(treeSet);
    }
}