JAVA——API（续）

目录

一、Arrays

二、Lambda表达式 

三、正则表达式

四、异常

五、异常处理方式

---

 

一、Arrays

关于Arrays的sort使用：

 

第一种：使用comparable接口，自己定制规则 

public class Student implements Comparable<Student>{
    private String name;
    private double height;
    private int age;

    //指定比较规则
    @Override
    public int compareTo(Student o) {
        //约定1：认为左边对象 大于 右边对象 返回正整数
        //约定2：认为左边对象 小于 右边对象 返回负整数
        //约定3：认为左边对象 大于 右边对象 一定要返回0

//        if (this.age > o.age){
//            return 1;
//        } else if (this.age < o.age) {
//            return -1;
//        }else {
//            return 0;
//        }

        //简化(升序）
        return this.age - o.age;

        //降序
        //return o.age - this.age;
    }
}

第二种：创建Comparator比较器接口的匿名内部类对象，自己指定规则

public static void main(String[] args) {
        String[] names = {"body","angela","Andy","dlei","cacao","Babo","jack","Cici"};
        //默认按字符串的首字符编号进行升序排序的
//        Arrays.sort(names);
//        System.out.println(Arrays.toString(names));

        //要求忽略首字符大小写排序
        Arrays.sort(names, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareToIgnoreCase(o2);
            }
        });

        Arrays.sort(names,(o1, o2) -> o1.compareToIgnoreCase(o2));
        //特定类型的方法引用
        Arrays.sort(names, String::compareToIgnoreCase);

        System.out.println(Arrays.toString(names));
    }

---

二、Lambda表达式 

public static void main(String[] args){
	/*Animal a1 = new Animal(){
	    @Override
	    publicvoidspark(){
		System.out.println("dogiswang");
	    }
	};
	a1.spark();*/
	
	//报错！！！！
	//注意：Lambda表达式并不是说能简化全部匿名内部类的写法，只能简化函数式接口的匿名内部类(interface接口并且里面只有一个抽象方法)
	/*Animal a1 = ()->{
		System.out.println("dogiswang");
	    }
	};*/
	
	/*Swimmings=newSwimming(){
	     @Override
	    public void swim(){
		    System.out.println("我不会游泳");
	    }
	};*/
	
	Swimming s = ()->{
		System.out.println("我不会游泳");
	};
	s.swim();
}

 继续简化：

 

public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("小明",175,25);
        students[1] = new Student("小红",164,30);
        students[2] = new Student("小刘",180,22);

//        Arrays.sort(students);
//        System.out.println(Arrays.toString(students));

        //方法二
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //约定1：认为左边对象 大于 右边对象 返回正整数
                //约定2：认为左边对象 小于 右边对象 返回负整数
                //约定3：认为左边对象 大于 右边对象 一定要返回0

//                if (o1.getHeight() > o2.getHeight()){
//                    return 1;
//                } else if (o1.getHeight() < o2.getHeight()) {
//                    return -1;
//                }
//                return 0;

                //简化写法(实质就是把上面的代码封装起来）
                return Double.compare(o1.getHeight(),o2.getHeight());
            }
        });

        //继续简化：（被重写方法的形参列表）-> {方法体}
        //参数类型可以不写 如果只有一个参数，则参数类型可以省略，（）也可以省略
        //如果重写方法的代码只有一行，则{}可以省略，同时省略分号，若是return语句，则return要省略
        Arrays.sort(students, (o1, o2) -> o1.getAge() - o2.getAge());

        //就是把上面的  o1.getAge() - o2.getAge() 给封装了 传入的是 student
        Arrays.sort(students,(o1, o2) -> CompareByage.compareByage(o1, o2));

        //静态方法引用 类名::静态方法
        //前后参数一致 且 调用的是静态方法
        Arrays.sort(students,CompareByage::compareByage);

        //实例方法引用 对象名::实例方法
        CompareByage compareDesc = new CompareByage();
        //Arrays.sort(students,(o1,o2) -> o2.getAge() - o1.getAge());

        Arrays.sort(students,(o1,o2) -> compareDesc.comparebyAgeDesc(o1, o2));
        Arrays.sort(students,compareDesc::comparebyAgeDesc);

        System.out.println(Arrays.toString(students));
    }

