2022.10.14（JavaIO）

一、File类常用方法

package demo3;
import java.io.*;
public class IOtest {
    public static void main(String[] args) throws IOException{
        File file=new File("demo3\\test.txt");

        if(!file.exists()){
            file.createNewFile();
        }
        System.out.println("文件绝对路径："+file.getAbsolutePath());
        System.out.println("文件大小："+file.length());

        file.delete(); //删除文件


        File file2=new File("D:\\");//文件夹遍历

        String[] str=file2.list();
        for(String s : str){
            System.out.println(s);
        }


        File files[] = file2.listFiles();//文件夹遍历
        for(File f:files){
            System.out.println(f.getAbsolutePath());
        }
    }
}

文件过滤

package demo3;
import java.io.*;
public class IOtest {
    public static void main(String[] args) throws IOException{
        File file=new File("D:\\");

        String[] filenames=file.list(new MyFileNamesFilter());//list(FileNameFilter)
        //File[] files=file.listFiles(new MyFileFilter());   listFiles(FileFilter)
        for(String str:filenames){
            System.out.println(str);
        }
    }
}

package demo3;

import java.io.File;
import java.io.FilenameFilter;

public class MyFileNamesFilter implements FilenameFilter{
    @Override
    public boolean accept(File file,String name){
        if(name.endsWith(".java")){
            return true;
        }else{
            return false;
        }
    }
}

二、字节流与字符流

由数据流编码格式可分为：字节流和字符流

InputStream和OutputStream的子类都为字节流，主要用于处理音频、歌曲、图片等，处理单元为一个字节

Reader和Writer的子类都为字符流，主要用于处理字符或字符串，处理单元为两个字节

根据封装类型不同可分为：节点流和处理流

若封装的是数据源，如字符串、文件等，则称为节点流；若封装的是其它流对象，成为处理流，处理流提供缓冲功能，提高读写效率

package demo3;
import java.io.*;
public class IOtest {
    public static void main(String[] args) throws IOException{
        File file=new File("demo3\\test.txt");
        FileReader fr=null;
        try {
            fr=new FileReader("demo3\\test.txt");
            int i=fr.read();
            while(i!=-1){
                System.out.print((char)i);
                i=fr.read();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(fr!=null){
                try {
                    fr.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

三、节点流和处理流中常用类

节点流：FileInputStream、FileOutputStream、FileReader、FileWriter

处理流：BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter

注：在使用字符缓冲输出流时，需要先flush()，再close()，防止数据丢失

BufferedReader 

package demo3;
import java.io.*;
public class IOtest {
    public static void main(String[] args) throws IOException{
        File file=new File("demo3\\test.txt");
        FileReader fr=null;
        BufferedReader br=null;
        try {
            fr=new FileReader("demo3\\test.txt");
            br=new BufferedReader(fr);
            String line=br.readLine();
            while(line!=null){
                System.out.println(line);
                line=br.readLine();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(fr!=null){
                try {
                    fr.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 BufferedWriter

package demo3;
import java.io.*;
public class IOtest {
    public static void main(String[] args) throws IOException{
        File file=new File("demo3\\test.txt");
        FileWriter fWriter=null;
        BufferedWriter bWriter=null;

        try {
            fWriter=new FileWriter(file, true);
            bWriter=new BufferedWriter(fWriter);
            bWriter.write("\r\nhello,world!");
            bWriter.flush();
            bWriter.close();
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
}

FileOutputStream与FileInputStream 

package demo3;
import java.io.*;
public class IOtest {
    public static void main(String[] args) throws IOException{
        File file=new File("demo3\\test.txt");

        FileOutputStream fileOutputStream=new FileOutputStream(file);
        fileOutputStream.write("hello,world".getBytes());//用中文会乱码
        fileOutputStream.close();

        FileInputStream fileInputStream=new FileInputStream(file);
        byte[] data=new byte[(int)file.length()];
        fileInputStream.read(data);
        String str=new String(data);
        System.out.println(str);
        fileInputStream.close();
    }
}

BufferedInputStream与BufferedOutputStream

略

利用BufferedReader和BufferedWriter拷贝文件

package demo3;
import java.io.*;
public class IOtest {
    public static void main(String[] args) throws IOException{
        File file=new File("demo3\\test.txt");
        File file2=new File("demo3\\test2.txt");

        CopyFile(file,file2);
    }

    private static void CopyFile(File file,File file2){
        BufferedReader bReader=null;
        BufferedWriter bWriter=null;

        FileReader fReader=null;
        FileWriter fWriter=null;

        try {
            fReader=new FileReader(file);
            fWriter=new FileWriter(file2);
            bReader=new BufferedReader(fReader);
            bWriter=new BufferedWriter(fWriter);

            String line=bReader.readLine();
            while(line!=null){
                bWriter.write(line);
                bWriter.newLine();
                line=bReader.readLine();
            }
            bWriter.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(bReader!=null){
                try {
                    bReader.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if(bWriter!=null){
                try {
                    bWriter.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

利用FileReader和FileWriter拷贝文件

package demo3;
import java.io.*;
public class IOtest {
    public static void main(String[] args) throws IOException{
        File file=new File("demo3\\test.txt");
        File file2=new File("demo3\\test2.txt");

        CopyFile(file,file2);
    }

    private static void CopyFile(File file,File file2){
        FileReader fReader=null;
        FileWriter fWriter=null;

        try {
            fReader=new FileReader(file);
            fWriter=new FileWriter(file2);
            int i=fReader.read();
            while(i!=-1){
                fWriter.write(i);
                i=fReader.read();
            }
            fWriter.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(fReader!=null){
                try {
                    fReader.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if(fWriter!=null){
                try {
                    fWriter.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

四、Scanner类用法

第一行输入n, m

第二行输入n个整数

第三行输入m个字符串

package demo3;

import java.util.Arrays;
import java.util.Scanner;

public class IOTest {
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        
        int n=sc.nextInt();
        int m=sc.nextInt();

        int[] arr=new int[n];
        String[] strs=new String[m];

        for(int i=0;i<n;i++){
            arr[i]=sc.nextInt();
        }
        for(int i=0;i<m;i++){
            strs[i]=sc.next();
        }

        Test(arr,strs);

        sc.close();
    }

    private static void Test(int[] arr,String[] strs){
        System.out.println(Arrays.toString(arr));

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