Java基础（IO流)

一、字节输出流

1.OutputStream中定义的方法：

2.FileOutputStream类

OutputStream有很多子类，其中子类FileOutputStream可用来写入数据到文件。FileOutputStream类，即文件输出流，是用于将数据写入 File的输出流。

示例：

import java.io.FileOutputStream;

public class demo01 {
    public static void main(String[] args) throws Exception {
        //如果文件不存在，会帮我们自动创建文件
        FileOutputStream fos=new FileOutputStream("1.txt");
        //输出
        fos.write(98);
        byte[] bytes={97,98,99};
        fos.write(bytes);
        //关闭流
        fos.close();
    }
}

        //第二个参数，是否续写
        FileOutputStream fos=new FileOutputStream("1.txt",true);
        fos.write(90);
        fos.close();

        FileOutputStream fos=new FileOutputStream("2.txt");
        //输出中文
        fos.write("你好".getBytes());
        //换行
        fos.write("\r\n".getBytes());
        fos.write("吴先生".getBytes());
        fos.close();

练习题：

1.复制文件

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class demo05_用数组复制 {
    public static void main(String[] args) throws Exception {
        FileInputStream fis=new FileInputStream("1.txt");
        FileOutputStream fos=new FileOutputStream("4.txt");
        byte[] bytes=new byte[4];
        int count=0;
        while((count=fis.read(bytes))!=-1){
            fos.write(bytes,0,count);
        }
        fos.close();
        fis.close();
        System.out.println("复制成功!");
    }
}

2.统计文件中字母出现的次数

import java.io.FileInputStream;
import java.util.TreeMap;

/**
 * 统计一个文件中
 * 字母出现的次数
 * 实现思路：
 *    1.读取文件，将文件内容保存到String类型的变量中
 */
public class demo06_练习题 {
    public static void main(String[] args) throws Exception {
        FileInputStream fis=new FileInputStream("char.txt");
        byte[] bytes=new byte[10];
        int count=0;
        StringBuffer s=new StringBuffer();
        while((count=fis.read(bytes))!=-1){
            s.append(new String(bytes,0,count));
        }
        TreeMap<Character,Integer> treeMap=new TreeMap<>();
        for(char c:s.toString().toCharArray()){
            treeMap.put(c,treeMap.containsKey(c)?treeMap.get(c)+1:1);
        }
        System.out.println(treeMap);

    }
}

二、字节输入流

示例：

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

