集合

集合

集合分为单列集合和双列集合。
Collection单列集合 （单列集合的顶级接口是Collection）

1. Collection集合的体系：
2.                                         Collection <E> (接口)
3.                                     /                            \
4.                         Set<E>(接口)                                   List<E>( 接    口   )
5.                         /        \                                   /        |           \
6.           HashSet<E>(实现类)    TreeSet<E>(实现类)  LinkedList<E>(实现类)    Vector(线程安全)   ArrayList<E>(实现类)
7.                      /
8.          LinkedHashSet<E>(实现类)

复制代码

Collection集合体系的特点:
Set系列集合： 添加的元素，是无序，不重复，无索引的。
-- HashSet：添加的元素，是无序，不重复，无索引的。
-- LinkedHashSet：添加的元素，是有序，不重复，无索引的。
List系列集合：添加的元素，是有序，可重复，有索引的。
-- LinkedList： 添加的元素，是有序，可重复，有索引的。
-- ArrayList： 添加的元素，是有序，可重复，有索引的。
-- Vector 是线程安全的，速度慢，工作中很少使用。所以本文没有总结。
Collection集合

简单代码举例List和Set一般标准代码的书写和规范

List：

1. // 有序 可重复 有索引
2.         Collection list = new ArrayList();  //多态
3.         list.add("Java");
4.         list.add("Java");
5.         list.add("Mybatis");
6.         list.add(23);
7.         list.add(23);
8.         list.add(false);
9.         list.add(false);
10.         System.out.println(list); //[Java, Java, Mybatis, 23, 23, false, false]

复制代码

Set

1. // 无序 不重复  无索引
2.         Collection list1 = new HashSet();
3.         list1.add("Java");
4.         list1.add("Java");
5.         list1.add("Mybatis");
6.         list1.add(23);
7.         list1.add(23);
8.         list1.add(false);
9.         list1.add(false);
10.         System.out.println(list1); // [Java, false, 23, Mybatis]

复制代码

Collection集合的常用API。

Collection是集合的祖宗类，它的功能是全部集合都可以继承使用的，所以要学习它。
Collection API如下:
- public boolean add(E e)：  把给定的对象添加到当前集合中 。
- public void clear() :清空集合中所有的元素。
- public boolean remove(E e): 把给定的对象在当前集合中删除。
- public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。
- public boolean isEmpty(): 判断当前集合是否为空。
- public int size(): 返回集合中元素的个数。
- public Object[] toArray(): 把集合中的元素，存储到数组中。
小结：
记住以上API。
代码：使用Collection集合常用的API

1. // HashSet:添加的元素是无序，不重复，无索引。
2.         Collection<String> c = new ArrayList<>();
3.         // 1.添加元素, 添加成功返回true。
4.         c.add("Java");
5.         c.add("HTML");
6.         System.out.println(c.add("HTML"));
7.         c.add("MySQL");
8.         c.add("Java");
9.         System.out.println(c.add("黑马"));
10.         System.out.println(c); // [Java, HTML, HTML, MySQL, Java, 黑马]
12.         // 2.清空集合的元素。
13.         // c.clear();
14.         // System.out.println(c);
16.         // 3.判断集合是否为空 是空返回true,反之。
17.         // System.out.println(c.isEmpty());
19.         // 4.获取集合的大小。
20.         System.out.println(c.size());
22.         // 5.判断集合中是否包含某个元素。
23.         System.out.println(c.contains("Java"));  // true
24.         System.out.println(c.contains("java")); // false
25.         System.out.println(c.contains("黑马")); // true
27.         // 6.删除某个元素:如果有多个重复元素默认删除前面的第一个！
28.         System.out.println(c.remove("java")); // false
29.         System.out.println(c);
30.         System.out.println(c.remove("Java")); // true
31.         System.out.println(c);
33.         // 7.把集合转换成数组  [HTML, HTML, MySQL, Java, 黑马]
34.         Object[] arrs = c.toArray();
35.         System.out.println("数组：" + Arrays.toString(arrs));
38.         System.out.println("----------------------拓展----------------------");
39.         Collection<String> c1 = new ArrayList<>();
40.         c1.add("java1");
41.         c1.add("java2");
42.         Collection<String> c2 = new ArrayList<>();
43.         c2.add("赵敏");
44.         c2.add("殷素素");
45.         // addAll把c2集合的元素全部倒入到c1中去。
46.         c1.addAll(c2);
47.         System.out.println(c1);
48.         System.out.println(c2);

