24/04/24总结

最新推荐文章于 2024-09-13 21:40:38 发布

动不了一点

最新推荐文章于 2024-09-13 21:40:38 发布

阅读量876

点赞数 21

文章标签： java

本文链接：https://blog.csdn.net/m0_66349413/article/details/138142510

版权

异常:

1.异常是什么?
程序中可能出现的问题
2.异常体系的最上层父类是谁?异常分为几类?
父类:Exception。
异常分为两类:编译时异常、运行时异常
编译时异常和运行时异常的区别?
编译时异常:没有继承RuntimeException的异常，直接继承于Exception。
编译阶段就会错误提示
运行时异常:RuntimeException本身和子类，
编译阶段没有错误提示，运行时出现的

自己处理(捕获异常)
格式:               ctrl+alt+t选择try catch
try{
可能出现异常的代码;
}
catch(异常类名变量名){
异常的处理代码:
}
目的:当代码出现异常时,可以让程序继续往下执行
细节:如果我们要捕获多个异常，这些异常中如果存在父子关系的话，那么父类一定要写在下面
Throwable 的成员方法
方法名称                              //说明
public String getMessage()           返回此 throwable 的详细消息字符串
public string toString()             返回此可抛出的简短描述
public void printStackTrace()        把异常的错误信息以红色字体输出在控制台(仅仅是打印信息不会停止程序运行)
抛出处理
throws
注意:写在方法定义处，表示声明一个异常
告诉调用者，使用本方法可能会有哪些异常
public void 方法()throws 异常类名1,异常类名2...{
....
}
编译时异常:必须要写，
运行时异常:可以不写
throw
注意:写在方法内，结束方法
手动抛出异常对象，交给调用者
方法中下面的代码不再执行了
public void 方法(){
throw new NullPointerException();
}
简单来说抛出和捕获的区别是:抛出:告诉调用者出错了,捕获:不让程序停止

File:

File对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径
这个路径可以是存在的，也允许是不存在的
方法名称                                                               说明
public File(String pathname)                          根据文件路径创建文件对象
public File(String parent,string child)               根据父路径名字符串和子路径名字符串创建文件对象
public File(File parent,string child)                 根据父路径对应文件对象和子路径名字符串创建文件对象

 //1.根据字符串表示的路径，变成File对象
        String str="C:\\Users\\35303\\Desktop\\a.txt";
        File f1 = new File(str);
        System.out.println(f1); //C:\Users\35303\Desktop\a.txt";

//2.父级路径:C:\Users\35303\Desktop
        //子级路径:a.txt
        String parent = "C:\\Users\\35303\\Desktop";
        String child = "a.txt";
        File f2 = new File(parent,child);
        System.out.println(f2);

  //3.把一个File表示的路径和String表示的路径进行拼接
        File parent2 = new File("C:\\Users\\35303\\Desktop");
        String child2 = "a.txt";
        File f3 = new File(parent2,child2);
        System.out.println(f3);

运行结果:

public boolean isDirectory()          判断此路径名表示的File是否为文件夹
public boolean isFile()                判断此路径名表示的File是否为文件
public boolean exists()                判断此路径名表示的File是否存在
public long length()                      返回文件的大小(字节数量)
public string getAbsolutePath()           返回文件的绝对路径
public string getPath()                   返回定义文件时使用的路径
public string getName()                   返回文件的名称，带后缀
public long lastModified()                返回文件的最后修改时间(时间毫秒值)

public boolean createNewFile()            创建一个新的空的文件
public boolean mkdir()                    创建单级文件夹
public boolean mkdirs()                   创建多级文件夹
public boolean delete()                   删除文件、空文件夹(delete方法直接删除不走回收站)

//createNewFile()创建一个新的空的文件
        //细节1:如果当前路径表示的文件是不存在的，则创建成功，方法返回true
        //如果当前路径表示的文件是存在的，则创建失败，方法返回false
        //细节2:如果父级路径是不存在的，那么方法会有异常IOException
        //细节3:createNewFile方法创建的一定是文件，如果路径中不包含后缀名，则创建一个没有后缀的文件
        File f1 = new File("C:\\Users\\35303\\Desktop\\a.txt");
        boolean b = f1.createNewFile();
        System.out.println(b);

        //mkdir
        File f2 = new File("C:\\Users\\35303\\Desktop\\aaa");
        boolean c = f2.mkdir();
        System.out.println(c);

输出结果:

桌面成功创建

//Delete 删除
        //细节1:
        //如果删除的是文件，则直接删除，不走回收站。
        //如果删除的是空文件夹，则直接删除，不走回收站
        //如果删除的是有内容的文件夹，则删除失败
        File f3 = new File("C:\\Users\\35303\\Desktop\\aaa");
        boolean delete = f3.delete();
        System.out.println(delete);

        File f4 = new File("C:\\Users\\35303\\Desktop\\a.txt");
        boolean delete1 = f4.delete();
        System.out.println(delete1);

