投稿
  1. 极客之音首页

Java中的IO流（一）

小半 • • 未分类 • 阅读 259

如果你不相信努力和时光，那么成果就会是第一个选择辜负你的。不要去否定你自己的过去，也不要用你的过去牵扯你现在的努力和对未来的展望。不是因为拥有希望你才去努力，而是去努力了，你才有可能看到希望的光芒。Java中的IO流（一），希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com，来源：原文

Java中的IO流（一）

一、前言

学习这部分内容的时候，跟着敲代码难免有些乱，这里先放一张图：

Java中的IO流（一）

二、实现对文件和文件夹的操作：

案例一：

package file.bytestream;

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

public class FileDemo1 {
    public static void main(String[] args) throws IOException {
        File f1 = new File("D:\\File\\test01.txt");
        System.out.println(f1);

        File f2 = new File("D:\\File","test02.txt");
        System.out.println(f2);

        File f3 = new File("D:\\File");
        File f4 = new File(f3,"test0.txt");

        //mkdirs()包含没有创建的文件夹也给创建处理啊
        //createNewFile()创建新文件
        System.out.println(f3.mkdirs());
        System.out.println(f4.createNewFile());

        //获取到文件的绝对路径
        System.out.println(f4.getAbsolutePath());
        //获取到文件路径
        System.out.println(f4.getPath());
        //获取到文件名字
        System.out.println(f4.getName());

        //判断f3是否为一个目录?
        if(f3.isDirectory()){
            String fileName;
            //循环创建多个文件
            for(int i = 1; i <= 40; i ++){
                fileName = "test" + i +".txt";
                new File(f3,fileName).createNewFile();
            }
            System.out.println("我要开始删除文件了!!!");
            deleteFile(f3);
        }

    }
    //删除文件
    public static void deleteFile(File f3){
        String fileName;
        for(int i = 0; i <= 40; i ++){
            System.out.println("我要开始删除test" + i + ".txt");
            fileName = "test" + i +".txt";
            new File(f3,fileName).delete();
        }
    }
}

案例二：

package file.bytestream;

import java.io.File;

public class FileDemo2 {
    public static void main(String[] args) {
        //绝对路劲与相对路劲
        //D:\\File\\a.txt   绝对路径
        //a.txt   相对路径
    }
}

二、字节流和字节缓存流：

这里提供一个快速记忆：
input 》》 输入 》》 向数组中输入 》》 从文件读取数据到数组中 》》 两种方法（一个一个、一个数组一个数组）

output 》》 输出 》》 从数组中输出 》》 从数组中输出数据到文件中 》》 write()

FileInputStream

例子一：

package file.bytestream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

//读取字节流
public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节流输入流对象
        //FileInputStream(String name)
        FileInputStream fis = new FileInputStream("myByteStream\\fos01.txt");

        int by;
        /*
         * fis.read():读数据
         * by = fis.read():把读取到的数据赋值给by
         * by != -1: 判断读取到的数据是否是-1
         * */
        while((by=fis.read())!=-1){
            System.out.print((char)by);
        }

        //释放资源
        fis.close();
    }
}

例子二：

package file.bytestream;

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字节流输入流对象
        FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");

        byte[] bys = new byte[1024]; //1024以及整数倍
        int len;

        //循环读取
        while((len=fis.read(bys)) != -1){
            System.out.println(new String(bys,0,len));
        }

        fis.close();
    }
}

FileOutputStream

例子一：

package file.bytestream;

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

public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        /*
        * 注意点:
        * 1、如果文件不存在，会帮我们创建
        *
        * 2、如果文件存在，会把文件清空
        * */
        //FileOutputStream(String name):创建文件输出流以指定的名称写入文件
        if(!new File("myByteStream").exists()){
            new File("myByteStream").mkdirs();
        }

        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
        //void write(int b): 将指定的字节写入文件输出流
        fos.write(97);
        fos.write(57);
        fos.write(55);

        //最后释放资源
        fos.close();
    }
}

例子二：

package file.bytestream;

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //FileOutputStream(String name): 创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
        byte[] bytes = "abscsd".getBytes();
        fos.write(bytes,1,3);  //从第一个索引开始，然后3个值

        //释放资源
        fos.close();
    }
}

例子三：

这个例子和trt{}catch{}结合，在finally函数内释放资源

package file.bytestream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo03 {
    public static void main(String[] args) {
        //加入finally来释放资源
        FileOutputStream fos = null;
        try{
            //创建字节输出对象
             fos = new FileOutputStream("myByteStream\\fos.txt");
            InputStream(fos);
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void InputStream(FileOutputStream fos) throws IOException {

        //写数据
        for(int i = 0; i < 10; i++){
            fos.write("hello".getBytes());
            fos.write("\r\n".getBytes());
        }

        //释放资源
        fos.close();
    }
}

BufferedInputStream && BufferedOutputStream

package file.bytestream;

import java.io.*;

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
        //字节缓冲输出流: BufferedOutputStream(OutputStream out)
        BufferedOutputStream bos = new BufferedOutputStream(new
                FileOutputStream("myByteStream\\bos.txt"));

        //写数据
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());

        //释放资源
        bos.close();

        //字节缓冲输入流：BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new
                FileInputStream("myByteStream\\bos.txt"));

        //一次读取一个字节数据
//        int by;
//        while((by = bis.read()) != -1){
//            System.out.println((char)by);
//        }

        //一次读取一个字节数组数据
        byte[] bys = new byte[1024];
        int len;
        while((len=bis.read(bys))!=-1){
            System.out.println(new String(bys,0,len));
        }

        //释放资源
        bis.close();
    }
}

三、应用

1、使用一个一个字节进行复制：

