文章目录
JAVA part14 IO流
IO流
字节缓冲区流
字节缓冲区流分两种:
BufferedOutputStream:字节缓冲输出流
BufferedInputStream:字节缓冲输入流
构造方法:
BufferedOutputStream(OutputStream out)
这种构造方法它提供了一个默认的缓冲区大小,所以我们一般使用默认缓冲区就好
代码:
package Day_14;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class test1 {
public static void main(String[] args) throws IOException {
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt"));
bos.write("hello".getBytes());
bos.close();
}
}
package Day_14;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class test2 {
public static void main(String[] args) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.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();
}
}
转换流
转换流其实就是一个字符流
转换流 = 字节流 + 编码表
OutputStringWriter: 字符输出流
public OutputStringWriter(OutputString out):根据默认编码把字节流的数据转换为字符流
public OutputStreamWriter(OutputStream out, String charsetName):根据指定编码把字节流数据转换为字符流
InputStreamReader:字符输入流
public InputStreamReader(InputStream in):用默认的编码表读数据
public InputStreamReader(InputStream in, String charsetName):用指定的编码读取数据
代码:
{
public static void main(String[] args) throws IOException {
//public OutputStreamWriter(OutputStream out, String charsetName):根据指定编码把字节流数据转换为字符流
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"), "UTF-8");
//调用写数据的方法
osw.write("你好");
//释放资源
osw.close();
System.out.println("----------------------");
//public InputStreamReader(InputStream in, String charsetName):用指定的编码读取数据
InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"), "UTF-8");
//读数据:一次读取一个字符数据
int ch;
while((ch=isr.read()) != -1){
System.out.println((char)ch);
}
//释放资源
isr.close();
}
}
字节流读取数据可能出现的问题:
字节流一次读取一个字节的方式读取带有汉字的文件是有问题的,因为读取到一个字节后就转为字符再控制台输出了,而汉字是由2个字节组成的,所以会出问题
文件赋值的时候,字节流读取一个字节,写入一个字节没有出现问题是因为最终第四层会根据字节做拼接得到汉字
汉字存储的规则:
左边的字节数据肯定是负数,右边的字节数据可能是负数,也可能是整数,大部分情况是负数
编码表
String类中的编码和解码问题
编码:
把看得懂的变成看不懂的
public byte[ ] getBytes(String charsetName) throws UnsupportedEncodingException
使用指定的字符集将此String编码为byte序列,并将结果存储到一个新的byte数组中
解码:
把看不懂的变成看得懂的
public String(byte[ ] bytes, String charsetName)
通过使用指定的charset解码指定的byte数组,构造一个新的String
代码:
package Day_14;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
public class test3 {
public static void main(String[] args) throws UnsupportedEncodingException {
//定义一个字符串
String s = "你好";
//编码
byte[] bys = s.getBytes("UTF-8");//指定UTF-8
System.out.println(Arrays.toString(bys));
//解码
String ss = new String(bys, "UTF-8");//指定UTF-8
System.out.println(ss);
}
}
OutputStreamWriter写数据的方式
OutputStreamWriter写数据有五种方式:
1.public void write(int c):写一个字符
2.public void write(char[ ] cbuf):写一个字符数组
3.public void write(char[ ] cbuf, int off, int len):写一个字符数组的一部分
4.public void write(String str):写一个字符串
5.public void write(String str, int off, int len):写一个字符串的一部分
public void write(int c):写一个字符
package Day_14;
import java.io.*;
public class test5 {
public static void main(String[] args) throws IOException {
//创建字符输出流对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"));
//public void write(int c):写一个字符
osw.write(97);
osw.write('a');
//void flush():刷新该流的缓冲
osw.flush();
//关闭资源
osw.close();
}
}
public void write(char[ ] cbuf):写一个字符数组
package Day_14;
import java.io.*;
public class test5 {
public static void main(String[] args) throws IOException {
//创建字符输出流对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"));
//public void write(char[ ] cbuf):写一个字符数组
char[] chs = {'a', 'b', 'c', 'd', 'e'};
osw.write(chs);
//void flush():刷新该流的缓冲
osw.flush();
//关闭资源
osw.close();
}
}
public void write(char[ ] cbuf, int off, int len):写一个字符数组的一部分
package Day_14;
import java.io.*;
public class test5 {
public static void main(String[] args) throws IOException {
//创建字符输出流对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"));
//public void write(char[ ] cbuf, int off, int len):写一个字符数组的一部分
char[] chs = {'a', 'b', 'c', 'd', 'e'};
osw.write(chs, 1, 3);
//void flush():刷新该流的缓冲
osw.flush();
//关闭资源
osw.close();
}
}
public void write(String str):写一个字符串
package Day_14;
import java.io.*;
public class test5 {
public static void main(String[] args) throws IOException {
//public void write(String str):写一个字符串
osw.write("hello");
//void flush():刷新该流的缓冲
osw.flush();
//关闭资源
osw.close();
}
}
public void write(String str, int off, int len):写一个字符串的一部分
package Day_14;
import java.io.*;
public class test5 {
public static void main(String[] args) throws IOException {
//public void write(String str, int off, int len):写一个字符串的一部分
osw.write("hello", 0, 3);
//void flush():刷新该流的缓冲
osw.flush();
//关闭资源
osw.close();
}
}
InputStramReader 读取数据的方式
InputStramReader 读取数据的方式有两种:
1.public int read():一次读取一个字符
2.public int read(char[ ] cbuf):一次读取一个字符数组
public int read():一次读取一个字符
package Day_14;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class test6 {
public static void main(String[] args) throws IOException {
//创建字符输入流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
//public int read ():一次读取一个字符
int ch;
while((ch=isr.read()) != -1){
System.out.println((char)ch);
}
//释放资源
isr.close();
}
}
public int read(char[ ] cbuf):一次读取一个字符数组
package Day_14;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class test6 {
public static void main(String[] args) throws IOException {
//创建字符输入流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));
//public int read(char[ ] cbuf):一次读取一个字符数组
char[] chs = new char[1024];
int len;
while((len=isr.read(chs)) != -1){
System.out.println(new String(chs, 0, len));
}
//释放资源
isr.close();
}
}
OutputStreamWriter和InputStreamReader简化
转换流的名字比较长,为了简化书写,转换流提供了对应的子类:
FileWriter:用来写入字符文件的便捷类
FileWriter = OutputStreamWriter
FileReader:用来读取字符文件的便捷类
FileReader = InputStreamReader
构造方法:
1.FIleWriter(String fileName)
2.FileReader(String fileName)
字符缓冲区流
BufferedWriter
将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。可以指定缓冲区的大小,或者接收默认的大小。再大多数情况下,默认值就足够大了
构造方法:
BufferedWriter(Writer out)
BufferedReader
从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。可以指定缓冲区的大小,或者可使用默认的大小。大多数情况,默认值就足够大了。
构造方法:
BufferedReader(Reader in)
特殊功能
BufferedWirter:
void newLine():写入一个行分隔符,这个行分隔符是由系统决定的
package Day_14;
import java.io.*;
public class test7 {
public static void main(String[] args) throws IOException {
//创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
//写数据
for(int x=0; x<3; x++){
bw.write("hello");
bw.newLine();
}
//释放资源
bw.close();
}
}
BufferedReader:
String readLine():包含该行内容的字符串,不包含任何终止符,如果已到达流末尾,则返回null
package Day_14;
import java.io.*;
public class test7 {
public static void main(String[] args) throws IOException {
//创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
String line;
while((line=br.readLine()) != null){
System.out.println(line);
}
//释放资源
br.close();
}
}