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

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、付费专栏及课程。

余额充值