IO流详解（input/output）

最新推荐文章于 2023-06-08 20:54:40 发布

o8699458

最新推荐文章于 2023-06-08 20:54:40 发布

阅读量717

点赞数

文章标签： java

本文链接：https://blog.csdn.net/o8699458/article/details/119954392

版权

IO流

FIle概述和方法

File：它是文件和目录路径的抽象表示

文件和目录是可以通过File封装成对象的
对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名。它是可以存在的，也可以说不存在的，要通过具体的操作把这个路径的内容转换为具体存在的

File(File parent, String child) 
从父抽象路径名和子路径名字符串创建新的 File实例。  
File(String pathname) 
通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。  
File(String parent, String child) 
从父路径名字符串和子路径名字符串创建新的 File实例。  

    
    import java.util.*;
import java.io.*;
public class pratise {
    public static void main(String[] args) {

        File f1=new  File("C:\\Users\\18049\\Desktop\\java\\java1\\java.txt");
        File f2=new File("C:\\Users\\18049\\Desktop\\java\\java1","java.txt");
        
        ----------------------------------------------------------------
        
        File f3=new File("C:\\Users\\18049\\Desktop\\java\\java1");
        File f4=new File(f3,"java.txt");
        System.out.println(f4);
    }
}

FIle类创建功能

public boolean createNewFile() 创建文件
public boolean mkdir() 创建目录
public boolean mkdirs() 创建多级目录



import java.util.*;
import java.io.*;
public class pratise {
    public static void main(String[] args) throws IOException {

        File f1=new  File("C:\\Users\\18049\\Desktop\\java\\java1\\java.txt");
        f1.createNewFile();
        File f2=new File("C:\\Users\\18049\\Desktop\\java\\java1\\javaweb");
        f2.mkdir();
        File f3=new File("C:\\Users\\18049\\Desktop\\java\\java1\\javaweb\\html");
        f3.mkdirs();
    }
}

File类判断和获取功能

public boolean isDirectory() 判断是否为目录
public boolean isFile（）判断是否为文件
public boolean exists（）判断文件是否存在
public String getAbsolutePath（）文件的绝对路径
public String getPath（）文件封装的路径
public String getName（）File类表示的文件名或者目录名
public String[] list（）FIle类表示的目录所在目录的所有文件和目录名称(字符串)
public File[] listFiles() FIle类表示的目录所在目录的所有文件和目录名称（FIle）

package pratise;


import java.util.*;
import java.io.*;
public class pratise {
    public static void main(String[] args) throws IOException {

        File f1=new  File("C:\\Users\\18049\\Desktop\\java");
        System.out.println(f1.isDirectory());//是否为目录
        System.out.println(f1.isFile());//是否为文件
        System.out.println(f1.exists());//是否存在
        System.out.println(f1.getAbsolutePath());//绝对路径
        System.out.println(f1.getPath());//封装路径
        System.out.println(f1.getName());//文件名字
        System.out.println("-----------");
        String[] strArray=f1.list();
        for(String s1:strArray)
        {
            System.out.println(s1);
        }

        System.out.println("-----------");
        File[] fileArray=f1.listFiles();
        for(File file:fileArray )
        {
            if(file.isFile())
            {
                System.out.println(file.getName());
            }
        }
    }

}

File类的删除功能

public boolea delete()

遍历目录

思路：使用递归，当File 表示的是目录的时候再调用一遍，直到不是目录为止。


import java.util.*;
import java.io.*;
public class pratise {
    public static void main(String[] args) throws IOException {

        File f1=new File("C:\\");

         long start=System.currentTimeMillis();
        GetFile(f1);
        long end =System.currentTimeMillis();
        System.out.println(end-start);


    }
    public static void GetFile(File file)
    {

        File[] fileArray=file.listFiles();
        if(fileArray!=null)
        {
            for(File f:fileArray)
            {
                if(f.isDirectory())
                {
                    GetFile(f);

                }
                else if(f.getName().equals("java.exe"))
                {
                    System.out.println(f.getAbsolutePath());
                }

            }
        }
    }

}

IO流概述和分类

IO：输入/输出（Input/Output）
流：是一种抽象的概念，是对数据传输的总称，也就是数据在设备间的传输称为流，流的本质是数据传输
IO流就是用来处理设备间数据传输问题的
常见应用：文件复制，文件上传，文件下载
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bzxz14j1-1630049562473)(C:\Users\18049\AppData\Roaming\Typora\typora-user-images\image-20210826133302247.png)]

字节流写数据

创建字节输出流对象
使用字节输出流对象的写数据方法
释放资源

void write(int b)
void write(byte[] b)
void write(byte[],int off,int len)

import java.util.*;
import java.io.*;
public class pratise {
    public static void main(String[] args) throws IOException {


        FileOutputStream fos = new FileOutputStream("C:\\Users\\18049\\Desktop\\java\\java.txt");
        fos.write(66);
        fos.close();
        
    }

}



