Java开发实践07-0130

一、今日内容

1、集合框架

（1）Set集合

    ① 基本概念：java.util.set集合是Collection集合的子集合，与List集合平级。该集合中元素没有先后放入次序，并且不允许重复。

    ② 该集合的主要实现类是：HashSet类 和Treeset类。其中HashSet类的底层是采用哈希表进行数据管理的。其中TreeSet类的底层是采用二叉树进行数据管理的。

    ③ 常用的方法

参考Collection集合中的方法即可！

（2）Map集合

    ① 基本概念

java.util.Map集合中存取元素的基本单位是：单对元素；其中类型参数如下：

K  - 此映射所维护的键(Key)的类型，相当于目录。

V  - 映射值(Value)的类型，相当于内容。

该集合中key是不允许重复的，而目一个key只能对应一个value。

    ② 该集合的主要实现类有：HashMap类和TreeMap类。

    ③ 常用的方法

V put(K key, V value)	- 将Key-Value对存入Map，若集合中已包含该Key，则替换该Key所对应Value，返回值为该Key原来所对应的Value，若没有则返回null
V get(Object key)	- 返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回null
boolean containsKey(Object key)	- 如果此映射包含对于指定键的映射关系，则返回true
boolean containsValue(Object value)	- 如果此映射将一个或多个键映射到指定值，则返回true
V remove(Object key)	- 从此映射中移除指定键的映射关系（如果存在）

    ④ Map集合的遍历方式

      a. 方式一：自动调用toString方法

      b. 方式二：调用keySet方法获取Map集合中所有的key

      c. 方式三：调用entrySet方法获取Map集合中所有的键值对

    ⑤ Map集合是面向查询优化的数据结构，在大数据量情况下有着优良的查询性能，经常用于根据key检素value的业务场景。

2、异常机制

（1）基本概念

异常就是“不正常”的含义，有java语言中体现为运行阶段发生的错误。java.lang.Throwable类是java语言中所有错误(Error类)和异常(Exception类)的超类。其中Error类主要用于描述比较严重无法编码解决的错误，如：JVM挂了等。其中Exception类主要用于描述比较轻微可以编码解決的错误，如：0作为除数等。

（2）基本分类

    ① java.lang.Exception类的所有子类主要分为两大类：
      RuntimeException类  - 运行时异常，也叫做非检测性异常。
      IOException和其它异常  - 其它异常，也叫做检测性异常。
                   - 所谓检测性异常就是指在编译阶段能够被编译器检测出来的异常。

    ② 注意：当程序执行过程中发生了异常但没有手动处理时，该异常由java虛拟机采用默认方式处理，而默认处理方式就是打印异常的名称、异常的原因以及异常发生的位置并终止程序。

（3）异常的避免

在以后的开发中尽量使用if条件判断来避免异常的发生。

（4）异常的捕获

    ① 语法格式

try {

编写所有可能发生异常的语句；

}

catch（异常类型 变量名）{

编写针对该类异常进行处理的语句;

}

finally {

编写无论是否发生异常都需要处理的语句；

}

    ② 注意事项

      a. 当编写多个catch分支时，切记将小类型放到大类型的前面，懒人的写法：

catch (Exception e) {

}
      b. finally主要用于善后处理，如：关闭已经打开的文件、删除临时创建的文件等。

    ③ 执行流程

try {

    a;

    b;   - 可能发生异常的语句

    c;

}

catch( ... ) {

    d;

}

finally {

    e;

}

当程序执行过程中没有发生异常时的执行流程：a b c d e;

当程序执行过程中发生异常后的执行流程：a b d e;

（5）异常的抛出

    ① 基本概念

在某些特殊情况下异常不便于处理或无法处理时，就可以将异常转移给该方法的调用者，这个过程就叫做异常的拋出。

（6）自定义异常

    ① 基本概念

虽然java官方提供了大量的异常类，但没有提供针对年龄不合理的异常，此时若希望描述这样的异常信息，就需要程序员自定义异常类。

    ② 实现流程

      a. 自定义xxException继承自Exception或者其子类。

      b. 提供两个版本的构造方法，一个是无参构造方法，另外一个是字符串作为参数的构造方法。

二、代码

1、SetTest

Set集合

import org.junit.Test;

import java.util.HashSet;
import java.util.Set;

/**
 * @Author: ydh 2303
 * @description: 准备一个Set集合指向HashSet对象；
 *               向集合中添加元素“one”并打印；
 *               向集合中添加元素“two”并打印；
 *               向集合中添加元素“three”并打印；
 *               向集合中添加元素“one”并打印。
 * @Date: 2024/1/30 8:15
 * @Version: 1.0
 */
public class SetTest {

    @Test
    public void setTest(){

        Set<String> set = new HashSet<>();

        boolean b = set.add("two");
        System.out.println("b = " + b); //true
        System.out.println(set); //two

        b = set.add("one");
        System.out.println("b = " + b); //true
        System.out.println(set); //[one, two]无序

        b = set.add("three");
        System.out.println("b = " + b); //true
        System.out.println(set); //[one, two, three]

        b = set.add("four");
        System.out.println("b = " + b);
        System.out.println(set);

        b = set.add("five");
        System.out.println("b = " + b);
        System.out.println(set);
        System.out.println("--------------------------");

        b = set.add("one");
        System.out.println("b = " + b); //false
        System.out.println(set);
    }
}

