目录

​编辑

IO流

File0utputstream 

FileOutputstream写数据的3种方式

void write(int b)     一次写一个字节数据

void write(byte[] b)     一次写一个字节数组数据

void write(byte[] b,int off,int len)   一次写一个字节数组的部分数据 

FileOutputstream写数据的两个小问题

该如何换行呢？

FilelnputStream

文件拷贝

编码与解码

编码 

解码 

---

 IO流

Java中的IO流是用于输入和输出数据的工具。Java的IO流分为字节流和字符流两种类型。

字节流可以操作所有类型的文件   

字符流可以操作纯文本文件（纯文本文件就是windows自带的笔记本打开能读懂的）

字节流：

• InputStream和OutputStream：用于读取和写入二进制数据（字节）。
• FileInputStream和FileOutputStream：用于读取和写入文件的字节流。
• ByteArrayInputStream和ByteArrayOutputStream：用于读写字节数组的字节流。
• BufferedInputStream和BufferedOutputStream：用于提供带缓冲的字节流，提高IO性能。

字符流：

• Reader和Writer：用于读取和写入字符数据。
• FileReader和FileWriter：用于读取和写入文件的字符流。
• CharArrayReader和CharArrayWriter：用于读写字符数组的字符流。
• BufferedReader和BufferedWriter：用于提供带缓冲的字符流。

File0utputstream 

字节输出流，可以把程序中的数据写到本地文件上，是字节流的基本流 

写出一段文字到本地文件中。👇

package io;


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

public class ioDemo1 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos=new FileOutputStream("..\\Myio\\a.txt");
        fos.write(97);
        fos.close();
    }
}

如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的。 

 

如果文件已经存在，则会清空文件👇 

运行之后👇 

字节输出流:

1.创建字节输出流对象

• 参数是字符串表示的路径或者是File对象都是可以的
• 如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的。
• 如果文件已经存在，则会清空文件

2.写数据

write方法的参数是整数，但是实际上写到本地文件中的是整数在ASCII上对应的字符

每次使用完流之后都要释放资源

FileOutputstream写数据的3种方式

void write(int b)     一次写一个字节数据
void write(byte[] b)     一次写一个字节数组数据
void write(byte[] b,int off,int len)   一次写一个字节数组的部分数据 

void write(int b)     一次写一个字节数据

void write(byte[] b)     一次写一个字节数组数据

package io;


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

public class ioDemo1 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos=new FileOutputStream("..\\Myio\\a.txt");
        byte[] bytes={97,98,99};
        fos.write(bytes);
        fos.close();
    }
}

 

void write(byte[] b,int off,int len)   一次写一个字节数组的部分数据 

 参数一：数组，参数二：起始索引，参数三：个数

package io;


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

public class ioDemo1 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos=new FileOutputStream("..\\Myio\\a.txt");
        byte[] bytes={97,98,99};
        fos.write(bytes,1,2);
        fos.close();
    }
}

FileOutputstream写数据的两个小问题

该如何换行呢？

package io;

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

public class ioDemo2 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("..\\Myio\\a.txt");
        //写出数据
        String str = "niihao";
        byte[] bytes1 = str.getBytes();
        fos.write(bytes1);
        String str2="\n";
        byte[] bytes2 = str2.getBytes();
        fos.write(bytes2);
        String str3="csdn";
        byte[] bytes3 = str3.getBytes();
        fos.write(bytes3);
        //释放资源
        fos.close();
    }
}

这里的\n为换行 

 

那又该如何续写？再次运行不会清空上次的数据呢？

package io;

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

public class ioDemo2 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("..\\Myio\\a.txt",true);
        //写出数据
        String str = "niihao";
        byte[] bytes1 = str.getBytes();
        fos.write(bytes1);
        String str2="\n";
        byte[] bytes2 = str2.getBytes();
        fos.write(bytes2);
        String str3="csdn";
        byte[] bytes3 = str3.getBytes();
        fos.write(bytes3);
        //释放资源
        fos.close();
    }
}

 

如果想要续写。打开续写开关即可开关位置:创建对象的第二个参数

默认false:表示关闭续写，此时创建对象会消空文件手动传递true:表示打开续写，此时创建对象不

会清空文件

FilelnputStream

操作本地文件的字节输入流，可以把本地文件中的数据读取到程序中来 

1、创建字节输入流对象

如果文件不存在，就直按报错。

2.写数据

一次读一个字节，读出来的是数据在ASCII上对应的数字

读到文件末尾了，read方法返回-1。

3.释放资源
细节:每次使用完流之后都要释放资源

 

package inputio;

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

public class inputDemo1 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis=new FileInputStream("..\\Myio\\b.txt");
        //读取数据
        int r1 = fis.read();
        System.out.println(r1);
        int r2 = fis.read();
        System.out.println(r2);
        int r3 = fis.read();
        System.out.println(r3);

        int r4 = fis.read();
        System.out.println(r4);
        //释放资源
        fis.close();
    }
}

 

