【笔记：List接口、Set接口和Map接口】

已于 2022-05-05 22:43:04 修改
阅读量1.2k 收藏 6
点赞数 3
分类专栏： Java 文章标签： java
于 2022-04-11 17:55:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Editplusplusplus/article/details/124105141
版权

文章目录

1.List接口和常用方法

1. List接口基本介绍

List接口是Collection接口的子接口 List_.java

  • List集合类中元素有序（即添加顺序和取出顺序一致）、且可重复
  • List集合中的每个元素都有其对应的顺序索引，即支持索引
  • List容器中的元素都对应一个整数型的序号记载其在元素中的位置，可以根据序号存取容器中的元素
  • 常用的List接口的实现有：ArrayList、LinkedList和Vector
    Vector、ArrayList、LinkedList的区别
    image.png
  • List三种遍历方式[ArrayList, LinkedList, Vector]
    • 使用iterator迭代器
      Iterator iter = col.iterator();
	while(iter.hasNext()){
        Object o = iter.next();
    }
    • 增强for循环
      for(Object o : col){
}
    • 普通for循环
      for(int i=0 ; i<list.size(); i++){
	Object object = list.get(i);
	System.out.println(object);
}

2. List接口常用方法

public static void main(String[] args) {
        List list = new ArrayList();

        //void add(obj): 按顺序添加元素
        list.add("one");
        list.add("two");
        list.add("three");
        System.out.println(list);
    	//[one, two, three]

        //void add(int index, Object obj):在index插入元素
        list.add(0,"zero");
        System.out.println(list);   
    	//[zero, one, two, three]

        //boolean addAll(int index, Collection eles)：从index位置开始将eles		中的所有元素添加进来；
        List list2 = new ArrayList();
        list2.add("four");
        list2.add("five");

        list.addAll(4,list2);
        System.out.println(list);   
    	//[zero, one, two, three, four, five]

        //Object get(int index):获取指定index位置的元素
        System.out.println(list.get(2));    
    	//two

        //int indexOf(Object obj):返回obj在当前集合中首次出现的位置
        //int lastIndexOf(Object obj):返回obj在当前集合中最后一次出现的位置
        list.add("one");
        System.out.println(list);   
    	//[zero, one, two, three, four, five, one]
        System.out.println(list.indexOf("one"));    //1
        System.out.println(list.lastIndexOf("one"));    //6

        //Object remove(int index):移除指定index位置的元素，并返回此元素
        list.remove(0);
        System.out.println(list);   
    	//[one, two, three, four, five, one]

        //Object set(int index, Object ele):指定index位置的元素为ele，相当于		替换
        list.set(0,"first");
        System.out.println(list);   
    	//[first, two, three, four, five, one]

        //List subList (int formIndex, int toIndex):返回从formIndex到			toIndex位置的子集合
        List returnList = list.subList(0,3);
        System.out.println(returnList); 
    	//[first, two, three]
    }

2.Set接口和常用方法

1. Set接口基本介绍

  • 无序（添加和取出的顺序不一致）， 没有索引

  • 不允许重复元素，所以最多包含一个null

        public static void main(String[] args) {
        //以Set接口的实现类HashSet演示
        //set接口的实现类的对象（Set接口对象），不能存放重复的元素，可以添加一个null
        //set接口对象存放数据无序（添加的顺序与去除的顺序不一致）
        //每次取出的顺序一致
        Set set = new HashSet();
        set.add("one");
        set.add("two");
        set.add("three");
        set.add("one"); //重复
        set.add(null);
        set.add(null);

        System.out.println(set);    //[null, one, two, three]
    }

  • Set 接口最常用的几个实现类是 HashSet、LinkedHashSet 以及 TreeSet

2. Set接口的常用方法

和List接口一样，Set接口也是Collection的子接口，因此常用方法和Collection接口一样。

  • Set接口的遍历方式
    • 可以使用迭代器
    • 增强for循环
    • 不能使用索引的方式

3. Set接口实现类-HashSet

  • HashSet说明

    • HashSet实现类Set接口

    • HashSet实际上是HashMap，源码如下：

          public HashSet() {
        map = new HashMap<>();
    }

    • 可以存放null值，但是只能有一个null

    • HashSet不保证元素是有序的，取决于hash之后，再确定索引的结果。(不保证存放元素的顺序与取出顺序一致)

    • 不能有重复元素/对象

  • HashSet的添加元素是如何实现的：(hash() + equals())

    • HashSet底层是HashMap
    • 添加一个元素时，先得到hash值-会转化成->索引值
    • 找到存储数据表table，看这个索引位置是否已经存放元素
    • 如果没有，直接加入
    • 如果有，调用equals比较。如果相同，就放弃添加；不想同就添加到最后
    • 在 Java8 中，如果一条链表的元素个数到达 TREEIFY_THRESHOLD(默认为8)，并且table大小>=MIN_TREEIFY_CAPACITY(默认64)，就会进行树化（红黑树）

4.Set接口实现类-LinkedHashSet

  • LinkedHashSet说明

    • LinkedHashSet是HashSet的子类

      public class LinkedHashSet<E>
    extends HashSet<E>

    • LinkedHashSet底层是一个LinkedHashMap，底层维护了一个数组+双向链表

    • LinkedHashSet根据元素的hashCode值来决定元素的存储位置，同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存的

    image.png

    • LinkedHashSet不允许重复元素

