自学Java基础知识第十五天

day15

1. Collections工具类

List : 有索引, 元素可重复

  实现类 : ArrayList(主要使用查询), LinkedList(主要增删)

Set : 没有索引, 元素不重复

  实现类 : HashSet(元素存取无序)  LinkedHashSet(元素存取有序)

Map : 没有索引, key值不重复

  双列数据, a= 4

  实现类 : HashMap(元素存取无序)  LinkedHashMap(元素存取有序)

 

注意 : 集合中存储自定义类型, 通过类型成员变量进行去重复, alt + shift + s 重写hashCode和equals方法

 

1. Collections 是单列集合(List,Set)工具类, 来自于java.util包
2. Collections工具类, JDK中没有给出任何构造, 不能实例化对象, 因为类型中的所有成员和方法都是静态的, 类名.直接调用
3. Collections常用方法功能:

1) sort(List list) : 将参数list集合进行默认的升序排列(从小到大),没有返回值类型

2) binarySearch(List<T> list, T key) : 查找参数key在list集合中的出现的索引位置, 找到了返回值结果 >= 0 , 没有找到返回负数

  注意 : 折半查找需要集合是升序

3) frequency(Collection<?> c, Object o): 获取到元素o在集合c中出现的次数,返回值类型int类型

4) max(Collection<?> c) : 获取到集合c中的最大值

5) min(Collection<?> c) : 获取到集合c中的最小值

6) replaceAll(List<T> list,T old, T new ) : 将集合list中的所有old元素替换成new元素

7) reverse(List list) : 将list集合中的元素进行反转(逆序排序)

8) shuffle(List list) : 将参数list集合中的元素进行无规则的混乱排序(洗牌场景使用)

9) swap(List list, int index1 , int index2) : 将集合list中index1和index2索引位置元素进行交换

 

代码

package com.ujiuye.collections;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashSet;

public class Demo01_Collections工具类 {

public static void main(String[] args) {

ArrayList<Integer> list = new ArrayList<>();

list.add(12);

list.add(99);

list.add(2);

list.add(-5);

list.add(12);

 

        // 1. sort(List list) : 将参数list集合进行默认的升序排列(从小到大)

Collections.sort(list);

System.out.println(list);// [-5, 2, 12, 99]

 

// 2. binarySearch(List<T> list, T key) : 查找参数key在list集合中的出现索引位置, 找到了返回值结果 >= 0 , 没有找到返回负数

int index = Collections.binarySearch(list, 99);

System.out.println(index);// 3

 

System.out.println(Collections.binarySearch(list, -99));

 

//3)frequency(Collection<?> c, Object o): 获取到元素o在集合c中出现的次数,返回值类型int类型

System.out.println(Collections.frequency(list, 12));// 1

 

HashSet<Integer> set = new HashSet<>();

set.add(199);

set.add(18);

set.add(6);

/*4)max(Collection<?> c) : 获取到集合c中的最大值

5)min(Collection<?> c) : 获取到集合c中的最小值*/

System.out.println(Collections.max(set));// 199

System.out.println(Collections.min(set));// 6

 

// 6. replaceAll(List<T> list,T old, T new ) : 将集合list中的old元素替换成new元素

Collections.replaceAll(list, 12, 888);

System.out.println(list);// [-5, 2, 888, 888, 99]

 

// 7. reverse(List list) : 将list集合中的元素进行反转(逆序排序)

Collections.reverse(list);

System.out.println(list);// [99, 888, 888, 2, -5]

 

// 8. shuffle(List list) : 将参数list集合中的元素进行无规则的混乱排序(洗牌场景)

/*Collections.shuffle(list);

System.out.println(list);//[2, 888, -5, 888, 99]

        */

 

// 9. swap(List list, int index1 , int index2) : 将参数index1和index2索引位置元素进行交换

Collections.swap(list, 0, 2);

System.out.println(list);//[888, 888, 99, 2, -5]

}

}

 

 

2. 异常

2.1 异常的概述