文件删除

Stream流:

stream流的作用:
结合了Lambda表达式,简化集合、数组的操作
Stream流的使用步骤:
① 先得到一条Stream流(流水线)，并把数据放上去
② 利用Stream流中的API进行各种操作:
1.过滤、转换: 中间方法:方法调用完毕之后，还可以调用其他方法
2.统计、打印: 终结方法:最后一步，调用完毕之后，不能调用其他方法

获取方式                  方法名                                                               说明
单列集合                  default Stream<E> stream() Co1lection中的默认方法
双列集合                                  无无法直接使用stream流
数组                      public static<T>stream<T> stream(T[] array)         Arrays工具类中的静态方法
一堆零散数据               public static<T>stream<T> of(T... values)          stream接口中的静态方法

  //1.单列集合获取stream流
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"a","b","c","d","e");       //给集合添加数据
       list.stream().forEach(s -> System.out.println(s));   //lambda表达式
        System.out.println("-------");

 //2.数组获取stream流
        int []arr = new int[]{1,2,3,4,5,6,7,8,9,10};
        String []arr1 = new String[]{"a","b","c"};
        Arrays.stream(arr).forEach(s-> System.out.println(s));
        Arrays.stream(arr1).forEach(s-> System.out.println(s));
        System.out.println("-------");

 //3.一堆零散的数据(前提：必须是同一种数据类型)
        Stream.of(1,2,3,4,5).forEach(s-> System.out.println(s));
        Stream.of("a","b","c","d").forEach(s-> System.out.println(s));

Stream流的中间方法
名称                                                              说明
Stream<T>filter(Predicate<? super T> predicate)                   过滤
Stream<T> limit(long maxSize)                                     获取前几个元素
Stream<T> skip(long n)                                            跳过前几个元素
Stream<T> distinct()                                              元素去重，依赖(hashcode和equals方法)
static <T> Stream<T> concat(Stream a, Stream b)                   合并a和b两个流为一个流
Stream<R>map(Function<T,R> mapper)                                转换流中的数据类型
注意1:中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
注意2:修改Strgam流中的数据，不会影响原来集合或者数组中的数据

 ArrayList<String>list = new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        //filter    过滤      把张开头的留下，其余数据过滤不要(只要张开头，且名字为3个的)
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length()==3).forEach(s -> System.out.println(s));
        System.out.println(list);   //这个时候集合里的值是没有变化的
        System.out.println("1--------");

//limit 获取前几个元素     skip 跳过前几个元素
        list.stream().limit(3).forEach(s -> System.out.print(s+' '));
        System.out.println();
        list.stream().skip(4).forEach(s -> System.out.print(s+' '));
        System.out.println();
        System.out.println("2--------");

 //distinct 去重
        ArrayList<String>list2 = new ArrayList<>();
        Collections.addAll(list2,"张无忌","张无忌","张无忌","张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        list2.stream().distinct().forEach(s -> System.out.print(s+' '));
        System.out.println();
        System.out.println("3--------");

//concat 合并两个流为一个流
        ArrayList<String>list3 = new ArrayList<>();
        Collections.addAll(list3,"shiaf","faefwafa");
        Stream.concat(list2.stream(),list3.stream()).forEach(s -> System.out.print(s+' '));
        System.out.println();
        System.out.println("4--------");

        //map:转换数据类型
        ArrayList<String>list4 = new ArrayList<>();
        Collections.addAll(list4,"张无忌-15","周芷若-14","赵敏-20","张强-18","张三丰-12","张翠山-20","张良-21");
        //Integer.parseInt()将字符串转换为10进制
        //split:根据里面的东西切割数据分配索引
        list4.stream().map(s -> Integer.parseInt(s.split("-")[1])).forEach(s-> System.out.print(s+" "));

Stream流的终结方法
名称                                                                  说明
void forEach(Consumer action)                 遍历
long count()                                                  统计
toArray()                                                收集流中的数据，放到数组中
collect(Collector collector)                  收集流中的数据，放到集合中

 //forEach 遍历
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰","张翠山","张良","王二麻子","谢广坤");
        list.stream().forEach(s -> System.out.print(s+' '));
        System.out.println();
        System.out.println("--------------------");

        //count 统计元素数量
        long count1 = list.stream().count();
        System.out.println(count1);
        System.out.println("--------------------");

        //toArray() 收集流中的数据，放到数组中
        String[] strings = list.stream().toArray(value -> new String[value]);
        System.out.print(Arrays.toString(strings)+' ');