运行结果：

2、RandomSetTest

随机生成10个1~20之间的随机数放入Set集合中并打印。

import org.junit.Test;

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

/**
 * @Author: ydh 2303
 * @description: 随机生成10个1~20之间的随机数放入Set集合中并打印。
 * @Date: 2024/1/30 8:43
 * @Version: 1.0
 */
public class RandomSetTest {

    @Test
    public void randomSetTest(){

        System.out.println("随机生成10个1~20之间的随机数：");
        //Set集合
        Set<Integer> set = new HashSet<>();
        //随机数
        Random random = new Random();

        //for循环（方法一）
        for (int i = 0; i < 10 ; i++){
            boolean b = set.add(random.nextInt(20) + 1);
            //判断是否相等
            if (b == false){
                i--;
            }
        }
        System.out.println(set);
        System.out.println("-------------------------");

        //while循环（方法二）
        while (true){
            int num = random.nextInt(20);
            set.add(num);
            if (set.size() == 10){
                break;
            }
        }
        System.out.println(set);
        System.out.println("-------------------------");

        while (set.size() < 10){
            set.add(random.nextInt(20) + 1);
        }
        System.out.println(set);
    }

}

运行结果：

3、MapTest

Map集合

import org.junit.Test;

import java.beans.IntrospectionException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * @Author: ydh 2303
 * @description: Map集合
 *               常用方法
 *               V put(K key, V value)	                - 将Key-Value对存入Map，若集合中已包含该Key，则替换该Key所对应Value，返回值为该Key原来所对应的Value，若没有则返回null
 *               V get(Object key)	                    - 返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回null
 *               boolean containsKey(Object key)	    - 如果此映射包含对于指定键的映射关系，则返回true
 *               boolean containsValue(Object value)	- 如果此映射将一个或多个键映射到指定值，则返回true
 *               V remove(Object key)	                - 从此映射中移除指定键的映射关系（如果存在）
 * @Date: 2024/1/30 9:49
 * @Version: 1.0
 */
public class MapTest {

    @Test
    public void hashMapTest(){
        System.out.println("Map常用方法：");
        Map<Integer, String> map = new HashMap<>();
        //向集合中添加元素
        System.out.println("1.向集合中添加元素：");
        map.put(1,"张三");
        map.put(2,"李四");
        map.put(3,"王五");
        map.put(4,"赵六");
        System.out.println(map);
        System.out.println("-----------------------------");

        System.out.println("2.返回指定键所映射的值：");
        String value = map.get(3);
        System.out.println("3 = " + value);
        System.out.println("-----------------------------");

        System.out.println("3.此映射包含对于指定键的映射关系：");
        boolean b = map.containsKey(5);
        System.out.println(b); //false
        b = map.containsKey(2);
        System.out.println(b); //true
        System.out.println("-----------------------------");

        System.out.println("4.此映射将一个或多个键映射到指定值：");
        b = map.containsValue("斯坦尼斯拉夫斯基");
        System.out.println(b); //false
        b = map.containsValue("张三");
        System.out.println(b); //true
        System.out.println("-----------------------------");

        //删除Map集合中的元素
        System.out.println("5.删除Map集合中的元素：");
        String  v = map.remove(3);
        System.out.println("删除的值为：" + v); //王五
        v = map.remove(11);
        System.out.println("删除的值为：" + v); //null
    }

    @Test
    public void iteratorMapTest(){
        System.out.println("遍历Map：");
        Map<Integer, String> map = new HashMap<>();
        //向集合中添加元素
        map.put(1,"张三");
        map.put(2,"李四");
        map.put(3,"王五");
        map.put(4,"赵六");
        System.out.println(map);
        //遍历Map集合,方式一
        System.out.println("方式一：");
        System.out.println(map);
        System.out.println("-----------------------------");

        //遍历Map集合,方式二
        System.out.println("方式二：");
        Set<Integer> set = map.keySet();
        for (Integer it : set){
            System.out.println(it + "=" + map.get(it));
        }
        System.out.println("-----------------------------");

        //使用entrySet遍历Map集合中的元素,方式三
        System.out.println("方式三：");
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        for (Map.Entry<Integer, String> e : entries){
            System.out.println(e);

        }
        System.out.println("=============================================");
    }
}

运行结果：

4、Exception异常

（1）ExceptionTest01

异常机制--五种

package Exception01;

import org.junit.Test;

import java.io.IOException;

/**
 * @Author: ydh 2303
 * @description: 异常机制--五种
 * @Date: 2024/1/30 15:50
 * @Version: 1.0
 */
