由浅到深认识Java语言（30）：集合

该文章Github地址：https://github.com/AntonyCheng/java-notes

在此介绍一下作者开源的SpringBoot项目初始化模板（Github仓库地址：https://github.com/AntonyCheng/spring-boot-init-template & CSDN文章地址：https://blog.csdn.net/AntonyCheng/article/details/136555245），该模板集成了最常见的开发组件，同时基于修改配置文件实现组件的装载，除了这些，模板中还有非常丰富的整合示例，同时单体架构也非常适合SpringBoot框架入门，如果觉得有意义或者有帮助，欢迎Star & Issues & PR！

上一章：由浅到深认识Java语言（29）：集合

40.集合

超级for循环

这是JDK1.5出现的特性：循环的特性；

Collection 是单列集合的顶级接口，但是到了 JDK1.5 版本之后，它成为了 Iterable 的子接口；

而只要实现 Iterable 接口，就可以成为超级 for 循环的目标；

所以 Collection List Set 以及数组都实现了这个接口，既能够超级 for 循环

基本格式：

for(数据源中数据的数据类型 迭代变量 : 数据源){System.out.println(迭代变量);
}

示例一：

package top.sharehome.Bag;import java.util.ArrayList;
import java.util.List;public class Demo {public static void main(String[] args) {List list = new ArrayList();list.add("A");list.add("B");list.add("B");list.add("C");list.add("D");list.add("E");list.add("F");for(Object obj:list) {System.out.println(obj);}}
}

打印效果如下：

示例二：

package top.sharehome.Bag;public class Demo {public static void main(String[] args) {int[] arr = {1,2,3,4,5,6};for(int a:arr) {System.out.println(a);}}
}

打印效果如下：

示例三：

package top.sharehome.Bag;public class Demo {public static void main(String[] args) {char[] ch = {'H','e','l','l','o',' ','W','o','r','l','d'};for(char c : ch) {System.out.print(c);}}
}

打印效果如下：

示例四：

package top.sharehome.BigJava;public class Demo {public static void main(String[] args) {int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};for (int i : arr) {for (int j : arr) {if (j > i) {break;}System.out.print(j + "*" + i + "=" + i * j + "  ");}System.out.println();}}
}

打印效果如下：

优缺点

• 优点：能够让我们快速看到一个数据源中具体的元素；
• 缺点：无法对数据源中的数据进行操作；

泛型

出现之前

JDK1.4 之前没有泛型，当时的集合想装什么就可以装什么；

安全机制

软件升级：安全性提高，修复 bug 错误，改善用户体验，增加功能，提升性能；

而 JDK1.5 是Java中的里程碑版本，就是因为加入了泛型的安全机制；

**泛型的作用：**强制了集合存储固定的数据类型，安全性提高了，长远来看程序的代码量会减少，避免了类型的强制转换，程序的问题有运行时问题提前到编译时问题；

初识泛型

集合的特点之一：数据类型是任意的，这个特点既是优点，但也是缺点，因为在实际开发中我们是不会希望集合中的数据类型七七八八，所以我们可以用泛型来约束集合中的数据类型；

在创建集合时指明集合中存放的数据类型，用 <> 包裹起来，此时在集合中，我们就只能引用我们所规定的数据类型，而不能存放其他的数据类型：

package top.sharehome.Bag;import java.util.ArrayList;
import java.util.Collection;public class Demo {public static void main(String[] args) {Collection<String> c = new ArrayList<String>();c.add("a");c.add("B");c.add("c");c.add(92);}
}

报错如下：

使用须知

泛型需要在指明有泛型的类当中使用，例如 Collection 中：

这个 <E> 可以理解成一个**数据类型（可以是基本数据类型，可以是一个对象）**的占位符，当我们改变这个 E 时，该类的方法提示中的数据类型也会跟着改变，但是一定要注意设置数据类型时，基本数据类型必须用包装类，如果我们不设置这个占位符，即删除掉 <E> ，该类会默认填入的数据类型为 Object；

未设置的情况示例：

设置后的情况示例：

注意事项

• 在 Java 1.7 之后可以省略创建对象时声明部分的泛型书写，但要保留创建部分的泛型书写；

  但是这里最好是写上！

  Collection<Integer> c = new ArrayList<>();
  