public class demo01 {
    public static void main(String[] args) throws Exception {
        FileInputStream file=new FileInputStream("test");
        //读取数据,一次一个,是int 型的数据
        System.out.println((char)file.read());
        file.close();
        //读取所有的内容
        FileInputStream file1=new FileInputStream("test");
        //第一种写法
        /*int n=file1.read();
        while(n!=-1){
            System.out.print((char)n);
            n=file1.read();
        }*/
        //第二种写法
        int n1=0;
        while ((n1=file1.read())!=-1){
            System.out.print((char)n1);
        }
        file1.close();
    }
}

        FileInputStream file=new FileInputStream("test");
        byte[] bytes=new byte[2];
        int count=0;
        //读取文件
        while((count=file.read(bytes))!=-1){
            String s=new String(bytes,0,count);
            System.out.println(s);

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

/**
 * 复制1.txt为3.txt
 */
public class demo04 {
    public static void main(String[] args) throws Exception {
        FileInputStream fis=new FileInputStream("1.txt");
        FileOutputStream fos=new FileOutputStream("3.txt");
        int n=0;
        while((n=fis.read())!=-1){
            fos.write(n);
        }
        fos.close();
        fis.close();
        System.out.println("复制成功！");
    }
}

练习题

1.将集合中的数据存入文件

import java.io.FileOutputStream;
import java.util.LinkedHashMap;
import java.util.Map;

public class demo_将集合中的数据存入文件中 {
    public static void main(String[] args) throws Exception {
        Map<String, Integer> map = new LinkedHashMap<>();
        map.put("摩卡",30);
        map.put("卡布奇诺",32);
        map.put("拿铁",27);
        FileOutputStream fos=new FileOutputStream("a.txt");
        for(String key:map.keySet()){
            fos.write(key.getBytes());
            fos.write("=".getBytes());
            fos.write(map.get(key).toString().getBytes());
            fos.write("\r\n".getBytes());
        }
        fos.close();
    }
}

2.将文件存入集合

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.LinkedHashMap;
import java.util.Map;

public class demo_从文件中读取数据 {
    public static void main(String[] args) throws Exception {
        Map<String,Integer> map=new LinkedHashMap<>();
        FileInputStream fis=new FileInputStream("a.txt");
        byte[] bytes=new byte[1024];
        int count=fis.read(bytes);
        String str=new String(bytes,0,count);
        String[] line=str.split("\r\n");
        for(String k:line){
            String[] s=k.split("=");
            map.put(s[0],Integer.parseInt(s[1]));
        }
        System.out.println(map);

    }
}

3.将指定路径的文件复制到当前目录下

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.util.Scanner;

public class demo_练习题 {
    public static void main(String[] args) throws Exception {
        File file=getFile();
        FileInputStream fis=new FileInputStream(file);
        FileOutputStream fos=new FileOutputStream(file.getName());
        byte[] bytes=new byte[10];
        int count=0;
        while((count=fis.read(bytes))!=-1){
            fos.write(bytes,0,count);
        }
        fos.close();
        fis.close();
        System.out.println("复制成功！");
    }

    public static File getFile() {
        Scanner sc=new Scanner(System.in);
        while(true) {
            System.out.print("请输入一个文件的路径:");
            String path = sc.next();
            File file = new File(path);
            if (!file.exists()) {
                System.out.println("输入路径不存在！");
            } else if (file.isDirectory()) {
                System.out.println("路径必须是文件！");
            } else{
                return file;
            }
        }
    }
}

三、字符输入流

示例：

import java.io.FileReader;

public class demo01 {
    public static void main(String[] args) throws Exception {
        //读取字符
        FileReader fr=new FileReader("1.txt");
        //单个读取
        /*int k=0;
        while((k=fr.read())!=-1){
            System.out.print((char)k);
        }*/
        //读取到数组里面
        char[] chars=new char[3];
        int count=0;
        while((count=fr.read(chars))!=-1){
            for(int i=0;i<chars.length;i++){
                System.out.print(chars[i]);
            }
        }
    }
}

四、字符输出流

示例：

import java.io.FileWriter;

public class demo02 {
    public static void main(String[] args) throws Exception {
        FileWriter fw=new FileWriter("5.txt");
        //写入字符串
        fw.write("你好！");
        //刷新
        fw.flush();
        //写入字符
        char[] chars={'吴','先','生'};
        fw.write(chars);
        fw.flush();
        //关闭流
        fw.close();
    }
}

练习题

1.复制文本文件

import java.io.FileReader;
import java.io.FileWriter;

/**
 * 使用字符流复制文本文件
 */
public class demo03 {
    public static void main(String[] args) throws Exception {
        FileReader fr=new FileReader("test.txt");
        FileWriter fw=new FileWriter("test1.txt");
        //循环读写操作效率低
       /* int c=0;
        while((c=fr.read())!=-1){
            fw.write(c);
            fw.flush();
        }*/

        //为了提高效率。自定义和缓冲区数组
        char[] chars=new char[1024];
        int len=0;
        while((len=fr.read(chars))!=-1){
            fw.write(chars,0,len);
        }
        fw.close();
        fr.close();
        System.out.println("复制完成！");

    }
}

五、转换流

有时候字节流和字符流之间需要进转换，此时就需要用到转换流。

示例：

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

public class demo04 {
    public static void main(String[] args) throws Exception {
        //将一个字节输出流转换成字符输出流，方便字节写入字符
        FileOutputStream fos=new FileOutputStream("6.txt");
        //转换流
        OutputStreamWriter osw=new OutputStreamWriter(fos);
        osw.write("你好呀！");
        osw.close();
        fos.close();
    }
}

六、缓冲流

1.字节缓冲输出流

示例：

public class Test {
	public static void main(String[] args) throws IOException {
		// 写数据到文件的方法
		write();
	}
	private static void write() throws IOException {
		// 创建基本的字节输出流
		FileOutputStream fos = new FileOutputStream("1.txt");
		// 使用高效的流，把基本的流进行封装，实现速度的提升
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		// 2，写数据
		bos.write("hello".getBytes());
		// 3，关闭流
		bos.close();
		fos.close();
	}
}

2.字节缓冲输入流

示例：

public class Test {
	public static void main(String[] args) throws IOException {
		// 1. 创建缓冲流对象
		FileInputStream fis = new FileInputStream("2.txt");
		// 把基本的流包装成高效的流
		BufferedInputStream bis = new BufferedInputStream(fis);
		// 2. 读数据
		int ch = -1;
		while ((ch = bis.read()) != -1) {
			// 打印
			System.out.print((char) ch);
		}
		bis.close();
		fis.close();
	}
}

3.字符缓冲流

示例：

import java.io.*;

public class demo2 {
    public static void main(String[] args) throws Exception {
        Writer fw=new FileWriter("6.txt");
        BufferedWriter bw=new BufferedWriter(fw);
        bw.write("吴先生");
        bw.newLine();
        bw.write("好久不见！");
        bw.flush();
        bw.close();

        Reader r=new FileReader("6.txt");
        BufferedReader br=new BufferedReader(r);
        String s=br.readLine();
        System.out.println(s);

    }
}

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

public class demo1 {
    public static void main(String[] args) throws Exception {
        FileOutputStream fos=new FileOutputStream("1.txt");
        //缓冲流
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        bos.write(97);
        bos.close();
        fos.close();
    }
}

七、对象序列化流

序列化：是指将一个"对象(包含属性值)"存储到一个文件中，或者通过网络进行传输

类介绍：ObjectOutputStream

构造方法

ObjectOutputStream(OutputStream out)

序列化的方法

void writeObject(Object obj) ：将指定的对象写入 ObjectOutputStream

注意：当某个对象需要被"序列化"时，此类必须实现：Serializable（接口）

在Serializable接口中，没有任何方法，这种接口叫：标记接口；它类似于一个标记，某个类如果实现了这样的接口，表示这个类就具有了某种权限（功能）

2.反序列化：是指将一个文本文件转成一个Java对象

类介绍：ObjectInputStream

构造方法

ObjectInputStream(InputStream in)

反序列化的方法

Object readObject() ：从 ObjectInputStream 读取对象。

示例：

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
*序列化
*/
public class demo1 {
    public static void main(String[] args) throws Exception{
        Student s=new Student("吴先生",18);
        //将s对象存入文件中
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("student"));
        //参数：要被写入的对象
        oos.writeObject(s);
        oos.close();
        System.out.println("写入成功！");

    }
}
class Student implements Serializable{
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

import java.io.FileInputStream;
import java.io.ObjectInputStream;

/**
 * 反序列化
 * 将文件中的对象读取到内存中
 */
public class demo2 {
    public static void main(String[] args)throws Exception {
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("student"));
        //读取
        Object o =ois.readObject();
        //将对象转回真正的类型
        Student s=(Student)o;
        System.out.println(s.getName());
        System.out.println(s.getAge());

    }
}

八、打印流

PrintStream打印流是输出信息最方便的类，主要包含字节打印流（PrintStream) 和字符打印流（PrintWriter) . 打印流提供了非常方便的打印功能，可以打印任何的数据类型，例如：小数、整数、字符串等等。

示例：

public class Demo {
	public static void main(String[] args) throws IOException {
		PrintWriter out = new PrintWriter("1.txt");
		out.write("你好");
		out.write("\r\n");
		out.write("Hello");
		out.write("\r\n");
		out.write("World");
		out.close();
	}
}

yyy苏苏

发布了75 篇原创文章 · 获赞 164 · 访问量 11万+

私信关注