Java基础——集合

一、集合的框架体系

二、 Collection接口和常用方法

2.1 Collection 接口常用方法

为单列集合的顶层接口，所有方法被List和Set系列集合共享

1. add:添加单个元素
2. remove:删除指定元素
3. list.remove(0);//删除第一个元素
4. list.remove(yrh);//指定删除某个元素
5. contains:查找元素是否存在
6. size:获取元素个数
7. isEmpty:判断是否为空
8. clear:清空集合中所有的元素
9. addAll:添加多个元素
10. containsAll:查找多个元素是否都存在
11. removeAll：删除多个元素

2.2 Collection 接口遍历元素方式

2.2.1 使用Iterator迭代器

所有实现了Collection接口的集合类都有一个iterator方法，用于返回一个实现了Iterator接口的对象，即可以返回一个迭代器

1.  在调用Iterator.next()方法前必须调用Iterator.hasNext()进行监测，否则可能抛出NoSuchElementException异常。使用一次hasnext方法只能使用一次next方法。
2. 迭代器遍历时，不能用集合的方法进行新增或者删除（并发修改异常），必须使用迭代器里面的方法来进行删除
3. 迭代器遍历完毕，指针不会复位

public class Main {
    public static void main(String[] args) {
        List<Object> list = new ArrayList<>();
        list.add("123");
        list.add(10086);
        list.add('2');
        list.add("马超");
        Iterator<Object> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

123
10086
2
马超

 2.2.2 使用增强for循环

增强for底层就是迭代器，为了简化迭代器的代码书写。所有的单列集合和数组才能用增强for进行遍历。

由于set方法没有索引，因此无法使用普通for循环来遍历

public class Main {
    public static void main(String[] args) {
        List<Object> list = new ArrayList<>();
        list.add("123");
        list.add(10086);
        list.add('2');
        list.add("马超");
        for (Object o :list) {
            System.out.println(o);
        }

    }
}

修改增强for中的变量，不会修改集合中原本的数据。 

2.2.3 使用增强for循环Lambda表达式

                List<Object> list = new ArrayList<>();
                list.add("123");
                list.add(10086);
                list.add('2');
                list.add("马超");
                list.forEach(s -> {
                    System.out.println(s);
                });

2.3 List接口和常用方法

 特点：

1. List集合类中元素有序、且可重复
2. List集合类中每个元素均有对应的顺序索引，即支持索引
3. List容器中的元素每对应一个整数型的序号记载其在容器中的位置，可以根据序号存取元素

2.3.1 List接口常用方法[ArrayList, LinkedList,Vector] 

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

public class Main {
    public static void main(String[] args) {
        List<Object> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(1,3);
        List<Object> list2 = new ArrayList<>();
        list.add(4);
        list.add(5);
        list.add(6);
        list.addAll(1,list2);
        System.out.println(list);
        System.out.println(list.get(3));
        System.out.println(list.indexOf(4));
        System.out.println(list.lastIndexOf(5));
        list.remove(4);
        list.set(1,10);
        System.out.println(list);
        System.out.println(list.subList(1,4));
    }
}

[1, 3, 2, 4, 5, 6]
4
3
4
[1, 10, 2, 4, 6]
[10, 2, 4]

2.3.2 List 的三种遍历方式

2.3.3 ArrayList 底层结构和源码分析

多线程情况下，ArrayList不安全，不建议使用

size表示元素个数及下次存入位置 。

如果一次添加多个元素，1.5倍还放不下，则新数组的长度以实际为准

2.3.4 Vector 底层结构和源码剖析

ArrayList 和 Vector的比较 

 

 2.3.5 LinkedList 底层结构

特有方法	说明
addFirst（E e）	在该列表开头插入特定元素
addLast（E e）	将特定元素追加到末尾
getFirst（）	返回列表中第一个元素
getLast（）	返回列表中最后一个元素
removeFirst（）	删除并返回第一个元素
removeLast（）	删除并返回最后一个元素

ArrayList 和 LinkedList 的比较

2.4 Set接口和常用方法

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

2.4.1 Set接口的遍历方式

1. 可以使用迭代器
2. 增强for
3. 不能使用索引方式来获取

2.4.2 Set 接口实现类-HashSet

2.4.3 Set 接口实现类-LinkedHashSet

2.5 Map 接口和常用方法

 常用方法：

1. containsKey：查找键是否存在
2. keySet：获取所有的键
3. entrySet：获取所有关系k-v
4. values：获取所有的值

Map遍历方式如下：

public class Main {
    public static void main(String[] args) {
        Map map = new HashMap();
        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());
        }
    }
}

2.5.1 Map 接口实现类-HashMap

 HashMap 底层机制及源码剖析

 2.5.2 Map 接口实现类-Hashtable

 

2.5.3 Map 接口实现类-Properties

2.6 如何选择合适的集合实现类

2.7 Collections 工具类

常用方法：

1. reverse（List）：反转list中元素的顺序
2. shufle（List）：对list集合元素进行随机序
3. sort（List）：根据元素的自然排序对指定List集合元素按升序排序
4. sort（List，Comparator）：根据指定的Comparator产生的顺序对List集合元素进行排序
5. swap（List，int，int）：将指定的List集合中的i处元素和j处元素进行交换
6. max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
7. int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
8. Object min(Collection)：根据元素的自然顺序，返回给定集合中的最小元素
9. void copy(List dest,List src)：将 src 中的内容复制到 dest 中
10. boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(1);
        integers.add(1213);
        integers.add(1241241);
        integers.add(124141);
        integers.add(112);
        Collections.sort(integers, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(integers);
        Collections.reverse(integers);
        System.out.println(integers);
        Collections.shuffle(integers);
        System.out.println(integers);
        Collections.swap(integers,1,2);
        System.out.println(integers);
        System.out.println(Collections.max(integers));
        System.out.println(Collections.min(integers));
    }
}

 [1241241, 124141, 1213, 112, 1]
[1, 112, 1213, 124141, 1241241]
[1, 124141, 1213, 1241241, 112]
[1, 1213, 124141, 1241241, 112]
1241241
1