复制代码

Collection集合的遍历方式。

什么是遍历? 为什么开发中要遍历？
遍历就是一个一个的把容器中的元素访问一遍。
开发中经常要统计元素的总和，找最值，找出某个数据然后干掉等等业务都需要遍历。
Collection集合的遍历方式是全部集合都可以直接使用的，所以我们学习它。
Collection集合的遍历方式有三种:
（1）迭代器。
（2）foreach(增强for循环)。
（3）JDK 1.8开始之后的新技术Lambda表达式(了解)
1.迭代器遍历集合。

-- 方法：
public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的
boolean hasNext():判断是否有下一个元素，有返回true ,反之。
E next():获取下一个元素值！
--流程：
1.先获取当前集合的迭代器
Iterator it = lists.iterator();
2.定义一个while循环，问一次取一次。
通过it.hasNext()询问是否有下一个元素，有就通过
it.next()取出下一个元素。
代码：

1. ArrayList<String> lists = new ArrayList<>();
2.         lists.add("赵敏");
3.         lists.add("小昭");
4.         lists.add("素素");
5.         lists.add("灭绝");
6.         System.out.println(lists);
7.         // [赵敏, 小昭, 素素, 灭绝]
9.         // 1、得到当前集合的迭代器对象。
10.         Iterator<String> it = lists.iterator();
11. //        String ele = it.next();
12. //        System.out.println(ele);
13. //        System.out.println(it.next());
14. //        System.out.println(it.next());
15. //        System.out.println(it.next());
16.         // System.out.println(it.next()); // NoSuchElementException 出现无此元素异常的错误
18.         // 2、定义while循环
19.         while (it.hasNext()){
20.             String ele = it.next();
21.             System.out.println(ele);
22.         }

复制代码

2.foreach(增强for循环)遍历集合。

格式及说明：
foreach是一种遍历形式，可以遍历集合或者数组。
foreach遍历集合实际上是迭代器遍历集合的简化写法。
foreach遍历的关键是记住格式：
for(被遍历集合或者数组中元素的类型 变量名称 : 被遍历集合或者数组){   }
代码：

1. Collection<String> lists = new ArrayList<>();
2.         lists.add("赵敏");
3.         lists.add("小昭");
4.         lists.add("殷素素");
5.         lists.add("周芷若");
6.         System.out.println(lists);
7.         // [赵敏, 小昭, 殷素素, 周芷若]
8.         //  ele
10.         for (String ele : lists) {
11.             System.out.println(ele);
12.         }
14.         System.out.println("------------------");
15.         double[] scores = {100, 99.5 , 59.5};
16.         for (double score : scores) {
17.             System.out.println(score);
18. //            if(score == 59.5){
19. //                score = 100.0; // 修改无意义，不会影响数组的元素值。
20. //            }
21.         }
22.         System.out.println(Arrays.toString(scores));

复制代码

3.JDK 1.8开始之后的新技术Lambda表达式。

代码：

1. Collection<String> lists = new ArrayList<>();
2.         lists.add("赵敏");
3.         lists.add("小昭");
4.         lists.add("殷素素");
5.         lists.add("周芷若");
6.         System.out.println(lists);
7.         // [赵敏, 小昭, 殷素素, 周芷若]
9.         lists.forEach(new Consumer<String>() {
10.             @Override
11.             public void accept(String s) {
12.                 System.out.println(s);
13.             }
14.         });
16. //        lists.forEach(s -> {
17. //                System.out.println(s);
18. //        });
20.         // lists.forEach(s ->  System.out.println(s) );
22.         lists.forEach(System.out::println );//最终简化版本

复制代码

实践：使用集合存储自定义类对象并将其遍历

要求：定义一个集合对象存储3部电影对象并遍历集合容器中的每个电影对象
代码：

