Java 常用工具类--输入输出流

作者: 磊_5d71 | 来源:发表于2018-09-17 07:30 被阅读0次

Java 常用工具类--输入输出流
JAVA(一)文件流的输入和输出
I/O流
Java-10 I/O流
020-Netty
8-Java常用工具类-输入输出流
2017-09-07-Java 输入输出流
Java的IO和NIO
Java新特性之Java8的那些事儿-Stream
Java IO流

输出流

image.png
输入流

image.png

File类

File类常用方法

package com.alan.file;

import java.io.File;
import java.io.IOException;
public class FileDemo {
    public static void main(String[] args) {

        // 方式1:创建File对象（即可以创建文件，也可以创建目录）
        //File file1 = new File("/Users/alan/eclipse-workspace/ThreadFileProj/io/hello.txt");
        // 方式2:创建File对象（即可以创建文件，也可以创建目录）
        //File file1 = new File("/Users/alan/eclipse-workspace/ThreadFileProj","io/hello.txt");
        // 方式3:创建File对象（即可以创建文件，也可以创建目录）
        File file = new File("/Users/alan/eclipse-workspace/ThreadFileProj/io");
        File file1 =  new File(file,"hello.txt");
        //判断是文件还是目录
        System.out.println("是否是目录："+file1.isDirectory());
        System.out.println("是否是文件："+file1.isFile());
        //创建目录
        File file2 = new File("/Users/alan/eclipse-workspace/ThreadFileProj","HashSet");
        if(!file2.exists()) {
            file2.mkdirs();
        }
        //创建文件
        if(!file1.exists()) {
            try {
                file1.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字节流

字节输入流 InputStream
字节输出流 OutputStream

FileInputStream

从文件系统中的某个文件中或者输入字节
用于读取诸如图像数据之类的原始字节流（如果是字符类型一般使用字符流）

image.png
案例1

package com.alan.file;

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

public class FileInputDemo1 {

    public static void main(String[] args) {
        // 读取本项目根目录的test.txt文件
        File file = new File("test.txt");
        try {
            FileInputStream fis = new FileInputStream(file);
            int n;
            // n为-1时，读取的末尾
            while ((n = fis.read()) != -1) {
                System.out.print((char) n);
            }
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

案例2

package com.alan.file;

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

public class FileInputDemo2 {

    public static void main(String[] args) {
        // 读取本项目根目录的test.txt文件
        File file = new File("test.txt");
        try {
            FileInputStream fis = new FileInputStream(file);
            //通过byte数组进行读操作
            byte[] b = new byte[200];
            fis.read(b);
            System.out.print(new String(b));
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

FileOutputStream

案例

package com.alan.file;

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

public class FileOutputDemo2 {

    public static void main(String[] args) {
        // 文件拷贝
        try {
            // FileInputStream实例化，为原文件
            FileInputStream fis = new FileInputStream("12345.jpg");
            // FileOutputStream实例化，为拷贝的新文件
            FileOutputStream fos = new FileOutputStream("12345copy.jpg");
            int n = 0;
            // 定义大小为1kb的数组
            byte[] b = new byte[1024];
            // 通过FileInputStream将文件读取，并保存在byte数组b中
            // 通过FileOutputStream写文件，实现拷贝。
            // n代表实际读取到的字节的个数。用另一个write方法实现，保证拷贝后的文件大小与之前的一致
            while ((n = fis.read(b)) != -1) {
                // fos.write(b);
                fos.write(b, 0, n);
            }
            fis.close();
            fos.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

缓冲流

缓冲输入流 BufferedInputStream
缓冲输出流 BufferedOutputStream
使用缓冲流，可以提高读写速度。需要与文件输入输出流配合使用。

flush() 当缓冲区不满的时候，需要使用此方法强制输出

案例

package com.alan.file;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedDemo {

    public static void main(String[] args) {

        try {
            // 缓冲输出流实例化，将文件输出流的对象赋值给缓冲输出流的构造函数
            FileOutputStream fos = new FileOutputStream("test.txt");
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            // 缓冲输入流实例化，将文件输入流的对象赋值给缓冲输出流的构造函数
            FileInputStream fis = new FileInputStream("test.txt");
            BufferedInputStream bis = new BufferedInputStream(fis);
            bos.write(50);
            bos.write('a');
            // 清空缓冲区，将数据写入，如果不调用flush方法，最后用close方法也可以达到效果，但一般还是将flush方法写上。
            bos.flush();
            System.out.println(bis.read());
            System.out.println((char)bis.read());
            fos.close();
            bos.close();
            fis.close();
            bis.close();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

字符流

字符输入流Reader
字符输出流Writer

字节字符转换流

InputStreamReader 其中InputStream是字节输入流的父类 Reader是字符输入流的父类
OutputStreamWriter 其中OutputStream是字节输出流的父类 Writer是字符输出流的父类
案例

package com.alan.charstream;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class ReaderDemo {

    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("test.txt");
            InputStreamReader isr = new InputStreamReader(fis);
            BufferedReader br = new BufferedReader(isr);
            FileOutputStream fos = new FileOutputStream("test1.txt");
            OutputStreamWriter osw = new OutputStreamWriter(fos);
            BufferedWriter bw = new BufferedWriter(osw);
            //方式1
            int n = 0;
//          while((n = isr.read())!= -1) {
//              System.out.print((char)n);
//          }
            //方式2
            char[] cbuf = new char[10];
            while((n = br.read(cbuf))!= -1) {
                bw.write(cbuf, 0, n);
                bw.flush();
            }
            fis.close();
            isr.close();
            fos.close();
            osw.close();
            br.close();
            bw.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

对象序列化

1、创建一个类，实现Serializable接口
2、创建对象
3、将对象写入文件
4、从文件读取对象信息

对象输入流ObjectInputStream
对象输出流ObjectOutputStream
Goods类

package com.alan.serial;

import java.io.Serializable;

public class Goods implements Serializable {
    
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    //属性：商品编号、商品名称、商品价格
    private String goodsId;
    private String goodsName;
    private double price;
    
    
    //带参构造
    public Goods(String goodsId, String goodsName, double price) {
        this.goodsId = goodsId;
        this.goodsName = goodsName;
        this.price = price;
    }
    
    
    public String getId() {
        return goodsId;
    }
    public void setId(String goodsId) {
        this.goodsId = goodsId;
    }
    public String getName() {
        return goodsName;
    }
    public void setName(String goodsName) {
        this.goodsName = goodsName;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }


    @Override
    public String toString() {
        return "商品编号:" + goodsId + ", 商品名称:" + goodsName + ", 商品价格:" + price;
    }

}

测试类

package com.alan.serial;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class GoodsTest {

    public static void main(String[] args) {
        // 定义Goods类的对象
        Goods goods1 = new Goods("gd001","电脑",3000);
        try {
            //写文件
            FileOutputStream fos = new FileOutputStream("test.txt");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            //读文件
            FileInputStream fis = new FileInputStream("test.txt");
            ObjectInputStream ois = new ObjectInputStream(fis);
            oos.writeObject(goods1);
            oos.flush();
            //读到对象存放
            Goods goods = (Goods)ois.readObject();
            System.out.println(goods);
            fis.close();
            ois.close();
            oos.close();
            fos.close();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

Java 常用工具类--输入输出流
输出流image.png 输入流image.png File类 File类常用方法字节流字节输入流 Input...
JAVA(一)文件流的输入和输出
一.java输入流类二.文件输出流三.工作中的输入输出流工作上的文件输入输出流都要判断流是否读取完整whil...
I/O流
输入输出流 Java.io包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。Java.i...
Java-10 I/O流
I/O流全称是Input/Output Stream,译为输入输出流 I/O流常用的类型都在java.io包中类...
020-Netty
简单系统的介绍一下Netty。 Java的输入输出流（IO流）是Java的一块基础知识，Java语言定义了许多类专...
8-Java常用工具类-输入输出流
Java输入输出流生活中无处不在，只要涉及到传输。复制粘贴操作;修改头像，将本地数据上传到网络服务器。将字符串...
2017-09-07-Java 输入输出流
Java 输入输出流 1，Java 中的流分为两种，一种是字节流，另一种是字符流，分别由四个抽象类来表示（每种流包...
Java的IO和NIO
一、IO java的IO功能都在java.io包下，包括输入输出两种IO流，每种输入输出流又可分为字节流和字符流两...
Java新特性之Java8的那些事儿-Stream
什么是流? Java Se中对于流的操作有输入输出IO流,而Java8中引入的Stream 属于Java ...
Java IO流
标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流等等，java中将输入输出抽象称为流，就好...