1. 异常(Exception) : 代码编译或者运行过程中,发生的不正常情况,或者错误情况,称为异常
2. java中, 每一种异常都封装成一个类, 当有异常场景发生, 创建出对应的异常对象, 会将异常的发生位置, 发生原因, 封装在对象中, 将异常信息展示,提示代码问题
3. 代码中发生的异常, 可以进行处理,可以进行代码跳转, 甚至可以避免

 

 

2.2 异常的体系结构

Throwable : 可抛出异常类型, 是所有的错误和异常的父类, 只有Throwable类型本身或者是他的子类之一, JVM虚拟机才能够对其进行异常处理

   --Error : 所有错误的父类, 错误就是代码发生问题比较严重, 需要通过修改代码改善问题, 目前不关注error类别

   --Exception : 所有异常父类, 异常表示代码中发生的不太严重的问题, 可以处理, 可以解决, 甚至可以避免, 举例 : NullPointerException

      a : 运行时异常 : RuntimeException, 代码运行时才会发生的异常, 这些异常不需要进行任何的处理

      b : 编译时异常 : 除了运行时异常之外的所有异常,全部都是编译时期异常, 编译时期异常如果发生, 代码自动提示进行处理, 必须进行声明或者处理

 

 

 

 

 

2.3 JVM虚拟机异常默认处理机制

1. 如果代码中发生异常, 代码中没有对于异常的任何处理方式, 此时JVM虚拟机自动帮助代码进行异常处理

 

 

 

 

 

总结 : 代码发生异常, 将异常一层一层向上抛给方法的调用者, 直到抛给main, main方法抛给JVM, 最后由JVM输出异常信息, 停止代码

 

 

2.4 异常手动处理方式

1. 异常声明 : 代码可能有异常, 不处理, 在方法上声明可能发生的异常类型, 目的, 就是为了告知方法调用者, 调用方法时,对于可能发生的异常问题进行预处理
2. 异常处理 : 使用语法结构, 将代码中发生的异常处理掉, 异常处理掉之后,代码不会停止, 可以继续运行

     try...catch系列语法结构

 

 

2.5 throw关键字

1. throw : 关键字, 表示抛出异常
2. throw关键字使用场景:

     如果认为代码中可能有一些不正常场景出现, 那么可以对这种场景的发生使用throw关键字抛出一个对应的异常信息, 进而让代码停止或者跳转. 因此代码的停止或者是跳转就把握在自己的控制中

1. throw关键字语法结构:

   使用在方式中 :

   throw new 异常(异常详细信息写清楚);

 

1. throw关键字每次只能创建和抛出一个异常

 

1. throw关键字在实际开发中使用:

   通过前端录入数据信息, 需要数据传送到后台系统, 后台接到信息之后,需要验证数据信息的合法性, 例如 : 验证客户姓名 ,规则 : 不能带有特殊符号,名字长度不超过50个字符, 于是验证出姓名并不符合实际要求, 可以使用throw关键字, 创建出一个异常, 抛出异常

   if(!name.matches(regex)){

      throw new Exception(“名字不能出现特殊字符,长度不能超过50位”);

}

 

代码

package com.ujiuye.exception;

public class Demo03_Throw {

public static void main(String[] args) {

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

getArrayEle(arr,5);

}

 

public static void getArrayEle(int[] arr , int index) {

 

// 1. 预判数组arr不能为null

if(arr == null) {

throw new NullPointerException("数组不能为null");

}

 

// 2. 预判操作的索引index,不能越界

if(index < 0 || index >= arr.length) {

  throw new ArrayIndexOutOfBoundsException(index+"在数组中不存在,无法操作");

}

int ele = arr[index];

System.out.println(ele);

}

}

 

 

2.6 throws关键字

1. throws :关键字, 表示异常的声明, 是异常的一种处理方式
2. throws 关键字使用场景:

   如果方法中可能会出现编译时期异常, 而方法中没有对异常进行任何处理, 那么可以在方法上将可能会发生的编译时期异常使用throws关键字进行声明, 如果有多个编译时期异常, 多个异常之间使用,进行分隔

    throws关键字声明异常, 目的就是为了告知方法调用者, 对于这些可能发生的异常进行预处理