public class ExceptionTest01 {
    @Test
    public void exceptionTest(){
        //1.ArithmeticException 算数异常
        int a = 10;
        int b = 0;
        if (b != 0){
            System.out.println(a / b);
        }

        //2.ArrayIndexOutOfBoundsException 数组下标越界异常
        int[] arr = new int[5];
        int len = 5;
        if (len < arr.length) {
            System.out.println(arr[len]);
        }

        //3.NullPointerException 空指针异常
        String str = null;
        if (str != null) {
            System.out.println(str.length());
        }

        //4.ClassCastException 类型转换异常
        Exception exception = new Exception();
        if (exception instanceof IOException){
            IOException io = (IOException) exception;
            System.out.println(io);
        }

        //5.NumberFormatException 数字格式异常
        String str2 = "123aa";
        //匹配正则表达式 \d+表示数字
        if (str2.matches("\\d+")) {
            System.out.println(Integer.parseInt(str2));
        }

        System.out.println("程序终于执行完成了！");
    }
}

运行结果：

（2）ExceptionTest02

文件找不到异常

package ExceptionTest;

import org.junit.Test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * @Author: ydh 2303
 * @description: 异常的捕获--流
 * @Date: 2024/1/30 16:01
 * @Version: 1.0
 */
public class ExceptionTest02 {
    @Test
    public void exceptionTest(){
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream("c:/a.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

（3）ExceptionTest03

电脑关机

package ExceptionTest;

import java.io.IOException;

/**
 * @Author: ydh 2303
 * @description: 电脑关机
 * 在某些特殊情况下异常不便于处理或无法处理时，就可以将异常转移给该方法的调用者，这个过程就叫做异常的拋出。
 * @Date: 2024/1/30 16:30
 * @Version: 1.0
 */
public class ExceptionTest03 {

    public static void main(String[] args) {
        try {
            exc();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void exc() throws IOException {
        Runtime.getRuntime().exec("shutdown -s -t 72000");
    }
}

（4）ExceptionTest04

算数异常

package ExceptionTest;

/**
 * @Author: ydh 2303
 * @description: 算数异常
 * @Date: 2024/1/30 17:27
 * @Version: 1.0
 */
public class ExceptionTest04 {
    public static void main(String[] args) {
        try {
            System.out.println(10 / 0);
            System.out.println("赚钱最重要！");
        }catch (ArithmeticException e){
            System.out.println("出异常了！");
            System.exit(0);
        }finally {
            System.out.println("我是finally，你看我有没有打印内容！");
        }
    }
}

运行结果：

（5）ExceptionTest05

package ExceptionTest;

/**
 * @Author: ydh 2303
 * @description:
 * @Date: 2024/1/30 17:33
 * @Version: 1.0
 */
public class ExceptionTest05 {

    public static void main(String[] args) {
        Person person = haha();
        System.out.println(person.age);
    }

    public static Person haha() {
        Person person = new Person();
        try {
            person.age = 10;
            return person;
        } catch (Exception e) {
            return null;
        } finally {
            person.age = 20;
        }
    }

//    public static void main(String[] args) {
//        int a = haha();
//        System.out.println(a);
//    }
//
//    public static int haha() {
//        int a = 10;
//        try {
//            return a;
//        } catch (Exception e) {
//            return 0;
//        } finally {
//            a = 20;
//        }
//    }

    //静态内部类
    static class Person{
        int age;
    }
}

运行结果：

5、自定义异常

编程实现Person类的封装，特征有：姓名和年龄，要求重写tostring方法；

编程实现PersonTest类，在main方法中使用有参方式构造对象并打印。

（1）Person

package ExceptionTest;

/**
 * @Author: ydh 2303
 * @description: 编程实现Person类的封装，特征有：姓名和年龄，要求重写tostring方法；
 *               编程实现PersonTest类，在main方法中使用有参方式构造对象并打印
 * @Date: 2024/1/30 16:34
 * @Version: 1.0
 */
public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) throws AgeException {
        setName(name);
        setAge(age);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) throws AgeException {

//        if (age > 0 && age < 100) {
//            this.age = age;
//        } else {
//            this.age = 0;
//            System.out.println("年龄不合理");
//        }

        if (age > 0 && age < 100) {
            this.age = age;
        } else {
            throw new AgeException("年龄不合理！");
        }
    }

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

（2）PersonTest

package ExceptionTest;

/**
 * @Author: ydh 2303
 * @description: 编程实现PersonTest类，在main方法中使用有参方式构造对象并打印
 * @Date: 2024/1/30 16:35
 * @Version: 1.0
 */
public class PersonTest {
    public static void main(String[] args) {
        Person person = null;
        try {
            person = new Person("张三", 20);
        } catch (AgeException e) {
            e.printStackTrace();
        }
        System.out.println(person);
    }
}

（3）AgeException

package ExceptionTest;

/**
 * @Author: ydh 2303
 * @description: 年龄异常
 * @Date: 2024/1/30 16:39
 * @Version: 1.0
 */
public class AgeException extends Exception {
    public AgeException() {
    }

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

运行结果：

三、总结

今日学习了集合框架的剩余部分内容，主要学习了异常机制，有基本概念、基本分类、异常的避免、异常的捕获、异常的抛出、自定义异常等，还联系了很多，还要继续学习！