3. Map接口和常用方法

1. Map实现类的特点

  • Map与Collection并列存在，用于保存具有映射关系的数据：Key - value;
  • Map中的 key 和 value 可以是任何引用类型的数据，会封装到HashMap$Node对象中
  • Map中的 key 不允许重复，原因同HashSet
  • Map中的 value 可以重复
  • Map中的 key 可以为null，value 也可以为null，但 key 为null只能有一个， value为null可以有多个
  • 常用String类作为Map的key
  • key 和 value 存在单向一对一关系，即通过指定的 key 总能找到对应的 value

2. Map常用方法

  • put：添加

  • remove：根据键删除映射关系

  • get：根据键获取值

  • size：获取元素个数

  • isEmpty：判断个数是否为0

  • clear：清除

  • containsKey：查找键是否存在

    public class Map_ {
    public static void main(String[] args) {
        Map map = new HashMap();

        //put(key , value) 添加
        map.put("one","1");
        map.put("one","first");//重复，替换
        map.put("two", "second");
        map.put("three", "third");
        map.put("four", null);
        map.put(null, null);

        System.out.println(map);
        //{null=null, four=null, one=first, two=second, three=third}

        //remove:根据键删除映射关系
        map.remove(null);
        System.out.println(map);
        //{four=null, one=first, two=second, three=third}

        //get：根据键获取值
        System.out.println(map.get("one")); //first

        //size：获取元素个数
        System.out.println(map.size()); //4

        //isEmpty：判断个数是否为0
        System.out.println(map.isEmpty());  //false

        //clear：清除(直接清空，慎用)
        map.clear();
        System.out.println(map);    //{}

        //containsKey：查找键是否存在
        map.put("1","one");
        System.out.println(map.containsKey("1"));   //true
        System.out.println(map.containsKey("2"));   //false
    }
}

  • Map接口遍历方式

    • keySet：获取所有的键
    • entry：获取所有的关系k-v
    • values：获取所有值
    public class MapFor {
    public static void main(String[] args) {

        Map map = new HashMap();
        map.put("one","first");
        map.put("two", "second");
        map.put("three", "third");

        //使用key获取value=================================
        //取处所有的key
        Set set = map.keySet();

        //(1)增强for循环
        for (Object key : set) {
            System.out.println(key + "-" + map.get(key) );
        }

        //(2)迭代器
        Iterator iterator = set.iterator();

        while (iterator.hasNext()) {
            Object key =  iterator.next();
            System.out.println(key + "-" + map.get(key) );
        }

        //直接取出value================================
        Collection values = map.values();

        //(1)增强for
        for (Object value : values) {
            System.out.println(value);
        }

        //(2)迭代器
        Iterator iterator1 = values.iterator();
        while (iterator1.hasNext()) {
            Object next = iterator1.next();
            System.out.println(next);
        }

        //通过EntrySet获取K-v========================
        Set entrySet = map.entrySet();
        //(1)增强for
        for (Object entry : entrySet) {
            //将entry转为Map.Entry
            Map.Entry m =(Map.Entry) entry;
            System.out.println(m.getKey()+"-"+m.getValue());
        }

        //(2)迭代器
        Iterator iterator2 = entrySet.iterator();
        while (iterator2.hasNext()) {
            Object entry = iterator2.next(); //HashMap$Node -实现-> Map.Entry(getKey,getValue)
            //向下转型
            Map.Entry m =(Map.Entry) entry;
            System.out.println(m.getKey()+"-"+m.getValue());
        }


    }
}

3.Map实现类-HashMap

  • Map接口常用实现类： HashMap，HashTable和Properties
  • HashMap是Map接口使用频率最高的实现类
  • HashMap是以key-val对的方式来存储数据（HashMap￥Node类型）
  • key不能重复，但是value可以重复。允许使用null键和null值
  • 如果添加相同的key，则会覆盖原来的key-val，等同于修改
  • 与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的
  • HashMap没有实现同步，因此是线程不安全的

4.Map实现类-HashTable

  • 存放元素是键值对，即K_V
  • HashTable的键和值都不能为null
  • HashTable 使用方式 基本上和HashMap一样
  • Hashtable是线程安全的

5.Map实现类-Properties

  • Properties类继承自HashTable类并且实现了Map接口，也是使用一种键值对的形式来保存数据。
  • 他的使用特点和HashTable类似
  • Properties还可以用于从 xxx.properties文件中，加载数据到Properties类对象,并进行读取和修改

总结-开发中如何选择集合实现类

在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合
实现类特性进行选择，分析如下：

  • 先判断存储的类型（一组对象[单列或一组键值对[双列]）
  • 一组对象[单列]：Collection接口
    • 允许重复：List
      1. 增删多：LinkedList[底层维护了一个双向链表]
      2. 改查多：ArrayList[底层维护Object类型的可变数组]
    • 不允许重复：Set
      1. 无序：HashSet[底层是HashMap,维护了一个哈希表即（数组+链表+红黑树）]
      2. 排序：TreeSet
      3. 插入和取出顺序一致：LinkedHashSet,维护数组+双向链表
  • 一组键值对[双列]：Map
    1. 键无序：HashMap[底层是：哈希表jdk7:数组+链表，jdk8:数组+链表+红黑树]
    2. 键排序：TreeMap
    3. 键插入和取出顺序一致：LinkedHashMap
    4. 读取文件Properties
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值