集合_异常_集合异常-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_54163882/article/details/117391432

本文详细讲解了Java中的Collections和Arrays工具类，涉及集合操作如复制、填充、排序、查找，以及数组处理方法。同时介绍了如何通过Comparable接口和Comparator实现类的可比较性，以及异常处理机制，包括抛出和捕获异常，以及自定义异常的创建和使用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1：Collections集合工具类

    Collections:单列集合的工具类(成员都是静态的)
    1 static <T> void  copy(List<T> dest, List<T> src) ：把src中元素复制到dest中  注意要求dest的长度>=src
    2 static <T> void  fill(List<? super T> list, T obj) ： 把list中所有元素更改为obj
    3 static  T  max(Collection<T> coll) ：获取最大的元素 
      static  T  min(Collection<T> coll) ： 获取最小的元素
    4 static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) :把list中所有的 oldVal替换为newVal
    5 static void reverse(List<?> list)   ： 元素反转
    6 static void shuffle(List<?> list)   ： 洗牌
    7 static <T> void  sort(List<T> list)  ： 排序
       static <T> void  sort(List<T> list, Comparator<? super T> c)

2：Arrays数组工具类

     //Arrays:数组工具类
      1：static void fill(boolean[] a, boolean val) ：把a数组中所有元素更改为val
      2：static void sort(Object[] a) :对数组中元素排序
         static <T> void  sort(T[] a, Comparator<T> c)   :对数组中元素排序
      3：static String toString(Object[] a) ：获取数组的字符串
      4：static <T> List<T> asList(T... a) ：由数组获取集合

不定参数

	public static void main(String[] args) {
//         show();
//         show(1);
//         show(1,2);
		
		List<Integer> list=Arrays.asList(arr);//由数组获取集合
		System.out.println(list);//[1, 2, 3, 4, 5, 6, 7, 8, 9]
	}
//	public static void show(int... a) {//不定参数：jdk1.8的新特性：：：参数的个数不确定
//		System.out.println(a);//[I@18127abc
//	}
//	//完全等价于
//	public static void show(int[] a) {
//		System.out.println(a);
//	}

3：类具有可比较性

方式1：让类实现Comparable接口并实现int compareTo(T o) 方法

public static void main(String[] args) {
		
		
		ArrayList<Person1> list3=new ArrayList<>();
		list3.add(new Person1(22, "张三", 2222));
		list3.add(new Person1(32, "张三1", 4222));
		list3.add(new Person1(42, "张三", 2522));
		list3.add(new Person1(22, "张三2", 2262));
		list3.add(new Person1(33, "张三3", 2227));
		list3.add(new Person1(33, "张三", 2322));
		
		Collections.sort(list3);
		//System.out.println(list3);
		for (Person1 p : list3) {
			System.out.println(p);
		}
	}

}
//一个类具有可比较性做法1：让类实现Comparable接口  并实现int compareTo(T o)  方法
class Person1  implements Comparable<Person1>{
	int age;
	String name;
	float salary;
	public Person1(int age, String name, float salary) {
		this.age = age;
		this.name = name;
		this.salary = salary;
	}
	@Override
	public String toString() {
		return "Person1 [age=" + age + ", name=" + name + ", salary=" + salary + "]";
	}
	
	//实现Comparable的compareTo(T o)  方法  当前对象和参数对象比较
	public int compareTo(Person1 o) {
		//指定比较规则：先按年龄 再按工资 最后按姓名
		if(this.age!=o.age) {return this.age-o.age;}
		if(this.salary!=o.salary) {return this.salary>o.salary?1:-1;}
		return this.name.compareTo(o.name);
	}
}

方式2：为此类定义一个比较器类实现接口Comparator 并实现方法int compare(T o1, T o2)

  public static void main(String[] args) {
		ArrayList<Person2> list2=new ArrayList<>();
		list2.add(new Person2(22, "张三", 2222));
		list2.add(new Person2(32, "张三1", 4222));
		list2.add(new Person2(42, "张三2", 2522));
		list2.add(new Person2(22, "张三22", 2262));
		list2.add(new Person2(33, "张三33", 2227));
		list2.add(new Person2(33, "张三23", 2322));
		
		Collections.sort(list2,new Person2Comparator());
		//System.out.println(list3);
		for (Person2 p : list2) {
			System.out.println("-----"+p);
		}
	}