1. // 1、定义一个电影类
2.         // 2、定义一个集合对象存储3部电影对象
3.         Collection<Movie> movies = new ArrayList<>();
4.         movies.add(new Movie("《你好，李焕英》", 9.5, "张小斐,贾玲,沈腾,陈赫"));
5.         movies.add(new Movie("《唐人街探案》", 8.5, "王宝强,刘昊然,美女"));
6.         movies.add(new Movie("《刺杀小说家》",8.6, "雷佳音,杨幂"));
8.         System.out.println(movies);
10.         // 3、遍历集合容器中的每个电影对象
11.         for (Movie movie : movies) {
12.             System.out.println("片名：" + movie.getName());
13.             System.out.println("得分：" + movie.getScore());
14.             System.out.println("主演：" + movie.getActor());
15.         }

复制代码

子接口List

• 1、List集合继承了Collection集合的全部功能，"同时因为List系列集合有索引"，
  
• 2、因为List集合多了索引，所以多了很多按照索引操作元素的功能:
  
• 3、ArrayList实现类集合底层基于数组存储数据的，查询快，增删慢！
  - public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
  - public E get(int index):返回集合中指定位置的元素。
  - public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
  - public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回更新前的元素值。
  小结：
  ArrayList集合的底层是基于数组存储数据。查询快，增删慢！（相对的）
  

总结：
如果查询多而增删少用ArrayList集合。(用的最多的)
如果查询少而增删首尾较多用LinkedList集合。

• List系列集合的遍历方式有：4种。
  List系列集合多了索引，所以多了一种按照索引遍历集合的for循环。
  
  
  
  • List遍历方式：
    （1）for循环。(独有的，因为List有索引)。
    （2）迭代器。
    （3）foreach。
    （4）JDK 1.8新技术。
    
  
  

ArrayList实现类

使用ArrayList创建集合对象并使用API对集合中的对象进行操作

代码：

1. public static void main(String[] args) {
2.         // 1.创建一个ArrayList集合对象：
3.         // List:有序，可重复，有索引的。
4.         ArrayList<String> list = new ArrayList<>(); // 一行经典代码！
5.         list.add("Java");
6.         list.add("Java");
7.         list.add("HTML");
8.         list.add("HTML");
9.         list.add("MySQL");
10.         list.add("MySQL");
12.         // 2.在某个索引位置插入元素。
13.         list.add(2, "白马");
14.         System.out.println(list);// [Java, Java, 白马, HTML, HTML, MySQL, MySQL]
16.         // 3.根据索引删除元素,返回被删除元素
17.         System.out.println(list.remove(1));// Java
18.         System.out.println(list);// [Java, 白马, HTML, HTML, MySQL, MySQL]
20.         // 4.根据索引获取元素:public E get(int index):返回集合中指定位置的元素。
21.         System.out.println(list.get(1));// 白马
23.         // 5.修改索引位置处的元素: public E set(int index, E element)
24.         System.out.println(list.set(1, "安师傅"));  // 白马 （返回被修改的元素）
25.         System.out.println(list); // [Java, 安师傅, HTML, HTML, MySQL, MySQL]
26.     }

复制代码

使用ArrayList实现List的四种遍历

代码

1. public static void main(String[] args) {
2.         List<String> lists = new ArrayList<>();
3.         lists.add("java1");
4.         lists.add("java2");
5.         lists.add("java3");
7.         /** （1）for循环。 */
8.         System.out.println("-----------------------");
10.         for (int i = 0; i < lists.size(); i++) {
11.             String ele = lists.get(i);
12.             System.out.println(ele);
13.         }
16.         /** （2）迭代器。 */
17.         System.out.println("-----------------------");
18.         Iterator<String> it = lists.iterator();
19.         while (it.hasNext()){
20.             String ele = it.next();
21.             System.out.println(ele);
22.         }
24.         /** （3）foreach */
25.         System.out.println("-----------------------");
26.         for (String ele : lists) {
27.             System.out.println(ele);
28.         }
30.         /** （4）JDK 1.8开始之后的Lambda表达式  */
31.         System.out.println("-----------------------");
32.         lists.forEach(s -> {
33.             System.out.println(s);
34.         });
36.     }

复制代码

研究集合遍历并删除元素可能出现的：并发修改异常问题。

代码

