java第五次(list(ArrayList和LinKedList),set,map集合)

集合
大概的概述
List ,set,Map 都是接口，前两个都是继承Collection 接口，Map 是独立的
set下有HashSet,LinkedHashSet,TreeSet
List下有ArrayList,Vector,LinkedList
Map下有Hashtable,LinkedHashMap,HashMap,TreeMap
Collection 接口下还有个Queue接口，有PriorityQuece类

Collection 接口
List 有序，可以重复

1 AyyayList
优点：底层数据结构，查询快，增加删除慢
缺点：线程不安全，效率高

2.vector
优点 ：底层数据结构是数组，查询快，增加删除慢
缺点：线程安全，效率低

3 LinkedList
优点 ：底层数据是链表，查询慢，增加和删除比较快
缺点：线程不安全，效率高

ArrayList和LinKedList增删查的效率对比

package com.hp.Collection;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ListDemo {
    private int maxnum= 100000;
    public static void main(String[] args) {
        //arraylist linkedlist效率测试
        //添加100000条数据
        //0、定义最大添加数
        //1.创建arraylist对象 linkedlist对象
        //2、添加数据到集合中借 助for循环来进行数据添加
        //3、添加时检测效率 删除时检测效 查询时检测效率(定义方法、方法中需要指定参数、方法需要将、
        //3. 1获取当前系统的毫秒数sys tem. currentMills();
        //3.2添加删除查询相关的逻辑
        //3.3再获取系统的毫秒数.系统之前3.1获取的时间
        //4调用相关方法检测效率将 毫米值输出
        List<Integer> al = new ArrayList<>();
        List<Integer> ll = new LinkedList<>();
        LinkedListAdd(ll);
        ArrayListAdd(al);


        ArrayListGetAll(al);
        LinkedListGetAll(ll);
        ArrayListdel(al);
        LinkedListDel(ll);
    }
    public static void ArrayListAdd(List<Integer> al){
        System.out.print("这是arraylist的添加毫秒数:");
        long alTimeBefore = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            al.add(i);
        }
        long alTimeAfter = System.currentTimeMillis();
        long altime = alTimeAfter - alTimeBefore;
        System.out.println(altime);
    }
    public static void LinkedListAdd(List<Integer> ll){
        System.out.print("这是LinkedList的添加毫秒数:");
        long llTimeBefore = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
            ll.add(i);
        }
        long llTimeAfter = System.currentTimeMillis();
        long lltime = llTimeAfter - llTimeBefore;
        System.out.println(lltime);
    }
    public static void ArrayListdel(List<Integer> al){
        System.out.print("这是arraylist的删除毫秒数:");
        long alTimeBefore = System.currentTimeMillis();
        for (int i = 9999999; i>=0; i--) {
            al.remove(i);
        }
        long alTimeAfter = System.currentTimeMillis();
        long altime = alTimeAfter - alTimeBefore;
        System.out.println(altime);
    }
    public static void LinkedListDel(List<Integer> ll){
        System.out.print("这是LinkedList的删除毫秒数:");
        long llTimeBefore = System.currentTimeMillis();
        for (int i = 9999999; i>=0; i--) {
            ll.remove(i);
        }
        long llTimeAfter = System.currentTimeMillis();
        long lltime = llTimeAfter - llTimeBefore;
        System.out.println(lltime);
    }
    public static void ArrayListGetAll(List<Integer> al){
        System.out.print("这是arraylist的查询毫秒数:");
        long alTimeBefore = System.currentTimeMillis();
        for (Integer i: al) {
            i=i;
        }
        long alTimeAfter = System.currentTimeMillis();
        long altime = alTimeAfter - alTimeBefore;
        System.out.println(altime);
    }
    public static void LinkedListGetAll(List<Integer> ll){
        System.out.print("这是LinkedList的查询毫秒数:");
        long llTimeBefore = System.currentTimeMillis();
        for (Integer i: ll) {
            i=i;
        }
        long llTimeAfter = System.currentTimeMillis();
        long lltime = llTimeAfter - llTimeBefore;
        System.out.println(lltime);
    }
}

set 无序 ，唯一 会自动去重

HashSet
底层数据结构是哈希表 （无序，唯一）
如何保证元素的唯一性？

依赖两个方法 ：hashCode()和equals（）

LinkHashSet

底层数据结构是链表和哈希表

1由链条保证元素有序
2由哈希表来保证唯一

TreeSet
底层数据结构是红黑树（唯一，有序）
如何保证元素排序？
自然排序
比较器排序
2如何保证元素的唯一性？
根据比较的返回值是否是0来决定

TreeSet的主要功能用于排序
LinkedHashSet的主要功能用于保证FIFO即有序的集合(先进先出)
HashSet只是通用的存储数据的集合

Map接口 map 通过key 和value 保存 如果key 相同 会自动去重
有三个实现类HashMap,TreeMap,和HashTable

TreeMap是有序的，其他是无序的
Hashtable的方法是同步的，HashMap的方法不是同步的，这两者最主要的区别

所以Hashtable是线程安全的，HashMap不是线程安全的。
HashMap效率较高，Hashtable效率较低。

map，set，list集合的具体使用

package com.hp.Collection;

import java.util.*;

public class CollectionDemo {
    //length是数组长度
    //size是集合长度
    /*
    集合
    set:元素无序，去除重复
    map:key value key和value必须为包装类型 key值不能重复 重复会将后面value值作为最终重复key的值
     */
    public static void main(String[] args) {
        System.out.println("set集合=====================");
        Set<String> set = new HashSet<String>();
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("a");
        System.out.println(set.size());
        //第一种循环遍历集合(增强for循环)
        for (String str: set
             ) {
            System.out.println(str);
        }
        //第二种遍历set集合
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        //map键只能是包装类类型
        Map<Integer,String > map = new HashMap<>();
        map.put(1,"aa");
        map.put(2,"bb");
        map.put(3,"cc");
        map.put(1,"dd");
        System.out.println("第一种:");
        //增强for循环遍历
        Set<Integer> integers = map.keySet();
        for (Integer i: integers
             ) {
            System.out.println(i+"="+map.get(i));

        }
        //遍历迭代
        System.out.println("第二种:");
        Iterator<Integer> i = integers.iterator();
        while (i.hasNext()){
            Integer next = i.next();
            System.out.println(map.get(next));
        }

        System.out.println("第三种:");
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        Iterator<Map.Entry<Integer, String>> ei = entries.iterator();
        while (ei.hasNext()){
            Map.Entry<Integer, String> next = ei.next();
            System.out.println(next.getKey()+"="+next.getValue());
        }

        System.out.println("=======================================");

        System.out.println("list集合====================");
        List<Integer> list = new ArrayList<>();
        list.add(11);
        list.add(11);
        list.add(22);
        list.add(33);
        Iterator<Integer> iterator1 = list.iterator();
        //list转set
        Set<Integer> set1 = new HashSet<>(list);
        List<Integer> list1 = new ArrayList<>(set1);
        for (Integer in1:  list1
             ) {
            System.out.println(in1);
        }
        while (iterator1.hasNext()){
            Integer next = iterator1.next();
            if (next==11) {
                iterator1.remove();
            }
        }
        for (Integer in:list
             ) {
            System.out.println(in);
        }
    }
}