//一个类具有可比较性做法2：为此类定义一个比较器类实现接口Comparator 并实现方法int compare(T o1, T o2) 
class Person2{
	int age;
	String name;
	float salary;
	public Person2(int age, String name, float salary) {
		this.age = age;
		this.name = name;
		this.salary = salary;
	}
	@Override
	public String toString() {
		return "Person2 [age=" + age + ", name=" + name + ", salary=" + salary + "]";
	}
}
class Person2Comparator  implements Comparator<Person2>{
	public int compare(Person2 o1, Person2 o2) {
		    //指定比较规则：先按年龄 再按工资 最后按姓名
			if(o1.age!=o2.age) {return o2.age-o1.age;}
			if(o1.salary!=o2.salary) {return o2.salary>o1.salary?1:-1;}
			return o2.name.compareTo(o1.name);
	}
}

4 ：异常类概念

异常：程序运行过程中遇到不正常的情况(程序无法正常运行)
异常体系：由一堆异常类组成
异常体系的顶层父类：Throwable
java处理异常原理：把异常情况封装成对象把对象交给虚拟机/程序进行处理
Throwable：按异常严重情况分类
Error: 非常严重的异常：不能通过代码逻辑进行处理的异常情况一般是内存/虚拟机/语法出现的错误

       eg: int a::java.lang.Error: Unresolved compilation problem: 
          test();//java.lang.StackOverflowError
          new long[1024][1024][1001];//java.lang.OutOfMemoryError: Java heap space 
      Exception:通过代码逻辑可以处理的异常情况
            Exception按是否继承RuntimeException分类
            继承了RuntimeException的异常---运行时异常(UnChecked Exception)
            没有继承RuntimeException的异常---编译时异常(Checked Exception)
       eg://Class cla=Class.forName("Student");//ClassNotFoundException: Student

异常体系的特点：

特点1：Throwable的所有子类都没有特有方法所有方法都继承于Throwable
异常体系中类之间的区别只在于类名和异常原因
特点2：异常体系中子类的名字都是以Error和Exception结尾

5 : Throwable类

      1 构造方法：
           Throwable()   ：不指定错误原因
          Throwable(String message) ：参数是错误原因
      2  String toString() ： 获取异常类型：异常原因
              java.lang.ArithmeticException: / by zero
      3  String getMessage() ：获取异常原因
      4  void printStackTrace()  ：调用标准错误输出流
              java.lang.Throwable: 出错了！
	          at com.zhiyou100..Demo03Throwable.main(Demo03Throwable.java:60)

6：异常处理：抛出机制

异常处理方式之抛出机制：把可能产生的异常封装为对象抛给方法的调用者

格式：在方法声明上添加一个throws 异常类型1，异常类型2…

注意1：如果程序一直选择通过抛出机制来处理异常：异常最终抛给虚拟机
- 虚拟机统一处理方式：打印异常输出流然后终止程序
注意2：如果方法的某段代码出现异常而选择抛出机制来处理异常那么当前方法的其他代码不再执行
注意3：子类重写父类的方法：子类方法不能抛出比父类方法多的大的异常
*

方法声明加throws xxxException的作用：

1 声明当前方法可能产生那些异常
2 如果产生指定的异常当前方法不处理而是把异常对象抛给方法的对应者

编译时异常和运行时运行

编译时异常：没有继承RuntimeException的异常
运行时异常：继承RuntimeException的异常
区别：
- 1 如果代码可能产生编译时异常编译器会报错要求必须对编译时异常进行处理
- 如果代码可能产生运行时异常编译器不检查方法默认抛出可能产生的运行时异常
- 2 编译时异常只有在指定情况下才会产生出现的频率低
- 运行时异常出现的频率比较高
- 3 编译时异常没有继承RuntimeException
- 运行时异常继承了RuntimeException

代码

public static void main(String[] args)throws UnsupportedEncodingException, ParseException {
		System.out.println("main方法开始");
		test1();//调用者必须对 所调用方法抛出的异常进行处理
		System.out.println("main方法结束");
	}
