三个小任务掌握List、Set、Map

任务一：

ArrayList、Vector 和 LinkedList 都实现了 List 接口，对它们分别进行如下操作后比 较它们的不同，然后形成初步耗时报告（三种不同 List 的耗时）：

追加元素（追加一万次）；

添加元素到任意位置（添加一万次）；

分别使用 for 循环、forEach 循环、迭代器进行遍历；

删除任意位置的元素（删除一万次）。

public class ListDemo {

    //add 追加
    public void addArrayList(){
        //追加元素一万次耗时
        ArrayList<Integer> a1 = new ArrayList<Integer>();
        //开始的时间
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            a1.add(i);
            //在同一位置追加
            // a1.add(1);
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("ArrayList追加一万次记录耗时："+(endTime-startTime)+"毫秒");
    }

    public void addVector(){
        //Vector追加一万次耗时
        Vector<Integer> v1 = new Vector<>();
        //开始的时间
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
           v1.add(i);
            //在同一位置追加
           // v1.add(1);
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("Vector追加一万次记录耗时："+(endTime-startTime)+"毫秒");
    }

    public void addLinkedList(){
        //LinkedList追加一万次记录耗时
        LinkedList<Integer> link1 = new LinkedList<>();
        //开始的时间
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
           link1.add(i);
            //在同一位置追加
           // link1.add(1);
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("LinkedList追加一万次记录耗时："+(endTime-startTime)+"毫秒");
    }