1. throws 关键字使用:

   修饰符  返回值类型 方法名(参数列表)  throws 异常类型1, 异常类型2...{

 

}

 

1. throws 关键字, 主要进行编译时期异常声明, 方法中发生的运行时异常, 可以不进行声明和处理

 

 

代码

package com.ujiuye.exception;

import java.io.FileNotFoundException;

public class Demo04_Throws {

public static void main(String[] args) throws FileNotFoundException{

String s = "123.txt";

// 预处理 : FileNotFoundException

checkFile(s);

}

 

// 1. 定义方法 : 验证给出的字符串是不是abc.txt文件

public static void checkFile(String s) throws FileNotFoundException{

// 1. 引用数据类型验证不为null

if(s == null) {

// 证明NullPointerException--->运行时异常

throw new NullPointerException("文件不能为空");

}

 

// 2. 验证文件是不是abc.txt

if(!"abc.txt".equals(s)) {

//Unhandled exception type FileNotFoundException

//没有解决异常类型  : FileNotFoundException

throw new FileNotFoundException("文件不是abc.txt,无法操作");

}

}

}

 

 

 

2.7 throw关键字和throws关键字的比较

1. 功能不同:

   a : throw 关键字表示抛出异常

   b : throws 关键字声明异常

1. 定义使用位置不同:

   a : throw关键字定义使用在方法中

   b : throws 关键字使用在方法声明上

1. 处理异常个数不同:

   a : throw关键字每次抛出一个异常

   b : throws 关键字可以声明多个异常

1. 运行机制不同:

   a : throw关键字执行到了, 一定有一个异常发生了

   b : throws 关键字执行到了, 不一定有异常发生

 

 

2.8 try...catch语句处理异常

1. 语法结构:

   try{

        // 可能会发生异常的代码

}catch(可能会发生异常类  异常对象名){

    // 异常发生后, 处理方式

}

 

1. 说明:

1) try : 关键字, 表示尝试, 语法结构中, try主要作用检测代码是否有异常

2) catch : 关键字, 表示捕获异常, 捕获小括号中罗列出的异常, catch大括号中就是对于异常的处理方式

 

1. try...catch运行机制:

1) 先执行try代码块中的逻辑, 如果try中没有异常, catch代码块不用执行, 代码接着try...catch语法之后继续运行

2) 如果try代码中发生异常, try检测出异常, 从发生异常当前行代码, 不再继续运行try之后的代码, 直接将发生的异常抛出, 抛给catch

3) catch接收到异常, 与小括号中的异常类型进行匹配

  a : 匹配成功, catch捕获异常成功, 执行catch大括号内容, 处理异常,异常处理完毕,代码不需要停止, 接着整个try..catch语句之后继续运行

  b : 匹配失败,证明catch没有捕获住异常, 异常通过JVM虚拟机默认处理, 打印异常信息,代码停止

 

代码

package com.ujiuye.exception;

public class Demo05_TryCatch {

public static void main(String[] args) {

int i;

try {

i = 10 / 0;

        System.out.println(i);

}catch(ArithmeticException ex) {

i = 0;

System.out.println("0不能做除数, 设置数据默认值为0");

}

System.out.println("处理异常完毕, 代码继续" + i);

}

}

 

 

2.9 try...catch...catch处理异常

1. 一段代码有可能会发生多种异常, 需要多个catch语句分别进行每一种异常的捕获, 因此有了多catch语句处理异常
2. 语法结构:

   try{

       // 可能会发生异常的代码

}catch(异常类型1  对象1){

   // 异常处理方式1;

}catch(异常类型2  对象2){

// 异常处理方式1;

}...

 

1. 执行机制:

1) 执行try代码块中逻辑, 没有异常发生, 所有catch都不执行, 代码继续向下运行

2) 如果try代码块中发生异常, 从发生异常当前行直接将异常抛给catch, catch从上到下依次进行异常类型匹配, 如果匹配某个catch成功, 执行对应的异常处理方式, 处理完毕, 整个try...catch语句结束, 代码继续向下运行,不停止

