Java—异常的理解与处理机制、File类

最新推荐文章于 2024-05-04 15:16:28 发布
最新推荐文章于 2024-05-04 15:16:28 发布
阅读量148 收藏
点赞数
分类专栏： 华迪Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33630838/article/details/79196377
版权

Java—异常的理解与处理机制、File类

1、异常的理解与分析

Throwable包含了错误(Error)和异常(Exception两类)
  Exception又包含了运行时异常(RuntimeException, 又叫非检查异常)和非运行时异  
常(又叫检查异常)
  (1) Error是程序无法处理了, 如果OutOfMemoryError、OutOfMemoryError等等,  
这些异常发生时, java虚拟机一般会终止线程 .
  (2) 运行时异常都是RuntimeException类及其子类,如 NullPointerException、  
IndexOutOfBoundsException等, 这些异常是不检查的异常, 是在程序运行的时候可能  
会发生的, 所以程序可以捕捉, 也可以不捕捉. 这些错误一般是由程序的逻辑错误引起的,   
程序应该从逻辑角度去尽量避免.
  (3) 检查异常是运行时异常以外的异常, 也是Exception及其子类, 这些异常从程序的  
角度来说是必须经过捕捉检查处理的, 否则不能通过编译. 如IOException、  
SQLException等
两者的区别

    非检查异常表示无法让程序恢复运行的异常，导致这种异常的原因通常是由于执行了错  
误的操作。一旦出现错误，建议让程序终止。
    受检查异常表示程序可以处理的异常。如果抛出异常的方法本身不处理或者不能处理  
它，那么方法的调用者就必须去处理该异常，否则调用会出错，连编译也无法通过。
    对于运行异常，建议不要用 try...catch...捕获处理，应该在程序开发调试的过程  
中尽量的避免，当然有一些必须要处理的，自己知道了那个部分会出现异常，而这种异常你要  
把它处理的你想要的结果，例如：空值处理。

代码展示：

package com.hwadee;
/**
 * 编译期异常，如果不处理，就没有办法运行。
 * 编译期异常：1、throws   2、try{}catch(异常类型  名字){}finally{释放资源的}
 * try:里面放的是可能出现问题的代码。最好里面少放代码，精确地放代码---->哪些代码有可能出错才放进去
 * catch:推荐的做法是，里面要有东西。哪怕仅仅是一句提示。
 * finally特点:里面的总是会执行，不管try里面是够报错。所以，它通常用于释放资源。
 */
import java.util.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;

public class TestException1 {

    public static void main(String[] args) {
        test1();
        test2();
        test3();
    }
    public static void test1() {
        Date date=new Date();
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = simpleDateFormat.format(date);
        System.out.println(time);
        System.out.println("---------------------");

        try {     //编译期异常，
            java.util.Date parseDate = simpleDateFormat.parse(time);
            System.out.println(parseDate);
        } catch (ParseException e) {
            System.out.println("出错了！！！");
            e.printStackTrace();
        }
    }
    public static void test2() {
        Date date=new Date();
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = simpleDateFormat.format(date);

        try {
            Date parsedDate = simpleDateFormat.parse(time);
            System.out.println("这是一句代码");
        } catch (ParseException e) {
            System.out.println("出错了！！！！！");
            //e.printStackTrace();
        }

        System.out.println("这是try catch 之外的语句");

    }
    public static void test3() {
        Date date=new Date();
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = simpleDateFormat.format(date);
        //声明了系统资源
        try {
            Date parsedDate = simpleDateFormat.parse(time);
            System.out.println("这是一句代码");
            System.out.println("这一句也不执行");
            System.out.println("如果我在这里使用了系统资源");
            System.out.println("使用完之后，释放系统资源；否则太耗费机子");
            //System.exit(0);
        } catch (ParseException e) {
            System.out.println("出错了！！！！！");
            //e.printStackTrace();
        } finally {
            System.out.println("这里是finally里面的语句");
        }

        System.out.println("这是try catch 之外的语句");

    }

}