    //traverse 遍历
    public void traverseArrayList(){
        System.out.println("ArrayList的三种遍历方式：");
        //创建ArrayList集合
        ArrayList<String> a1 = new ArrayList<>();
        //添加元素
        a1.add("从前有座山");
        a1.add("山上有座庙");
        a1.add("庙里有个小和尚在敲代码");
        //for 循环遍历
        System.out.println("for循环遍历：");
        for (int i = 0; i < a1.size(); i++) {
            System.out.println(a1.get(i));
        }

        //foreach 遍历
        System.out.println("foreach 遍历：");
        for (String s:a1) {
            System.out.println(s);
        }
        //iterator(迭代器遍历)
        System.out.println("iterator 遍历：");
        Iterator<String> iterator = a1.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    public void traverseVector(){
        System.out.println("Vector的三种遍历方式：");
        //创建Vector集合
        Vector<String> v1 = new Vector<>();
        //添加元素
        v1.add("从前有座山");
        v1.add("山上有座庙");
        v1.add("庙里有个小和尚在敲代码");
        //for 循环遍历
        System.out.println("for循环遍历：");
        for (int i = 0; i < v1.size(); i++) {
            System.out.println(v1.get(i));
        }

        //foreach 遍历
        System.out.println("foreach 遍历：");
        for (String s:v1) {
            System.out.println(s);
        }
        //iterator(迭代器遍历)
        System.out.println("iterator 遍历：");
        Iterator<String> iterator = v1.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    public void traverseLinkedList(){
        System.out.println("LinkedList的三种遍历方式：");
        //创建LinkedList集合
        LinkedList<String> link = new LinkedList<>();
        //添加元素
        link.add("从前有座山");
        link.add("山上有座庙");
        link.add("庙里有个小和尚在敲代码");
        //for 循环遍历
        System.out.println("for循环遍历：");
        for (int i = 0; i < link.size(); i++) {
            System.out.println(link.get(i));
        }

        //foreach 遍历
        System.out.println("foreach 遍历：");
        for (String s:link) {
            System.out.println(s);
        }
        //iterator(迭代器遍历)
        System.out.println("iterator 遍历：");
        Iterator<String> iterator = link.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    //remove 删除
    public void removeArrayList(){
        //创建集合
        ArrayList<Integer> a1 = new ArrayList<>();
        //添加一万个记录
        for (int i = 0; i < 10000; i++) {
            a1.add(i);
        }
        //开始的时间
        long startTime = System.currentTimeMillis();
        //删除操作
        for (int i = 0; i < a1.size(); i++) {
            a1.remove(i);
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("ArrayList删除一万记录耗时："+(endTime -startTime)+"毫秒");

    }

    public void removeVector(){
        //创建集合
        Vector<Integer> v1 = new Vector<>();
        //添加一万个记录
        for (int i = 0; i < 10000; i++) {
            v1.add(i);
        }
        //开始的时间
        long startTime = System.currentTimeMillis();
        //删除操作
        for (int i = 0; i < v1.size(); i++) {
            v1.remove(i);
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("Vector删除一万记录耗时："+(endTime -startTime)+"毫秒");
    }

    public void removeLinkedList(){
        //创建集合
        LinkedList<Integer> link = new LinkedList<>();
        //添加一万个记录
        for (int i = 0; i < 10000; i++) {
            link.add(i);
        }
        //开始的时间
        long startTime = System.currentTimeMillis();
        //删除操作
        for (int i = 0; i < link.size(); i++) {
            link.remove(i);
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("LinkedList删除一万记录耗时："+(endTime -startTime)+"毫秒");
    }

    @Test
    public void test(){
        addArrayList();
        addVector();
        addLinkedList();
        traverseArrayList();
        traverseVector();
        traverseLinkedList();
        removeArrayList();
        removeVector();
        removeLinkedList();
    }
}

任务二：

HashSet 和 TreeSet 都实现了 Set 接口，对它们分别进行如下操作后比较它们的不 同，然后形成初步耗时报告（两种不同 Set 的耗时）：

添加元素（添加一万次）；

分别使用 forEach 循环、迭代器进行遍历；

删除任意位置的元素（删除一万次）

public class SetDemo {

    //追加
    public void addHashSet(){
        //创建 HashSet集合
        HashSet<Integer> hashset = new HashSet<>();
        //开始的时间
        long startTime = System.currentTimeMillis();
        //追加元素
        for (int i = 0; i < 10000; i++) {
            hashset.add(i);
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("HashSet追加一万条记录耗时："+(endTime-startTime)+"毫秒");
    }

    public void addTreeSet(){
        //创建 TreeSet集合
        TreeSet<Integer> treeSet = new TreeSet<>();
        //开始的时间
        long startTime = System.currentTimeMillis();
        //追加元素
        for (int i = 0; i < 10000; i++) {
            treeSet.add(i);
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("TreeSett追加一万条记录耗时："+(endTime-startTime)+"毫秒");
    }

    //遍历 traverse
    public void traverseHashSet(){
        System.out.println("HashSet遍历方式：");
        //创建集合
        HashSet<String> hashSet = new HashSet<>();
        //添加元素
        hashSet.add("从前有座山");
        hashSet.add("山上有座庙");
        hashSet.add("庙有个小和尚在敲代码");

        //foreach 遍历
        System.out.println("foreach遍历：");
        for (String s:hashSet) {
            System.out.println(s.toString());
        }

        //iterator 遍历
        System.out.println("iterator遍历：");
        Iterator<String> iterator = hashSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    public void traverseTreeSet(){
        System.out.println("TreeSett遍历方式：");
        //创建集合
        TreeSet<String> treeSet = new TreeSet<>();
        //添加元素
        treeSet.add("从前有座山");
        treeSet.add("山上有座庙");
        treeSet.add("庙有个小和尚在敲代码");

        //foreach 遍历
        System.out.println("foreach遍历：");
        for (String s:treeSet) {
            System.out.println(s.toString());
        }

        //iterator 遍历
        System.out.println("iterator遍历：");
        Iterator<String> iterator = treeSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    //删除 remove
    public void removeHashSet(){
        //创建集合
        HashSet<Integer> hashSet = new HashSet<>();
        //添加元素
        for (int i = 0; i < 10000; i++) {
            hashSet.add(i);
        }
        //开始的时间
        long startTime = System.currentTimeMillis();
        //删除元素
        for (int i = 0; i < hashSet.size(); i++) {
            hashSet.remove(i);
        }
        //结束的时间
        long  endTime = System.currentTimeMillis();
        System.out.println("删除一万条元素HashSet耗时为："+(endTime-startTime)+"毫秒");
    }

    public void removeTreeSet(){
        //创建集合
        TreeSet<Integer> treeSet = new TreeSet<>();
        //添加元素
        for (int i = 0; i < 10000; i++) {
            treeSet.add(i);
        }
        //开始的时间
        long startTime = System.currentTimeMillis();
        //删除元素
        for (int i = 0; i < treeSet.size(); i++) {
            treeSet.remove(i);
        }
        //结束的时间
        long  endTime = System.currentTimeMillis();
        System.out.println("删除一万条元素TreeSet耗时为："+(endTime-startTime)+"毫秒");
    }
    @Test
    public void test(){
        addHashSet();
        addTreeSet();
        traverseHashSet();
        traverseTreeSet();
        removeHashSet();
        removeTreeSet();
    }
}

任务三：

HashMap、TreeMap、LinkedHashMap 和 Hashtable 都实现了 Map 接口，对它 们分别进行如下操作后比较它们的不同，然后形成初步耗时报告（两种不同 Map 的耗 时）：

追加键值对（追加一万次）；

替换键值对（替换一万次）；

分别使用 entrySet、keySet/values、迭代器进行遍历；

删除键值对（删除一万次）

public class MapDemo {

    //追加
    public void addHashMap(){
        //创建集合
        HashMap<Integer, String> hashMap = new HashMap<>();
        //开始的时间
        long startTime = System.currentTimeMillis();
        //追加记录
        for (int i = 0; i < 10000; i++) {
            hashMap.put(i,"hello,word");
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("HashMap追加一万条键值对耗时为："+(endTime-startTime)+"毫秒");
    }

    public void addTreeMap(){
        //创建集合
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        //开始的时间
        long startTime = System.currentTimeMillis();
        //追加记录
        for (int i = 0; i < 10000; i++) {
            treeMap.put(i,"hello,word");
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("TreeMap追加一万条键值对耗时为："+(endTime-startTime)+"毫秒");
    }

    public void addLinkedHashMap(){
        //创建集合
        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();
        //开始的时间
        long startTime = System.currentTimeMillis();
        //追加记录
        for (int i = 0; i < 10000; i++) {
            linkedHashMap.put(i,"hello,word");
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("LinkedHashMap追加一万条键值对耗时为："+(endTime-startTime)+"毫秒");
    }

    public void addHashtable(){
        //创建集合
        Hashtable<Integer, String> hashtable = new Hashtable<>();
        //开始的时间
        long startTime = System.currentTimeMillis();
        //追加记录
        for (int i = 0; i < 10000; i++) {
            hashtable.put(i,"hello,word");
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("Hashtable追加一万条键值对耗时为："+(endTime-startTime)+"毫秒");
    }

    //replace 替换
    public void replaceHashMap(){
        //创建集合
        HashMap<Integer, String> hashMap = new HashMap<>();
        //追加元素
        for (int i = 0; i < 10000; i++) {
            hashMap.put(i,"hello,word");
        }
        //开始的时间
        long startTime = System.currentTimeMillis();
        //替换元素
        for (int i = 0; i < hashMap.size(); i++) {
            hashMap.replace(i,"你好，世界");
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("HashMap替换一万次元素耗时为："+(endTime-startTime)+"毫秒");
    }

    public void replaceTreeMap(){
        //创建集合
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        //追加元素
        for (int i = 0; i < 10000; i++) {
            treeMap.put(i,"hello,word");
        }
        //开始的时间
        long startTime = System.currentTimeMillis();
        //替换元素
        for (int i = 0; i < treeMap.size(); i++) {
            treeMap.replace(i,"你好，世界");
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("TreeMap替换一万次元素耗时为："+(endTime-startTime)+"毫秒");
    }

    public void replaceLinkedHashMap(){
        //创建集合
        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();
        //追加元素
        for (int i = 0; i < 10000; i++) {
            linkedHashMap.put(i,"hello,word");
        }
        //开始的时间
        long startTime = System.currentTimeMillis();
        //替换元素
        for (int i = 0; i < linkedHashMap.size(); i++) {
            linkedHashMap.replace(i,"你好，世界");
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("LinkedHashMap替换一万次元素耗时为："+(endTime-startTime)+"毫秒");
    }

    public void replaceHashtable(){
        //创建集合
        Hashtable<Integer, String> hashtable = new Hashtable<>();
        //追加元素
        for (int i = 0; i < 10000; i++) {
            hashtable.put(i,"hello,word");
        }
        //开始的时间
        long startTime = System.currentTimeMillis();
        //替换元素
        for (int i = 0; i < hashtable.size(); i++) {
            hashtable.replace(i,"你好，世界");
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("Hashtable替换一万次元素耗时为："+(endTime-startTime)+"毫秒");
    }

    //遍历
    public void traverseHashMap() {
        //创建集合
        HashMap<Integer, String> hashMap = new HashMap<>();
        //添加元素
        hashMap.put(1, "赵云");
        hashMap.put(2, "张飞");
        hashMap.put(3, "马超");

        System.out.println("HashMap遍历方式：");
        //entrySet 迭代器遍历
        System.out.println("entrySet 迭代器遍历：");
        Iterator<Map.Entry<Integer, String>> iterator01 = hashMap.entrySet().iterator();
        while (iterator01.hasNext()){
            Map.Entry<Integer, String> entry = iterator01.next();
            System.out.print("key:"+entry.getKey());
            System.out.println("  value:"+entry.getValue());
        }

        //keySet 迭代器遍历
        System.out.println("keySet 迭代器遍历");
        Iterator<Integer> iterator02 = hashMap.keySet().iterator();
        while (iterator02.hasNext()){
            Integer key = iterator02.next();
            System.out.println("key:"+key+"  value:"+hashMap.get(key));
        }
    }

    public void traverseTreeMap() {
        //创建集合
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        //添加元素
        treeMap.put(1, "赵云");
        treeMap.put(2, "张飞");
        treeMap.put(3, "马超");

        System.out.println("treeMap遍历方式：");
        //entrySet 迭代器遍历
        System.out.println("entrySet 迭代器遍历：");
        Iterator<Map.Entry<Integer, String>> iterator01 = treeMap.entrySet().iterator();
        while (iterator01.hasNext()){
            Map.Entry<Integer, String> entry = iterator01.next();
            System.out.print("key:"+entry.getKey());
            System.out.println("  value:"+entry.getValue());
        }

        //keySet 迭代器遍历
        System.out.println("keySet 迭代器遍历");
        Iterator<Integer> iterator02 = treeMap.keySet().iterator();
        while (iterator02.hasNext()){
            Integer key = iterator02.next();
            System.out.println("key:"+key+"  value:"+treeMap.get(key));
        }
    }

    public void traverseLinkedHashMap() {
        //创建集合
        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();
        //添加元素
        linkedHashMap.put(1, "赵云");
        linkedHashMap.put(2, "张飞");
        linkedHashMap.put(3, "马超");

        System.out.println("linkedHashMap遍历方式：");
        //entrySet 迭代器遍历
        System.out.println("entrySet 迭代器遍历：");
        Iterator<Map.Entry<Integer, String>> iterator01 = linkedHashMap.entrySet().iterator();
        while (iterator01.hasNext()){
            Map.Entry<Integer, String> entry = iterator01.next();
            System.out.print("key:"+entry.getKey());
            System.out.println("  value:"+entry.getValue());
        }

        //keySet 迭代器遍历
        System.out.println("keySet 迭代器遍历");
        Iterator<Integer> iterator02 = linkedHashMap.keySet().iterator();
        while (iterator02.hasNext()){
            Integer key = iterator02.next();
            System.out.println("key:"+key+"  value:"+linkedHashMap.get(key));
        }
    }

    public void traverseHashtable() {
        //创建集合
        Hashtable<Integer, String> hashtable = new Hashtable<>();
        //添加元素
        hashtable.put(1, "赵云");
        hashtable.put(2, "张飞");
        hashtable.put(3, "马超");

        System.out.println("hashtable遍历方式：");
        //entrySet 迭代器遍历
        System.out.println("entrySet 迭代器遍历：");
        Iterator<Map.Entry<Integer, String>> iterator01 = hashtable.entrySet().iterator();
        while (iterator01.hasNext()){
            Map.Entry<Integer, String> entry = iterator01.next();
            System.out.print("key:"+entry.getKey());
            System.out.println("  value:"+entry.getValue());
        }

        //keySet 迭代器遍历
        System.out.println("keySet 迭代器遍历");
        Iterator<Integer> iterator02 = hashtable.keySet().iterator();
        while (iterator02.hasNext()){
            Integer key = iterator02.next();
            System.out.println("key:"+key+"  value:"+hashtable.get(key));
        }
    }

    //remove 删除
    public void removeHashMap(){
        //创建集合
        HashMap<Integer, String> hashMap = new HashMap<>();
        //添加元素
        for (int i = 0; i < 10000; i++) {
            hashMap.put(i,"hello,word");
        }
        //开始的时间
        long startTime = System.currentTimeMillis();
        //删除元素
        for (int i = 0; i < hashMap.size(); i++) {
            hashMap.remove(i);
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("hashMap删除一万条键值对耗时为："+(endTime-startTime)+"毫秒");
    }

    public void removeTreeMap(){
        //创建集合
        TreeMap<Integer, String> treeMap = new TreeMap<>();
        //添加元素
        for (int i = 0; i < 10000; i++) {
            treeMap.put(i,"hello,word");
        }
        //开始的时间
        long startTime = System.currentTimeMillis();
        //删除元素
        for (int i = 0; i < treeMap.size(); i++) {
            treeMap.remove(i);
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("treeMap删除一万条键值对耗时为："+(endTime-startTime)+"毫秒");
    }

    public void removeLinkedHashMap(){
        //创建集合
        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();
        //添加元素
        for (int i = 0; i < 10000; i++) {
            linkedHashMap.put(i,"hello,word");
        }
        //开始的时间
        long startTime = System.currentTimeMillis();
        //删除元素
        for (int i = 0; i < linkedHashMap.size(); i++) {
            linkedHashMap.remove(i);
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("linkedHashMap删除一万条键值对耗时为："+(endTime-startTime)+"毫秒");
    }

    public void removeHashtable(){
        //创建集合
        Hashtable<Integer, String> hashtable = new Hashtable<>();
        //添加元素
        for (int i = 0; i < 10000; i++) {
            hashtable.put(i,"hello,word");
        }
        //开始的时间
        long startTime = System.currentTimeMillis();
        //删除元素
        for (int i = 0; i < hashtable.size(); i++) {
            hashtable.remove(i);
        }
        //结束的时间
        long endTime = System.currentTimeMillis();
        System.out.println("hashtable删除一万条键值对耗时为："+(endTime-startTime)+"毫秒");
    }
    @Test
    public void test(){
        addHashMap();
        addTreeMap();
        addLinkedHashMap();
        addHashtable();
        replaceHashMap();
        replaceTreeMap();
        replaceLinkedHashMap();
        replaceHashtable();
        traverseHashMap();
        traverseTreeMap();
        traverseLinkedHashMap();
        traverseHashtable();
        removeHashMap();
        removeTreeMap();
        removeLinkedHashMap();
        removeHashtable();
    }
}