java-集合

java-集合

一.简介

1.可以动态保存任意多个对象，使用比较方便
2.提供了一系列方便的操作对象的方法：add、remove、set、get等
3.使用集合添加，删除新元素的示意代码

集合主要分成两大类，主要分成Collection和Map两大类，其中Collection可以分成List和Set

二.Collection接口和常用方法

1.常用方法

Collection接口常用方法，以实现子类ArrayList来演示
1.add：添加单个元素
2.remove：删除指定元素
3.contains：查找元素是否存在
4.size：获取元素个数
5.isEmpty：判断是否为空
6.clear：清空
7.addAll：添加多个元素
8.containsAll：查找多个元素是否都存在
9.removeAll：删除多个元素

以ArrayList实现来演示

        List list = new ArrayList();
        // add:添加单个元素
        list.add("jack");
        list.add(10);//list.add(new Integer(10))
        list.add(true);
        System.out.println("list=" + list);
        // remove:删除指定元素
        //list.remove(0);//删除第一个元素
        list.remove(true);//指定删除某个元素
        System.out.println("list=" + list);
        // contains:查找元素是否存在
        System.out.println(list.contains("jack"));//T
        // size:获取元素个数
        System.out.println(list.size());//2
        // isEmpty:判断是否为空
        System.out.println(list.isEmpty());//F
        // clear:清空
        list.clear();
        System.out.println("list=" + list);
        // addAll:添加多个元素
        ArrayList list2 = new ArrayList();
        list2.add("红楼梦");
        list2.add("三国演义");
        list.addAll(list2);
        System.out.println("list=" + list);
        // containsAll:查找多个元素是否都存在
        System.out.println(list.containsAll(list2));//T
        // removeAll：删除多个元素
        list.add("聊斋");
        list.removeAll(list2);
        System.out.println("list=" + list);//[聊斋]
        // 说明：以 ArrayList 实现类来演示.

2.遍历方式1–迭代器

1.Iterator对象称为迭代器，主要用于遍历Collection集合中的元素
2.所有实现了Collection接口的集合类都有一个iterator()方法，用于返回一个实现了Iterator接口的对象，即可以返回一个迭代器
3.Iterator仅用于遍历集合，Iterator本身并不存放对象

迭代器的执行原理：

Iterator iterator=coll.iterator();//得到一个集合的迭代器
//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
//next()作用：1.下移 2.将下移以后集合位置上的元素返回
}

举例说明：

        Collection col = new ArrayList();
        col.add(new Book("三国演义", "罗贯中", 10.1));
        col.add(new Book("小李飞刀", "古龙", 5.1));
        col.add(new Book("红楼梦", "曹雪芹", 34.6));
        //System.out.println("col=" + col);
        //现在老师希望能够遍历 col 集合
        //1. 先得到 col 对应的 迭代器
        Iterator iterator = col.iterator();
        //2. 使用 while 循环遍历
        // while (iterator.hasNext()) {//判断是否还有数据
        // //返回下一个元素，类型是 Object
        // Object obj = iterator.next();
        // System.out.println("obj=" + obj);
        // }
        //老师教大家一个快捷键，快速生成 while => itit
        //显示所有的快捷键的的快捷键 ctrl + j
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }
        //3. 当退出 while 循环后 , 这时 iterator 迭代器，指向最后的元素
        // iterator.next();//NoSuchElementException
        //4. 如果希望再次遍历，需要重置我们的迭代器
        iterator = col.iterator();
        System.out.println("===第二次遍历===");
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }

3.for循环增强版

增强for就是简化版的iterator,本质一样，只能用于遍历集合或数组

for(元素类型 元素名：集合名或数组名){
	访问元素
}

三.List接口和常用方法

1.List接口的特点

List接口是Collection接口的子接口
特点：
1.List集合类中元素有序(添加顺序和取出顺序一致)、且可重复
2.List集合中的每个元素都有其对应的顺序索引，即支持索引。
3.List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素

2.常用的方法