3) 如果所有catch语句都没有捕获住try代码块中的异常, 那只能使用JVM默认异常处理方式

 

1. 多catch语句使用的注意事项:

   在使用多catch语句捕获多个异常时,如果多个异常之间具有子父类继承关系, 必须先捕获子类异常,后捕获父类异常, 因为如果父类异常先捕获, 会利用多态表达式将抛出的子类异常捕获住, 如果后面的子类异常没有可执行捕获的机会, 就会报错

 

代码

package com.ujiuye.exception;

import java.io.FileNotFoundException;

public class Demo06_TryCatchCatch {

public static void main(String[] args) {

String s = "123.txt";

try {

checkFile(s);

}catch(FileNotFoundException ex) {// 先捕获子类

System.out.println("文件no");

}catch(Exception ex) {// 后捕获父类

System.out.println("文件为空");

}

 

try {

checkFile(s);

}catch(Exception ex) { // Exception ex = new FileNotFoundException("文件不是abc.txt,无法操作");

System.out.println("文件为空");

}/*catch(FileNotFoundException ex) {// 报错原因是这段代码永远不会执行到,上面多态将子类异常捕获住了

System.out.println("文件no");

}*/

 

System.out.println("处理异常完毕, 代码继续");

}

 

    // 1. 定义方法 : 验证给出的字符串是不是abc.txt文件

public static void checkFile(String s) throws FileNotFoundException,Exception{

// 1. 引用数据类型验证不为null

if(s == null) {

// 证明Exception--->编译时期异常

throw new Exception("文件不能为空");

}

 

// 2. 验证文件是不是abc.txt

if(!"abc.txt".equals(s)) {

//Unhandled exception type FileNotFoundException

//没有解决异常类型  : FileNotFoundException

throw new FileNotFoundException("文件不是abc.txt,无法操作");

}

}

}

 

 

2.10 try...catch...finally处理异常

1. 语法结构:

   try{

       // 可能会发生异常的代码

}catch(异常类型1  对象1){

   // 异常处理方式1;

}catch(异常类型2  对象2){

// 异常处理方式1;

}...

finally{

   // 一定需要执行代码

}

 

1. 说明:

   finally : 表示一定会被执行的

 

1. 运行机制:

1) 如果try代码块没有异常, catch不执行, 在整个try...catch..finally语法结构结束之前, 必须先执行finally

2) 如果try代码块中有异常, 与catch匹配和异常捕获, 在整个try...catch..finally语法结构结束之前, 必须先执行finally

3) 实际开发中尽量不要在finally中设计return关键字返回, 因为返回一定会执行

 

1. 实际开发中划账交易:

   购买成功, 必须划账成功;  购买失败, 必须划账失败;

   boolean flag = false; // flag表示划账是否成功标志, false证明划账失败, true证明划账成功

try{

flag = 划账交易调用; // 如果成功划账, flag就为true

}catch(Exception e){// 证明划账失败

    冲销客户账务; // 把钱退还给客户

}finally{

    // 保证客户账务一定归还成功

    if(!flag){

           // 1. 查询当前交易流水

           // 2. 根据交易流水的状态,决定是否继续进行账务的二次撤销

}

}

   

代码

package com.ujiuye.exception;

public class Demo07_TryCatchFinally {

public static void main(String[] args) {

int i = funciton();

System.out.println(i);// 99

}

 

public static int funciton() {

try {

int i = 10 / 0;

System.out.println("try----"+i);

return i;

}catch(Exception e) {

int i = 10;

System.out.println("catch---"+i);

return i;

}finally {

System.out.println("我必须执行");

return 99;

}

}

}

 

 

2.11 try...finally语句

1. 语法结构:

   try{

        代码逻辑;

}finally{

   // 一定会被运行的代码

}

 

1. 上述语法结构,没有catch语句, 因此代码中发生异常, 没有异常的处理方式,还是需要通过JVM虚拟机默认进行异常处理

 

