JavaSE基础--第七章：List集合2

第七章：List集合2

3.3 Vector接口

优点：底层数据结构是数组，查询快，增删慢。

缺点：添加同步锁，线程安全，效率低。

Stack是Vector类的实现类

4.Set接口

Set接口：接口，不允许重复元素

**HashSet:**无序(不是按照添加顺序排序，而是按照哈希表排序)，不可重复。

TreeSet:有序(按照元素的自然顺序存储，例如b,a,c–>a,b,c)不可重复。数据类型必须实现Comparable接口，重写Compare To()

1)HashSet

HashSet:无序(不是按照添加顺序排序，而是按照哈希表排序)，不可重复

哈希表加链表存储，同一位置可以存储不同的元素

底层为HashMap

public native hashcode(),意为调用本地系统方法

public class HashSetDemo {
    /*
    Set接口继承了Collection接口，set中的元素是没有索引的
    HashSet无序存储(不是按照添加顺序排序)
    底层是HashMap
    不能存储重复元素
     */
    public static void main(String[] args) {
        HashSet<String> set = new HashSet();
                set.add("a");
                set.add("a");
                set.add("v");
                set.add("b");
        System.out.println(set);//[a, b, v]
    }
}

1.哈希结构是如何进入存储？

哈希表(本身也是数组)

HashSet是使用了HashMap键的那一列，是从HashMap扩展出来的一格单列存储的类。

2.HashSet是如何去除重复元素的？

先用元素的哈希值比较(快),但是内容不同，哈希值可能相同,hash值相同时，再使用equals()方法判断内容是否相等(安全可靠，但是效率低).双保险[既保证效率，又保证安全]。

2)TreeSet

TreeSet：有序(按照元素的自然顺序排列),不可重复

底层为红黑树

数据类型必须实现Comparable接口，重写Compare To()方法。

1.如何保证元素排序的呢?

自然排序；比较器排序

2.如何保证元素唯一性？

根据比较的返回值是否是0来决定。

5.Map接口

Map:双列存储，键–值

键不能重复，而值可以重复。

键相同时，后面的会将前面的键包括值覆盖掉。

键值去重复:hashcode(),equals()

允许存在一个为null的键，map.put(“null”,“a”);

分为三类:

1. HashMap
2. TreeMap
3. Hashtable

1.HashMap

hashmap:无序(通过Hashcode(),equas()去重复，添加元素)。

public class HashMapDemo {
    public static void main(String[] args) {
        HashMap<String,String> m = new HashMap<>();
        /*
        hashMap
        键 值对，键是无序的
        可以存储一个为null的键
        不能重复，如果由重复的键，后面的值会把前面的覆盖掉
         */
        m.put("a","b");
        m.put("a","w");//键一样,w把b覆盖掉
        m.put("f","b");
        m.put("p","b");
        m.put("null","v");
        //m.remove("a");删除键为a的值
        //m.clear();清空集合
        System.out.println(m.containsKey("f"));//根据键来判断集合是否包含元素 true
        System.out.println(m.containsValue("b"));//根据值判断集合是否包含元素  true
        System.out.println(m.isEmpty());//判断集合是否为空 false
        System.out.println(m.size());//判断集合大小  4
        System.out.println(m.get("null"));//根据键获得值  v
        System.out.println(m);//{p=b, a=w, null=v, f=b}
        System.out.println(m.keySet());//[p, a, null, f]  输出集合中的键
        System.out.println(m.values());//[b, w, v, b] 输出集合中的值
        Hashtable<String,String> t = new Hashtable<>();
        /*
        HashTable 不允许存储为null的键，否则会出现异常
         */
          // t.put(null,"a");//java.lang.NullPointerException
          System.out.println(t);
    }
}

2.TreeMap

TreeMap:按照键的自然顺序排列，键的类型所属类必须实现Comparable接口，TreeMap根据compare To()的逻辑对Key进行排序。底层为红黑树

public class TreeMapDemo {
    public static void main(String[] args) {
        /*
        基本属性与hashMap相同
        可以根据键的自然顺序排序
        指定的键的类型的类必需实现Comparable接口，排序使用。
         */
        TreeMap<String,String> m = new TreeMap<>();
        m.put("a","b");
        m.put("a","w");//键一样,w把b覆盖掉
        m.put("f","b");
        m.put("p","b");
        m.put("null","v");
        System.out.println(m);//{a=w, f=b, null=v, p=b}
    }
}

3.Hashtable

Hashtable:线程安全的，按照添加元素的顺序排序，底层也是哈希表加单链表

哈希碰撞:哈希值一样，内容不一样

public static void main(String[] args) {
        Hashtable<String,String> able = new Hashtable<>();
        able.put("b","b");
        able.put("b","c");
        able.put("a","b");
        able.put("c","d");
        // 按照添加顺序排序
        System.out.println(able);// {b=c, a=b, c=d}
    }

4.集合遍历

方式1：根据键找值

• 获取所有键的集合
• 遍历键的集合，获取每一个键
• 根据键找值

方式2：根据键值对对象找键和值

• 获取所有键值对对象的集合
• 遍历键值对对象的集合，获取到每一个键值对对象
• 根据键值对对象找键和值

1）以流的方式进行遍历

public static void main(String[] args) {
        HashMap<String,String> m = new HashMap<>();
        m.put("a","b");
        m.put("f","b");
        m.put("p","b");
        m.put("null","v");
        // 1.以流的方式进行遍历
        m.forEach((k,v)-> System.out.println(k+":"+v));
}

2)keySet()

public static void main(String[] args) {
        HashMap<String,String> m = new HashMap<>();
        m.put("a","b");
        m.put("f","b");
        m.put("p","b");
        m.put("null","v");
        //2. keySet() 先获取到Map中所有的键，存储到Set集合中，再对Set集合进行遍历，通过拿到的key获得对应的值
        Set<String> keySet = m.keySet();
        for (String key:keySet) {
            System.out.println(key+":"+m.get(key));
        }

3)entrySet() 增强for循环

public class MapDemo {
    public static void main(String[] args) {
        HashMap<String,String> m = new HashMap<>();
        m.put("a","b");
        m.put("f","b");
        m.put("p","b");
        m.put("null","v");
     
        //entrySet() 增强for循环
       Set<Map.Entry<String,String>> entrySet = m.entrySet();
        for (Map.Entry<String,String> entrySet1:entrySet){
            System.out.println(entrySet1.getKey()+":"+entrySet1.getValue());
        }

6.Collections

Collections:对集合进行常规操作的类(工具类)

定义的静态方法分为两类:1.同步集合对象的方法 2.对List排序的方法

public class CollectionsDemo {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("a");
        Collections.addAll(list, "c", "f", "m", "c", "c");//[a, c, f, m, c, c]
        ArrayList list1 = new ArrayList();
        list1.add("1");
        list1.add("5");
        System.out.println(Collections.binarySearch(list, "c"));//1
        Collections.copy(list, list1);// java.lang.IndexOutOfBoundsException 前面的集合的长度要比后面的长度要大
        System.out.println(list);
        System.out.println(Collections.emptyList());//[]
        System.out.println(Collections.max(list));//m
        Collections.replaceAll(list, "c", "C");//[1, 5, f, m, C, C]
        System.out.println(list);
    }
}

附图: