Java复习05

异常概述

异常：就是程序出现了不正常的情况

异常体系

Error：严重问题，不需要处理

Exception：称为异常类，它表示程序本身可以处理的问题

• RuntimeException：在编译期是不检查的，出现问题后，需要我们回来修改代码
• 非RuntimeException：编译期就必须处理的，否则程序不能通过编译，就更不能正常运行了

JVM的默认处理方案

如果程序出现了问题，我们没有做任何处理，最终JVM会做默认的处理

• 把异常的名称、异常原因及异常出现的位置等信息输出在了控制台
• 程序停止执行

异常处理

如果程序出现了问题，我们需要自己来处理，有两种方案：

• try …catch …
• throws

1. 异常处理之try …catch …

   • 格式“

     try{

     ​ 肯出现异常的代码；

     }catch(异常类名 变量名){

     ​ 异常的处理代码；

     }

     执行流程：

     程序从try里面的代码开始执行

     出现异常，会自动生成一个异常类对象，该异常对象将被提交给Java运行时系统

     当Java运行时系统接受到异常对象时，会到catch中去找匹配的异常类，找到后进行异常处理

     执行完毕后，程序还可以继续往下执行

     package heima01;
     
     public class ExceptionDemo01 {
         public static void main(String[] args) {
             System.out.println("开始");
             method();
             System.out.println("结束");
         }
     
         public static void method() {
             try {
                 int[] arr = {1, 2, 3};
                 System.out.println(arr[3]);//new ArrayIndexOutOfBoundsException();
     //        System.out.println(arr[2]);
             } catch (ArrayIndexOutOfBoundsException e) {
     //            System.out.println("你访问的数组的索引不存在");
                 e.printStackTrace();
             }
         }
     
     
     }
     

Throwable的成员方法

 public static void method() {
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);//new ArrayIndexOutOfBoundsException();
        } catch (ArrayIndexOutOfBoundsException e) {
//            System.out.println("你访问的数组的索引不存在");
//            System.out.println(e.getMessage());
//            System.out.println(e.toString());
            e.printStackTrace();//一般使用这个方法将错误信息输出
        }
    }

编译时异常和运行时异常的区别

Java中的异常被分为两大类：编译时异常和运行时异常，也被称为受检异常和非受检异常

所有的RuntimeException类及其子类被称为运行时异常，其他的异常都是编译时异常

• 编译时异常：必须显示处理，否则程序就会发生错误，无法通过编译
• 运行时异常：无需显示处理，也可以和编译时异常一样处理

异常处理之throws

虽然我们通过try … catch … 可以对异常进行处理，但是并不是所有的情况我们都有权限进行异常处理，也就是说，有些时候可能出现的异常是我们处理不了的

针对这种情况，Java提供了throws的处理方案

格式：

​ throws 异常类名；

注意：这个格式是跟在方法的括号后面的

