B站 韩顺平 老师课程的笔记

集合（collection）

本文件讲的是实现 Collection 接口的集合的共性
独有的看别的文件

集合的优点

  1. 可以==动态==保存任意多个对象，使用比较方便
  2. 提供一系列方便的操作对象的方法：add、remove、set、get 等（相当于增删改查都写好了）
  3. 使用集合添加，删除新元素更简洁方便

数组的不足之处

  1. 长度开始必须指定，而且一旦指定不能更改
  2. 保存的必须为同一类型的的元素
  3. 使用数组进行增加/删除元素比较麻烦
    总之，灵活性不够

集合的框架体系（常用）

Collection 接口继承了 Iterable 接口
Collection 接口被 List 接口和 Set 接口实现了
List 接口被 Vector、ArrayList、LinkedList 类实现了
Set 接口被 TreeSet、HashSet 类实现了


List 是有序的，Set 是无序的(有序指的是添加顺序和取出顺序相同)

不同集合之间的区别

取长度方面

==主要注意是 length、length()还是 size()==

普通数组：int[] a = new int[10]; ==> a.length;

字符串：String a = “zhang”; ==> a.length();
StringBuffer、StringBuilder ==> a.length();

Collection(List(ArrayList、LinkedList、Vector)、Set(TreeSet、HashSet)) ==> col.zise();
Map(HashMap、TreeMap、HashTable) ==> map.size();

Stack ==> stack.size();
Queue(LinkedList、ArrayQueue) ==> queue.size();
Deque(ArrayDeque、LinkedList) ==> deque.size();
==总结==
普通数组用 length;字符串以及和字符串有关的 StringBuffer 等用 length();集合有关的都用 size()

存取方法

Collection 接口下的 List、Set 接口的方法都是使用 add()添加、使用 get()取出元素

Map 接口下的实现类都是使用 put(K,V)进行存，使用 get()取

Stack 使用 push()或 add()存、使用 pop()、get()、peek()取

Queue、和 Deque 都是接口，其实现类都可是 LinkedList,使用 offer()、add()进行存、使用 poll()、pop()、peek()、get()取

常用方法

add:添加单个元素
remove:删除单个元素
contains：查找元素是否存在
size:获取元素个数
isEmpty:判断是否为空
clear:清空
addAll:添加多个元素
containsAll:查找多个元素是否都存在
removeAll:删除多个元素
以 ArrayList 演示，可看文件：ArrayList

代码展示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
public static void main(String[] args) {
  List arrayList = new ArrayList();//编译类型为ArrayList的接口

//        add:添加当单个元素,参数类型是Object，所以所有类型的对象都可添加进同一个arrayList
  arrayList.add("jack");
  arrayList.add(10);
  arrayList.add(true);
  arrayList.add(21.001);
  arrayList.add(3, false);//在指定位置（下标为3的前面,添加后新的对象的下标就是3了）添加一个对象（false）(List接口中特有的)
  //可如此直接输出集合内容，格式和Arrays.toString()一样，输出结果：arrayList= [jack, 10, true, false, 21.001]
  System.out.println("arrayList= " + arrayList);

//        remove:删除单个元素
  arrayList.remove(0);//删除第一个元素（按下标索引删除）
  System.out.println("arrayList= " + arrayList);//输出arrayList= [10, true, false, 21.001]
  arrayList.remove(true);//指定对象删除
  System.out.println("arrayList= " + arrayList);//输出arrayList= [10, false, 21.001]
  arrayList.add(0, "tom");

//        contains:查找元素是否存在，返回值为Boolean类型
  System.out.println("找jack " + arrayList.contains("jack"));//输出：找jack false
  System.out.println("找tom " + arrayList.contains("tom"));//输出：找tom true
  boolean con = arrayList.contains(false);
  System.out.println("找false(arrayList中的一个对象) " + con);//输出：找false(arrayList中的一个对象) true

//        size:获取元素个数，返回值是int类型的
  System.out.println("先看一下有几个元素：" + arrayList);//输出：先看一下有几个元素：[tom, 10, false, 21.001]（4个元素）
  System.out.println("用size()输出元素个数：" + arrayList.size());//输出：用size()输出元素个数：4
  int size = arrayList.size();
  System.out.println("得到返回值后再输出" + size);//输出：得到返回值后再输出4

//        isEmpty:判断是否为空，返回值为boolean
  System.out.println("arrayList.isEmpty(): " + arrayList.isEmpty());//输出：arrayList.isEmpty(): false
  List arrayList2 = new ArrayList();//创建一个空集合
  System.out.println("arrayList2.isEmoty(): " + arrayList2.isEmpty());//输出：arrayList2.isEmoty(): true

//        clear:清空
  arrayList2.add("有元素了");
  arrayList2.add("yes");
  System.out.println("调用clear()前的arrayList2: "+arrayList2);//输出：调用clear()前的arrayList2: [有元素了, yes]
  arrayList2.clear();//将arratList2的元素清空
  System.out.println("调用clear()后的arrayList2: "+arrayList2);//输出：调用clear()后的arrayList2: []

//        addAll:添加多个元素
  System.out.println("使用addAll()前的arrayList: " + arrayList);//输出：使用addAll()前的arrayList: [tom, 10, false, 21.001]
  //先给arrayList2添加两个元素（之前被clear()了）
  arrayList2.add("西游记");
  arrayList2.add("三国演义");
  arrayList.addAll(arrayList2);//将arrayList2的所有元素添加到末尾
  System.out.println("使用addAll()后的arrayList: " + arrayList);//输出：使用addAll()后的arrayList: [tom, 10, false, 21.001, 西游记, 三国演义]

//        containsAll:查找多个元素是否都存在,也是返回boolean类型的值
  System.out.println("arrayList" + arrayList);
  System.out.println("arrayList2" + arrayList2);
  System.out.println(arrayList.containsAll(arrayList2));//输出true

//        removeAll:删除多个元素
  arrayList.removeAll(arrayList2);
  System.out.println("删除arrayList2元素后的arrayList：" + arrayList);//输出删除arrayList2元素后的arrayList：[tom, 10, false, 21.001]
}