• 一个类中可以创建多个泛型，在使用时也要一并使用，也就是说要么都不指明泛型类型，要么都必须全部指明泛型类型，如果有==一些不明确（表示至少有一种明确的类型）==的类型，可以使用 <已知的一种类型 , Object> 来指明；

  Student 类：

  package top.sharehome.Bag;
  //假设A，B两种类不明确
  public class Student<A, B> {private String name;private int age;private A a;private B b;public A getA() {return a;}public void setA(A a) {this.a = a;}public B getB() {return b;}public void setB(B b) {this.b = b;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
  }
  

  Teacher 类：

  package top.sharehome.Bag;public class Teacher<String, Integer, Character> {private String name;private int age;private char sex;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public char getSex() {return sex;}public void setSex(char sex) {this.sex = sex;}
  }
  

  Demo 类：

  package top.sharehome.Bag;public class Demo {public static void main(String[] args) {Student stu1 = new Student();Student<String, Object> stu2 = new Student<String, Object>();Teacher T1 = new Teacher();Teacher<String, Integer, Character> T2 = new Teacher<String, Integer, Character>}
  }
  

• 继承或实现有泛型类型的抽象类或接口；

  情况一：在设计子类或者实现类时，直接指明父类的泛型，那么此时父类的泛型就被明确；

  Father 类：

  package top.sharehome.Bag;public class Father<String> {}
  

  Son 类：

  package top.sharehome.Bag;public class Son extends Father<String>{}
  

  情况二：在设计子类或实现类时，可以为子类设计一个泛型，用于指明父类的泛型；

  son 类：

  package top.sharehome.Bag;public class Son<T> extends Father<T>{//此时这个T表示的是一个占位符
  }
  

  Demo 类：

  package top.sharehome.Bag;public class Demo {public static void main(String[] args) {Son<Boolean> s = new Son<Boolean>();//此时父类Father中的T就是Boolean}
  }
  

  注意：此时子类中的 T 既指明了父类的泛型，也可以在子类中使用这个 T ；

• 在 Map 集合中使用泛型；

  现在就可以很轻松地（不用向下转型）遍历 Map 集合；

  示例如下：

  package top.sharehome.Bag;import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Set;public class Demo {public static void main(String[] args) {Map<Integer,String> map = new HashMap<>();map.put(1, "A");map.put(2, "B");map.put(3, "C");Set<Entry<Integer,String>> entrySet = map.entrySet();//使用泛型后，Set集合中存放的元素数据类型就是 Entry 类型System.out.println(entrySet);Iterator<Entry<Integer, String>> iterator = entrySet.iterator();while(iterator.hasNext()) {//这里也可以直接得到Entry，不用向下转型，可以直接输出Entry<Integer,String> next = iterator.next();Integer key = entry.getKey();String value = entry.getValue();System.out.println("entry = " + "\"" + entry + "\"" + " key = " + key + " value = " + value);}}
  }
  

  打印效果如下：

  

• 自定义泛型类，提高类的可变性；

  package top.sharehome.BigJava;public class Demo {public static void main(String[] args) {Student<String> stu = new Student<>();stu.setQ("1911261716");Student<Integer> stu1 = new Student<>();stu1.setQ(1911261716);System.out.println(stu.getQ());System.out.println(stu1.getQ());}
  }class Student<QQ>{private QQ q;public void setQ(QQ q){this.q = q;}public QQ getQ(){return q;}
  }
  

  打印效果如下：

  

• 通配符 ？的用法：

  package top.sharehome.BigJava;import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;public class Demo {public static void main(String[] args) {List<String> l = new ArrayList<>();List<Integer> i = new ArrayList<>();l.add("haha");l.add("xixi");l.add("lala");i.add(1);i.add(2);i.add(3);each(l);each(i);}public static void each(List<?> t){Iterator it = t.iterator();while (it.hasNext()){System.out.println(it.next());}}
  }
  

  打印效果如下：

  

• 泛型的限定：

  <? extends Company> 传递类型可以是Company 或者是他的子类；

  泛型限定限定的是数据类型；

  package top.sharehome.BigJava;import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;public class Demo {public static void main(String[] args) {List<Student> studentList = new ArrayList<Student>();Student stu1 = new Student();stu1.setName("张三");stu1.setAge(21);Student stu2 = new Student();stu2.setName("李四");stu2.setTeamNum(3);studentList.add(stu1);studentList.add(stu2);List<Teacher> teacherList = new ArrayList<Teacher>();Teacher t1 = new Teacher();t1.setName("王五");t1.setAge(39);Teacher t2 = new Teacher();t2.setName("王六");t2.setWorkNum(98);teacherList.add(t1);teacherList.add(t2);work(teacherList);work(studentList);}/*** 此时就明确了该方法参数对象，不会有其他的数据类型或者结构能够传入该方法* @param l*/public static void work(List<? extends Class> l){//这里就是泛型的限定Iterator<? extends Class> it = l.iterator();while (it.hasNext()){Class obj = it.next();System.out.println(obj);}}
  }class Class {private String name;private int age;public Class(String name, int age) {this.name = name;this.age = age;}public Class() {}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Class{" +"name='" + name + '\'' +", age=" + age +'}';}
  }class Student extends Class {public Student() {}private int teamNum;public Student(String name, int age, int teamNum) {super(name, age);this.teamNum = teamNum;}public Student(int teamNum) {this.teamNum = teamNum;}public int getTeamNum() {return teamNum;}public void setTeamNum(int teamNum) {this.teamNum = teamNum;}@Overridepublic String toString() {return "Student{" +"teamNum=" + teamNum +"} " + super.toString();}
  }class Teacher extends Class {public Teacher() {}private int workNum;public Teacher(String name, int age, int workNum) {super(name, age);this.workNum = workNum;}public Teacher(int workNum) {this.workNum = workNum;}public int getWorkNum() {return workNum;}public void setWorkNum(int workNum) {this.workNum = workNum;}@Overridepublic String toString() {return "Teacher{" +"workNum=" + workNum +"} " + super.toString();}
  }
  

  打印效果如下：

  

  注意：泛型上下限的限定；

  • <? extends E> 传递 E 类型或者是 E 的子类，这是泛型的上限限定；
  • <? super E> 传递 E 类型或者是 E 的父类，这是泛型的下限限定；