欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-07-10 18:04:21
第七章:List集合23.3 Vector接口优点:底层数据结构是数组,查询快,增删慢。缺点:添加同步锁,线程安全,效率低。Stack是Vector类的实现类4.Set接口Set接口:接口,不允许重复元素**HashSet:**无序(不是按照添加顺序排序,而是按照哈希表排序),不可重复。TreeSet:有序(按照元素的自然顺序存储,例如b,a,c–>a,b,c)不可重复。数据类型必须实现Comparable接口,重写Compare To()1)HashSetHashSet:无序(不...

第七章: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);
    }
}

附图:JavaSE基础--第七章:List集合2

本文地址:https://blog.csdn.net/weixin_46076814/article/details/112217099