Java IO字符流与字节流

一、基本概念

流：从一端流向另一端，从源头到目的地。

始终与程序为中心，都是程序与文件|数组|网络连接|数据库进行操作。

二、IO流分类

1.流向：

输入流和输出流

2.数据：

字节流：二进制，可以处理文本文件，视频，音频等。

字符流：文本文件，只能处理纯文本，全款为可见字符（.txt、.html）。

3.功能：

节点：包裹源头

处理：增强功能，提高性能。

三、字节流与字符流

1.字节流

输入流：InputStream

int read(byte[] b)
int read(byte[] b, int off, int len)
void close()

FileInputStream

输出流：OutputStream

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

FileOutputStream

2.字符流

输入流：Reader

int read(char[] cbuf)
abstract  int read(char[] cbuf, int off, int len)
abstract  void close()

FileReader

输出流：Writer

void write(char[] cbuf)
abstract  void write(char[] cbuf, int off, int len)
void write(String str, int off, int len)
abstract  void flush()
abstract  void close()

FileWriter

四、基本操作步骤

五、读取文件（字节流）

1、建立联系 –> File对象源头

2、选择流 –> 文件输入流InputStream、FileInputStream

3、操作 –> byte[] car = new byte[1024];+read+读取大小、输出

4、释放资源–>关闭

package IO;

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

/**
 * 文件的读取
 * 1、建立联系
 * 2、选择流
 * 3、操作 不断读取
 * 4、释放资源
 *
 * String(byte[] bytes, int offset, int length)
 * 通过使用平台的 默认字符集解码 指定的byte子数组，构造一个新的 String。
 */

public class Demo01 {
    public static void main(String[] args) {
        String path = "g:/love.txt";
        //1、建立联系
        File src= new File(path);
        //2、选择流
        InputStream is= null;//提升作用域
        try {
            //is = new FileInputStream(path);
            is = new FileInputStream(src);

            //3、操作不断读取   缓冲数组
            byte[] car = new byte[20];
            int len = 0;//接收实际读取的大小
            //循环读取
            while(-1!=(len=is.read(car)))
            {
                //输出 字节数组转成字符串(默认字符集解码)
                String info = new String(car,0,len);
                System.out.print(info);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件不存在");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("读取文件失败");
        }
        finally
        {
            //4、释放资源
            if(null!=is)
            {

                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                    System.out.println("关闭输入流文件失败");
                }
            }
        }

    }
}

运行结果：

if LOVE,
Please deeping LOVE.

六、写出文件（字节流）

1、建立联系 –> File对象目的地

2、选择流 –> 文件输出流OutputStream、FileOutputStream

3、操作 –> write+flush

4、释放资源–>关闭

package IO;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
 *  文件的写出
 * 1、建立联系
 * 2、选择流
 * 3、操作 不断写出
 * 4、释放资源
 */
public class Demo02 {
    public static void main(String[] args) {
        String path = "g:/oo.txt";
        //1、建立联系
        File dest= new File(path);
        //2、选择文件输出流  OutputStream、FileOutputStream
        OutputStream os = null;
        try {
            //以追加的形式写出文件为true   覆盖为false  默认是false
            os = new FileOutputStream(dest, true);
            //3、操作  \r\n回车
            String str = "Ladygaga is my nvshen.\r\n";
            //字符集转字符数组
            byte[] data = str.getBytes();
            os.write(data,0,data.length);
            os.flush();//强制刷新出去
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件不存在");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件写出失败");
        }
        finally
        {
            //4、释放资源
            if(null!=os)
            {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                    System.out.println("关闭输出流失败");
                }
            }
        }
    }
}

运行结果：

七、文件拷贝（字节流）

1、建立联系 File对象源头目的地

2、选择流

文件输入流
文件输出流

3、操作

byte[] flush = new byte[1024];
int len = 0;
while(-1!=(len=输入流.read(flush)))
{
    输出流.write(flush,0,len);
}
输出流.flush

4、释放资源：关闭两个流

package IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 拷贝文件
 * 1、建立联系 File对象 源头 目的地
 * 2、选择流
 *      文件输入流
 *      文件输出流
 * 3、操作  拷贝
 *      byte[] flush = new byte[1024];
 *      int len = 0;
 *      while(-1!=(len=输入流.read(flush)))
 *      {
 *          输出流.write(flush,0,len);
 *      }
 *      输出流.flush
 * 4、释放资源：关闭两个流
 */

public class Demo03 {
    final static String pathsrc = "G:/picture/520.jpg";
    final static String pathdest = "G:/1314.jpg";

    public static void main(String[] args)  {

        try {
            copyFile(pathsrc,pathdest);//源-->目的地
        } catch(FileNotFoundException e){
            e.printStackTrace();
            System.out.println("文件不存在");
        }catch (IOException e) {
            e.printStackTrace();
            System.out.println("拷贝文件失败|关闭输出流失败");
        }
    }

    /**
     * 文件的拷贝
     */
    public static void copyFile(String srcPath,String destPath)
            throws FileNotFoundException,IOException
    {
        //1、建立联系  源存在(且为文件)+目的地(文件可以不存在)
        File src = new File(srcPath);
        File dest = new File(destPath);
        if(!src.isFile())
        {
            System.out.println("只能拷贝文件");
            throw new IOException("只能拷贝文件");
        }
        //2、选择流
        InputStream is = new FileInputStream(src);
        OutputStream os = new FileOutputStream(dest);

        //3、文件拷贝  循环(读取+写出)
        byte[] flush = new byte[1024];
        int len = 0;
        while(-1!=(len = is.read(flush)))//读入
        {
            //写出
            os.write(flush,0,len);
        }
        os.flush();//强制刷出
        //关闭流 先打开后关闭
        os.close();
        is.close();
    }
}

八、文件夹拷贝（字节流）

1、递归查找子孙级文件|文件夹

2、如果是文件复制（IO流复制）

如果是文件夹创建，递归

package IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 文件夹的拷贝
 * 1、文件  复制
 * 2、文件夹  创建mkdirs()
 * 3、递归查找子孙级
 * @author Administrator
 */

@SuppressWarnings("all")
public class Demo04 {
    public static void main(String[] args) {
        String srcPath = "g:/try/123/432";//源目录
        String destPath = "g:/try/";//目标目录

        //File dest =null;
        //copyDir(srcPath,destPath);
        //FileUtil.copyDir(srcPath,destPath);
        copyDir(new File(srcPath),new File(destPath));
    }

    /**
     * 拷贝文件夹
     * src 源文件对象
     * dest 目标文件对象
     */
    public static void copyDir(File src,File dest)
    {
        if(src.isDirectory())//文件夹
        {

            dest = new File(dest,src.getName());//****
            //如果父目录不能拷贝到子目录中，这样会造成死循环。
            if(dest.getAbsolutePath().contains(src.getAbsolutePath()))
            {
                System.out.println("父目录不能拷贝到子目录中");
                return;
            }
        }
        copyDirDetail(src,dest);
    }