import java.util.*;
import java.io.*;
public class pratise {
    public static void main(String[] args) throws IOException {


        FileOutputStream fos = new FileOutputStream("C:\\Users\\18049\\Desktop\\java\\java.txt");
        byte[] bys="世界RPG".getBytes();
        fos.write(bys);
        fos.close();
    }

}

实现换行

import java.util.*;
import java.io.*;
public class pratise {
    public static void main(String[] args) throws IOException {


        FileOutputStream fos = new FileOutputStream("C:\\Users\\18049\\Desktop\\java\\java.txt");

        byte[] bys="世界RPG".getBytes();
        for(int i=0;i<10;i++) {

            fos.write(bys);
            fos.write("\n".getBytes());
        }
        fos.close();
    }

}

追加写入

import java.util.*;
import java.io.*;
public class pratise {
    public static void main(String[] args) throws IOException {


        FileOutputStream fos = new FileOutputStream("C:\\Users\\18049\\Desktop\\java\\java.txt",true);

        byte[] bys="世界RPG".getBytes();
        for(int i=0;i<10;i++) {

            fos.write(bys);
            fos.write("\n".getBytes());
        }
        fos.close();
    }

}

finally释放资源

import java.util.*;
import java.io.*;
public class pratise {
    public static void main(String[] args) {

        FileOutputStream fos=null;
        try {


            fos = new FileOutputStream("C:\\Users\\18049\\Desktop\\java\\java.txt", true);

            byte[] bys = "世界RPG".getBytes();
            for (int i = 0; i < 10; i++) {

                fos.write(bys);
                fos.write("\n".getBytes());

            }
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(fos!=null)
            try {
                fos.close();
            }
            catch(IOException e)
            {
                e.printStackTrace();
            }
        }
    }
}

//或者
/*
try(定义流对象)
{}
catch(异常类名 变量名)
自动释放资源
//或者
定义流对象
try(对象名)
{}
catch(异常类名 变量名)
自动释放资源
*/

字节流读取数据

int read() 
从该输入流读取一个字节的数据。  
int read(byte[] b) 
从该输入流读取最多 b.length个字节的数据为字节数组。  
int read(byte[] b, int off, int len) 
从该输入流读取最多 len字节的数据为字节数组。  


import java.util.*;
import java.io.*;
public class pratise {
    public static void main(String[] args)throws IOException {

        FileInputStream fis=new FileInputStream("C:\\Users\\18049\\Desktop\\java\\java.txt");
        FileOutputStream fos =new FileOutputStream("C:\\Users\\18049\\Desktop\\java\\java1.txt");
        int by;
        while((by=fis.read())!=-1)//一次读取一个数据
        {
            fos.write(by);
        }
        fis.close();
        fos.close();

    }
}

import java.util.*;
import java.io.*;
public class pratise {
    public static void main(String[] args)throws IOException {

        FileInputStream fis=new FileInputStream("C:\\Users\\18049\\Desktop\\java\\java.txt");
        byte[] bys=new byte[1024];
        int len=0;
        while((len=fis.read(bys))!=-1)//一次读取一个字节数组
        {
            System.out.println(new String(bys,0,len));
        }
        fis.close();

复制文本

import java.util.*;
import java.io.*;
public class pratise {
    public static void main(String[] args)throws IOException {

        FileInputStream fis=new FileInputStream("C:\\Users\\18049\\Desktop\\java\\java.txt");
        FileOutputStream fos =new FileOutputStream("C:\\Users\\18049\\Desktop\\java\\java1.txt");
        byte[] bys =new byte[1024];
        int len=0;
        while((len=fis.read(bys))!=-1)
        {
            fos.write(bys,0,len);
        }
        fis.close();
        fos.close();

    }
}

字节缓冲流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zL061LE3-1630049562475)(C:\Users\18049\AppData\Roaming\Typora\typora-user-images\image-20210826210730796.png)]

import java.util.*;
import java.io.*;