这里写图片描述
2、throw与throws使用

   throws的方式处理异常:定义功能方法时，需要把出现的问题暴露出来让调用者去处理。  
那么就通过throws在方法上标识。
   throw的概述:在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就  
用throw把异常对象抛出。
throw与throws的区别:
    throws:用在方法声明后面，跟的是异常类名。可以跟多个异常类名，用逗号隔开。表  
 示抛出异常，由该方法的调用者来处理。
    throw:用在方法体内，跟的是异常对象名。只能抛出一个异常对象名。表示抛出异常，  
 由方法体内的语句处理。

代码展示:

package com.hwadee;

/**
 * throws ParseException
 * 
 * throws + 异常类名
 * 
 * 谁调用方法，那么就将异常抛给谁。 在实际开发中，抛给jvm，是不理智的行为，没有意义，不推荐这么做。
 * 
 * 在教学当中仅仅是为了方便而已，才这么干。
 *
 */
public class TestException2 {

    public static void main(String[] args) {
//      test1();
//      test2();
        test3();
//      test4();
//      test5();
    }
    /*
     * finally:被finally控制的语句体一定会执行
     * 注意：如果在执行到finally之前jvm退出了，就不能执行了。
     * 
     * A:格式
     *      try...catch...finally...
     * B:用于释放资源，在IO流操作和数据库操作中会见到
     */
    public static void test1() {
        int a = 3;
        int b = 0;
        if (b != 0) {
            int result = a / b;
            System.out.println(result);
        } else {
            System.out.println("今天天气不是很好");
        }
    }

    public static void test2() {

        try {
            System.out.println(3 / 0);
        } catch (ArithmeticException e) {
            System.out.println("报了一个错误");
        } finally {
            System.out.println("finally");
        }
    }

    public static void test3() {
        try {
            int result = 3 / 0;
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException 的异常");
        } finally {
            System.out.println("这里释放资源!!!");
        }

        try {
            int a[] = { 1, 2, 3 };
            System.out.println(a[3]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("ArrayIndexOutOfBoundsException 的异常");
        } finally {
            System.out.println("这里释放资源!!!");
        }
    }

    public static void test4() {
        try {

            int a[] = { 1, 2, 3 };
            System.out.println(a[3]);
            System.out.println("------");
            int result = 3 / 0;
            System.out.println(result);

        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException 的异常");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("ArrayIndexOutOfBoundsException 的异常");
        } finally {
            System.out.println("这里释放资源!!!");
        }

    }

    public static void test5() {
        try {

            int a[] = { 1, 2, 3 };
            System.out.println(a[3]);
            System.out.println("------");
            int result = 3 / 0;
            System.out.println(result);

        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException 的异常");
        } catch (RuntimeException e) {
            System.out.println("RuntimeException 的异常");
        } finally {
            System.out.println("这里释放资源!!!");
        }

    }
}

这里写图片描述

package com.hwadee;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TestException3 {

    public static void main(String[] args) throws ParseException {
        test1();
    }
    public static void test1() throws ParseException {
        test2();
    }

    public static void test2() throws ParseException {
        Date date = new Date();
        System.out.println(date);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = simpleDateFormat.format(date);
        System.out.println(time);
        Date parsedDate = simpleDateFormat.parse(time);
        System.out.println(parsedDate);

    }

}

这里写图片描述

package com.hwadee;
/*
 * throw:如果出现了异常情况，我们可以把该异常抛出，这个时候的抛出的应该是异常的对象。
 * 
 * throws和throw的区别(面试题)
 *  throws
 *      用在方法声明后面，跟的是异常类名
 *      可以跟多个异常类名，用逗号隔开
 *      表示抛出异常，由该方法的调用者来处理
 *      throws表示出现异常的一种可能性，并不一定会发生这些异常
 *  throw
 *      用在方法体内，跟的是异常对象名
 *      只能抛出一个异常对象名
 *      表示抛出异常，由方法体内的语句处理
 *      throw则是抛出了异常，执行throw则一定抛出了某种异常
 *   编译期异常的抛出
 *   在方法声明上抛出，是为了告诉调用者，你注意了，我有问题。
 */
public class TestException4 {