package file.bytestream;


import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Scanner;

//字节流复制文件

/*=============================
适合txt文件
============================*/
public class CopyFileDemo {
    public static void main(String[] args) {
        System.out.println("请按照以下一种方式书写:");
        System.out.println("1、'D:\\\\File\\\\txt01.txt'\t绝对路径");
        System.out.println("2、'File\\\\txt01.txt'\t相对路劲");
        String sourcePath = "";
        String targetPath = "";
        Scanner sc = new Scanner(System.in);
        sourcePath = sc.nextLine();
        targetPath = sc.nextLine();

//        println(sourcePath,targetPath); //验证是否有问题

        copyFileByBytes(sourcePath,targetPath);
    }

    //工具函数
    public static void copyFileByBytes(String sourcePath, String targetPath){
        FileInputStream fis = null;  //输入流，将信息输入到字节数组中并存储起来
        FileOutputStream fos = null; //输出流，将字节数组中的数据输出到文件中
        try{
            fis = new FileInputStream(sourcePath);
            fos = new FileOutputStream(targetPath);

            //读写数据
            int by; //存储字节流(int)
            while((by = fis.read()) != -1){
                fos.write(by);
            }

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

    public static void println(String ...array){
        System.out.println(array.getClass().isArray()); //判断数据类型
        System.out.println(Arrays.toString(array));
    }
}

2、使用一个一个数组进行复制

package file.bytestream;


import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Scanner;

//字节流复制文件
/*=============================
适合所有文件
============================*/
public class CopyFIleDemo01 {
    public static void main(String[] args) {
        System.out.println("请按照以下一种方式书写:");
        System.out.println("1、'D:\\\\File\\\\txt01.txt'\t绝对路径");
        System.out.println("2、'File\\\\txt01.txt'\t相对路劲");
        String sourcePath = "";
        String targetPath = "";
        Scanner sc = new Scanner(System.in);
        sourcePath = sc.nextLine();
        targetPath = sc.nextLine();

//        println(sourcePath,targetPath); //验证是否有问题

        copyFileByBytes(sourcePath,targetPath);
    }

    //工具函数
    public static void copyFileByBytes(String sourcePath, String targetPath){
        FileInputStream fis = null;  //输入流，将信息输入到字节数组中并存储起来
        FileOutputStream fos = null; //输出流，将字节数组中的数据输出到文件中
        try{
            fis = new FileInputStream(sourcePath);
            fos = new FileOutputStream(targetPath);

            //读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
            //跟第一种使用一个一个读取字节不一样，这样做的好处是什么？
            //1、相比第一种方式使用一个字节一个字节地读取和写入，具有更高的效率。这是因为磁盘I/O操作是相对较慢的，通过一次性读取多个字节并进行批量写入，可以减少磁盘I/O操作的次数，提高数据传输的效率。
            //2、使用字节数组还可以减少内存开销，因为在Java中，一次读取多个字节并将其存储在字节数组中，可以更好地利用内存，而不是为每个字节都分配一个变量。
            byte[] bytes = new byte[1024];
            int len;
            while((len = fis.read(bytes)) != -1){
                fos.write(bytes,0,len);
            }

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

    public static void println(String ...array){
        System.out.println(array.getClass().isArray()); //判断数据类型
        System.out.println(Arrays.toString(array));
    }
}

3、使用BufferInputStream和BufferOutputStream以及方法一和方法二进行复制：

package file.bytestream;


import java.io.*;
import java.util.Arrays;
import java.util.Scanner;

//字节缓存流复制文件
/*=============================
适合所有文件
============================*/
public class CopyFileDemo02 {
    public static void main(String[] args) {
        System.out.println("请按照以下一种方式书写:");
        System.out.println("1、'D:\\\\File\\\\txt01.txt'\t绝对路径");
        System.out.println("2、'File\\\\txt01.txt'\t相对路劲");
        String sourcePath = "";
        String targetPath = "";
        Scanner sc = new Scanner(System.in);
        sourcePath = sc.nextLine();
        targetPath = sc.nextLine();

//        println(sourcePath,targetPath); //验证是否有问题

//        copyFileByBytes01(sourcePath,targetPath);  //字节数组读取字节流  一个数组一个数组
        copyFileByBytes02(sourcePath,targetPath); //字节流  一个一个
    }

    //工具函数
    public static void copyFileByBytes01(String sourcePath, String targetPath){
        BufferedInputStream bis = null;  //输入流，将信息输入到字节数组中并存储起来
        BufferedOutputStream bos = null; //输出流，将字节数组中的数据输出到文件中
        try{
            bis = new BufferedInputStream(new FileInputStream(sourcePath));;
            bos = new BufferedOutputStream(new FileOutputStream(targetPath));

            //读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
            byte[] bytes = new byte[1024];
            int len;
            while((len = bis.read(bytes)) != -1){
                bos.write(bytes,0,len);
            }

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


    public static void copyFileByBytes02(String sourcePath, String targetPath){
        BufferedInputStream bis = null;  //输入流，将信息输入到字节数组中并存储起来
        BufferedOutputStream bos = null; //输出流，将字节数组中的数据输出到文件中
        try{
            bis = new BufferedInputStream(new FileInputStream(sourcePath));;
            bos = new BufferedOutputStream(new FileOutputStream(targetPath));

            //读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
            int by; //存储字节流(int)
            while((by = bis.read()) != -1){
                bos.write(by);
            }

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

    public static void println(String ...array){
        System.out.println(array.getClass().isArray()); //判断数据类型
        System.out.println(Arrays.toString(array));
    }
}

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/199429.html

赞 (0)
小半的头像小半
0 0

相关推荐

极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！