java基础学习之流(Stream)、文件(File)和IO（九）

最新推荐文章于 2024-10-22 21:07:54 发布
最新推荐文章于 2024-10-22 21:07:54 发布
阅读量349 收藏
点赞数
分类专栏： JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41283310/article/details/105483309
版权

基本概念


Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。

Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。

一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。

Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。

文件操作类:File

NO.方法类型描述
1public File(String pathname)构造传递完整文件操作路径
2public File(File parent, String child)构造设置父路径与子文件名称
3public boolean createNewFile() throws IOException普通创建新文件
4public boolean exists()普通判断给定路径是否存在
5public boolean delete()普通删除指定路径的文件（路径不删除，保留住）
6public File getParentFile()普通取得当前路径的父路径
7public boolean mkdirs()普通创建多级目录
8public long length()普通取得文件大小，以字节为单位返回
9public boolean isFile()普通判断给定路径是否是文件
10public boolean isDirectory()普通判断给定路径是否是目录
11public long lastModified()普通取得文件的最后一次修改日期（以毫秒为单位）
12public String[] list()普通列出指定目录中的全部内容
13public File[] listFiles()普通列出所有的路径以File类对象包装

文件基本操作

// An highlighted block
public class Main {
//File.separator路径分隔符 类似\
    public static void main(String args[]) throws Exception{
        File file = new File("E:" + File.separator + "test.txt");//设置一个文件的路径
        if(file.exists()){ //判读文件是否存在
            file.delete();//存在，则删除文件
        }else {
            file.createNewFile();//不存在，则创建文件
        }
    }
}

创建带路径的文件

public class Main {

    public static void main(String args[]) throws Exception{
        File file = new File("E:" + File.separator+"hello"+File.separator+ "test.txt");
        if(!file.getParentFile().exists()){
            file.getParentFile().mkdirs();//创建父路径
        }
        file.createNewFile();//创建新文件
    }
}
注意：在创建文件前，需要先判断父路径是否存在，如果不存在则一定要先创建父目录（否则会出现“java.io.IOException:系统找不到指定路径”）,由于目录会存在多级目录的情况，所以需要使用mkdirs()方法进行创建。

取得文件或者目录的信息

public class Main {
    public static void main(String args[]) throws Exception{
        File file = new File("E:" +File.separator+ "my.jpg");
        if(file.exists()){
            System.out.println("是否是文件："+file.isFile());
            System.out.println("是否是目录："+file.isDirectory());
            System.out.println("文件大小："+String.format("%.2f",(double)file.length()/1024)+"KB");
            System.out.println("上次修改文件时间："+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(file.lastModified())));
        }
    }
}

列出目录信息

public class Main {
    public static void main(String args[]) throws Exception{
        File file = new File("E:" +File.separator);
        if(file.isDirectory()){
            File[] files = file.listFiles();
            for(int i = 0; i < files.length; i++){
                System.out.println(files[i]);
            }
        }
    }
}
结果：E:\$RECYCLE.BIN
E:\my.jpg
E:\origin
E:\reactproject
E:\System Volume Information

列出指定目录下的所有文件及子目录信息
在每一个目录中有可能还会存在其他子目录，并且还可能有更深层次的子目录，所以为了可以列出所有的内容，应该判断每一个给定的路径是否是目录。如果是目录应该继续列出，这样的操作最好使用递归的方式完成。

public class Main {
    public static void main(String args[]) throws Exception{
        File file = new File("E:" +File.separator);
        list(file);
    }
    public static void list(File file){
        if(file.isDirectory()){
            File[] files = file.listFiles();
            if(files != null){
                for(int i = 0; i < files.length; i++){
                    list(files[i]);
                }
            }
        }
        System.out.println(file);
    }
}

字节流与字符流