void add(int index, Object ele):在 index 位置插入 ele 元素
boolean addAll(int index, Collection eles):从 index 位置开始将 eles 中的所有元素添加进来
Object get(int index):获取指定 index 位置的元素
int indexOf(Object obj):返回 obj 在集合中首次出现的位置
int lastIndexOf(Object obj):返回 obj 在当前集合中末次出现的位置
Object remove(int index):移除指定 index 位置的元素，并返回此元素
Object set(int index, Object ele):设置指定 index 位置的元素为 ele , 相当于是替换.
List subList(int fromIndex, int toIndex):返回从 fromIndex 到 toIndex 位置的子集合，左闭右开

3.List的三种遍历方式

        //1. 迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);
        }
        System.out.println("=====增强 for=====");
        //2. 增强 for
        for (Object o : list) {
            System.out.println("o=" + o);
        }
        System.out.println("=====普通 for====");
        //3. 使用普通 for
        for (int i = 0; i < list.size(); i++) {
            System.out.println("对象=" + list.get(i));
        }

4.ArrayList类

1.ArrayList可以加入null，并且多个
2.ArrayList是由数组来实现数据存储的
3.ArrayList基本等同于Vector，除了ArrayList是线程不安全（执行效率高）看源码，在多线程情况下，不建议使用ArrayList

5.Vector类

1.Vector底层也是一个对象数组
2.Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized
3.在开发中，需要线程同步安全时，考虑使用Vector

6.LinkedList类

1.LinkedList底层实现了双向链表和双端队列特点
2.可以添加任意元素(元素可以重复)，包括null
3.线程不安全，没有实现同步

四.Set接口和常用方法

1.基本介绍

1.无序(添加和取出的顺序不一致)，没有索引
2.不允许重复元素，所以最多包含一个null

2.常用方法

与List接口一样，Set接口也是Collection的子接口，所以常用方法和Collection接口一样

3.Set接口的遍历方式

同Collection的遍历方式一样，因为Set接口是Collection接口的子接口
1.可以使用迭代器
2.增强for
3.不能使用索引的方式来获取

        //1. 以 Set 接口的实现类 HashSet 来讲解 Set 接口的方法
        //2. set 接口的实现类的对象(Set 接口对象), 不能存放重复的元素, 可以添加一个 null
        //3. set 接口对象存放数据是无序(即添加的顺序和取出的顺序不一致)
        //4. 注意：取出的顺序的顺序虽然不是添加的顺序，但是他的固定.
        Set set = new HashSet();
        set.add("john");
        set.add("lucy");
        set.add("john");//重复
        set.add("jack");
        set.add("hsp");
        set.add("mary");
        set.add(null);//
        set.add(null);//再次添加 null
        for(int i = 0; i <10;i ++) {
            System.out.println("set=" + set);
        }
        //遍历
        //方式 1： 使用迭代器
        System.out.println("=====使用迭代器====");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }
        set.remove(null);
        //方式 2: 增强 for
        System.out.println("=====增强 for====");
        for (Object o : set) {
            System.out.println("o=" + o);
        }
        //set 接口对象，不能通过索引来获取

4.HashSet类

特点：
1.HashSet实现了Set接口
2.HashSet实际上是HashMap
3.可以存放null值，但是只能有一个
4.不保证元素时有序的，取决于hash后，再确定索引的结果
5.不能有重复元素/对象

5.LinkedHashSet

特点：
1.是HashSet的子类
2.底层是一个LinkedHashMap，底层维护了一个数组+双向链表
3.LinkedHashSet根据元素的hashCode值在决定元素的存储位置，同时使用链表维护元素的次序图
4.不允许添加重复元素

可以重写类中的重写 equals 方法 和 hashCode来修改相同判断

6.TreeSet

在构造器中添加匿名内部类来指定顺序，举例如果我们按字符串长度来比较，相同字符串长度的不会加入到里面，可以查看源码

五.Map接口和常用方法

1.特点

1.Map与Collection并列存在，用于保存具有映射关系的数据：key-value
2.map中的key和value可以是任意引用类型的数据，会封装到HashMap$Node对象中
3.Map中的key不允许重复
4.Map中的value可以重复
5.Map中的key可以为null，value也可以为null，但是key为null只能有一个
6.常用String类作为Map的key
7.key和value存在单向一对一关系

2.常用方法

