java第一阶段-JavaSE-Day16-集合

一、JVM的默认处理异常的方式

（一）概述

        1.在代码的某个位置，出现了和正常情况不同的情况，JVM就将异常情况封装到一个异常对象中。

        2.将异常对象抛给调用该方法的方法。

        3.某个方法接收到底层方法抛上来的异常，也没有办法自己处理，继续向上抛出，最终抛给主方法，主方法也没有办法处理，抛给调用自己的jvm虚拟机

        4.jvm虚拟机是我们手动调用的，只能将异常对象的所有信息通过错误流打印出来，结束jvm虚拟机

        5.总结：jvm默认处理的方式（一层一层向上抛，jvm接收到之后结束自己，捕获处理）

 

二、Throwable

（一）概述

        异常体系下类的特点

        1.每个类几乎没有自己独有的成员方法，都是从Throwable类中继承过来

        2.每个类的类名都比较长，目的就是为了让我们看到类名就知道是什么问题。

        3.每个类大部分都只提供构造方法

        java中异常都是通过类来体现的，类有异常的体系，体系中关于异常对象的操作功能统一定义在体系的Throwable类中，其他的异常继承这个类就可以。

        Throwable构造方法

        1.Throwable（）：创建一个没有任何信息的异常对象

        2.Throwable（String message）：创建一个具有描述异常信息的异常对象

        3.Throwable（Throwable t）：创建一个具体异常原因信息的异常对象

        常用方法

 

public class Demo01 {
    public static void main(String[] args) throws Throwable {
        Throwable t1 = new Throwable();
        System.out.println(t1);
        //throw t1;
        Throwable t2 = new Throwable("出错了");
        System.out.println(t2);
        //throw t2;
        RuntimeException cause = new RuntimeException("出错了");
        Throwable t3 = new Throwable(cause);
        //throw t3;
        t1.printStackTrace();
        System.out.println("==================");
        t2.printStackTrace();
        System.out.println("====================");
        t3.printStackTrace();
        System.out.println("===========================");
        System.out.println(t1.getCause());
        System.out.println(t2.getCause());
        System.out.println(t3.getCause());

    }

三、异常的注意事项

        运行时异常抛出可以不处理，即不捕获也不声明抛出。

        如果父类（接口）方法抛出了多个编译时异常，子类覆盖（重写）父类（接口）的方法时，可以不抛出异常，或者抛出相同的异常，或者父类抛出异常的子类。子类不能抛出比父类方法更大异常。

        如果父类（接口）方法没有异常抛出，子类覆盖父类（接口）方法时，不能抛出编译时异常。

import java.awt.print.PrinterException;

public class Fu {
    public void eat()throws PrinterException{

    }
    public void sleep(){

    }
}

import java.awt.print.PrinterException;
import java.awt.print.PrinterIOException;

public class Zi extends Fu {

   /* @Override
    public void eat() throws PrinterException {
        super.eat();
    }*/

   /* @Override
    public void eat(){

    }*/

    @Override
    public void eat() throws PrinterIOException {

    }
}

四、自定义异常的使用

        自定义异常概述

        当java中提供的异常不能够满足我们的需求时，我们可以自定义异常类。

        类要想成为异常类必须得成为异常体系的一员，需要继承异常体系中的某个类。

        异常无非就编译时异常和运行时异常，定义的时候只需要设计自己类继承代表整个编译时异常类或运行时异常的类，来决定自己定义的那种异常。

        Exception：代表整个编译时异常

        RunTimeException：代表整个的运行异常

        实现步骤

        1、设计异常列表，要让自己的类名也要见名知意。

        2、定义一个类继承对应的父类

        3、提供空参构造即可或者可传递异常信息的构造方法

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

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

public class Person {
    private String name;
    private int age;
    public Person(){}
    public Person(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) {
        if(age<0||age>120){
            try {
                throw new IllegaAgeException("年龄不合法");
            } catch (IllegaAgeException e) {
                e.printStackTrace();
            }
            age = 0;
        }
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class UsePerson {
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("dasd");
        p.setAge(-18);
        System.out.println(p);
    }
}

        集合体系

一、集合概述

（一）集合和数组的区别

        1、概述

        集合是java中用来存放多个引用类型（对象）数据的容器，它是解决了数组的一些弊端的一个多数据容器，他有的操作集合的方法。

        java中集合的体系使用接口和类进行体现使用的。

        2、集合和数组的相同点

        都是存放多个数据的容器

        3、集合和数组的不同点

        数组：

                ①可以存放任意数据类型数据，例如：int[],Person[],String[],double[]

                ②创建后长度不变

                ③创建后只能存放单一数据类型数据

        集合：

                ①只能存放引用类型数据

                ②集合长度可变

                ③可以同时存放多种类型的数据。

（二）集合体系结构

 

二、单列集合

（一）Collection接口中常用功能

        1、概述

        Collection是单列集合的顶层接口，定义了所有单列集合功能的行为声明（单列机和共有抽象方法），他的功能需要单列集合的实现类去实现，他功能通过实现类对象来使用。今天对于Collection的功能使用典型的实现类ArrayList实现。