public class pratise {
    public static void main(String[] args) throws IOException {

        FileOutputStream fos = new FileOutputStream("C:\\Users\\18049\\Desktop\\java\\java1\\java1.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        FileInputStream fis =new FileInputStream("C:\\Users\\18049\\Desktop\\java\\java1\\java1.txt");
        BufferedInputStream bis=new BufferedInputStream(fis);
        for (int i = 0; i < 10; i++) {
            bos.write("了不起的修仙模拟器\n".getBytes());
        }

        bos.close();
        byte[] bys=new byte[1024];
        int len=0;
        while( (len=bis.read(bys))!=-1)
        {
            System.out.println(new String(bys,0,len));
        }
        bis.close();
    }

}

字符流

为什么会出现字符流？

由于字节流操作中文不是特别方便，所以java提供了字符流

字符流=字节流+编码表

用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文

汉字存储的时候，无论选择哪种编码存储，第一个字节都是负数

import java.util.*;
import java.io.*;

public class pratise {
    public static void main(String[] args) throws IOException {

        FileOutputStream fos = new FileOutputStream("C:\\Users\\18049\\Desktop\\java\\java1\\java1.txt");
        FileInputStream fis = new FileInputStream("C:\\Users\\18049\\Desktop\\java\\java1\\java1.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos);
        InputStreamReader isr = new InputStreamReader(fis);
       for(int i=0;i<10;i++)
        osw.write("戴森球计划\n");
        char[] ch=new char[1024];
        int len;
        osw.close();
        while((len=isr.read(ch))!=-1)
        {
            System.out.println(new String(ch,0,len));
        }
        isr.close();

    }

}

便捷子类

FileReader()

FileWriter()

import java.util.*;
import java.io.*;

public class pratise {
    public static void main(String[] args) throws IOException {

        FileWriter fw=new FileWriter("C:\\Users\\18049\\Desktop\\java\\java1\\java1.txt");
        FileReader fr=new FileReader("C:\\Users\\18049\\Desktop\\java\\java1\\java1.txt");

        for(int i=0;i<10;i++)
        {
            fw.write("了不起的修仙模拟器\n");

        }
        fw.close();
        char[] ch=new char[1024];
        int len;
        while((len=fr.read(ch))!=-1)
        {
            System.out.println(new String(ch,0,len));
        }

        fr.close();
    }

}

字符缓冲流

可以指定缓冲区大小，也可以使用默认大小

import java.util.*;
import java.io.*;

public class pratise {
    public static void main(String[] args) throws IOException {

        FileWriter fw=new FileWriter("C:\\Users\\18049\\Desktop\\java\\java1\\java1.txt");
        FileReader fr=new FileReader("C:\\Users\\18049\\Desktop\\java\\java1\\java1.txt");
        BufferedReader br=new BufferedReader(fr);
        BufferedWriter bw=new BufferedWriter(fw);
        for(int i=0;i<10;i++)
        {
            bw.write("了不起的修仙模拟器\n");

        }
        bw.close();
        char[] ch=new char[1024];
        int len;
        while((len=br.read(ch))!=-1)
        {
            System.out.println(new String(ch,0,len));
        }

        br.close();
    }

}

移动单级目录

import java.util.*;
import java.io.*;

public class pratise {
    public static void main(String[] args) throws IOException {

        File src=new File("C:\\Users\\18049\\Desktop\\java\\java1");
        String srcname=src.getName();
        File des=new File("C:\\Users\\18049\\Desktop\\java\\java2",srcname);
        CopyFile(src,des);

    }
    public static void CopyFile (File src,File des)throws IOException
    {
        if(src.isDirectory())
        {

            File[] file =src.listFiles();
            for(File file1:file)
            {
                if(file1!=null) {
                    FileInputStream fis = new FileInputStream(file1);
                    BufferedInputStream bis = new BufferedInputStream(fis);


                    String filename = file1.getName();

                    File desfile = new File(des, filename);

                    des.mkdir();//建立目录
                    desfile.createNewFile();//建立文件

                    FileOutputStream fos = new FileOutputStream(desfile);
                    BufferedOutputStream bos = new BufferedOutputStream(fos);
                    byte[] bys = new byte[1024];
                    int len;
                    while ((len = bis.read(bys)) != -1) {
                        bos.write(bys, 0, len);
                    }

                    bos.close();
                    bis.close();
                }
            }

        }

    }

}

多级目录的复制

首先判断是不是目录，是目录继续调用方法，同时更新src和des
然后判断是不是null和文件夹，若不是文件夹则继续
在目的地建立目录和文件
使用字节缓冲输入流读取数据
使用字节缓冲输出流写数据

import java.util.*;
import java.io.*;
public class pratise {
    public static void main(String[] args) throws IOException {

        File src=new File("C:\\Users\\18049\\Desktop\\java\\java1");
        String srcname=src.getName();
        File des=new File("C:\\Users\\18049\\Desktop\\java\\java2",srcname);
        CopyFile(src,des);

    }
    public static void CopyFile(File src,File des)throws IOException
    {
        if(src!=null&&des!=null)
        {
            File[] files=src.listFiles();
            for(File file:files )
            {
                if(file.isDirectory())
                {
                    File newsrc=new File(src,file.getName());
                    File newdes=new File(des,file.getName());
                    CopyFile(newsrc,newdes);
                }
                if(file!=null&&file.isDirectory()==false) {//只有不是空和file不是文件夹的时候才运行

                    des.mkdirs();
                    String filename = file.getName();
                    File file1 = new File(des, filename);
                    file1.createNewFile();
                    FileInputStream fis = new FileInputStream(file);//源文件
                    BufferedInputStream bis = new BufferedInputStream(fis);
                    FileOutputStream fos = new FileOutputStream(file1);//目的地文件
                    BufferedOutputStream bos = new BufferedOutputStream(fos);
                    byte[] bys = new byte[1024];
                    int len;
                    while ((len = bis.read(bys)) != -1) {
                        bos.write(bys, 0, len);
                    }
                    bis.close();
                    bos.close();
                }
            }
        }
    }
}

o8699458

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
IO流详解（input/output）

IO流FIle概述和方法File：它是文件和目录路径的抽象表示文件和目录是可以通过File封装成对象的对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名。它是可以存在的，也可以说不存在的，要通过具体的操作把这个路径的内容转换为具体存在的File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例。 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
复制链接

扫一扫