put:(k,v) 可以添加/修改元素
remove(k) 根据键删除映射关系
get(k) 根据键获取值
size 获取元素个数
isEmpty 判断个数是否为0
clear 清除k-v
containsKey 查找键是否存在

3.遍历方法

        Map map = new HashMap();
        map.put("邓超", "孙俪");
        map.put("王宝强", "马蓉");
        map.put("宋喆", "马蓉");
        map.put("刘令博", null);
        map.put(null, "刘亦菲");
        map.put("鹿晗", "关晓彤");
        //第一组: 先取出 所有的 Key , 通过 Key 取出对应的 Value
        Set keyset = map.keySet();
        //(1) 增强 for
        System.out.println("-----第一种方式-------");
        for (Object key : keyset) {
            System.out.println(key + "-" + map.get(key));
        }
        //(2) 迭代器
        System.out.println("----第二种方式--------");
        Iterator iterator = keyset.iterator();
        while (iterator.hasNext()) {
            Object key = iterator.next();
            System.out.println(key + "-" + map.get(key));
        }
        //第二组: 把所有的 values 取出
        Collection values = map.values();
        //这里可以使用所有的 Collections 使用的遍历方法
        //(1) 增强 for
        System.out.println("---取出所有的 value 增强 for----");
        for (Object value : values) {
            System.out.println(value);
        }
        //(2) 迭代器
        System.out.println("---取出所有的 value 迭代器----");
        Iterator iterator2 = values.iterator();
        while (iterator2.hasNext()) {
            Object value = iterator2.next();
            System.out.println(value);
        }
        //第三组: 通过 EntrySet 来获取 k-v
        Set entrySet = map.entrySet();// EntrySet<Map.Entry<K,V>>
        //(1) 增强 for
        System.out.println("----使用 EntrySet 的 for 增强(第 3 种)----");
        for (Object entry : entrySet) {
        //将 entry 转成 Map.Entry
            Map.Entry m = (Map.Entry) entry;
            System.out.println(m.getKey() + "-" + m.getValue());
        }
        //(2) 迭代器
        System.out.println("----使用 EntrySet 的 迭代器(第 4 种)----");
        Iterator iterator3 = entrySet.iterator();
        while (iterator3.hasNext()) {
            Object entry = iterator3.next();
        //System.out.println(next.getClass());//HashMap$Node -实现-> Map.Entry (getKey,getValue)
        //向下转型 Map.Entry
            Map.Entry m = (Map.Entry) entry;
            System.out.println(m.getKey() + "-" + m.getValue());
        }

4.HashMap类

是Map接口使用频率最高的实现类
如果添加相同的key，则会覆盖原来的key-val,等同于修改元素
HashMap没有实现同步，因此是线程不安全的

5.Hashtable类

使用基本和HashMap一样，是线程安全的，效率较高，但是键和值都不能为null

6.Properties类

主要是从xxx.properties文件中加载数据

六.选择合适的实现类

1.先判断存储类型(单列还是双列)

单列：Collection接口
允许重复：List
增删多：LinkedList
改查多：ArrayList
不允许重复：Set
无序：HashSet
排序：TreeSet
插入和取出顺序一致：LinkedHashSet

双列： Map
键无序：HashMap
键排序：TreeMap
键插入和取出顺序一致：LinkedHashMap
读取文件：Properties

七.Collections工具类

Collections是一个操作Set、List和Map等集合的工具类
Collections中通了一系列静态的方法对集合元素进行排序、查询和修改

排序方法：
1.reverse(List):反转List中元素的顺序
2.shuffle(List):对List集合元素进行随机排序
3.sort(List):根据自然顺序对元素进行升序排序
4.sort(List,Comparator):根据指定顺序进行排序
5.swap(List,int,int)交换顺序

查找和替换
1.max 返回元素最大值(自然顺序)
2.max(Collection,Comparator) 根据指定顺序返回最大值
3.min同上
4.frequenct(Collection,Object)返回指定集合中指定元素的出现次数
5.copy(List dest,List src)将src中的内容赋值到dest中
6.boolean replaceAll(List list,Object oldVal,Object newVal):使用新值替换List对象的所有旧值