可以看到最后一次读到文件末尾了，read方法返回-1。

字节输入流的循环读取👇

package inputio;

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

public class inputDemo2 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis=new FileInputStream("..\\Myio\\b.txt");
        int b=0;
        //循环读取
        while((b=fis.read())!=-1){
            System.out.println((char)b);
        }
        //释放资源
        fis.close();
    }

}

一次读取多个字节数据，具体读多少，跟数组的长度有关

返回值:本次读取到了多少个字节数据

package inputio;

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

public class inputDemo3 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("..\\Myio\\a.txt");
        byte[] bytes=new byte[2];
        int len1 = fis.read(bytes);
        String str1=new String(bytes);
        System.out.println(str1);
        System.out.println(len1);
        System.out.println("----------------------");
        int len2 = fis.read(bytes);
        String str2=new String(bytes);
        System.out.println(str2);
        System.out.println(len2);
        System.out.println("----------------------");
        int len3 = fis.read(bytes);
        String str3=new String(bytes);
        System.out.println(str3);
        System.out.println(len3);
        System.out.println("----------------------");
        int len4 = fis.read(bytes);
        String str4=new String(bytes);
        System.out.println(str4);
        System.out.println(len4);
        fis.close();
    }
}

 

第3次读取到的数据为什么是ed呢？

这是第一次读取到的👇len为2

这是第二次读取到的👇len为2

a跟b都被覆盖了

这是第三次读取👇len为1

可以发现c被覆盖了，d没有被覆盖，这是因为只读取到了一个数据

还可以给这个代码优化一下

package inputio;

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

public class inputDemo3 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("..\\Myio\\a.txt");
        byte[] bytes=new byte[2];
        int len1 = fis.read(bytes);
        String str1=new String(bytes,0,len1);
        System.out.println(str1);
        System.out.println(len1);
        System.out.println("----------------------");
        int len2 = fis.read(bytes);
        String str2=new String(bytes,0,len2);
        System.out.println(str2);
        System.out.println(len2);
        System.out.println("----------------------");
        int len3 = fis.read(bytes);
        String str3=new String(bytes,0,len3);
        System.out.println(str3);
        System.out.println(len3);
       
        fis.close();
    }
}

 

文件拷贝

将abc拷贝进a.txt中

package inputio;

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

public class IODemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("D:\\b.txt");
        FileOutputStream fos=new FileOutputStream("..\\Myio\\a.txt");
        int b=0;
        while((b=fis.read())!=-1){
            fos.write(b);
        }
        fos.close();
        fis.close();
    }
}

 

但是这样写对于文件过大的情况，运行的会非常的慢

下面我们来优化一下

package inputio;

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

public class IODemo2 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("D:\\b.txt");
        FileOutputStream fos=new FileOutputStream("..\\Myio\\a.txt");
        //这里的大小设置为1024的整数倍就好了
        byte[] bytes=new byte[1024];
        int len=0;
        while ((len=fis.read(bytes))!=-1){
            fos.write(bytes,0,len);
        }
        fos.close();
        fis.close();
    }
}

编码与解码

我们先了解一下这个👇

GBK字符集完全兼容ASCII字符集

一个英文占一个字节，二进制第一位是0

一个中文占两个字节，二进制高位字节的第一位是1

以下为GBK字符集中编码之后的二进制，请说出有几个中文，几个英文

Unicode字符集的UTF-8编码格式

一个英文占一个字节，二进制第一位是0，转成十进制是正数

一个中文占三个字节，二进制第一位是1，第一个字节转成十进制是负数

Java中编码的方法

• public byte[] getBytes()                使用默认方式进行编码
• public byte[]getBytes(string charsetName)                        使用指定方式进行编码

Java中解码的方法

• string(byte[] bytes)        使用默认方式进行解码
• string(byte[] bytes,string charsetName)                使用指定方式进行解码 

编码 

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class ioDemo1 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String str="ai你呀";
        byte[] bytes1 = str.getBytes();
        System.out.println(Arrays.toString(bytes1));

        byte[] bytes2 = str.getBytes("GBK");
        System.out.println(Arrays.toString(bytes2));
    }
}

Java默认的是UTF-8

解码 

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class ioDemo1 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //编码
        String str="ai你呀";
        byte[] bytes1 = str.getBytes();
        System.out.println(Arrays.toString(bytes1));
        //解码
        String s1 = new String(bytes1);
        System.out.println(s1);

        String s2 = new String(bytes1, "GBK");
        System.out.println(s2);
    }
}

 

UTF-8一个英文占一个字节，一个中文占三个字节

 

GBK字符集一个英文占一个字节一个中文占两个字节

 

---

IO流的字节流就先说到这啦！！！感谢各位观看

字节流在这👇

 想先占个位😀