        2、创建Collection集合的对象

        Collection是一个接口，不能直接创建对象，使用实现类ArrayList来创建对象使用

        大部分的集合创建对象使用的都是空参构造

        例：

                Collection c = new ArrayList（）；

        3、Collection集合常用方法

 

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Predicate;

public class Demo01 {
    public static void main(String[] args) {
        //创建一个Collection接口类型集合引用
        //
        Collection c = new ArrayList();
        //添加元素
        c.add("aaa");
        c.add("bbb");
        c.add("ccc");
        boolean b = c.add("ddd");
        System.out.println(b);
        System.out.println(c);
        //删除元素
        boolean b1 = c.remove("aaa");
        System.out.println(b1);
        System.out.println(c);
        //清空集合
       /* c.clear();
        System.out.println(c);*/
        //获取集合中元素个数
        int size = c.size();
        System.out.println(size);
        //判断是否为空
        System.out.println(c.isEmpty());
        //判断是否包含某个元素
        System.out.println(c.contains("bbb"));
        System.out.println("====================================");
        //removeIf(Predicate p)
        //Predicate断言接口
        Collection c2 = new ArrayList();
        c2.add("aaa");
        c2.add("aa");
        c2.add("a");
        c2.add("bbb");
        Predicate p = new Predicate() {
            @Override
            public boolean test(Object o) {
                String s= (String)o;
                return  s.contains("a");
            }
        };
        c2.removeIf(p);
        System.out.println(c2);
    }
}

（二）单列集合的遍历

        1、集合遍历：就是把集合中元素一个一个取出的过程

        2、迭代器遍历

        迭代器（Iterator）：他本身就是一个定义了专门对集合进行遍历功能的一个接口，我们不需要提供此接口的实现类对象

        原理：

        集合对象通过想过方法得到迭代器的对象，迭代器的对象调用相关方法遍历集合

        获取迭代器对象功能：集合Collection提供相关功能

        Iterator（）：获取Iterator类型的迭代器实现类对象

        迭代器的功能：

        Iterator：

        hasNext（）：判断下一个位置是否有元素，返回boolean类型的值，有返回true，否则返回false

        next（）：获取迭代器对象指向集合位置上的元素，同时移动迭代器指针到下一个位置

        remove（）：删除当前元素

        遍历：

                ①使用集合对象获取迭代器对象

                ②利用while循环结合迭代器的hasNext和next方法进行遍历即可

        3、迭代器遍历原理

 

        文字描述：

                ①获取迭代器对象的时候迭代器的指针指向第一个位置

                ②调用hasNext方法判断下一个位置是否有值

        false：没有元素，直接结束遍历

        true：有元素

        调用next方法获取该位置元素

        同时移动迭代器指针到下一个位置 重复2的操作一直到hasNext方法结果为false结束遍历

public class Demo02 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");
        Iterator it = c.iterator();
        while (it.hasNext()){
            Object o = it.next();
            System.out.println(o);
        }
        Collection c1 = new ArrayList();
        c1.add("张三");
        c1.add("李四");
        c1.add("王五");
        Iterator it1 = c1.iterator();
        while (it1.hasNext()){
            Object o = it1.next();
            String s = (String)o;
            System.out.println(s+"---"+s.length());
        }
    }
}

        注意事项：

        ①每次都是先判断，再去元素，不要判断一次，取多个

        ②hasNext方法执行次数是集合当前长度+1；

        ③next方法执行集合的长度次

        ④一个迭代器对象遍历完集合之后，就不要在用了

        4、增强for循环

        增强for循环遍历，也称之为foreach遍历，他的底层是使用迭代器遍历的一个全新格式，增强for遍历本质是迭代器遍历，只是简化了操作而已。

        格式：

        for（数据类型 变量名 ： 容器对象）{

        对集合元素的操作逻辑

        }

        解释：

        数据类型：集合中存放的数据的数据类型

        变量名：存放每次迭代到的元素的具体的值

        容器对象：要遍历的集合容器或者数组

        代码：

public class Demo03 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};
        for(int i: arr){
            System.out.println(i);
        }
        Collection c = new ArrayList();
        c.add("11");
        c.add("22");
        c.add("33");
        c.add("44");
        for(Object o : c){
            System.out.println(o);
        }
    }
}

（三）有序单列集合

        1、概述

        有序集合值的是Collection的分支，有序集合的顶层接口是List，List除了继承Collection接口的所有功能和遍历方式外具有自己的特有的功能和遍历方式

        2、特点

        ①有序：对集合的存取数据的顺序一致

        ②有索引：存放数据的位置有编号（和数组一样）

        ③元素可以重复：同一个集合下可以存放多个相同的元素

        研究List和研究Collection一样。用ArrayList类实现

        3、List集合的特有方法

 

代码：

 

4、List特有的遍历

①listItertor（）；

②使用普通的for循环遍历，因为有索引了