【原】Java学习笔记027 - 泛型

 package cn.temptation.test;

 import java.util.ArrayList;
 import java.util.Iterator;

 public class Sample01 {
     public static void main(String[] args) {
         ArrayList arrayList = new ArrayList();

         arrayList.add("中国");
         arrayList.add("美国");
         // 下句会导致执行异常：java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
         arrayList.add(250);

         Iterator iterator = arrayList.iterator();

         while (iterator.hasNext()) {
             // 因为在向ArrayList对象中添加元素时，add方法的参数类型为Object类型，换句话说，在添加元素时没有做类型检查
             // 在遍历时，强行要求取出的是某一种数据类型
             String item = (String) iterator.next();
             // 上句改为下句，执行时不会有异常产生
 //            Object item = iterator.next();

             System.out.println(item);
         }

         // 回忆一下，前面使用另一种容器-----数组时，没有出现过取出数据时数据类型不匹配的错误，为何？
         // 这是因为数组在创建时，就已经规定好了其中的元素是什么数据类型
         // 数组的这种特点属于"丑话讲在前"，即在编译阶段就提示语法错误的写法具有较好的前瞻性
 //        int[] arrInt = { 1, 2, 3, "abc" };
 //        String[] arrString = { "abc", "admin", 123, "test" };

         // 我们希望在集合的使用中，也有数组的这种优点，即在编译阶段就提示出语法错误的功能
         // 换句话说，就是在编译阶段就能强制确定集合中的元素的数据类型

         // Java中引入了       泛型（Generic），从JDK 1.5之后引入的，大家维护早期项目时无法使用泛型的
     }
 }

 package cn.temptation.test;

 import java.util.ArrayList;
 import java.util.Iterator;

 public class Sample02 {
     public static void main(String[] args) {
         /*
          * 泛型（Generic）
          *
          * 定义：把类型确定的工作推迟到创建对象或方法调用时才做的方式
          *
          * 格式：<数据类型>
          *
          * 注意：泛型中的数据类型只能是引用数据类型，参数化类型（或者称为不明确具体的类型），也就是把数据类型作为参数一样进行传递
          *
          * 优点：
          * 1、把执行时才能发现的问题提前到编译时发现并处理
          * 2、避免强制类型转换
          * 3、让程序中不再到处都出现警告
          *
          * 理解：
          * 泛型，开始会觉得泛型的"泛"是否指的是有宽泛、广泛的意思，使用后发现使用了泛型，其实对数据类型带来强制性，也就是"泛型不泛"
          *
          */
         // 在JDK 1.7之前，创建泛型对象时，如下写法：
 //        ArrayList<String> arrayList = new ArrayList<String>();
         // 在JDK 1.7之后，创建泛型对象时，简化为如下写法：
         ArrayList<String> arrayList = new ArrayList<>();

         arrayList.add("中国");
         arrayList.add("美国");
         // 创建了泛型的ArrayList对象后，因为指明了该集合对象中的元素类型为String类型，再向其中放入其他数据类型的元素时，就提示出错了
         // 【在编译阶段暴露问题    远远好于     在执行阶段暴露问题】
         // 语法错误：The method add(int, String) in the type ArrayList<String> is not applicable for the arguments (int)
 //        arrayList.add(250);

         Iterator<String> iterator = arrayList.iterator();

         while (iterator.hasNext()) {
             String item = iterator.next();
             System.out.println(item);
         }
     }
 }

 package cn.temptation.test;

 import java.util.ArrayList;
 import java.util.Iterator;

 public class Sample03 {
     public static void main(String[] args) {
         /*
          * 泛型可以用在哪些地方？
          * 1、泛型用在类上，称为泛型类
          * 2、泛型用在接口上，称为泛型接口
          * 3、泛型用在方法上，称为泛型方法
          */

         ArrayList<String> arrayList = new ArrayList<>();

         arrayList.add("China");
         arrayList.add("USA");

         Iterator<String> iterator = arrayList.iterator();

         while (iterator.hasNext()) {
             String item = (String) iterator.next();
             System.out.println(item);
         }
     }
 }

 package cn.temptation.test;

 import java.util.ArrayList;
 import java.util.Iterator;

 public class Sample04 {
     public static void main(String[] args) {
         // 需求：使用泛型ArrayList和Iterator存放并遍历三个学生对象
         ArrayList<Student> arrayList = new ArrayList<>();

         arrayList.add(new Student("张三", 20));
         arrayList.add(new Student("李四", 22));
         arrayList.add(new Student("王五", 18));

         Iterator<Student> iterator = arrayList.iterator();

         while (iterator.hasNext()) {
             Student item = (Student) iterator.next();
             System.out.println(item);
         }
     }
 }

 package cn.temptation.test;

 public class Sample05 {
     public static void main(String[] args) {
         /*
          * 泛型没有出现时，使用Object类型作为引用数据类型转换的桥梁
          */
         ObjectTool objectTool = new ObjectTool();

         objectTool.setObj(new Student("张三", 20));

         Object obj = objectTool.getObj();
         System.out.println(obj);

         // 对Object工具类返回的对象使用具体类型，就必须使用强制类型转换（向下转型）
         Student student = (Student) objectTool.getObj();
         System.out.println(student);

         // 因为向下转型使用强制类型转换，会有风险
         // 为了能无异常的进行向下转型，必须要清楚的知道向上转型时元素的数据类型
         // 执行产生异常：java.lang.ClassCastException: cn.temptation.Student cannot be cast to java.lang.String
         String str = (String) objectTool.getObj();
         System.out.println(str);
     }
 }

 package cn.temptation.test;

 /**
  * 对象工具类
  */
 public class ObjectTool {
     // 成员变量
     private Object obj;

     // 成员方法
     public Object getObj() {
         return obj;
     }

     public void setObj(Object obj) {
         this.obj = obj;
     }
 }

 package cn.temptation.test;

 public class Sample06 {
     public static void main(String[] args) {
         ObjectToolEx<Student> objectToolEx = new ObjectToolEx<>();

         objectToolEx.setObj(new Student("张三", 20));
         // 语法错误：The method setObj(Student) in the type ObjectToolEx<Student> is not applicable for the arguments (int)
 //        objectToolEx.setObj(123);
         // 语法错误：The method setObj(Student) in the type ObjectToolEx<Student> is not applicable for the arguments (String)
 //        objectToolEx.setObj("abc");
         // 语法错误：The method setObj(Student) in the type ObjectToolEx<Student> is not applicable for the arguments (Integer)
 //        objectToolEx.setObj(new Integer(456));

         // 理解：泛型 -----> 范型（规范类型），"泛型有范"
     }
 }

 package cn.temptation.test;

 /**
  * 对象工具类（泛型版）：使用泛型对ObjectTool工具类进行升级
  *
  * 思路：
  * 原来使用Object类作为方法形参的类型以及成员变量的类型，都是出于通用性的考虑（即越抽象越好）
  * 现在在类的声明时，不急于确定传入进来的对象到底是什么类型，而是使用占位符把位置先占住，在使用时，根据传入进来的数据类型进行相应的设置
  * 优点在于使用时明确到底用什么类型，避免了强制类型转换
  * 使用泛型的占位符，先不需要知道数据类型是什么，推迟到类的实例化（具体使用时）再去替换为对应的数据类型
  */
 public class ObjectToolEx<T> {
     // 成员变量
     private T obj;
     private T resultT;
     // 语法错误：E cannot be resolved to a type
 //    private E resultE;

     // 成员方法
     public T getObj() {
         return obj;
     }

     public void setObj(T obj) {
         this.obj = obj;
     }

     // 泛型方法1、参数类型与类的类型一致
     public void show(T param) {
         System.out.println(param);
     }

     public T showEx(T param) {
         return resultT;
     }

     // 泛型方法2、参数类型与类的类型不一致
     public <E> void method(E param) {
         System.out.println(param);
     }

     // 泛型方法的返回值类型和其所在泛型类不一致时，只能返回null值，返回其他类型语法错误
     public <E> E methodEx(E param) {
         // 语法错误：resultE cannot be resolved to a variable
 //        return resultE;

         // 下面写法语法OK，但是返回的是null值
         return null;
     }
 }

 package cn.temptation.test;

 public class Sample07 {
     public static void main(String[] args) {
         // 泛型类的使用，可以传递的数据类型只能是引用数据类型
 //        ObjectToolEx<String> objectToolEx = new ObjectToolEx<>();
 //        objectToolEx.setObj("java");
 //        System.out.println(objectToolEx.getObj());

         // 语法错误：Syntax error, insert "Dimensions" to complete ReferenceType
 //        ObjectToolEx<int> objectToolEx = new ObjectToolEx<>();
     }
 }

 package cn.temptation.test;

 public class Sample08 {
     public static void main(String[] args) {
         // 泛型方法的定义，参数可以和其所在的泛型类的类型相同，也可以不相同
         // 参数不相同的使用时，根据传入的数据类型进行相应的使用

         ObjectToolEx<String> objectToolEx = new ObjectToolEx<>();

         objectToolEx.show("admin");                            // admin
         System.out.println(objectToolEx.showEx("test"));    // null

         objectToolEx.method(123);                            //
         System.out.println(objectToolEx.methodEx(true));    // null
     }
 }

 package cn.temptation.test;

 public class Sample09 {
     public static void main(String[] args) {
         // 1、创建泛型接口时，已经明确泛型接口使用的数据类型是什么类型
         Foo<String> foo1 = new FooImpl();
         foo1.show("java");

         // 2、创建接口的实现类对象时，才传入泛型接口使用的数据类型是什么类型
         Foo<Integer> foo2 = new FooImplEx<>();
         foo2.show(123);
     }
 }

 package cn.temptation.test;

 /**
  * 泛型接口
  * @param <T>
  */
 public interface Foo<T> {
     public abstract void    show(T param);
 }

 package cn.temptation.test;

 /**
  * 制作泛型接口的实现类时，已经知道泛型接口使用的是什么数据类型
  */
 public class FooImpl implements Foo<String> {
     // 既然已经知道泛型接口使用的是什么数据类型，那么重写的成员方法也就明确使用什么数据类型
     @Override
     public void show(String param) {
         System.out.println(param);
     }
 }

 package cn.temptation.test;

 /**
  * 制作泛型接口的实现类时，还不知道泛型接口使用的是什么数据类型
  * 实现类需要和泛型接口使用相同数据类型的占位符
  *
  * @param <T>
  */
 public class FooImplEx<T> implements Foo<T> {
     // 既然还不知道泛型接口使用的是什么数据类型，那么重写的成员方法也就不能明确使用什么数据类型，那么还是使用占位符先占住位置
     @Override
     public void show(T param) {
         System.out.println(param);
     }
 }

 package cn.temptation.test;

 import java.util.ArrayList;
 import java.util.Collection;

 public class Sample10 {
     public static void main(String[] args) {
         /*
          * 泛型的通配符
          * ?            ：任意类型
          * ?  extends T    ：向下限定，指的是  ? 对应的类型必须是  T 对应的类型的子类或自身
          * ?  super T    ：向上限定，指的是  ? 对应的类型必须是  T 对应的类型的父类或自身
          */

         Collection<Object> collection1 = new ArrayList<Object>();
         Collection<Animal> collection2 = new ArrayList<Animal>();
         Collection<Dog> collection3 = new ArrayList<Dog>();

         // 使用 ? 泛型表示任意类型
         Collection<?> collection4 = new ArrayList<Object>();
         Collection<?> collection5 = new ArrayList<Animal>();
         Collection<?> collection6 = new ArrayList<Dog>();

         // 使用 ?  extends T    ：向下限定，指的是  ? 对应的类型必须是  T 对应的类型的子类或自身
         // 语法错误：Type mismatch: cannot convert from ArrayList<Object> to Collection<? extends Animal>
 //        Collection<? extends Animal> collection7 = new ArrayList<Object>();
         Collection<? extends Animal> collection8 = new ArrayList<Animal>();
         Collection<? extends Animal> collection9 = new ArrayList<Dog>();

         // 使用?  super T    ：向上限定，指的是  ? 对应的类型必须是  T 对应的类型的父类或自身
         Collection<? super Animal> collection10 = new ArrayList<Object>();
         Collection<? super Animal> collection11 = new ArrayList<Animal>();
         // 语法错误：Type mismatch: cannot convert from ArrayList<Dog> to Collection<? super Animal>
 //        Collection<? super Animal> collection12 = new ArrayList<Dog>();
     }
 }

 class Animal extends Object {

 }

 class Dog extends Animal {

 }

 package cn.temptation.test;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;

 public class Sample11 {
     public static void main(String[] args) {
         /*
          * 使用集合存储元素，有哪些遍历的方式？
          * 1、使用一般for循环（结合size方法和get方法）
          * 2、使用迭代器
          * 3、使用增强型for循环
          *
          * Iterable接口：实现这个接口允许对象成为 "foreach" 语句的目标。
          *
          * 注意：增强型for循环可以认为是简化使用迭代器
          */

         Collection<String> collection = new ArrayList<>();

         collection.add("中国");
         collection.add("美国");

         System.out.println("collection:" + collection);            // collection:[中国, 美国]

         // 1、使用一般for循环（结合size方法和get方法）
         for (int i = 0; i < collection.size(); i++) {
             // 下面两种写法效果一致
 //            String item = ((List<String>)collection).get(i);
             String item = ((ArrayList<String>)collection).get(i);

             System.out.println(item);
         }

         System.out.println("---------------------------------------------------------------");

         // 2、使用迭代器
         Iterator<String> iterator = collection.iterator();

         while (iterator.hasNext()) {
             String item = (String) iterator.next();
             System.out.println(item);
         }

         System.out.println("---------------------------------------------------------------");

         // 3、使用增强型for循环
         for (String item : collection) {
             System.out.println(item);
         }
     }
 }

 package cn.temptation.test;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;

 public class Sample12 {
     public static void main(String[] args) {
         /*
          * 使用集合存储元素，有哪些遍历的方式？
          * 1、使用一般for循环（结合size方法和get方法）
          * 2、使用迭代器
          * 3、使用增强型for循环
          *
          * Iterable接口：实现这个接口允许对象成为 "foreach" 语句的目标。
          *
          * 注意：增强型for循环可以认为是简化使用迭代器
          */
         Collection<Student> collection = new ArrayList<>();

         collection.add(new Student("张三", 20));
         collection.add(new Student("李四", 18));

         System.out.println("collection:" + collection);            // collection:[中国, 美国]

         // 1、使用一般for循环（结合size方法和get方法）
         for (int i = 0; i < collection.size(); i++) {
             // 下面两种写法效果一致
 //            Student item = ((List<Student>)collection).get(i);
             Student item = ((ArrayList<Student>)collection).get(i);

             System.out.println(item);
         }

         System.out.println("---------------------------------------------------------------");

         // 2、使用迭代器
         Iterator<Student> iterator = collection.iterator();

         while (iterator.hasNext()) {
             Student item = (Student) iterator.next();
             System.out.println(item);
         }

         System.out.println("---------------------------------------------------------------");

         // 3、使用增强型for循环
         for (Student item : collection) {
             System.out.println(item);
         }
     }
 }

 package cn.temptation.test;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;

 public class Sample13 {
     public static void main(String[] args) {
         Collection<String> collection = new ArrayList<>();

         collection = null;

         System.out.println("collection:" + collection);            // collection:[]

         // 执行异常：java.lang.NullPointerException
         // 使用一般for循环遍历
 //        for (int i = 0; i < collection.size(); i++) {
 ////            String item = ((List<String>)collection).get(i);
 //            String item = ((ArrayList<String>)collection).get(i);
 //
 //            System.out.println(item);
 //        }

         // 执行异常：java.lang.NullPointerException
         // 使用迭代器遍历
 //        Iterator<String> iterator = collection.iterator();
 //
 //        while (iterator.hasNext()) {
 //            String item = (String) iterator.next();
 //            System.out.println(item);
 //        }

         // 执行异常：java.lang.NullPointerException
         // 使用增强型for循环遍历
 //        for (String item : collection) {
 //            System.out.println(item);
 //        }

         // 上述三种遍历形式对于集合对象为null值均缺乏必要的检查操作
         // 所以遍历集合时，应该手工添加检查
         if (collection != null) {
             for (String item : collection) {
                 System.out.println(item);
             }
         }
     }
 }

 package cn.temptation.test;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;

 public class Sample14 {
     public static void main(String[] args) {
         /*
          * 类 Arrays：此类包含用来操作数组（比如排序和搜索）的各种方法。
          *
          * Arrays类的常用成员方法：
          * static <T> List<T> asList(T... a) ：返回一个受指定数组支持的固定大小的列表。
          *
          * 【数组转换为集合】的常用方法
          */
         String[] arrStr = { "中国", "美国", "日本" };

         List<String> list1 = Arrays.asList(arrStr);

         for (String item : list1) {
             System.out.println(item);
         }

         System.out.println("-------------------------------------------------");

         // 语法错误：Syntax error on token ".", @ expected after this token
 //        List<String> list2 = Arrays.asList({ "中国", "美国", "日本" });
         // 正确写法：可变长参数的理解，参数有多少无所谓，这些参数识别为是数组的元素
         List<String> list2 = Arrays.asList("中国", "美国", "日本");

         for (String item : list2) {
             System.out.println(item);
         }

         System.out.println("-------------------------------------------------");

         // 【集合转换为数组】的常用方法
         // Collection接口的常用成员方法：
         // 1、Object[] toArray() ：返回包含此 collection 中所有元素的数组。
         // 2、<T> T[] toArray(T[] a) ：返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

         Collection<String> collection = new ArrayList<>();

         collection.add("中国");
         collection.add("美国");
         collection.add("日本");

         Object[] arr1 = collection.toArray();
         for (Object item : arr1) {
             System.out.println(item);
         }

         System.out.println("-------------------------------------------------");

 //        String[] arr2 = (String[]) collection.toArray();
 //        // 执行异常：java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
 //        for (String item : arr2) {
 //            System.out.println(item);
 //        }

         String[] arrTemp = new String[collection.size()];
         String[] arr3 = collection.toArray(arrTemp);

         for (String item : arr3) {
             System.out.println(item);
         }

         for (String item : arrTemp) {
             System.out.println(item);
         }
     }
 }

 package cn.temptation.test;

 import java.util.ArrayList;
 import java.util.Collection;

 public class Sample15 {
     public static void main(String[] args) {
         // 需求：使用集合和泛型，存储5个同学：张三 20岁，李四 18岁，王五 22岁，赵六 19岁，钱七 20岁

         Collection<Student> collection = new ArrayList<>();

         collection.add(new Student("张三", 20));
         collection.add(new Student("李四", 18));
         collection.add(new Student("王五", 22));
         collection.add(new Student("赵六", 19));
         collection.add(new Student("钱七", 20));

         System.out.println("collection:" + collection);

         for (Student item : collection) {
             System.out.println(item);
         }
     }
 }

 package cn.temptation.test;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;

 public class Sample16 {
     public static void main(String[] args) {
         // 需求：把上个例子中的五个同学分为两组进行存储，前三个同学一组，后两个同学一组

         // 思路：
         // 回顾一下，数组是容器，数组中可以放入数组（容器里可以嵌套容器），所以，集合也是容器，集合中也可以嵌套集合

         // 创建组的容器
         Collection<Student> team1 = new ArrayList<>();

         team1.add(new Student("张三", 20));
         team1.add(new Student("李四", 18));
         team1.add(new Student("王五", 22));

         // 创建组的容器
         Collection<Student> team2 = new ArrayList<>();

         team2.add(new Student("赵六", 19));
         team2.add(new Student("钱七", 20));

         // 创建班级的容器来存放组的容器
         Collection<Collection<Student>> clazz = new ArrayList<>();

         clazz.add(team1);
         clazz.add(team2);

         System.out.println("clazz:" + clazz);

         // 遍历嵌套集合的集合

         // 增强型for循环的遍历
         for (Collection<Student> team : clazz) {
             for (Student item : team) {
                 System.out.println(item);
             }
         }

         System.out.println("---------------------------------------------");

         // 迭代器的遍历

         // 外层的迭代器在班级集合上
         Iterator<Collection<Student>> iterator = clazz.iterator();

         while (iterator.hasNext()) {
             Collection<Student> team = (Collection<Student>) iterator.next();

             // 内层的迭代器在组集合上
             Iterator<Student> iteratorEx = team.iterator();

             while (iteratorEx.hasNext()) {
                 Student item = (Student) iteratorEx.next();
                 System.out.println(item);
             }
         }

         System.out.println("---------------------------------------------");

         // 一般for循环的遍历
         for (int i = 0; i < clazz.size(); i++) {
             List<Student> team = (List<Student>)(((List<Collection<Student>>)clazz).get(i));

             for (int j = 0; j < team.size(); j++) {
                 Student item = team.get(j);
                 System.out.println(item);
             }
         }
     }
 }

 package cn.temptation.test;

 public class Student {
     // 成员变量
     private String name;
     private int age;

     // 构造函数
     public Student() {
         super();
     }

     public Student(String name, int age) {
         super();
         this.name = name;
         this.age = age;
     }

     // 成员方法
     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 "学生 [姓名为：" + name + ", 年龄为：" + age + "]";
     }
 }

 package cn.temptation.test;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.Scanner;

 public class Sample18 {
     public static void main(String[] args) {
         // 需求：使用集合和泛型，通过键盘录入一些整数，以录入整数0作为录入的结束。
         //         判断录入的整数的大小，显示出录入的整数，形如：{整数1,整数2,...整数n}，并显示最大整数是多少

         // 思路1：
         // 1、因为录入的整数个数未知，所以选择容器时，不选择数组，而是选择集合来存储数据
         // 2、通过键盘录入整数，考虑使用死循环，判断录入的数字为0时跳出死循环
         // 3、比较大小（通过遍历集合中元素进行比较）
         // 4、打印结果，大量字符串的拼接考虑使用字符串缓冲区

         // 写法1

         // 创建容器对象
         Collection<Integer> collection = new ArrayList<>();
         // 声明最大整数变量
         int max = 0;

         // 接收键盘录入，把录入的数据放入容器中
         Scanner input = new Scanner(System.in);
         while (true) {
             System.out.println("输入若干个整数：");
             Integer i = input.nextInt();
             if (i == 0) {        // 判断录入的数字为0时跳出死循环
                 break;
             } else {
                 collection.add(i);
             }
         }
         input.close();

         if (collection.size() > 0) {    // 判断集合中是否有元素
             // 创建字符串缓冲区对象
             StringBuffer sb = new StringBuffer("录入的整数为：{");

             // 遍历容器进行比较
             Iterator<Integer> iterator = collection.iterator();

             while (iterator.hasNext()) {
                 Integer item = (Integer) iterator.next();

                 // 比较大小
                 if (item > max) {
                     max = item;
                 }

                 // 遍历到的元素添加到字符串缓冲区对象中
                 sb.append(item + ",");
             }

             // 上述遍历操作会在最后一个元素获取放入到字符串缓冲区对象中时多添加一个逗号
             String str = sb.substring(0, sb.length() - 1) + "}";

             System.out.println(str + "，最大整数为：" + max);
         }
     }
 }

 package cn.temptation.test;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Scanner;

 public class Sample19 {
     public static void main(String[] args) {
         // 需求：使用集合和泛型，通过键盘录入一些整数，以录入整数0作为录入的结束。
         //         判断录入的整数的大小，显示出录入的整数，形如：{整数1,整数2,...整数n}，并显示最大整数是多少

         // 思路2：
         // 1、因为录入的整数个数未知，所以选择容器时，不选择数组，而是选择集合来存储数据
         // 2、通过键盘录入整数，考虑使用死循环，判断录入的数字为0时跳出死循环
         // 3、比较大小（通过Arrays类的sort方法进行排序）
         // 4、打印结果，大量字符串的拼接考虑使用字符串缓冲区

         // 写法1

         // 创建容器对象
         Collection<Integer> collection = new ArrayList<>();

         // 接收键盘录入，把录入的数据放入容器中
         Scanner input = new Scanner(System.in);
         while (true) {
             System.out.println("输入若干个整数：");
             Integer i = input.nextInt();
             if (i == 0) {        // 判断录入的数字为0时跳出死循环
                 break;
             } else {
                 collection.add(i);
             }
         }
         input.close();

         if (collection.size() > 0) {    // 判断集合中是否有元素
             Integer[] arr = new Integer[collection.size()];
             collection.toArray(arr);

             // 创建字符串缓冲区对象
             StringBuffer sb = new StringBuffer("录入的整数为：{");

             for (Integer item : arr) {
                 sb.append(item + ",");
             }

             // 上述遍历操作会在最后一个元素获取放入到字符串缓冲区对象中时多添加一个逗号
             String str = sb.substring(0, sb.length() - 1) + "}";

             // 通过Arrays类的sort方法进行排序
             Arrays.sort(arr);

             System.out.println(str + "，最大整数为：" + arr[arr.length - 1]);
         }
     }
 }

 package cn.temptation.test;

 import java.util.Scanner;

 import cn.temptation.model.User;
 import cn.temptation.service.UserService;
 import cn.temptation.service.UserServiceImpl;

 public class Sample20 {
     public static void main(String[] args) {
         // 需求：结合集合和泛型实现一般系统都有的功能
         // 1、注册功能：存储用户信息（用户帐号  和   用户密码）
         // 2、登录功能：输入用户信息（帐号和密码） 和 存储的用户信息进行比较，来确定输入的用户信息是否正确，如果正确，提示登录成功；否则不给其登录系统
         // 3、游戏功能：登录成功后可以玩猜数字的游戏（猜测从0~9之间的一个数），猜对了，提示是否还要继续玩，继续玩就继续猜数字；猜错了也提示猜错了，提示是否还要继续玩
         //                （输入Y表示继续玩，输入N表示不玩了）

         // 通过分层思想，把有相同性质的操作划为一层

         // 系统的数据载体：用户信息存储在用户类

         System.out.println("【用户系统】");
         Scanner input = new Scanner(System.in);

         // 注意：下句语句会带来逻辑错误，会导致注册时集合中只有一个用户信息，后续注册会覆盖之前注册的信息；
         //        并且怎么登录都是成功，因为集合中只存储一个User对象，所以正确写法应该注册时创建不同的用户对象，登录时接受交互数据也使用不同的用户对象
 //        User user = new User();
         // 正确写法：只做声明，不进行初始化
         User user;

         // 调用业务逻辑处理
         UserService service = new UserServiceImpl();

         while (true) {
             System.out.println("----------------------------------");
             System.out.println("1、登录");
             System.out.println("2、注册");
             System.out.println("3、退出");

             System.out.println("根据功能菜单，输入操作指令：");

             String str = input.nextLine();
             user = new User();

             switch (str) {
             case "1":    // 登录处理
                 // 既然登录和注册时都需要创建用户对象，所以放在switch之外写
 //                user = new User();

                 System.out.println("欢迎使用【登录功能】");

                 // 接收交互数据，并封装在用户类的对象中
                 System.out.println("输入用户帐号：");
                 user.setUsername(input.nextLine());
                 System.out.println("输入用户密码：");
                 user.setPassword(input.nextLine());

                 if (service.login(user)) {
                     System.out.println("登录成功！");

                     while (true) {
                         System.out.println("想玩猜数字的游戏么？输入Y表示想玩，输入N表示不玩");

                         String flag = input.nextLine();

                         if ("Y".equalsIgnoreCase(flag)) {
                             service.play(input);
                         } else if ("N".equalsIgnoreCase(flag)) {
                             break;
                         }
                     }
                 } else {
                     System.out.println("登录失败！");
                 }

                 break;
             case "2":    // 注册处理
                 // 既然登录和注册时都需要创建用户对象，所以放在switch之外写
 //                user = new User();

                 System.out.println("欢迎使用【注册功能】");

                 // 接收交互数据，并封装在用户类的对象中
                 System.out.println("输入用户帐号：");
                 user.setUsername(input.nextLine());
                 System.out.println("输入用户密码：");
                 user.setPassword(input.nextLine());

                 if (service.register(user)) {
                     System.out.println("注册成功！");
                 }

                 break;
             case "3":    // 退出处理
             default:
                 System.out.println("谢谢使用！");
                 // System类的常用成员方法：
                 // static void exit(int status) ：终止当前正在运行的 Java 虚拟机。
                 System.exit(0);
                 break;
             }
         }
     }
 }

 package cn.temptation.service;

 import java.util.Scanner;

 import cn.temptation.model.User;

 /**
  * 用户业务逻辑处理接口
  */
 public interface UserService {
     // 接口中方法定义的思路：
     // 以注册为例，可以给注册方法传递两个参数 ----- 用户帐号 和 用户密码
     // 但是考虑到如果注册业务逻辑发生了变化，比如：注册还需要加上邮箱，这样必然需要修改方法的声明，修改非常麻烦
     // 出于封装性的考虑，直接传递一个POJO对象----- 用户实体类，封装全部用户信息，这样即使逻辑变化，方法的声明不用修改

     // 用户注册
 //    public abstract boolean register(String username, String password);
     public abstract boolean register(User user);

     // 用户登录
     public abstract boolean login(User user);

     // 玩猜数字游戏
     public abstract void play(Scanner input);
 }

 package cn.temptation.service;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Scanner;

 import cn.temptation.model.User;

 /**
  * 用户业务逻辑处理接口的实现类
  */
 public class UserServiceImpl implements UserService {
     // 成员变量
     // 下面两种写法效果相同
     // 写法1、非静态的成员变量，类初始化时进行初始化，创建出集合对象
 //    Collection<User> collection = new ArrayList<>();
     // 写法2、静态的成员变量，类加载时就进行初始化，创建出集合对象
     static Collection<User> collection = new ArrayList<>();

     @Override
     public boolean register(User user) {
         // 考虑到用户信息存储在内存中，因为注册的用户数量未知，所以选用集合进行存储
 //        Collection<User> collection = new ArrayList<>();

         // 向集合容器添加用户对象，并返回添加结果
         return collection.add(user);
     }

     @Override
     public boolean login(User user) {
         // 因为登录时要判断登录录入的用户信息和集合容器中存储的用户信息是否有一致的，所以登录功能用的集合容器和注册功能用的集合容器应该一致

         boolean result = false;

         // 遍历容器中用户信息
         for (User item : collection) {
             // 帐号 和 密码均一致
             if (item.getUsername().equals(user.getUsername()) && item.getPassword().equals(user.getPassword())) {
                 result = true;
                 // 找到有匹配的用户对象就不用再继续遍历了
                 break;
             }
         }

         return result;
     }

     @Override
     public void play(Scanner input) {
         // 1、生成答案数字
         int result = (int) (Math.random() * 10);

         System.out.println("输入0~9之间的一个整数：");

         // 2、让用户猜测，并给予提示
         for (;;) {
             int temp = Integer.parseInt(input.nextLine());

             if (temp > result) {
                 System.out.println("猜大了！");
             } else if (temp < result) {
                 System.out.println("猜小了！");
             } else {
                 System.out.println("恭喜，猜对了！");
                 break;
             }
         }
     }
 }

 package cn.temptation.model;

 // POJO：Plain Orinary Java Object   简单的单纯的Java对象
 // POJO类在系统架构中，一般用作数据的载体，在系统架构的不同层之间进行数据传递（实体类）
 /**
  * 用户实体类
  */
 public class User {
     // 成员变量
     // 用户帐号
     private String username;
     // 用户密码
     private String password;

     // 构造函数
     public User() {
         super();
     }

     public User(String username, String password) {
         super();
         this.username = username;
         this.password = password;
     }

     // 成员方法
     public String getUsername() {
         return username;
     }

     public void setUsername(String username) {
         this.username = username;
     }

     public String getPassword() {
         return password;
     }

     public void setPassword(String password) {
         this.password = password;
     }
 }