    /**
     * 拷贝文件夹细节
     * @param src
     * @param dest
     */
    public static void copyDirDetail(File src,File dest)
    {
        if(src.isFile())//如果是文件，直接拷贝。
        {
            try {
                copyFile(src, dest);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        else if(src.isDirectory())//如果是文件夹，递归。
        {
            //确保目标文件夹存在
            dest.mkdirs();//****
            //获取下一级目录文件夹
            for(File sub:src.listFiles())
            {
                copyDirDetail(sub, new File(dest,sub.getName()));
            }
        }
    }

    /**
     * 文件的拷贝
     * 源文件的File对象
     * 目标文件的File对象
     */
    public static void copyFile(File src,File dest) throws IOException
    {
        if(!src.isFile())
        {
            System.out.println("只能拷贝文件");
            throw new IOException("只能拷贝文件");
        }
        //如果过dest为已经存在的文件件，不能建立同名的文件
        if(dest.isDirectory())
        {
            System.out.println("不能建立同名的文件");
            throw new IOException("不能建立同名的文件");
        }

        //2、选择流
        InputStream is = new FileInputStream(src);
        OutputStream os = new FileOutputStream(dest);
        //3、文件拷贝  循环+读取+写出
        byte[] flush = new byte[1024];
        int len = 0;
        while(-1!=(len = is.read(flush)))
        {
            //写出
            os.write(flush,0,len);
        }
        os.flush();//强制刷出
        //关闭流 先打开后关闭
        os.close();
        is.close();
    }
}

九、自制文件|文件夹拷贝工具

package IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 文件操作综合更加完整，健壮
 * 1、文件拷贝
 * 2、文件夹拷贝
 */
public class FileUtil {
    /**
     * 文件的拷贝
     * 源文件的String对象
     * 目标文件的String对象
     */
    public static void copyFile(String srcPath,String destPath) throws IOException
    {
        //1、建立联系  源存在(且为文件)+目的地(文件可以不存在)
         copyFile(new File(srcPath),new File(destPath));
    }

    /**
     * 文件的拷贝
     * 源文件的File对象
     * 目标文件的File对象
     */
    public static void copyFile(File src,File dest) throws IOException
    {
        if(!src.isFile()||null==src)//不是文件或者为null
        {
            System.out.println("只能拷贝文件");
            throw new IOException("只能拷贝文件");
        }
        //如果dest为已经存在的文件夹，不能建立与文件夹同名的文件。
        if(dest.isDirectory())
        {
            System.out.println(dest.getAbsolutePath()+"不能建立与文件夹同名的文件");
            throw new IOException(dest.getAbsolutePath()+"不能建立与文件夹同名的文件");
        }

        //2、选择流
        InputStream is = new FileInputStream(src);
        OutputStream os = new FileOutputStream(dest);

        //3、文件拷贝  循环+读取+写出
        byte[] flush = new byte[1024];
        int len = 0;
        while(-1!=(len = is.read(flush)))
        {
            //写出
            os.write(flush,0,len);
        }
        os.flush();//强制刷出
        //4、关闭流 先打开后关闭
        os.close();
        is.close();
    }

    /**
     * 拷贝文件夹
     * 原路径
     * 目标路径
     */
    public static void copyDir(String srcPath,String destPath)
    {
        File src = new File(srcPath);
        File dest = new File(destPath);
        copyDir(src,dest);
    }

    /**
     * 拷贝文件夹
     * src 源文件对象
     * dest 目标文件对象
     */
    public static void copyDir(File src,File dest)
    {
        if(src.isDirectory())//文件夹
        {
            dest = new File(dest,src.getName());
            if(dest.getAbsolutePath().contains(src.getAbsolutePath()))
            {
                System.out.println("父目录不能拷贝到子目录中");
                return;
            }
        }
        copyDirDetail(src,dest);
    }

    /**
     * 拷贝文件夹细节
     * @param src
     * @param dest
     */
    public static void copyDirDetail(File src,File dest)
    {
        if(src.isFile())
        {
            try {
                FileUtil.copyFile(src, dest);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        else if(src.isDirectory())//文件夹
        {
            //确保目标文件夹存在
            dest.mkdirs();
            //获取下一级目录文件夹
            for(File sub:src.listFiles())
            {
                copyDirDetail(sub, new File(dest,sub.getName()));
            }
        }
    }
}

十、读取纯文本（字符流）

1、建立联系 –> File对象源头

2、选择流 –> 文件输入流Reader、FileReader

3、操作 –> char[] car = new char[1024];+read+读取大小、输出

4、释放资源–>关闭

package IOChar;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
/**
 * 纯文本读取
 * String(char[] value, int offset, int count)
 * 分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
 */
public class Demo01 {
    public static void main(String[] args) {
        String path = "G:/kfcv.txt";
        //1、创建源
        File src = new File(path);
        //2、选择流
        Reader reader = null;
        try {
            reader = new FileReader(src);
            //3、读取操作
            char[] flush = new char[10];
            int len = 0;
            while(-1!=(len = reader.read(flush)))
            {
                //字符数组转成字符串
                String str = new String(flush,0,len);
                System.out.print(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件不存在");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件读取失败");
        }
        finally
        {
            if(null!=reader)
            {
                try {
                    //4、关闭
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果：

?机会对于不能利用它的人又有什么用呢？
正如风只对于能利用它的人才是动力。

十、纯文本写出（字符流）

1、建立联系 –> File对象目的地

2、选择流 –> 文件输出流Writer、FileWriter

3、操作 –> write(字符数组,0,长度)+flush

4、释放资源–>关闭

package IOChar;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/**
 * 纯文件的写出
 * write(char[] cbuf)   写入字符数组。
 * void write(String str)  写入字符串。
 * abstract  void write(char[] cbuf, int off, int len)
 */
public class Demo02 {
    public static void main(String[] args) {
        String path = "G:/output.txt";
        //创建源
        File dest = new File(path);
        //选择流
        Writer wr = null;
        try {
            //wr = new FileWriter(dest,true);//true表示追加文件  默认是false,覆盖文件。
            wr = new FileWriter(dest);
            //写出
            String msg = "每个人都有青春，\r\n每个青春都有一个故事，\r\n每个故事都有一个遗憾，\r\n每个遗憾却都存在着他的美好。";
            wr.write(msg);
            wr.append("ouye");
            wr.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally
        {
            if(null!=wr)
            {
                try {
                    wr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果：

十一、纯文本拷贝（字符流）

package IOChar;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
/**
 * 纯文件的拷贝
 * @author liguodong
 */

public class Demo03 {
    public static void main(String[] args) {
        String srcPath = "G:/output.txt";
        String destPath = "G:/writer.txt";
        //创建源
        File src = new File(srcPath);
        //创建源
        File dest = new File(destPath);
        //选择流
        Reader reader = null;
        //选择流
        Writer writer = null;
        try {
            reader = new FileReader(src);
            writer = new FileWriter(dest);
            //读取操作
            char[] flush = new char[10];
            int len = 0;
            while(-1!=(len = reader.read(flush)))
            {
                //字符数组转成字符串
                //String str = new String(flush,0,len);
                //writer = new FileWriter(dest,true);
                //writer.write(str);
                writer.write(flush,0,len);
            }
            writer.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件不存在");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件读写失败");
        }
        finally
        {
            if(null!=reader)
            {
                try {
                    writer.close();
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

时间： 2024-10-10 15:54:47

Java IO字符流与字节流的相关文章

理解Java中字符流与字节流的区别

1. 什么是流 Java中的流是对字节序列的抽象,我们可以想象有一个水管,只不过现在流动在水管中的不再是水,而是字节序列.和水流一样,Java中的流也具有一个“流动的方向”,通常可以从中读入一个字节序列的对象被称为输入流:能够向其写入一个字节序列的对象被称为输出流. 2. 字节流 Java中的字节流处理的最基本单位为单个字节,它通常用来处理二进制数据.Java中最基本的两个字节流类是InputStream和OutputStream,它们分别代表了组基本的输入字节流和输出字节流.InputStre

Java中字符流与字节流的区别

字符流处理的单元为2个字节的Unicode字符,分别操作字符.字符数组或字符串,而字节流处理单元为1个字节,操作字节和字节数组.所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的,所以它对多国语言支持性比较好!如果是音频文件.图片.歌曲,就用字节流好点,如果是关系到中文(文本)的,用字符流好点. 所有文件的储存是都是字节(byte)的储存,在磁盘上保留的并不是文件的字符而是先把字符编码成字节,再储存这些字节到磁盘.在读取文件(特别是文本文件)时,也是一个字节一

Java: IO 字符流

FileInputStream和FileOutputStream分别是InputStream和OutputStream的子类,都是字节流.下面例子中有三个方法可以读写字节流: 1.一个一个的 2.一组一组的,可以自定义字节数组的长度 3.使用available方法,可以返回目标文件的长度从而利用该特性建立一个刚刚好长度的字节数组.但该方法有使用风险,例如目标文件过大,一个电影或者一个大数据文件,则会导致超过虚拟机内存的大小,从而出现错误.所以使用该方法要评估风险,如果可以确定目标是小文件,则可以

java - io字符流

1.字符流是什么字符流是可以直接读写字符的io流字符流读取字符,就是要先读取到字节数据,然后转为字符,如果要写出字符,需要把字符转为字节再写出 2.FileReader FileReader类的read(),可以按照字符大小读数读取的是单个字符,返回的是int 读取字符,如果已到达流的末尾,则返回-1 3.FileWrite 写出字符拷贝: 什么时候使用字符流: 字符流也可以拷贝文本文件,但不推荐使用,因为读取时会把字节转为字符,写出时还要把字符转回字节程序需要读取一段文本,或者需要写

java -io字符流FileWrite操作演示

FileWriter字符输出流演示: /* * FiileWriter 字符流的操作 * FileWriter 的构造方法可传递 File类型还可以传递String类型 * * 方法 : * write(int c) 传递一个字节 * write(char[] a ) 传递一个字符数组 * write(char[]a , 开始索引 , 传递几个) * write(String s) 传递一个字符串 * * 注意:写完之后一定要刷新缓冲区不然数据写入不进 * 对象.flush() * */

Java基础---IO(一)---IO流概述、字符流、字节流、流操作规律

第一讲 IO概述概述 1.IO流:即InputOutput的缩写. 2.特点: 1)IO流用来处理设备间的数据传输. 2)Java对数据的操作是通过流的方式. 3)Java用于操作流的对象都在IO包中. 4)流按操作数据分为两种:字节流和字符流. 5)流按流向分为:输入流和输出流. 注意:流只能操作数据,而不能操作文件. 3.IO流的常用基类: 1)字节流的抽象基流:InputStream和OutputStream 2)字符流的抽象基流:Reader和Writer 注:此四个类派生出来

java 核心编程——IO流之字符流和字节流相互转换（四）

1.为什么字符流和字节流需要转换? 这是因为有一些时候系统给你提供的只有字节流,比如说System.in标准输入流.就是字节流.你想从他那里得到用户在键盘上的输入,只能是以转换流将它转换为Reader以方便自己的程序读取输入.再比如说Socket里的getInputStream()很明显只给你提供字节流,你要不行直接用,就得给他套个InputStreamReader()用来读取.网络传输来的字符. 2.字节流和字符流怎么转换? 2.1.字节流转换为字符流:InputStreamReader 2.

黑马程序员—IO(一)流概述、字符流、字节流、流操作规律

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 第一节 IO概述概述 1.IO流:即InputOutput的缩写. 2.特点: 1)IO流用来处理设备间的数据传输. 2)Java对数据的操作是通过流的方式. 3)Java用于操作流的对象都在IO包中. 4)流按其操作数据的类型分为两种:字节流和字符流. 5)流按其流向分为:输入流和输出流. 注意:流只能操作数据,而不能操作文件. 3.IO流的常用基类: 1)字节流的抽象基流:Inp

黑马程序员——IO流概述、字符流、字节流、流操作规律(一)

第一节 IO概述概述 1.IO流:即InputOutput的缩写. 2.特点: 1)IO流用来处理设备间的数据传输. 2)Java对数据的操作是通过流的方式. 3)Java用于操作流的对象都在IO包中. 4)流按其操作数据的类型分为两种:字节流和字符流. 5)流按其流向分为:输入流和输出流. 注意:流只能操作数据,而不能操作文件. 3.IO流的常用基类: 1)字节流的抽象基流:InputStream和OutputStream 2)字符流的抽象基流:Reader和Writer 注:此四个