集合遍历

迭代器遍历

iterator 对象成为迭代器，主要用于遍历 Collection 集合中的元素
实现了 Collection 接口的的集合类都有一个 iterator()方法，用以返回一个实现了 iterator 接口的对象

iterator 的方法

Iterator iterator = coll.iterator();//得到一个集合的迭代器
hasNext():判断是否还有下一个元素
next():指针下移，将下移以后集合位置上的元素返回（有两步）
==在使用 next()前一定要使用 hasNext()判断==
==得到 next 一定要用 Object 类型来引用，即只能：Object = iterator.next()==

使用代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
public class CollectionIterator01 {
    public static void main(String[] args) {
        Collection col = new ArrayList();

        col.add(new Book("三国演义","罗贯中" , 110));
        col.add(new Book("西游记","吴承恩",150));
        col.add(new Book("红楼梦","曹雪芹",115));

        //第一种输出
        System.out.println(col);//输出：[书名：三国演义 作者：罗贯中 价格：110, 书名：西游记 作者：吴承恩 价格：150, 书名：红楼梦 作者：曹雪芹 价格：115]

        //使用迭代器遍历输出
        Iterator iterator = col.iterator();//实现Collection接口的类都有iterator()对象直接取出来用
        //使用while循环遍历输出
        while(iterator.hasNext()){
            Object next = iterator.next();//接收下一个位置的返回值
            System.out.println(next);
        }
        //输出：
        /**
         * 书名：三国演义 作者：罗贯中 价格：110
         * 书名：西游记 作者：吴承恩 价格：150
         * 书名：红楼梦 作者：曹雪芹 价格：115
         */
        //退出循环后iterator要指向最后一个元素
        //如果需要再次遍历需要重置迭代器，方式：
        iterator = col.iterator();
        //重置迭代器后，第二次遍历输出
        while(iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}
class Book{
    private String name;
    private String author;
    private int price;

    public Book(String name, String author, int price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "书名：" + name + " 作者：" + author + " 价格：" + price;
    }
}

增强 for 循环遍历

相当于是使用简便的迭代器

使用代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void main(String[] args) {
    Collection col = new ArrayList();

    col.add(new Book("三国演义","罗贯中" , 110));
    col.add(new Book("西游记","吴承恩",150));
    col.add(new Book("红楼梦","曹雪芹",115));

    //使用增强for循环遍历
    for(Object book : col){//底层其实还是用的迭代器，只是使用起来更方便,一定要用Object来接收
        System.out.println("book = " + book);
    }
    /** 输出：
        * book = 书名：三国演义 作者：罗贯中 价格：110
        * book = 书名：西游记 作者：吴承恩 价格：150
        * book = 书名：红楼梦 作者：曹雪芹 价格：115
        */
}