public	static	void	main (String[] args){
	String[]  names={"body","angela","Andy","dlei","cacao","Babo","jack","Cici"};
	//默认按字符串的首字符编号进行升序排序的
	//Arrays.sort(names);
	//System.out.println(Arrays.toString(names));
	
	//要求忽略首字符大小写排序
	Arrays.sort(names,newComparator<String>(){
		@Override
		publicintcompare(Stringo1,Stringo2){
		returno1.compareToIgnoreCase(o2);
		}
	});
	
	Arrays.sort(names,(o1,o2)->o1.compareToIgnoreCase(o2));
	//特定类型的方法引用
	Arrays.sort(names,String::compareToIgnoreCase);
	
	System.out.println(Arrays.toString(names));
}

---

三、正则表达式

作用：1. 校验数据格式是否合法

           2. 在一段文本中查找满足要求的内容

 public static void main(String[] args) {
        //替换 把数字替换成-
        String s1 = "今天是七夕666666没说我都不知道698745321好吧好吧456321卡啊看看卡";
        System.out.println(s1.replaceAll("\\w+","-"));

        //优化
        String s2 = "我我我嘻嘻嘻哈哈哈哈哈哈";
        /*
        (.)一组，.匹配任意字符
        \\ 1:为这个组声明一个组号：1号
        +：声明必须是重复的字
        $1可以去到第一组代表的那个重复的字
        */
        System.out.println( s2.replaceAll("(.)\\1+","$1") );

        //把人名取出来
        String s3 = "今天是七夕666666没说我都不知道698745321好吧好吧456321卡啊看看卡";
        String[] names = s3.split("\\w+");
        System.out.println(Arrays.toString(names));
    }

---

四、异常

 

 

 

 public static void main(String[] args) {
       /* try {
            saveAge(25);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }*/

        try {
            saveAge2(30);
            System.out.println("执行成功！！！");
        } catch (AgeIllegalException e) {
            throw new RuntimeException(e);
        }


    }

    public static void saveAge2(int age) throws AgeIllegalException{
        if (age > 20 && age < 120) {
            System.out.println("执行成功！！！年龄保存成功！ " + age);
        }else {
            throw new AgeIllegalRuntimeException("/age is illegal " + age);
        }
    }

    public static void saveAge(int age) {
        if (age > 20 && age < 120) {
            System.out.println("执行成功！！！");
        }else {
            throw new AgeIllegalRuntimeException("/age is illegal " + age);
        }
    }

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

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

---

五、异常处理方式

//1.捕获异常，记录异常并响应合适的信息给用户

package com.Exception;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class dealException {
    public static void main(String[] args) {
        try {
            test1();
        } catch (Exception e) {
            System.out.println("当前操作有问题!!!");
            e.printStackTrace(); //打印出这个异常对象的信息 记录下来
        }
    }

    public static void test1() throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d = sdf.parse("2024-12-26 8:20:20");
        System.out.println(d);
        test2();

    }

    public static void test2() throws Exception {
        //
        InputStream is = new FileInputStream("D:/mein/note");
    }
}
 

//2.捕获异常，尝试修复

package com.Exception;

import java.util.Scanner;

public class dealExeption2 {
    public static void main(String[] args) {
        while (true) {
            try {
                test();
                break;
            } catch (Exception e) {
                System.out.println("请输入合法的数字！！！");
            }
        }
    }

    public static void test(){
        while (true) {
            System.out.println("请输入一个合适的价格：");
            Scanner sc = new Scanner(System.in);
            double price = sc.nextDouble();
            if (price >= 0) {
                System.out.println("价格是：" + price);
                break;
            }else {
                System.out.println("输入有问题！！！");
            }
        }
    }
}

---