1. public static void main(String[] args) {
2.         // 1、准备数据
3.         ArrayList<String> list = new ArrayList<>();
4.         list.add("马儿");
5.         list.add("Java");
6.         list.add("Java");
7.         list.add("赵敏");
8.         list.add("赵敏");
9.         list.add("素素");
10.         System.out.println(list);
11.         // [马儿, Java, Java, 赵敏, 赵敏, 素素]
12.         //        it
14.         // 需求：删除全部的Java信息。
15.         // a、迭代器遍历删除
16.         Iterator<String> it = list.iterator();
17.         while (it.hasNext()){
18.             String ele = it.next();
19.             if("Java".equals(ele)){
20.                 // 删除Java
21. //                 list.remove(ele); // 集合删除会出毛病
22.                 it.remove(); // 删除迭代器所在位置的元素值（没毛病）
23.             }
24.         }
25.         System.out.println(list);
27.         // b、foreach遍历删除 (会出现问题，这种无法解决的，foreach不能边遍历边删除，会出bug)
28. //        for (String s : list) {
29. //            if("Java".equals(s)){
30. //                list.remove(s);
31. //            }
32. //        }
34.         // c、lambda表达式(会出现问题，这种无法解决的，Lambda遍历不能边遍历边删除，会出bug)
35. //        list.forEach(s -> {
36. //            if("Java".equals(s)){
37. //                list.remove(s);
38. //            }
39. //        });
41.         // d、for循环(边遍历边删除集合没毛病，但是必须从后面开始遍历删除才不会出现漏掉应该删除的元素)
42.         for (int i = list.size() - 1; i >= 0 ; i--) {
43.             String ele = list.get(i);
44.             if("Java".equals(ele)){
45.                 list.remove(ele);
46.             }
47.         }
48.         System.out.println(list);
49.     }

复制代码

总结：

• 1.使用迭代器删除时我们要删除迭代器所在位置的元素值，而不是使用集合删除，（使用集合删除会直接报错：ConcurrentModificationException）。
  
• 2.使用foreach遍历删除和lambda遍历删除会出bug，他们都不能边遍历边删除。
  
• 3.使用for循环遍历删除集合时，如果正向遍历注意在删除成功之后 i--，否则会漏删，如果逆向遍历删除那么没有任何问题。
  

LinkedList实现类

• LinkedList也是List的实现类：底层是基于双链表的，增删比较快，查询慢！！
  
• LinkedList是支持双链表，定位前后的元素是非常快的，增删首尾的元素也是最快的
  
• 所以LinkedList除了拥有List集合的全部功能还多了很多操作首尾元素的特殊功能：
  - public void addFirst(E e):将指定元素插入此列表的开头。
  - public void addLast(E e):将指定元素添加到此列表的结尾。
  - public E getFirst():返回此列表的第一个元素。
  - public E getLast():返回此列表的最后一个元素。
  - public E removeFirst():移除并返回此列表的第一个元素。
  - public E removeLast():移除并返回此列表的最后一个元素。
  - public E pop():从此列表所表示的堆栈处弹出一个元素。
  - public void push(E e):将元素推入此列表所表示的堆栈。
  
• 小结：
  LinkedList是支持双链表，定位前后的元素是非常快的，增删首尾的元素也是最快的。
  所以提供了很多操作首尾元素的特殊API可的实以做栈和队列现。
  

使用LinkedList完成队列结构、栈结构及其简单操作（双链表）

代码

1. // LinkedList可以完成队列结构，和栈结构 （双链表）
2.         // 1、做一个队列：
3.         LinkedList<String> queue = new LinkedList<>();
4.         // 入队
5.         queue.addLast("1号");
6.         queue.addLast("2号");
7.         queue.addLast("3号");
8.         System.out.println(queue);
9.         // 出队
10.         // System.out.println(queue.getFirst());
11.         System.out.println(queue.removeFirst());
12.         System.out.println(queue.removeFirst());
13.         System.out.println(queue);
15.         // 2、做一个栈
16.         LinkedList<String> stack = new LinkedList<>();
17.         // 入栈 压栈 (push)
18.         stack.push("第1颗子弹");
19.         stack.push("第2颗子弹");
20.         stack.push("第3颗子弹");
21.         stack.push("第4颗子弹");
22.         System.out.println(stack);
24.         // 出栈  弹栈 pop
25.         System.out.println(stack.pop());
26.         System.out.println(stack.pop());
27.         System.out.println(stack.pop());
28.         System.out.println(stack);

复制代码

子接口Set

Map双列集合 （双列集合的顶级接口是Map）




免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！