在java中针对数据流的操作也分为输入与输出两种方式，而且针对此操作提供了以下两类支持。
字节流（JDK1.0开始提供）：InputStream(输入字节流)、OutputStream(输出字节流)；
字符流（JDK1.1开始提供）：Reader（输入字符流）、Writer（输出字符流）
在java.io包中，四个操作流的类全部都属于抽象类，所以在使用这些类时，一定要通过子类对象的向上转型来进行抽象类对象的实例化操作。

字节输出流：OutputStream

NO.方法类型描述
1public void close() throws IOException普通关闭字节输出流
2pubilc void flush() throws IOException普通强制刷新
3public abstract void write(int b) throws IOException普通输出单个字节
4public void write(byte[] b) throws IOException普通输出全部字节数组
5public void write(byte[] b, int off,int len) throws IOException普通输出部分字节数组

FileOutputStream类的常用方法

NO.方法类型描述
1public FileOutputStream (File file) throws FileNotFoundException构造将内容输出到指定路径，如果文件已存在，则使用新的内容覆盖旧的内容
2pubilc FileOutputStream (File file, boolean append) throws FileNotFoundException构造如果将布尔参数设置为true，表示追加新的内容到文件中
//文件内容的输出
public class Main {
    public static void main(String args[]) throws Exception{
        //1.定义要输出的文件路径
        File file = new File("E:" +File.separator+"hello"+File.separator+"test.txt");
        //2.判断文件父路径是否存在
        if(!file.getParentFile().exists()){
            file.getParentFile().mkdirs();
        }
        //3.文件不存在，不需要手工调用createNewFile()，构造方法会自动创建一个空文件
        OutputStream output = new FileOutputStream(file);
        String str = "aaa";
        byte[] bytes = str.getBytes();
        output.write(bytes);
        output.close();
    }

输出单个字节

for(int x=0; x < data.length; x++){
	output.write(data[x]);
}

输出部分字节数组

//设置了数组的开始索引和长度
output.write(data,6,6)

字节输入流：InputStream

NO.方法类型描述
1public void close() throws IOException普通关闭字节输入流
2public abstract int read(int b) throws IOException普通读取单个字节
3public int read(byte[] b) throws IOException普通将数据读取到字节数组中，同时返回读取长度
4public int read(byte[] b, int off,int len) throws IOException普通将数据读取到部分字节数组中，同时返回长度

在这里插入图片描述
FileInputStream类的常用方法

NO.方法类型描述
1public FileInputStream (File file) throws FileNotFoundException构造设置要读取文件数据的路径

数据读取操作

public class Main {
    public static void main(String args[]) throws Exception{
        //1.定义要输出的文件路径
        File file = new File("E:" +File.separator+"hello"+File.separator+"test.txt");
        //2.判断文件是否存在
        if(file.exists()){
            InputStream inputStream = new FileInputStream(file);
        //3.设置一个长度为1024的byte数组接收数据
            byte[] bytes = new byte[1024];
            int len = inputStream.read(bytes);
            inputStream.close();
        //4.讲读取的字节数组变成字符串进行输出
            System.out.println(new String(bytes,0,len));
        }
    }
}

采用while循环实现输入流操作

public class Main {
    public static void main(String args[]) throws Exception{
        //1.定义要输出的文件路径
        File file = new File("E:" +File.separator+"hello"+File.separator+"test.txt");
        //2.判断文件是否存在
        if(file.exists()){
            InputStream inputStream = new FileInputStream(file);
            byte[] bytes = new byte[1024];
            int foot = 0;       //设置字节数组脚标
            int temp = 0;       //获取读取的字节数据
            // temp = inputStream.read()  表示将读取到个单个字节数据给temp变量
            while ((temp = inputStream.read()) != -1){
                // foot++ 可以看成  i = foot++  i先等于0 ，然后foot自增1
                bytes[foot++] = (byte) temp;
            }
            inputStream.close();
        //3.讲读取的字节数组变成字符串进行输出
            System.out.println(new String(bytes,0,foot));
        }
    }
}

字符输出流：Writer

NO.方法类型描述
1public void close() throws IOException普通关闭字符输出流
2pubilc void flush() throws IOException普通强制刷新
3public Write append(CharSequence csq) throws IOException普通追加数据
4public void write(String str) throws IOException普通输出字符串数据
5public void write(char[] b) throws IOException普通输出字符数组数据

FileWriter类常用方法

NO.方法类型描述
1public FileWriter (File file) throws IOException构造将内容输出到指定路径，如果文件已存在，则使用新的内容覆盖旧的内容
2pubilc FileWriter (File file, boolean append) throws FileNotFoundException构造如果将布尔参数设置为true，表示追加新的内容到文件中

使用Writer类实现内容输出

public class Main {
    public static void main(String args[]) throws Exception{
        //1.定义要输出的文件路径
        File file = new File("E:" +File.separator+"hello"+File.separator+"test.txt");
        if(!file.getParentFile().exists()){
            file.getParentFile().mkdirs();
        }
        Writer fileWriter = new FileWriter(file);
        fileWriter.write("hello");
        fileWriter.close();
    }
}

字符输入流：Reader

NO.方法类型描述
1public void close() throws IOException普通关闭字符输入流
2public int read() throws IOException普通读取单个字符
3public int read(char[] b) throws IOException普通将数据读取到字数符组中，同时返回读取长度
4public long skip(long b) throws IOException普通跳过字节长度

使用Reader读取数据

public class Main {
    public static void main(String args[]) throws Exception{
        //1.定义要输出的文件路径
        File file = new File("E:" +File.separator+"hello"+File.separator+"test.txt");
        if(file.exists()){
            Reader fileReader = new FileReader(file);
            char[] chars = new char[1024];
            int len = fileReader.read(chars);
            fileReader.close();
            System.out.println(new String(chars,0,len));
        }
    }
}

字节流和字符流的区别

➢在使用OutputStream输出数据的时候即使最后没有关闭输出流，那么内容也可以正常输出,但是反过来如果使用的是字符输出流Writer,在执行到最后如果不关闭输出流，那么就表示在缓冲区之中处理的内容不会被强制性的清空,所以就不会输出数据。如果现在有特殊情况不能够关闭字符输出流，可以使用flush()方法强制清空缓冲区。
强制清空缓冲区

public class Main {
    public static void main(String args[]) throws Exception{
        //1.定义要输出的文件路径
        File file = new File("E:" +File.separator+"hello"+File.separator+"test.txt");
        if(!file.getParentFile().exists()){
            file.getParentFile().mkdirs();
        }
        Writer fileWriter = new FileWriter(file);
        fileWriter.write("hahaha");
        fileWriter.flush(); //强制清空缓冲区，不然文件中没数据
    }
}

转换流

➢虽然字节流与字符流表示两种不同的数据流操作，但是这两种流彼此间是可以实现互相转换的，而要想实现这样的转换就可以通过InputStreamReader、 OutputStreamWriter两个类实现。 首先来观察一下这两个类的继承结构以及构造方法:

名称InputStreamReaderOutputStreamWriter
定义结构public class InputStreamReader extends Readerpublic class OutputStreamWriter extends Writer
构造方法public InputStreamReader(InputStream in)public OutputStreamWriter(OutputStream out)

实现字节输出流转换字符输出流

public class Main {
    public static void main(String args[]) throws Exception{
        //1.定义要输出的文件路径
        File file = new File("E:" +File.separator+"hello"+File.separator+"test.txt");
        if(!file.getParentFile().exists()){
            file.getParentFile().mkdirs();
        }
        OutputStream output = new FileOutputStream(file);
        //将字节输出流转换为字符输出流
        OutputStreamWriter out = new OutputStreamWriter(output);
        out.write("aaa");
        out.close();
    }
}

文件拷贝

➢现在要求实现一个文件的拷贝操作，在拷贝的过程中利用初始化参数设置拷贝的源路径与目标路径,同时在本程序执行时可以拷贝任何的文件,例如:图片、视频、文本等。
➢对于此时的要求首先必须确认要使用何种数据流进行操作，由于程序要求可以拷贝任意类型的文件,
所以很明显必须利用字节流(InputStream. OutputStream) 类完成，而对于具体的拷贝操作实现，就有两种做法:
➢做法二:采用边读边的操作方式，每次从源文件输入流中读取部分数据， 而后将这部分数据交给输出流输出， 这样的做法不会5用较大的内存空间，
但是会适当损耗-些时间(可以通过限制文件大小来避免此类问题)
在这里插入图片描述

public class App {

