Collection常用API、遍历方式、存储自定义类型的对象

Collection是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的。

1. 常用API

 1 import java.util.ArrayList;
 2 import java.util.Arrays;
 3 import java.util.Collection;
 4 
 5 public class CollectionDemo1 {
 6     public static void main(String[] args) {
 7         // HashSet : 添加的元素是无序、不重复、无索引
 8         // 同一改变量名 shift + fn + f6
 9 
10         Collection<String> c = new ArrayList<>();
11 
12         // 1. 添加元素， 添加成功返回true
13         c.add("java");
14         c.add("scala");
15         c.add("hello");
16         System.out.println(c.add("java"));
17 
18         System.out.println("-------------------------------------");
19 
20         // 2. 清空集合的元素
21         //c.clear();
22 
23         // 3. 判断集合是否为空，是空返回true， 反之
24         System.out.println(c.isEmpty());
25 
26         // 4. 获取集合的大小
27         System.out.println(c.size());
28 
29         System.out.println("--------------------------------------");
30 
31         // 5. 判断集合中是否包含某个元素
32         System.out.println(c.contains("java"));
33         System.out.println(c.contains("hadoop"));
34 
35         System.out.println("-------------------------------------");
36 
37         // 6. 删除某个元素，如果有多个重复元素，默认删除前面第一个
38         // 只有list集合家族的才有索引
39         System.out.println(c.remove("java"));
40         System.out.println(c);
41 
42         // 7. 把集合转换为数组
43         Object[] arr = c.toArray();
44         System.out.println("数组：" + Arrays.toString(arr));
45 
46 
47         System.out.println("-----------------------扩展----------------------");
48 
49         Collection<String> c1 = new ArrayList<>();
50         c1.add("wl");
51 
52         Collection<String> c2 = new ArrayList<>();
53         c2. add("phx");
54 
55         // 把 c2 中的元素拷贝到 c1 中去
56         c1.addAll(c2);
57         System.out.println(c1);
58         System.out.println(c2);
59     }
60 }

2. 遍历  

（1）迭代器遍历概述：

   遍历就是一个一个的把容器中的元素访问一遍。

   迭代器在java中的代表是Interator，迭代器是集合的专用遍历方式。

 1 import java.util.ArrayList;
 2 import java.util.Collection;
 3 import java.util.Iterator;
 4 
 5 public class CollectionTraversalDemo2 {
 6     public static void main(String[] args) {
 7         Collection<String> c = new ArrayList<>();
 8 
 9         c.add("java");
10         c.add("scala");
11         c.add("hello");
12         System.out.println(c);
13 
14         // 1. 得到当前集合的迭代器对象
15         Iterator<String> it = c.iterator();
16         //不用这种方式遍历
17 //        String n = it.next();
18 //        System.out.println(n);
19 //        System.out.println(it.next());
20 //        System.out.println(it.next());
21 
22         System.out.println("-----------------------------------------");
23 
24         // 2. 用while循环
25         while (it.hasNext()) {
26             String n = it.next();
27             System.out.println(n);
28         }

（2） 增强for循环 / foreach

   内部原理是一个iterator迭代器，遍历集合相当于是迭代器的简化写法（迭代器不能遍历数组）。

   可以遍历集合和数组。

   实现interable接口的类才可以使用迭代器和增强for， Collection接口已经实现了iterable接口。

格式：

   for（元素数据类型 变量名 ： 数组或者Collection集合）{

         // 在此处使用变量即可， 该变量就是元素

   }

 1 import java.util.ArrayList;
 2 import java.util.Collection;
 3 
 4 public class CollectionForDemo3 {
 5     public static void main(String[] args) {
 6         Collection<String> c = new ArrayList<>();
 7 
 8         c.add("java");
 9         c.add("scala");
10         c.add("hello");
11         System.out.println(c);
12 
13         // s 只是一个变量，修改不会影响集合或数组
14         for (String s : c) {
15             System.out.println(s);
16         }
17 
18         System.out.println("--------------------------------");
19 
20         double[] scores = {78, 34, 99};
21         for (double s1 : scores) {
22             System.out.println(s1);
23         }
24     }
25 }

（3）lambda表达式遍历集合

 1 import java.util.ArrayList;
 2 import java.util.Collection;
 3 
 4 public class CollectionLambdaDemo4 {
 5     public static void main(String[] args) {
 6         Collection<String> c = new ArrayList<>();
 7 
 8         c.add("java");
 9         c.add("scala");
10         c.add("hello");
11         System.out.println(c);
12 
13 //        c.forEach(new Consumer<String>() {
14 //            @Override
15 //            public void accept(String s) {
16 //                System.out.println(s);
17 //            }
18 //        });
19 
20         // 简化后的lambda表达式遍历
21         // 在源码中有一个for增强循环遍历，然后传给forEach中的变量，来完成
22 
23         c.forEach(s -> System.out.println(s));
24     }
25 }

存储自定义类型的对象

   集合中存储的是元素对象的地址。

例子：

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        // 1. 定义一个电影类
        // 2. 定义一个集合对象存储3部电影对象

        ArrayList<Movie> movies = new ArrayList<>();
        movies.add(new Movie("《你好，李焕英》", 9.9, "张小斐， 贾玲"));
        movies.add(new Movie("《刺杀小说家》", 9.5, "雷佳音， 杨幂"));

        // 地址
        System.out.println(movies);

        // 遍历集合容器中的每一个电影对象
        for (Movie movie : movies) {
            System.out.println("片名：" + movie.getName());
            System.out.println("评分：" + movie.getScore());
            System.out.println("主演：" + movie.getActor());
        }
    }
}

Movie类

 1 public class Movie {
 2     private  String name;
 3     private double score;
 4     private String actor;
 5 
 6     public Movie() {
 7     }
 8 
 9     public Movie(String name, double score, String actor) {
10         this.name = name;
11         this.score = score;
12         this.actor = actor;
13     }
14 
15     public String getName() {
16         return name;
17     }
18 
19     public void setName(String name) {
20         this.name = name;
21     }
22 
23     public double getScore() {
24         return score;
25     }
26 
27     public void setScore(double score) {
28         this.score = score;
29     }
30 
31     public String getActor() {
32         return actor;
33     }
34 
35     public void setActor(String actor) {
36         this.actor = actor;
37     }
38 }