1. 运行机制:

   不论try代码块中是否有异常, finally中的逻辑一定会执行

   使用场景 : 如果代码不进行异常任何处理, 但是又有一定需要执行的代码, 可以使用上述语句

 

代码

package com.ujiuye.exception;

public class Demo08_TryFinally {

public static void main(String[] args) {

          try {

           System.out.println(10/0);

           System.out.println("123");

          }finally {

           System.out.println("456");

          }

}

}

 

 

2.12 异常中方法功能

在所有异常和错误父类Throwable中, 定义出了可以追踪异常信息的方法功能 , 子类异常本身没有特殊方法功能, 都是使用从父类Throwable中继承来的方法

 

1. 构造方法:

   a : Throwable() , 表示创建出一个异常对象, 没有描述异常发生具体信息

   b : Throwable(String message) : 创建出一个异常对象, 也将异常的发生原因描述清楚

 

1. Throwable中提供了获取异常信息的方式

   a : getMessage() : 获取到封装在异常对象中的异常信息 ,返回值类型String类型

   b : toString() : 获取到异常类型和异常信息, 返回值类型String类型

   c : printStackTrace() : 将异常的发生原因, 异常类型, 异常详细信息, 异常发生具体代码行数进行输出,开发中常见的异常信息输出方式

 

代码

package com.ujiuye.exception;

import java.io.FileNotFoundException;

public class Demo09_Throwable中的方法功能 {

public static void main(String[] args) {

String s = "123.txt";

try {

checkFile(s);

} catch (FileNotFoundException e) {//new FileNotFoundException("文件不是abc.txt,无法操作");

/*String result = e.getMessage();

System.out.println(result);*/

 

/*String result1 = e.toString();

System.out.println(result1);*/

 

// 方法中自带异常信息输出打印, 打印时以标准错误流,红色突出显示进行输出

e.printStackTrace();

}

 

System.out.println("over");

}

 

// 1. 定义方法 : 验证给出的字符串是不是abc.txt文件

public static void checkFile(String s) throws FileNotFoundException{

// 1. 引用数据类型验证不为null

if(s == null) {

// 证明NullPointerException--->运行时异常

throw new NullPointerException("文件不能为空");

}

 

// 2. 验证文件是不是abc.txt

if(!"abc.txt".equals(s)) {

//Unhandled exception type FileNotFoundException

//没有解决异常类型  : FileNotFoundException

throw new FileNotFoundException("文件不是abc.txt,无法操作");

}

}

}

 

 

2.13自定义异常

为什么要自定义异常类 : 因为发现异常类中,没有封装其他方法功能, 只能追踪异常信息, 实际项目需求中, 发生异常, 处理异常, 需要给出问题的解决方案, 不仅仅是查看异常信息而已, 因此可以自定义出异常, 在自定义异常类中封装很多的方法, 当自定义异常发生, 创建出一个自定义异常类对象, 可以随意调用封装好的方法功能, 因而解决异常问题

 

自定义异常的实现步骤:

1. 创建出一个类, 类名以Exception为结尾, 标志是一个异常类
2. 自定义类继承Exception, 或者RuntimeException

   a : 如果自定义类直接父类是Exception, 自定义异常类就是编译时期异常类

   b : 如果自定义类直接父类是RuntimeException, 自定义异常类就是运行时期异常类

1. 在自定义类中,定义出构造方法, 为了可以封装异常具体描述信息
2. 可以在异常类中随便定义很多方法功能

 

代码

package com.ujiuye.exception;

public class WrongNumberException extends Exception{

public WrongNumberException(String s) {

       super(s);

      }

 

public WrongNumberException() {

         super();

    }

      

    public void wrongNumber() {

       System.out.println("数据为负数不合理");

    }

}

 

 

package com.ujiuye.exception;

public class Demo10_测试自定义异常类 {

public static void main(String[] args) {

         int age = -20;

         try {

         if(age < 0) {

         throw new WrongNumberException("年龄不合理");

         }

         }catch(WrongNumberException ex) {// new WrongNumberException("年龄不合理");

          ex.printStackTrace();

          ex.wrongNumber();

         }

  }

}