    public static void main( String[] args ) throws IOException {
        long start = System.currentTimeMillis();//取得复制开始时间
        if(args.length != 2){
            System.out.println("缺少源文件或输出文件");
            System.exit(1);
        }
        File inFile = new File(args[0]);//源文件
        File outFile = new File(args[1]);//输出文件
        //实现文件内容的复制，分别定义输出流和输入流对象
        FileInputStream input = new FileInputStream(inFile);
        FileOutputStream output = new FileOutputStream(outFile);
        int temp = 0; //保存每次读取的数据长度
        byte data[] = new byte[1024]; //每次读取1024字节
        while ((temp = input.read(data)) != -1){
            output.write(data,0,temp);
        }
        input.close();
        output.close();
        long end = System.currentTimeMillis();
        System.out.println("复制所花费时间："+(end - start));
    }
}

字符编码

➢计算机中所有的信息组成都是二进制数据， 那么所有能够描述出的中文文字都是经过处理后的结果。在计算机的世界里,所有的语言文字都会使用编码来进行描述,例如:最常见的编码是ASC |I码。在实际的工作里面最为常见的几种编码如下:
➢UTF编码(Unicode Transformation Format) :是一-种UNICODE的可变长度编码，常见的编码为UTF -8编码;

public class Main {
    public static void main(String args[]) throws Exception{
        //获取系统中的环境属性中的文件编码
        System.out.println(System.getProperty("file.encoding"));
    }
}
结果：UTF-8

程序中出现乱码

public class Main {
    public static void main(String args[]) throws Exception{
        //1.定义要输出的文件路径
        File file = new File("E:" +File.separator+"hello"+File.separator+"test.txt");
        OutputStream out = new FileOutputStream(file);
        out.write("厚度赛".getBytes("ISO8859-1"));
        out.close();
    }
}
//文件内容为：？？？

内存流

➢在流的操作中除了进行文件的输入与输出操作之外,也可以针对于内存进行同样的操作。假设说现在某一种应用， 需要进行I0操作,但是又不希望在磁盘上产生一些文件的时候， 就可以将内存当作一个临时文件进行操作。 在Java中,针对于内存操作提供有两组类:
➢字节内存流: ByteArrayInputStream (内存字节输入流)、ByteArrayOutputStream (内存字节输出流) ;
➢字符内存流: CharArrayReader (内存字符输入流)、CharArrayWriter (内存字符输出流)。

实现大小写字母转换

public class Main {
    public static void main(String args[]) throws Exception{
        String str = "www.baidu.com";
        //将要读取的数据设置到内存输入流中
        InputStream input = new ByteArrayInputStream(str.getBytes());
        OutputStream output = new ByteArrayOutputStream();
        int temp = 0;
        while ((temp = input.read()) != -1){
            //将小写字母转换为大写字母
            output.write(Character.toUpperCase(temp));
        }
        System.out.println(output);
        input.close();
        output.close();
    }
}
结果：WWW.BAIDU.COM

实现文件的合并

public class Main {
    public static void main(String args[]) throws Exception{
        File fileA = new File("E:"+File.separator+"hello"+File.separator+"a.txt");
        File fileB = new File("E:"+File.separator+"hello"+File.separator+"test.txt");
        InputStream inputA = new FileInputStream(fileA);
        InputStream inputB = new FileInputStream(fileB);
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        int temp = 0;
        //读取文件中的字节内容
        while ((temp = inputA.read()) != -1){
            //将文件中的字节数据输出到内存流
            output.write(temp);
        }
        while ((temp = inputB.read()) != -1){
            output.write(temp);
        }
        //将内容作为字节数组取出
        byte[] data = output.toByteArray();
        output.close();
        inputA.close();
        inputB.close();
        System.out.println(new String(data));
    }
}	
结果：����aaa		//乱码是因为之前设置了文件编码

打印流

➢在java.io包中OutputStream是进行输出操作的最核心控制类，但是利用OutputStream会存在有一个问题: 所有的输出数据必须以字节类型的数据为主。也就是说如果现在要输出的数据是int (Integer) 、double (Double) 、java.util.Date等 常用类型都需要将其转换为字节后才可以输出。为了解决这样的矛盾问题，在java.io包中又专[ ]提供了一-组打印流 (字节打印流: PrintStream、 字符打印流: PrintWriter) 方便用户的输出操作

➢java.io.OutputStream类主要是进行数据输出，所以如果要设计更加合适的打印流操作类,那么就必须可以解决OutputStream输出数据类型有限(只有byte类型)的问题，这个时候可以采用一 种包装设计的模式，即:将OutputStream类利用其它类进行包装,組在这个类中提供有各种常见数据类型的输出操作,这样胪在进行输出操作时就可以回避掉字节数据的操作。

在这里插入图片描述
打印流
➢OutputStream提供 了核心的数据输出操作标准，但是为了更方便的实现输出操作，在java.io包中提供有两个数据打印流的操作类: PrintStream (打印字节流)、PrintWriter (打印字符流) ,以PrintStream类为例， 此类的继承结构如图所示。
在这里插入图片描述
PrintStream类的常用操作方法

NO.方法类型描述
1public PrintStream (OutputStream out)构造通过已有OutputStream确定输出目标
2pubilc void print (数据类型，参数名称)普通输出各种常见数据类型
3pubilc void println (数据类型，参数名称)普通输出各种常见数据类型,并追加一个换行

使用PrintStream类实现输出

public class Main {
    public static void main(String args[]) throws Exception{
        File file = new File("E:"+File.separator+"hello"+File.separator+"test.txt");
        OutputStream output = new FileOutputStream(file);
        PrintStream pu = new PrintStream(output);
        //输出  “你好”  到文件里面
        pu.print("你好");
        pu.println("www");
        pu.println(1.1);
        pu.close();
    }
}

PrintStream类的改进
➢rintStram类在最初设计时主要是为了弥补OutputStream输出类的功能不足，但是从JDK 1.5开始，为PrintStream增加 了格式化输出的支持方法: public PrintStream printf(String format, bjet… args)。利用这些方法可以使用像C语言那样的数据标记实现内容填充，常见的输出标记为:整数(%d) 、字符串(%s) 、小数(%m.nf) 、字符(%c)。

public class Main {
    public static void main(String args[]) throws Exception{
        String name = "小李";
        int age = 19;
        double score = 59.9;
        File file = new File("E:"+File.separator+"hello"+File.separator+"test.txt");
        OutputStream output = new FileOutputStream(file);
        PrintStream pu = new PrintStream(output);
        pu.printf("姓名：%s,年龄：%d,分数：%5.2f",name,age,score);
        pu.close();
    }
}

System类与I0有关的对象常量

NO.常量类型描述
1public static final PrintStream err常量显示器上错误输出
2pubilc static final PrintStream out常量显示器上信息输出
3pubilc static final PrintStream in常量键盘数据输入

错误输出

public class Main {
    public static void main(String args[]) throws Exception{
        try {
            //此处会抱一个异常
            Integer.parseInt("abc");
        }catch (Exception e){
            System.err.println(e);
        }
    }
}
结果：java.lang.NumberFormatException: For input string: "abc"

屏幕信息输出

public class Main {
    public static void main(String args[]) throws Exception{
        System.out.println("abc");
    }
}

键盘数据输入

public class Main {
    public static void main(String args[]) throws Exception{
        InputStream in = System.in;
        StringBuffer buffer = new StringBuffer();
        System.out.print("请输入数据：");
        int temp = 0;
        while ((temp = in.read()) != -1){
            //这里这样设置字符的ASCII 可以自动转换为int
            if(temp == '\n'){
                break;
            }
            buffer.append(temp);
        }
        System.out.println(buffer);
    }
}
结果：请输入数据：哈哈
229147136229147136

字符缓冲区读取

➢为了可以进行完整数据的输入操作，最好的做法是采用缓冲区的方式对输入的数据进行暂存，而后程序可以利用输入流-次性读取内容 ,如图所示，这样就可以避免输入中文时的读取错乱问题。
在这里插入图片描述
➢在java.i0包中如果要使用缓冲区进行数据操作, 提供有两种操作流:
➢字符缓冲区流: BufferedReader、 BufferedWriter; .
➢字节缓冲区流: BufferedInputStream、 BufferedOutputStream;
➢以上给出的四个操作类中，最为重要的就是BufferedReader类,此类是Reader的子类,属于字符缓冲输入流,而如果要处理中文数据，字符流是最方便的,
BufferedReader类的常用方法如表所示。

NO.方法类型描述
1public BufferedReader构造设置一个字符输入流
2pubilc String readLine() throws IOException普通读取一行数据，默认以’\n‘ 为分隔符

字节输入流转字符缓冲输入流
➢如果要想使用BufferedReader类来处理System.in的操作就会出现-个问题，BufferedReader是Reader的子类, 并且构造方法中也要接收Reader类型，而System.in是InputStream类型, 所以此处就必须将InputStream类型转换为Reader类型,那么就可以利用InputStreamReader类来实现这-转换操作
在这里插入图片描述
键盘数据输入的标准格式

public class Main {
    public static void main(String args[]) throws Exception{
        // System. in是InputStream类对象，BufferedReader的构造方法 里面需要接收Reader类对象
        //利用InputStreamReader将字节流对象变为字符流对象
        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
        System.out.print("请输入数据: ");
        String str = buf.readLine();
        //以回车作为换行
        System.out.println("输入的内容: " + str);
    }
}
结果：请输入数据: 多好多好
输入的内容: 多好多好

判断输入内容

public class Main {
    public static void main(String args[]) throws Exception {
        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
        boolean flag = true; //编写- -个循环的逻辑
        while (flag) {//判断标志位
            System.out.print("请输入年龄: ");
            //提示信息
            String str = buf.readLine();
            //以回车作为换行
            if (str.matches("\\d{1,3}")) {
                //输入数据由数字组成
                System.out.println("年龄是:" + Integer.parseInt(str));
                flag = false;//退出循环
            } else {
                System.out.println("年龄输入错误，应该由数字所组成。");
            }

        }
    }
}
结果：请输入年龄: 20
年龄是:20

读取文件

public class Main {
    public static void main(String args[]) throws Exception {
        File file = new File("E:"+File.separator+"hello"+File.separator+"test.txt");
        BufferedReader buf = new BufferedReader(new FileReader(file));
        String str = null;
        while ((str = buf.readLine()) != null){
            System.out.println(str);
        }
        buf.close();
    }
}
结果：姓名：小李,年龄：19,分数：59.900

Scanner

➢从JDK 1.5开始增加有一个java.util.Scanner的程序类， 利用这个类可以方便的实现数据的输入操作，但是Scanner类并没有定义在java.io包中，而是定义在了java.util包中,所以此类是一个工具类, 而此类的继承关系如图所示。
在这里插入图片描述
Scannner类中常用的方法

NO.方法类型描述
1public Scanner(InputStream in)构造接收InputStream输入流对象，此为输入源
2pubilc boolean hasNext()普通判断是否有数据输入
3pubilc String next()普通取出输入数据，以String形式返回
4pubilc boolean hasNextXxx()普通判断是否有指定类型数据存在
5pubilc 数据类型 nextXxx()普通取出指定数据类型的数据
6pubilc Scanner userDelimiter(String pattern)普通设置读取的分隔符

利用Scannner实现键盘数据输入

public class Main {
    public static void main(String args[]) throws Exception {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容：");
        if(scanner.hasNext()){
            System.out.println("输入内容："+scanner.next());
        }
        scanner.close();
    }
}
结果：请输入内容：哈哈
输入内容：哈哈

输入一个数字 double

public class Main {
    public static void main(String args[]) throws Exception {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容：");
        if(scanner.hasNextDouble()){
            double aDouble = scanner.nextDouble();
            System.out.println("输入内容："+aDouble);
        }else {
            System.out.println("输入的不是数字");
        }
        scanner.close();
    }
}

正则验证–出生日期

public class Main {
    public static void main(String args[]) throws Exception {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容：");
        if(scanner.hasNext("\\d{4}-\\d{2}-\\d{2}")){
            String bir = scanner.next("\\d{4}-\\d{2}-\\d{2}");
            System.out.println("输入内容："+bir);
        }else {
            System.out.println("输入的不是出生日期格式");
        }
        scanner.close();
    }
}

读取文件

public class Main {
    public static void main(String args[]) throws Exception {
        File file = new File("E:" + File.separator + "hello" + File.separator + "test.txt");
        InputStream fileInputStream = new FileInputStream(file);
        Scanner scanner = new Scanner(fileInputStream);
        scanner.useDelimiter("\n");
        while (scanner.hasNext()){
            System.out.println(scanner.next());
        }
        scanner.close();
    }
}
结果：姓名：小李,年龄：19,分数：59.90
	  666
茉莉915
关注
专栏目录
Java基础之Stream流、File类
weixin_40119218的博客
04-09 394
Stream流 Stream流的获取 Stream流常用API
详解Java 流(Stream)、文件(File)和IO（一）
r1037的博客
10-13 816
一、关于Java I/OJava.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。 Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。 一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。 Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。如前所述，一个流被
5、Stream流和File类介绍
Surplus.的博客
11-10 1287
文章目录1、Stream流2、File类 1、Stream流 1. 什么是Stream流 在Java 8中，得益于Lamdba所带来的的函数式编程，引入了一个全新的Stream流概念，用于解决已有集合、数组类库存在的弊端(采用了Stream流简化集合和数组的操作) 案例：从集合中筛选出所有姓张的人出来,然后再找出姓名长度为3的人 传统方式： public class StreamDemo1 { public static void main(String[] args) { //需求
File类和stream流
ZHOU_0522的博客
05-20 595
File类操作文件和目录、stream流操作文件内容 File类： InputStream 输入流（写文件）抽象类，用ctrl+h找子类 FileInputStream file1=new FileInputStream(文件路径/文件名) ; OutputStream 输出流（读文件） FileOutputStream file2=new FileOutputStream(文件路径/文件名) ; /*复制文件：Fi...
Java 流（Stream）、文件（File）、IO
长城郭靖的专栏
12-21 300
Java 流（Stream）、文件（File）、IO流的概念及基本分类流的分类字节流与字符流的区别常用流 流的概念及基本分类 流的概念： 流（Stream）是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这个时候你就可以想象数据好像在这其中“流动”一样 流的分类 按数据...
JAVA 对文件的操作、流(Stream)、文件(File)和IO，含实例
adaizzz的博客
10-29 507
对文件的操作 通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例。 File(String pathname) public String getAbsolutePath();//返回抽象路径名的绝对路径名字符串。 public boolean mkdirs();//创建此抽象路径名指定的目录，包括创建必需但不存在的父目录。 public boolean mkdir()//创建此抽象路径名指定的目录。 //返回一个抽象路径名数组，这些路径名表示此抽象路径名所表示目录中的文件。 publi
Java文件io-stream-file教程
08-23
Java 流(Stream)、文件(File)和 IOJava.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。一个流可以...
java流式文件读写_Java 流(Stream)、文件(File)和IO
weixin_28699741的博客
02-28 2276
参考于：https://blog.csdn.net/qq_22063697/article/details/52137369版权声明：本文为博主原创文章，转载请附上博文链接！一. 什么是 IOJava中 I/O 操作主要是指使用 Java 进行输入，输出操作。 Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java 的 I/O 流提供了读写数据的...
Java Stream、File、IO.pdf
07-23
总的来说，Java Stream 提供了一种强大的处理集合数据的新方式，而 Java File 和 Java IO 则是进行文件操作和数据传输的关键工具。理解并熟练掌握这些概念，对于开发高效的 Java 应用程序至关重要。
JAVA基础篇--Java 流(Stream)、文件(File)和IO
最新发布
xiaoaque的博客
10-22 952
JAVA基础篇--Java 流(Stream)、文件(File)和IO
精选Java IO面试题（转发）
chenlintao_csdn的博客
02-28 1891
前言 本文转发自精选Java IO面试题及参考答案，内容有所修改。 Java IO面试题汇总 什么是IO流？ 它是一种数据的流从源头流到目的地。比如文件拷贝，输入流从文件中读取数据存储到进程（process）中，输出流从进程中读取数据然后写入到目标文件。 字节流和字符流的区别？ 字节流用于操作包含ASCII字符的文件。JAVA也支持其他的字符如Unicode，为了读取包含Unicode字符的...
Java基础：IO流之File类
JackChan
10-14 1211
一、File类概述文件和目录路径名的抽象表示形式1、构造方法 方法 功能描述 File(String pathname) 根据路径得到File对象 File(String parent,String child) 根据目录和子文件/目录得到对象 File(File parent,String child) 根据父File对象和子文件/目录得到对象 示例代码package
Java8特性之Stream的常用方法:filter，map，sorted
睡竹的博客
01-12 5050
Java8特性之Stream的常用方法:filter，map，sorted
【JAVA】使用Java8 stream流对List进行遍历、过滤、查询、去重、排序、分组等
热门推荐
小朋友的博客
10-18 6万+
使用Java8 stream流对List进行遍历、过滤、查询、去重、排序、分组等
Java基础 Stream流&逐一处理forEach&过滤filter&map映射
qq_41570023的博客
04-18 9721
Stream流 说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带 来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。 引言 传统集合的多步遍历代码 几乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或间接的遍历操作。而当我们需要对集合中的元 ...
java8 遍历目录_使用java8API遍历过滤文件目录及子目录及隐藏文件
weixin_39942995的博客
02-13 352
1. 使用Files.list()迭代目录及其子目录文件Files.list()可以迭代目录及其子目录文件Files.list(Paths.get(".")) //当前目录.forEach(System.out::println);输出:.\filename1.txt.\directory1.\filename2.txt.\Employee.java2. 使用 filter表达式过滤文件过滤器...
文件（file）和流（stream）的联系和区别
ghevinn欢迎您光临
01-21 1万+
文件（File）和流(Stream)是既有区别又有联系的两个概念。          文件是计算机管理数据的基本单位，同时也是应用程序保存和读取数据的一个重要场所。                  存储介质：文件是指在各种存储介质上（如硬盘、可移动磁盘、CD等）永久存储的数据的有序集合，它是进行数据读写操作的基本对象。                        特性：每个文件都有文件名
File类（常用方法、遍历目录下的文件、listFiles()方法和删除文件及目录）
m0_53821599的博客
08-18 4160
File类 File类的常用方法 Filie类常用的构造方法 File(String pathname) //通过指定的一个字符串类型的文件路径来创建一个新的File对象 File(String parent,String child) //通过指定的一个字符串类型的父路径和一个字符串类型的子路径(包括文件名称)创建一个File对象 File(File parent,String child) //根据指定的File类的父路径和字符串类型的子路径(包括文件的名称)创建一个F
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值