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

莱布尼杰

已于 2022-05-05 22:43:04 修改

阅读量1.2k

点赞数 3

分类专栏： Java 文章标签： java

于 2022-04-11 17:55:55 首次发布

本文链接：https://blog.youkuaiyun.com/Editplusplusplus/article/details/124105141

版权

Java 专栏收录该内容

7 篇文章

订阅专栏

文章目录

1.List接口和常用方法
- 1. List接口基本介绍
- 2. List接口常用方法
2.Set接口和常用方法
3. Map接口和常用方法

1.List接口和常用方法

1. List接口基本介绍

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

List集合类中元素有序（即添加顺序和取出顺序一致）、且可重复
List集合中的每个元素都有其对应的顺序索引，即支持索引
List容器中的元素都对应一个整数型的序号记载其在元素中的位置，可以根据序号存取容器中的元素
常用的List接口的实现有：ArrayList、LinkedList和Vector
Vector、ArrayList、LinkedList的区别

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值来决定元素的存储位置，同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存的
- 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