心得感悟

虽说今天只学了集合的方法，但真的想要吃透它，工程量还是很大的。上课时听着懵懵懂懂，后面自己又看了几次，再写完简书，才算是掌握了。有些东西的确就是回过头来看就简单很多了，学而不思则罔，思而不学则殆，如果思考很久都不理解，就等敲多了代码再回头看吧。

---

内容简概

• 一、集合与数组的差异
• 二、常见集合分类
• 三、Collection的方法
• 四、Collection的遍历方法
• 五、ArrayList列表的方法
• 六、Lambda表达式
• 七、自己创建代码模板

具体内容

一、集合与数组的差异

区别	数组	集合
长度	不可变	可变
顺序	有序（角标）	无序（角标）
元素	可重复	不可重复
元素类型	只能放同种类型	可放不同类型

二、常见集合分类

在这里我们只讲几个常用的列表List，如下图①所示，其他方法如图②暂且不讲。

部分集合类型·图①
全部集合类型·图②
列表、集合和队列·图③

三、Collection的方法

1. 添加元素
2. 删除元素
3. 获取元素个数
4. 判断是否包含一个元素
5. 判断是否为空
6. 判断两个集合是否相同（比较内容）
7. 清空集合

        // 添加元素
         Collection<String> t1 = new ArrayList();
         t1.add("Jack");
         t1.add("Marry");

         //删除元素
         t1.remove("Jack");

         //获取元素个数
         System.out.println(t1.size());

         //判断是否包含一个元素
         if (t1.contains("Marry")) {
             System.out.println("有Marry");
         } else {
             System.out.println("没有Marry");
         }

         //判断是否为空
         if (t1.isEmpty()) {
             System.out.println("是空的");
         }

        //判断两个集合是否相同（比较内容）
         Collection<String> t2 = new ArrayList<>();
         t2.add("Marry");
         t2.add("Jack");
         t2.add("Rose");
         t2.add("Tom");

         if (t1.equals(t2)) {
             System.out.println("相同");
         } else {
             System.out.println("不相同");
         }

         //清空
         t1.clear();

四、Collection的遍历方法

1. Iterator遍历
2. for-each 增强的for循环 快速循环
3. for-i循环遍历

         Collection<String> t2 = new ArrayList<>();
         t2.add("Marry");
         t2.add("Jack");
         t2.add("Rose");
         t2.add("Tom");

        //Iterator遍历
        Iterator iterator = t2.iterator();
         while (iterator.hasNext()) {
             System.out.println(iterator.next());
         }
         while (iterator.next() != null){
             System.out.println(iterator.next());
         }

         //for-each 增强的for循环 快速循环
         for (String obj:t2){
             System.out.println(obj);
         }

         //for-i循环遍历
         for (int i = 0; i < t2.size(); i++){
             System.out.println(((ArrayList<String>) t2).get(i));
         }

五、ArrayList列表的方法

1. ArrayList<>的<>中只能放对象或者包装类

包装类：
在Java中不能定义基本数据类型对象，为了能将基本数据类型视为对象处理，并能连接相关方法，java为每个基本类型都提供包装类。

数据类型	boolean	byte	char	short	int	long	float	double
包装类	Boolean	Byte	Char	Short	Integer	Long	Float	Double

方法
1. 在末尾添加元素
2. 在指定位置添加元素
3. 访问指定元素
4. 修改一个元素
5. 删除指定位置元素
6. 删除指定对象
7. 清空集合

         ArrayList<Integer> score = new ArrayList<>();
         //在末尾添加元素
         score.add(3);
         //在指定位置添加元素
         score.add(0,1);

         //访问指定元素
         score.get(1);

         //修改一个元素
         score.set(0,0);

         //删除指定位置的元素
         score.remove(0);
         System.out.println(score);

         //删除指定的对象
         score.remove((Integer)2);
         System.out.println(score);

         //清空集合
         score.clear();

8. 将一个集合里面的内容添加到当前集合中
9. 取两个集合的交集
11. 访问某个对象在集合里面的索引
12. 将ArrayList转化为普通数组(toArray)
13. 遍历集合
14. 获取集合某个范围的子集合

         ArrayList<Integer> score = new ArrayList<>();
         ArrayList<Integer> a2 = new ArrayList<>();
         a2.add(1);
         a2.add(2);
         a2.add(3);

         //将一个集合里面的内容添加到当前集合中
         score.addAll(a2);

         ArrayList<Integer> a3 = new ArrayList<>();
         a3.add(1);
         a3.add(2);
         a3.add(1);

        a2.retainAll(a3);//取两个集合的交集
  
         //访问某个对象在集合里面的索引
         System.out.println(a3.indexOf(1));//第一次出现位置，无则返回-1
         System.out.println(a3.lastIndexOf(1));//最后一次出现的位置

         //将ArrayList转化为普通数组
         //法一：
         Integer[] objects = new Integer[a2.size()];
         a2.toArray(objects);
         for (Integer i: objects){
             System.out.println(i);
         }

         //法二：（不常用）
         Object[] objects1 = a2.toArray();
         for (Object i: objects1){
             System.out.print(i);
         }

         //遍历集合
         Iterator iterator1 = a2.iterator();
         while (iterator1.hasNext()){
             System.out.print(iterator1.next());
         }

         //获取集合某个范围的子集合
         List<Integer> integers = a2.subList(0,2);
         System.out.println(integers);*/
         //输出[1,2]

• 六、Lambda表达式

1. 概念
Lambda 表达式，也可称为闭包，使用 Lambda 表达式可以使代码变的更加简洁紧凑。

2. 格式
(parameters) -> expression 或 (parameters) ->{ statements; }
方法只有一个语句则不用大括号。

3. 简单例子

// 1. 不需要参数,返回值为 1
() -> 1
  
// 2. 接收一个参数(数字类型),返回其3倍的值  
x -> 3 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并打印
(String s) -> System.out.print(s)

4. 进阶版例子
求出数组里的单数

         ArrayList<Integer> nums = new ArrayList<>();
         nums.add(1);
         nums.add(2);
         nums.add(3);
         nums.add(4);

         //法一：（使用Lambda表达式）
         nums.removeIf(obj -> obj % 2 == 0);
         for (Integer obj:nums){
             if (obj % 2 == 0){
                 nums.remove(obj);
             }
         }

         //法二：（不使用Lambda表达式）
         for (int i = 0; i < nums.size(); i++){
             Integer obj = nums.get(i);
             if (obj % 2 == 0){
                 nums.remove(i);
                 i--;
             }
         }

• 七、自己创建代码模板

因为我们常会用到for...i循环，而Java中又没有提供这个方法，故我们可以自己向软件中添加代码模板。在此示范Android studio的添加过程。

1.先敲出这样一段代码
2.对模板命名和编写提示
3.点击确认
4.再次编写时，就可看到自己创建的模板
效果如图，不用敲3次循环变量真的很方便