    public static void main(String[] args) {
//      method();

        try {
            test2();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void test1() {
        int a = 10;
        int b = 0;
        if (b == 0) {
            throw new ArithmeticException();
        } else {
            System.out.println(a / b);
        }
    }

    public static void test2() throws Exception {
        int a = 10;
        int b = 0;
        if (b == 0) {
            throw new Exception();
        } else {
            System.out.println(a / b);
        }
    }
}

这里写图片描述
3、多个异常的处理
根据代码进行理解：

package com.hwadee;

/*
 * A:一个异常
 * 
 * B:二个异常的处理
 *      a:每一个写一个try...catch
 *      b:写一个try，多个catch
 *          try{
 *              ...
 *          }catch(异常类名 变量名) {
 *              ...
 *          }
 *          catch(异常类名 变量名) {
 *              ...
 *          }
 *          ...
 * 
 *          注意事项：
 *              1:能明确的尽量明确，不要用大的来处理。
 *              2:平级关系的异常谁前谁后无所谓，如果出现了子父关系，父必须在后面。
 * 
 * 注意：
 *      一旦try里面出了问题，就会在这里把问题给抛出去，然后和catch里面的问题进行匹配，
 *      一旦有匹配的，就执行catch里面的处理，然后结束了try...catch
 *      继续执行后面的语句。
 */
public class TestException5 {

    public static void main(String[] args) {
        // test1();

        // test2();

        // test3();

        test4();
    }

    // 一个异常
    public static void test1() {
        int a = 10;
        int b = 0;
        try {
            System.out.println(a / b);
        } catch (ArithmeticException ae) {
            System.out.println("除数不能为0");
        }
        // 第二阶段
        System.out.println("over");
    }

    // 两个异常
    public static void test2() {
        int a = 10;
        int b = 0;
        try {
            System.out.println(a / b);
        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        }

        int[] arr = { 1, 2, 3 };
        try {
            System.out.println(arr[3]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("你访问了不该的访问的索引");
        }
        System.out.println("over");
    }

    // 两个异常的处理
    public static void test3() {
        int a = 10;
        int b = 0;
        int[] arr = { 1, 2, 3 };

        try {
            System.out.println(arr[3]);
            System.out.println(a / b);
            // System.out.println(arr[3]);
        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("你访问了不该的访问的索引");
        }

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

    public static void test4() {
        int a = 10;
        int b = 0;
        int[] arr = { 1, 2, 3 };

        // 爷爷在最后
        try {
            System.out.println(a / b);
            System.out.println(arr[3]);
            System.out.println("这里出现了一个异常,怎么办?");
        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("你访问了不该的访问的索引");
        } catch (Exception e) {
            System.out.println("出问题了");
        }

        // 爷爷在前面的情况
        // try {
        // System.out.println(a / b);
        // System.out.println(arr[3]);
        // System.out.println("这里出现了一个异常，怎么办?");
        // } catch (Exception e) {
        // System.out.println("出问题了");
        // } catch (ArithmeticException e) {
        // System.out.println("除数不能为0");
        // } catch (ArrayIndexOutOfBoundsException e) {
        // System.out.println("你访问了不该的访问的索引");
        // }

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

这里写图片描述
4、File类的概述以及使用

   File类主要是完成了文件夹管理的命名、查询、文件属性和处理目录等到操作它不进行  
文件夹内容的读取操作。
   File更应该叫做一个路径，文件路径或者文件夹路径，路径分为绝对路径和相对路径，  
绝对路径是一个固定的路径，从盘符开始，相对路径相对于某个位置，在ecplise下是指当  
前项目下，在dos下，查看API指的是当前路径，文件和目录路径名的抽象表示形式。

代码展示：

package com.hwadee;

import java.io.File;
import java.io.IOException;

public class TestFile1 {

    public static void main(String[] args) throws IOException {
        file1();
        file2();
        file3();
        file4();
        file5();
        file6();
        file7();
        file8();
        file9();
        file10();
        file11();
    }
    //新建文件
    public static void file1() throws IOException {
        File file=new File("D:\\132.txt");
        boolean isSuc = file.createNewFile();
        System.out.println(isSuc);
    }
    //删除文件
    public static void file2() throws IOException {
        File file=new File("D:\\111");
        boolean isSuc = file.delete();
        System.out.println(isSuc);
    }
    //新建文件夹
    public static void file3() throws IOException {
        File file=new File("D:\\100\\456");
        boolean isSuc = file.mkdirs();
        System.out.println(isSuc);
    }
    //删除文件夹，若文件夹中存在文件夹，必须先删除里面的文件夹，才能删除总文件夹
    public static void file4() throws IOException {
        File file=new File("D:\\100");
        boolean isSuc = file.delete();
        System.out.println(isSuc);
    }
    //重命名文件夹
    public static void file5() throws IOException {
        File fileO=new File("D:\\100");
        File fileT=new File("D:\\hhh");
        boolean isSuc = fileO.renameTo(fileT);
        System.out.println(isSuc);
    }
    //判断是否是文件夹
    public static void file6() throws IOException {
        File fileO=new File("D:\\hhh");
        boolean isSuc = fileO.isDirectory();
        System.out.println(isSuc);
    }
    //判断是否可读
    public static void file7() throws IOException {
        File fileO=new File("D:\\hhh");
        boolean isSuc = fileO.canRead();
        System.out.println(isSuc);
    }
    //判断是否可写
    public static void file8() throws IOException {
        File fileO=new File("D:\\hhh");
        boolean isSuc = fileO.canWrite();
        System.out.println(isSuc);
    }
    //判断是否是文件
    public static void file9() throws IOException {
        File fileO=new File("D:\\132.txt");
        boolean isSuc = fileO.isFile();
        System.out.println(isSuc);
    }
    //判断是否存在
    public static void file10() throws IOException {
        File fileO=new File("D:\\132.txt");
        boolean isSuc = fileO.exists();
        System.out.println(isSuc);
    }
    //判断是否隐藏
    public static void file11() throws IOException {
        File fileO=new File("D:\\hhh");
        boolean isSuc = fileO.isHidden();
        System.out.println(isSuc);
    }
}

这里写图片描述

package com.hwadee;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TestFile2 {

    public static void main(String[] args) {
        file1();
        file2();
        file3();
        file4();
    }
    //length的单位是字节
    //getname返回的包括了文件名和后缀名
    //lastModified  最后修改文件的时间
    public static void file1() {
        File file1=new File("D:\\英雄时刻\\qqq.txt");
        long length = file1.length();
        System.out.println(length);
        String name = file1.getName();
        System.out.println(name);
        long time = file1.lastModified();
        System.out.println(time);
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(new Date(time));
        System.out.println(format);
    }
    public static void file2() {
        File file1=new File("D:\\课程");
        String[] list = file1.list();
        for(String s:list) {
            System.out.println(s);
        }
    }
    public static void file3() {
        File file1=new File("D:\\课程");
        File[] listFiles = file1.listFiles();
        for(int i=0;i<listFiles.length;i++) {
            File f=listFiles[i];
            System.out.println(f.getName());
        }
    }
    public static void file4() {
        String separator = File.separator;
        System.out.println(separator);

        File file1=new File("D:\\hhh");
        System.out.println(file1.getAbsolutePath());
        file1=new File("D:"+File.separator+"hhh");
        System.out.println(file1.getAbsolutePath());
    }
}

这里写图片描述

码小生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java异常处理-异常处理的方式1
01-12
Java异常处理机制是一种优雅的错误处理方式，它允许开发者在程序中集中处理可能出现的问题，而不会使代码变得混乱。在Java中，异常处理主要通过两种方式实现：捕获异常（try-catch-finally）和声明异常（throws + ...
Java异常处理-异常处理的方式2：throws
01-16
Java异常处理机制是编程中必不可少的部分，用于处理程序运行时可能出现的错误情况。在Java中，异常处理主要有两种方式：捕获异常（try-catch-finally）和声明抛出异常（throws）。本篇主要讨论第二种方式——声明抛...
Java学习之异常，File类
Ande1922的博客
05-26 278
异常处理    代码中的异常举例：    1.空指针异常（NullPointerException）    2.下标越界异常（IndexOutOfBoundsException）    3.算数异常（ArithmeticException）main方法中的异常处理    处理异常的方式有两种，自己处理或者由上级处理，main函数在接受到异常后，由上级来处理，由于main函数是JVM调用的，所以ma...
01_03_java异常机制和File类
weixin_41596178的博客
12-23 163
异常机制和File类 异常机制（重点） 基本概念 异常就是"不正常"的含义，在Java语言中主要指程序执行中发生的不正常情况。 java.lang.Throwable类是Java语言中错误(Error)和异常(Exception)的超类。 其中Error类主要用于描述Java虚拟机无法解决的严重错误，通常无法编码解决，如：JVM挂掉了等。 其中Exception类主要用于描述因编程错误或偶然外在因素导致的轻微错误，通常可以编码解决，如：0作为除数等。 异常的分类 java.lang.Exception
异常捕获和file类
a452228300的博客
03-29 1027
1.异常捕获 1）异常是什么：异常是在程序的编写过程中出现的一些异于常态的事情，比如说a除以b，当b被赋值为0时，则程序就会抛出异常 2）异常的处理方法：通过try..catch的方法来捕获异常或者通过throws的方法来抛出异常 3）异常处理的格式：try{会产生异常的代码块}catch(异常处理类型的变量){一般为打印出错误}finally{所有出口}
Java进阶【十三期】：【异常处理】 （抛出捕获异常、自定义异常处理）、处理异常的几种方式 & 【（File】文件路径操作、File文件处理的综合练习
最新发布
Forever_Hopeful的博客
05-04 863
Java进阶【十三期】：【异常处理】 （抛出捕获异常、自定义异常处理）、处理异常的几种方式 & 【（File】文件路径操作、File文件处理的综合练习
File文件的操作以及异常处理
小甜
03-22 780
一、判断文件是目录还是正式文件、文件系统 1、文件的全名包含文件的路径名和扩展名，单独命名文件时用的是其扩展名； 2、同一目录下不能存在同名的目录和真实文件（系统主要有目录型文件、真实文件，和不需要计算的如虚拟内存文件，其中真实文件可以没有扩展名； 3、相对路径：不以路径分割符开头的文件路径 绝对路径：以根目录开头的路径 4、目录分割符和路径分割符在windows、Linux平台...
最全最详细的Java异常处理机制
波哩个波的博客
01-27 3万+
一、异常概述与异常体系结构 异常概述 在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如：客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等。 程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常（开发过程中的语法错误和逻辑错误不是异常）。 Java程序在执行过程中所发生的异常事件可分为两类： ...
java(3)-深入理解java异常处理机制
热门推荐
黄规速博客:学如逆水行舟，不进则退
01-20 37万+
1. 引子 try…catch…finally恐怕是大家再熟悉不过的语句了，而且感觉用起来也是很简单，逻辑上似乎也是很容易理解。不过，我亲自体验的“教训”告诉我，这个东西可不是想象中的那么简单、听话。不信？那你看看下面的代码，“猜猜”它执行后的结果会是什么？不要往后看答案、也不许执行代码看真正答案哦。如果你的答案是正确，那么这篇文章你就不用浪费时间看啦。 pa
java 异常分类和处理机制
Wonder ZH
06-01 1万+
一、背景介绍 程序在运行过程中发生错误或异常情况是不可避免的，如果每一个运行时错误都由程序员手动控制和处理，其工作量是不可想象的。 Java语言中的异常处理机制就解决的上述问题，把错误与异常的管理带到了面向对象的世界 Java语言定义了很多异常类，将运行错误和异常的信息和处理方法封装在了异常类中，帮助程序员检查和控制异常。即J...
JAVA内部类与异常类实验报告
06-30
本次实验报告主要探讨了Java编程语言中的内部类和异常处理机制，旨在帮助学生理解并熟练掌握这两个核心概念。实验分为两部分，第一部分是创建一个内部类来模拟校内报纸，第二部分则涉及异常处理，未在提供的内容中...
Java异常处理 Throwable实现方法解析
08-25
Java异常处理是编程中至关重要的一个环节，它用于在程序执行过程中捕获并处理错误或非正常情况。在Java中，所有的异常都是由`Throwable`类派生的，包括`Exception`和`Error`。`Throwable`是Java异常体系的基础，它...
通过实践了解如何处理Java异常
08-26
Java异常处理机制允许程序员在遇到错误情况时优雅地终止程序执行或进行恢复操作。下面我们将深入探讨如何处理Java异常，并遵循一些最佳实践。 首先，我们来看一个常见的问题——在`finally`块中清理资源。在处理...
Mysql在dos窗口下的命令语句
qq_33630838的博客
02-03 980
Mysql在dos窗口下的命令语句 /* * 数据： * 就是描述事物的符号。除了常用的数字数据外，还如图形、图像、声音、视频等。 * * 数据的保存: * 1.保存在内存中 * 优点：读取的速度快 * 缺点：程序一旦关闭或者计算机关机，数据就丢失。 * * 2.保存到文件中 *
Java—实现区域网内聊天（TCP与UDP）
qq_33630838的博客
02-02 899
Java—实现区域网内聊天 1、获取本机IP package com.hwadee; import java.net.InetAddress; import java.net.UnknownHostException; public class Test1 { public static void main(String[] args) throws UnknownHostE
类的加载与类加载器、反射与枚举
qq_33630838的博客
02-02 382
类的加载与类加载器、反射与枚举 对于上个博客的特注：在实现局域网内的互相发送与接收时，必须打开各自电脑的网络发现，否则将会出现发送不到、接收不到的情况。 1、类的加载 (1)加载：就是指将class文件读入内存，并为之创建一个Class对象。任何类被使用 时系统都会建立一个Class对象。 (2)连接 验证：是否有正确的内部结构，并和其他类协调一致。
Java—字符流、内存流、对象操作流、打印流与Properties
qq_33630838的博客
01-29 314
Java—字符流、内存流、对象操作流、打印流与Properties 1、FileReader，FileWriter 和字节流类似，字符流也有四步基本步骤：选择管道→创建管道→读写操作→关闭管道。 字符流就是按字符为处理单位的数据流，就是可以直接读写字符的io流。 字符流读取字符，就要先读取到字节数据，然后转为字符。如果要写出字符，需要把字符 转为字节再写出。 对于FileReade
Java—集合与泛型
qq_33630838的博客
01-24 288
Java—集合与泛型 1、数组和集合的区别: (1)数组既可以存储基本数据类型，又可以存储引用数据类型，基本数据类型存储的是值，引用数据类型存储的是地址值。集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型，但是在存储的时候会自动装箱变成对象。 (2)数组长度是固定的，不能自动增长。集合的长度的是可变的，可以根据元素的增加而增长。 (3)如果元素个数是固定的推荐用数组，如果元素个数不
正则表达式的入门理解
qq_33630838的博客
01-18 278
正则表达式的初步理解 1、正则表达式的概述 正则表达式的定义：是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符。其实就是一种规则。 正则表达式的作用：比如注册邮箱，邮箱有用户名和密码，一半会对其限制长度，这个限制长度的事情就是正则表达式做的。 package com.hwadee; import java.util.regex.Matcher; import
Java File类与异常处理详解
理解和掌握`File`类的使用、异常处理机制以及输入输出操作是Java编程的基本技能，对于开发可靠的、能够处理各种异常情况的软件至关重要。在实际编程中，正确地使用这些工具和概念能够提高代码的可维护性和用户体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值