public static void test1() throws UnsupportedEncodingException, ParseException {
		System.out.println("test1方法开始");
		String s=new String(new byte[] {46, 48,49},"gbk1");
		//Unhandled exception type UnsupportedEncodingException
		Date date=new SimpleDateFormat("yyyy-MM-dd").parse("1234-11-12");
		//ParseException
		System.out.println("test1方法结束");
}

7：异常处理：捕获机制

异常处理方式之捕获机制：通过代码逻辑对产生的异常进行处理

    格式：
        try{
          可能产生异常的代码块
        }catch(定义引用接受产生的异常对象){
            异常处理的代码
        }finally{
           不管是否出现异常 都要执行的代码
        }

捕获机制注意事项：
- 1 当try代码块中出现异常 try代码块不再执行而是执行对应的catch代码块
- 2 无论是否出现异常无论catch任何处理异常都要执行finally代码块(除了System.exit(0))
  一般情况下：finaly代码块用于关闭流释放资源
  3 捕获父类异常的catch 必须写在捕获子类成员的catch后面
  
  开发过程中遇到异常：尽量捕获避免抛出

代码

public static void main(String[] args){
    test1();//调用者无需对方法中的异常进行处理 因为方法本身已经对可能产生的异常处理掉了
    System.out.println(11);
}
public static void test1() {
    System.out.println("test1方法开始");
    try {
        System.out.println("try代码块开始");
        String s=new String(new byte[] {46, 48,49},"gbk1");
        System.out.println(1);
        Date date=new SimpleDateFormat("yyyy-MM-dd").parse("1234-11-12");
        System.out.println("try代码块结束");
        Class cla=Class.forName("xxx");
    }catch(UnsupportedEncodingException e) {
        System.out.println("catch__1");
        System.out.println("对异常UnsupportedEncodingException进行处理的代码！");
        //System.exit(0);
        //long[][][][] arr=new long[1024][1024][1024][1024];
        return;
    }catch(ParseException e) {
        System.out.println("catch__2");
        System.out.println("对异常ParseException进行处理的代码！");
    }catch(Exception e) {//抛出父类异常的catch必须放在抛出子类异常catch的后面
        System.out.println("catch__3");
        System.out.println("对异常Exception进行处理的代码！");
    }finally {
        //无论是否出现异常 无论catch任何处理异常 都要执行finally代码块(除了System.exit(0))
        //一般情况下：finaly代码块 用于关闭流释放资源
        System.out.println("finally代码块！");
    }
    System.out.println("test1方法结束");
}

8：自定义异常

自定义异常：定义一些jre中不存在的异常

步骤：
- 1 继承异常体系中的类才能称为异常类
- 2 提供一个有参数的构造方法并通过调用super(message)来传递异常原因
- 3 在方法中通过throw来产生一个自定义异常情况
- 4 对异常情况进行处理

public class Demo06MySelfException {
   
	public static void main(String[] args){
		char sex='妖';
		//创建了一个异常对象：不是出现异常情况
		SexNotSupportedException e=new SexNotSupportedException("性别不存在！");
		
		//throw 异常对象;表示程序出现异常情况
		if(sex!='男'&&sex!='女') {
			//4 对产生的异常进行处理
			try {
				throw e;//3 通过throw产生一个自定义类型的异常情况
			} catch (SexNotSupportedException e1) {
				System.out.println("性别："+sex+"不合理！");
				sex='男';
			}
		}
		System.out.println("sex="+sex);
	}
	 
}
//1 继承异常体系中的类 才能称为异常类 
class SexNotSupportedException extends Throwable {
	//2 通过构造方法的参数列表指定异常原因
	public SexNotSupportedException(String message) {
		//通过调用父类有参数的构造方法来传递异常原因
		super(message);
	}
}

throw和throws的区别
- 位置不同：throw用在方法体中 throws用在方法声明上
- 后面跟的内容不同：
  - throw后面跟一个异常对象
  - throws后面跟多个异常类型
- 作用不同：
  - throw 用在方法体中表示当前方法运行时产生了一个异常情况
  - throws 用在方法声明上表示当前方法可能产生那些异常如果产生这些异常就抛给方法的调用者去处理