本文介绍了作者分享的SpringBoot项目初始化模板，包含常见的开发组件和通过修改配置文件加载组件的功能。文章详细讲解了JDK1.5中超级for循环、Collection接口与Iterable的关系，以及泛型的使用，包括优点、缺点和不同类型场景的应用实例。
该文章Github地址：https://github.com/AntonyCheng/java-notes【有条件的情况下推荐直接访问GitHub以获取最新的代码更新】
在此介绍一下作者开源的SpringBoot项目初始化模板（Github仓库地址：https://github.com/AntonyCheng/spring-boot-init-template【有条件的情况下推荐直接访问GitHub以获取最新的代码更新】& 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; } @Override public 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; } @Override public 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; } @Override public String toString() { return "Teacher{" + "workNum=" + workNum + "} " + super.toString(); } }打印效果如下：
注意：泛型上下限的限定；
- <? extends E> 传递 E 类型或者是 E 的子类，这是泛型的上限限定；
- <? super E> 传递 E 类型或者是 E 的父类，这是泛型的下限限定；
扫一扫
2706
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