public static void main(String[] args) {
//        method();
        try {
            method2();
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
    //编译时异常
    public static void method2() throws ParseException {

            String s = "2022-03-13";
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date d = sdf.parse(s);//抛出一个异常,调用该方法的时候再try...catch...
            System.out.println(d);

    }

• ​ 编译时异常必须要进行处理，两种处理方案：try…catch…或者 throws, 如果采用throws这种方案，将来谁调用谁处理
• 运行时异常可以不处理，出现问题后，需要我们回来修改代码

自定义异常

格式：

​ public class 异常类名 extends Exception{

​ 无参构造

​ 带参构造

}

范例：

public class ScoreException extends Exception{

​ public ScoreException（）{}

​ public ScoreException(String message){

​ super(message);

​ }

}

package heima02;

public class ScoreException extends Exception {
    public ScoreException() {
    }

    public ScoreException(String message) {
        super(message);
    }
}

package heima02;

public class Teacher {
    public void checkScore(int score) throws ScoreException {
        if (score < 0 || score > 100) {
            throw new ScoreException();
        } else {
            System.out.println("分数正常");
        }
    }
}

package heima02;

import java.util.Scanner;

public class TeacherTest {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入分数:");
        int score = sc.nextInt();

        Teacher t=new Teacher();
        try {
            t.checkScore(score);
        } catch (ScoreException e) {
            e.printStackTrace();
        }

    }
}

该方法下，如果输入的分数不正常时，没有输出异常的原因，故不用该无参构造方法，而使用带参构造方法

package heima02;

public class Teacher {
    public void checkScore(int score) throws ScoreException {
        if (score < 0 || score > 100) {
//            throw new ScoreException();
            throw new ScoreException("你给的分数有误,分数应当在0-100之间");
        } else {
            System.out.println("分数正常");
        }
    }
}

throws和throw的区别

throws

• 用在方法声明后面，跟的时异常类名
• 表示抛出异常，由该方法的调用者来处理
• 表示出现异常的一种可能性，并不一定会发生这些异常

throw

• 用在方法体内，跟的时异常对象名
• 表示抛出异常，由方法体内的语句处理
• 执行throw一定抛出了某种异常

Collection

1. 集合知识回顾

   集合的特点：提供了一种存储空间可变的存储模型，存储的数据容量可以随时发生改变

2. 集合体系结构

   单列，如：

   张三
   李四
   王五

   双列，如：

   itcast1	张三
   itcast2	李四
   itcast3	王五

   list，可重复，如：

   张三
   李四
   张三

   set，不可重复，如：

   张三
   李四

3. Collection集合概述和使用

   Collection集合概述

   • 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
   • JDK不提供此接口的任何直接实现，它提供更具体的子接口(如Set和List)实现

   创建Collection集合的对象

   • 多态的方式
   • 具体的实现类ArrayList

4. Collection集合常用方法

   方法名	说明
   boolean add (E e)	添加元素
   boolean remove(Object o)	从集合中移除指定的元素
   void clear()	清空集合中的元素
   boolean contains(Object o)	判断集合中是否存在指定的元素
   boolean isEmpty()	判断集合是否为空
   int size()	集合的长度，也就是集合中元素的个数

   package heima03;
   
   import java.util.ArrayList;
   import java.util.Collection;
   
   public class CollectionDemo02 {
       public static void main(String[] args) {
           Collection c = new ArrayList();
           //boolean add(E e);添加元素
           System.out.println(c.add("hello"));
           System.out.println(c.add("world"));
           System.out.println(c.add("world"));
   
           //boolean remove(Object o);从集合中移除指定的元素
           System.out.println(c.remove("world"));
   
   //        void clear(); 清空集合中的元素
   //        c.clear();
   
           //boolean isEmpty();判断集合是否为空
           System.out.println(c.isEmpty());
   
           //int size();集合的长度，也就是集合中元素的个数
           System.out.println(c.size());
   
           System.out.println(c);
       }
   }
   

   运行结果：

   true
   true
   true
   true
   false
   2
   [hello, world]

   Process finished with exit code 0

5. Collection集合的遍历

   Iterator:迭代器，集合的专用遍历方式

   • Iterator iterator():返回此集合中元素的迭代器，通过集合的iterator()方法得到
   • 迭代器史通过集合的iterator()方法得到的，所有我们说它是依赖于集合而存在的

   Iterator中的常用方法

   • E next(): 返回迭代中的下一个元素

   • boolean hasNext(): 如果迭代具有更多元素，则返回true；

     package heima03;
     
     import java.util.ArrayList;
     import java.util.Collection;
     import java.util.Iterator;
     
     public class CollectionDemo02 {
         public static void main(String[] args) {
             //创建集合对象
             Collection c = new ArrayList();
     
             //添加元素
             c.add("hello");
             c.add("world");
             c.add("java");
     
             //Iterator iterator():返回此集合中元素的迭代器，通过集合的iteratorF()方法得到
             Iterator it = c.iterator();//通过多肽类得到iterator对象
     
             //E next(): 返回迭代中的下一个元素
             System.out.println(it.next());//输出hello
             System.out.println(it.next());// world
             System.out.println(it.next());// java
     //        System.out.println(it.next());//NoSuchElementException 被请求访问的元素不存在
     
             //boolean hasNext(): 如果迭代具有更多元素，则返回true；
             if (it.hasNext()) {
                 System.out.println(it.next());
             }
             if (it.hasNext()) {
                 System.out.println(it.next());
             }
             if (it.hasNext()) {
                 System.out.println(it.next());
             }
             if (it.hasNext()) {
                 System.out.println(it.next());
             }
     
             //用while循环改进判断
             while (it.hasNext()) {
     //            System.out.println(it.next());
                 String s = it.next();
                 System.out.println(s);
             }
         }
     }
     

6. 集合的使用步骤

7. 案例：Collection集合存储学生对象并遍历

   需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

   实现思路：

   1. 定义学生类
   2. 创建Collection集合对象
   3. 创建学生对象
   4. 把学生添加到集合
   5. 遍历集合（迭代器方式）

   package heima04;
   //定义学生类
   public class Student {
       private String name;
       private int age;
   
       public Student() {
       }
   
       public Student(String name, int age) {
           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;
       }
   }
   

   package heima04;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Iterator;
   
   public class CollectionDemo {
       public static void main(String[] args) {
           //创建Collection集合对象
           Collection c = new ArrayList();
   
           //创建学生对象
           Student s1 = new Student("ling", 30);
           Student s2 = new Student("zhang", 35);
           Student s3 = new Student("wang", 30);
   
           //把学生添加到集合
           c.add(s1);
           c.add(s2);
           c.add(s3);
           //遍历集合（迭代器方式）
           Iterator it = c.iterator();
           while (it.hasNext()) {
               Student s = it.next();
               System.out.println(s.getName() + "," + s.getAge());
           }
       }
   }
   

List

1. List集合概述和特点

   List集合概述

   • 有序集合（也成为序列），用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
   • 与Set集合不同，列表通常允许重复的元素

   List集合特点

   • 有序：存储和取出的元素顺序一致
   • 可重复：存储的元素可以重复

   package heima05;
   
   import java.util.ArrayList;
   import java.util.Iterator;
   import java.util.List;
   
   public class ListDemo01 {
       public static void main(String[] args) {
           //创建集合对象
           List list = new ArrayList();
   
           //添加元素
           list.add("hello");
           list.add("world");
           list.add("java");
           list.add("java");
   
           //输出集合对象
   //        System.out.println(list);
   
           //迭代器的方式遍历
           Iterator it = list.iterator();
           while (it.hasNext()) {
               String s = it.next();
               System.out.println(s);
           }
   
       }
   }
   

2. List集合特有方法

   方法名	说明
   void add(int index,E element)	在此集合中的指定位置插入指定的元素
   E remove(int index)	删除指定索引处的元素，返回被删除的元素
   E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
   E get(int index)	返回指定索引处的元素

3. 并发修改异常

   并发修改异常

   • ConcurrentModificationException

   产生原因

   • 迭代器遍历的过程中，通过集合对象修改了元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致

   解决方案

   • 用for循环遍历，然后用集合对象做对应的 *** 作即可

4. ListIterator

   LisIterator：列表迭代器

   • 通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
   • 用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

   ListIterator中的常用方法

   • E next():返回迭代中的下一个元素
   • boolean hasNext():如果迭代具有更多元素，则返回true
   • E previous():返回列表中的上一个元素
   • boolean hasPrevious():如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
   • void add(E e):将指定的元素插入列表

   ListIterator lit = list.listIterator();
   while (lit.hasNext()) {
       String s = lit.next();
       System.out.println(s);
   }
   System.out.println("--------------------");
   
   while (lit.hasPrevious()) {
       String s = lit.previous();
       System.out.println(s);
   }
   

5. 增强for循环

   增强for：简化数组和Collection集合的遍历

   • 实现Iterator接口的类允许其对象成为增强型for语句的目标
   • 它时JDK之后出现的，其内部原理是一个Iterator迭代器

   增强for的格式

   • 格式：

     for(元素书籍类型变量名：数组或者Collection集合){

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

     }

   • 范例：

     int[] arr={1,2,3,4,5};

     for(int i:arr){

     ​ System.out.println(i);

     }

     public static void main(String[] args) {
         int[] arr = {1, 2, 3, 4, 5};
         for (int i : arr) {
             System.out.println(i);
         }
         System.out.println("--------------");
         String[] atrArray = {"hello", "world", "java"};
         for (String s : atrArray) {
             System.out.println(s);
         }
         System.out.println("--------------");
         List list = new ArrayList(
                 list.add("hello");
         list.add("world");
         list.add("java");
     
         for (String s : list) {
             System.out.println(s);
         }
         System.out.println("--------------");
         //
         for (String s : list) {
             if (s.equals("world")) {
                 list.add("javaee");
             }
         }
     }
     

     案例：List集合存储学生对象用三种方式遍历

     需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台编辑该集合

     思路：

     1. 定义学生类

     2. 创建List集合对象

     3. 创建学生对象

     4. 把学生添加到集合

     5. 遍历集合

        ​ 迭代器：集合特有的遍历方式

        ​ 普通for：带有索引的遍历方式

        ​ 增强for：最方便的遍历方式

        package heima06;
        
        import heima04.Student;
        
        import java.util.ArrayList;
        import java.util.Iterator;
        import java.util.List;
        import java.util.ListIterator;
        
        public class ListDemo {
            public static void main(String[] args) {
                //创建List集合对象
                List list = new ArrayList();
                //创建学生对象
                Student s1 = new Student("ling", 19);
                Student s2 = new Student("wang", 18);
                Student s3 = new Student("chen", 19);
        
                //添加学生到集合
                list.add(s1);
                list.add(s2);
                list.add(s3);
        
                //迭代器遍历集合
                Iterator it = list.iterator();
                while (it.hasNext()) {
                    Student s = it.next();
                    System.out.println(s.getName() + "," + s.getAge());
                }
                System.out.println("--------------------");
                //普通for：带有索引的遍历方式
                for (int i = 0; i < list.size(); i++) {
                    Student s = list.get(i);
                    System.out.println(s.getName() + "," + s.getAge());
                }//如果操作过程中要使用索引，就使用普通for
                System.out.println("--------------------");
                //增强for
                for (Student s : list) {
                    System.out.println(s.getName() + "," + s.getAge());
                }//如果只是遍历，使用增强for
        
            }
        }
        
        

6. 数据结构

   数据结构是计算机存储、组织数据的方式，是指相互之间存在一种或多种特定关系的数据元素的集合

   通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率

7. 常见数据结构之栈

8. 常见数据结构之队列

9. 常见数据结构之数组

10. 常见数据结构之链表

11. List集合子类特点

    List集合常用子类：ArrayList、LinkedList

    • ArrayList：底层数据结构是数组，查询快，增删瞒
    • LinkedList：底层数据结构是链表，查询慢，增删快

    练习：分别使用ArrayList和LinkedList完成存储字符串并遍历

12. LinkedList集合特有的功能

    方法名	说明
    public void addFirst(E e)	在该列表开头插入指定的元素
    public void addLast(E e)	将指定的元素追加到此列表的末尾
    public E getFirst()	返回此列表中的第一个元素
    public E getLast()	返回此列表中的最后一个元素
    public E removeFirst()	从此列表中删除并返回第一个元素
    public E removeLast()	从此列表中删除并返回最后一个元素

Set

1. Set集合概述和特点

   Set集合特点

   • 不包含重复元素的集合
   • 没有带索引的方法，所以不能使用普通for循环遍历

   HashSet：对集合的迭代器顺序不作任何保证

   Set集合联系

   • 存储字符串并遍历

   package heima08;
   
   import java.util.HashSet;
   import java.util.Set;
   
   public class SetDemo {
       public static void main(String[] args) {
           //创建集合对象
           Set set = new HashSet();
           //添加元素
           set.add("hello");
           set.add("world");
           set.add("java");
           set.add("world");
   
           //遍历
           for (String s : set) {
               System.out.println(s);
           }
       }
   }
   

   输出结果：

   world
   java
   hello

2. 哈希值

   哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

   Object类中有一个方法可以获取对象的哈希值

   • ​ public int hashCode(): 返回对象的哈希码值

   package heima09;
   
   public class HashDemo {
       public static void main(String[] args) {
           Student s1 = new Student("ling", 30);
           //同一个对象多次调用hashCode()方法返回的哈希值是相同的
           System.out.println(s1.hashCode());
           System.out.println(s1.hashCode());//685325104
           System.out.println("---------------------------------------");
   
           Student s2 = new Student("ling", 30);
           //默认情况下，不同对象的哈希值是不同的
           System.out.println(s2.hashCode());//460141958
       }
   }
   

   package heima09;
   
   public class HashDemo {
       public static void main(String[] args) {
           Student s1 = new Student("ling", 30);
           //同一个对象多次调用hashCode()方法返回的哈希值是相同的
           System.out.println(s1.hashCode());
           System.out.println(s1.hashCode());//685325104
           System.out.println("---------------------------------------");
   
           Student s2 = new Student("ling", 30);
           //默认情况下，不同对象的哈希值是不同的
           //通过方法重写，可以实现不同对象的哈希值是不同的
           System.out.println(s2.hashCode());//460141958
   
           System.out.println("--------------------------------");
           System.out.println("hello".hashCode());//99162322
           System.out.println("world".hashCode());//113318802
           System.out.println("java".hashCode());//3254818
           System.out.println("hello".hashCode());//99162322
           System.out.println("---------------------------------");
   
           System.out.println("重地".hashCode());
           System.out.println("童话".hashCode());
   
       }
   }
   

   对象的哈希值特点

   • 同一个对象多次调用hashCode()方法返回的哈希值是相同的
   • 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

3. HashSet集合概述和特点

   HashSet集合特点

   • 底层数据结构是哈希表
   • 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
   • 没有带索引的方法，所以不能使用普通for循环遍历
   • 由于是Set集合，所以是不包含重复元素的集合

4. HashSet集合保证元素唯一性源码分析

   HashSet集合添加一个元素的过程：

   HashSet集合存储元素：

   • 要保证元素唯一性，需要重写hashCode()和equals()

5. 常见数据结构之哈希表

   哈希表

   • JDK8之前，底层采用数组+链表实现，可以说是一个元素为链表的数组
   • JDK8之后，在长度比较长的时候，底层实现了优化

   对16取余后按结果存储，如取余结果都为2，则先比较哈希值，如果哈希值不同则用链表方式存储在2位置，如果哈希值相同再比较元素，如果元素也相同则不存储

   案例：HashSet集合存储学生对象并遍历

   需求：创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历集合

   要求：学生对象的成员变量值相同，我们就认为是同一个对象

   思路：

   • ​ 定义学生类
   • 创建HashSet对象
   • 创建学生对象
   • 把学生添加到集合
   • 遍历集合(增强for)

• 在学生类中重写两个方法 hashCode()和equals() 自动生成即可

  package heima10;
  
  public class Student {
      private String name;
      private int age;
  
      public Student() {
      }
  
      public Student(String name, int age) {
          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 boolean equals(Object o) {
          if (this == o) return true;
          if (o == null || getClass() != o.getClass()) return false;
  
          Student student = (Student) o;
  
          if (age != student.age) return false;
          return name != null ? name.equals(student.name) : student.name == null;
      }
  
      @Override
      public int hashCode() {
          int result = name != null ? name.hashCode() : 0;
          result = 31 * result + age;
          return result;
      }
  }
  

  package heima10;
  
  import java.util.HashSet;
  
  public class HashSetDemo {
      public static void main(String[] args) {
          //创建集合对象
          HashSet hs = new HashSet();
          //创建学生对象
          Student s1 = new Student("ling", 19);
          Student s2 = new Student("wang", 19);
          Student s3 = new Student("cai", 18);
  
          Student s4 = new Student("wang", 19);
  
          //把学生添加到集合
          hs.add(s1);
          hs.add(s2);
          hs.add(s3);
          hs.add(s4);//为保证添加元素的唯一性，我们需要重写HashCode方法
  
          //遍历
          for (Student s : hs) {
              System.out.println(s.getName() + "," + s.getAge());
          }
  
      }
  }
  

6. LinkedHashSet集合概述和特点

   LinkedHashSet集合特点

   • 哈希表和链表实现Set接口，具有可预测的迭代次序
   • 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
   • 由哈希表保证元素唯一，也就是说没有重复的元素

   LinkedHashSet集合练习

   • 存储字符串TreeSet集合并遍历

7. TreeSet集合概述和特点

   TreeSet集合

   • 元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方法取决于构造方

     ​ TreeSet():根据其元素的自然排序进行排序

     ​ TreeSet(Comparator comparator):根据指定的比较强进行排序

   • 没有带索引的方法，所以不能使用普通for循环遍历

   • 由于是Set集合，所以不包含重复元素的集合

   TreeSet集合练习

   • 存储整数并遍历

   package heima12;
   
   import java.util.TreeSet;
   
   public class TreeSetDemo01 {
       public static void main(String[] args) {
           //创建集合对象
           TreeSet ts = new TreeSet();//集合存储的是引用类类型，应该使用int类型的包装类类型Integer
   
           //添加元素
           ts.add(98);
           ts.add(20);
           ts.add(50);
           ts.add(30);
           ts.add(10);
   
           ts.add(30);
   
           //
           for (Integer i : ts) {
               System.out.println(i);
           }
       }
   }
   

8. 自然排序Comparable的使用

   • 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
   • 要求：按照年龄从小到大排序，年龄相同时，按照名字的字母顺序排序

   结论

   • 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
   • 自然排序，就是让元素所属的类实现Comparable接口，重写comparableTo(To) 方法
   • 重写方法时，一定要注意排序规则按照要求的注意条件和次要条件来写

   package heima12;
   
   public class Student implements Comparable<Student> {
       private String name;
       private int age;
   
       public Student() {
       }
   
       public Student(String name, int age) {
           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 int compareTo(Student s) {//若返回0，则说明元素是重复的，就不会存储，结果只输出一项值；若返回1，则升序存储；若返回-1，则降序存储
   //        return 0;
           //按年龄从小到大排序
           int num = this.age - s.age;//升序this放前面，降序this放后面
           int num2 = num == 0 ? this.name.compareTo(s.name) : num;
           return num2;
       }
   }
   

   package heima12;
   
   import java.util.TreeSet;
   
   public class TreeSetDemo02 {
       public static void main(String[] args) {
           //创建集合对象
           TreeSet ts = new TreeSet();
   
           //创建学生对象
           Student s1 = new Student("xishi", 19);
           Student s2 = new Student("diaochan", 18);
           Student s3 = new Student("yang", 20);
           Student s4 = new Student("wang", 21);
           Student s5 = new Student("ling", 21);
           System.out.println("-----------------------------------");
           //把学生类添加到集合
           ts.add(s1);
           ts.add(s2);
           ts.add(s3);
           ts.add(s4);
           ts.add(s5);
   
           //遍历集合
           //要实现对类的自然排序，该类需要实现comparable 接口
           for (Student s : ts) {
               System.out.println(s.getName() + "," + s.getAge());
           }
       }
   }
   

9. 比较器排序Comparator的使用

   • 存储学生对象并遍历，创建TreeSet集合使用代餐构造方法
   • 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

   package heima12;
   
   public class Student{
       private String name;
       private int age;
   
       public Student() {
       }
   
       public Student(String name, int age) {
           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;
       }
   
   }
   

   package heima12;
   
   import java.util.Comparator;
   import java.util.TreeSet;
   
   public class TreeSetDemo02 {
       public static void main(String[] args) {
           //创建集合对象
           TreeSet ts = new TreeSet(new Comparator() {
               @Override
               public int compare(Student s1, Student s2) {
                   //this.age-s.age;
                   //s1 s2
                   int num = s1.getAge() - s2.getAge();
                   int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                   return num2;
               }
           });
   
           //创建学生对象
           Student s1 = new Student("xishi", 19);
           Student s2 = new Student("diaochan", 18);
           Student s3 = new Student("yang", 20);
           Student s4 = new Student("wang", 21);
           Student s5 = new Student("ling", 21);
           System.out.println("-----------------------------------");
           //把学生类添加到集合
           ts.add(s1);
           ts.add(s2);
           ts.add(s3);
           ts.add(s4);
           ts.add(s5);
   
           //遍历集合
           //要实现对类的自然排序，该类需要实现comparable 接口
           for (Student s : ts) {
               System.out.println(s.getName() + "," + s.getAge());
           }
       }
   }
   

   结论：

   • 用TreeSet集合存储自定义对象，带参构造方法使用的时比较强排序对元素进行 排序的
   • 比较器排序，就是让集合构造方法接受Comparator的实现类对象，重写compara(T o1,T o2)方法
   • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

   案例：成绩排序

   要求：用TreeSet集合存储多个学生信息(姓名，语文成绩，数学成绩)，并遍历该集合，按照总分从高到低出现

   思路：

   • 定义学生类
   • 创建TreeSet集合对象，通过比较器进行排序
   • 创建学生对象
   • 把学生对象添加到集合
   • 遍历集合

泛型

1. 泛型概述f

   泛型：是JDK中引入的特征，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型，它本质是参数化类型，也就是说所 *** 作的数据类型被指定为一个参数

   一提到参数，最熟悉的就是定义方法时由形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？

   顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型

   这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

   泛型定义格式：

   • <类型>：指定一种类型的格式。这里的类型可以看成是形参
   • <类型1，类型2…>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
   • 将来具体调用时给定的类型可以看成是实参，并且实参的类型只能是引用数据类型

   泛型的好处：

   • 把运行时期的问题提前到了编译期间
   • 避免了强制类型转换

   package heima13;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Iterator;
   
   public class GenericDemo {
       public static void main(String[] args) {
           //创建集合对象
   //        Collection c=new ArrayList();
           Collection c = new ArrayList();
           //添加元素
           c.add("hello");
           c.add("world");
           c.add("java");
   //        c.add(100);
   
           //遍历集合
   //        Iterator it = c.iterator();
           Iterator it = c.iterator();
           while (it.hasNext()) {
   //            Object obj = it.next();
   //            System.out.println(obj);
   //            String s=(String)it.next();
               String s = it.next();
               System.out.println(s);
           }
   
       }
   }
   

2. 泛型类

   泛型类的定义格式：

   • 格式：修饰符class类名<类型>{}

   • 范例：public class Generic{}

     ​ 此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型

   package heima14;
   
   public class Generic<T> {
       private T t;
   
       public T getT() {
           return t;
       }
   
       public void setT(T t) {
           this.t = t;
       }
   }
   

   package heima14;
   
   public class GenericDemo {
       public static void main(String[] args) {
           Student s = new Student();
           s.setName("ling");
           System.out.println(s.getName());
   
           Teacher t = new Teacher();
           t.setAge(30);
           System.out.println(t.getAge());
           System.out.println("------------------------");
   
           Generic<String> g1 = new Generic<String>();
           g1.setT("ling");
           System.out.println(g1.getT());
   
           Generic<Integer> g2 = new Generic<Integer>();
           g2.setT(30);
           System.out.println(g2.getT());
   
           Generic<Boolean> g3 = new Generic<Boolean>();
           g3.setT(true);
           System.out.println(g3.getT());
       }
   }
   

3. 泛型方法

   泛型方法的定义格式：

   • 格式：修饰符<类型> 返回值类型方法名(类型 遍历名){}
   • 范例： public void show(T t){}

   package heima15;
   
   /*public class Generic {
       public void show(String s){
           System.out.println(s);
       }
       public void show(Integer i){
           System.out.println(i);
       }
       public void show(Boolean b){
           System.out.println(b);
       }
   }*/
   //泛型类改进
   /*public class Generic {
       public void show(T t){
           System.out.println(t);
       }*/
   //泛型方法改进
   public class Generic {
       public  void show(T t) {
           System.out.println(t);
       }
   }
   

   package heima15;
   
   public class GenericDemo {
       public static void main(String[] args) {
   //        Generic g=new Generic();
   //        g.show("ling");
   //        g.show(30);
   //        g.show(true);
           /*Generic g1=new Generic();
           g1.show("ling");
           Generic g2=new Generic();
           g2.show(30);
           Generic g3=new Generic();
           g3.show(true);*/
   
           Generic g = new Generic();
           g.show("ling");
           g.show(30);
           g.show(true);
           g.show(12.34);
       }
   }
   

4. 泛型接口

   泛型接口的定义格式：

   • 格式：修饰符interface 接口名<类型>{}

   package heima16;
   
   public interface Generic<T> {
       void show(T t);
   }
   

   package heima16;
   
   public class GenericImpl<T> implements Generic<T> {
       @Override
       public void show(T t) {
           System.out.println(t);
       }
   }
   

   package heima16;
   
   public class GenericDemo {
       public static void main(String[] args) {
           Generic<String> g1=new GenericImpl<String>();
           g1.show("ling");
           Generic<Integer> g2=new GenericImpl<Integer>();
           g2.show(30);
       }
   }
   

5. 类型通配符

   为了表示各种泛型List的父类，可以使用类型通配符

   • 类通配符：
   • List:表示元素类型未知的List，它的元素可以皮牌任何的类型
   • 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中

   如果说我们不希望List是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限

   • 类型通配符上限：
   • List:它表示的类型是Number或者其子类型

   除了可以指定类型通配符的上限，我们也可以指定类型通配符下限

   • 类型通配符下限：
   • List:它表示的类型是Number或者父类型

   package heima17;
   
   import com.sun.org.apache.xerces.internal.xs.datatypes.ObjectList;
   
   import java.util.ArrayList;
   import java.util.List;
   
   public class GenericDemo {
       public static void main(String[] args) {
           //类型通配符：
           List list1 = new ArrayList