流
字节缓冲流 BufferedInputStream BufferedOutputStream
字符缓冲流 BufferedReader BufferedWriter
在缓冲区增加一个数组,增加他们的读写效率。
-----------------------------------------------------------------------------------
BufferedOutputStream
java.io.BufferedOutputStream extends OutputStream
字节换从输出流,继承自父类共性的成员方法
构造方法
BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流,以将数据写入指定的底层输出流
BufferedOutputStream(OutputStream out, int size)
创建一个新的缓冲输出流,以将指定缓冲区大小的数据写入指定的底层输出流
参数 OutputStream out 字节输出流
我们可以传递FileOutputStream,缓冲区会给FileOutputStream增加一个缓冲区,提高FileOutputStream
的写入效率
int size,指定缓冲流内部缓冲区的大小,不指定则默认
创建一个FileOutputStream字节输出流,构造方法中绑定要输出的目的地
创建BufferedOutputStream对象,构造方法中传递FileOutputStream对象,提高FileInputStream的效率
使用BufferedOutputStream对象中的方法write,把数据写入到内部换从区中
使用BufferedOutputStream对象中的方法flush,把内部缓冲区的数据刷新到文件中
释放资源
===================
public class BufferDemo {
//字节换从输出流的使用
public static void main(String[] args) throws Exception {
//创建file流,构造方法中绑定要输出的目的地。
FileOutputStream fos = new FileOutputStream("D:\\1907testjava\\day01\\c.txt");
//创建缓冲流,流中传递file流。
BufferedOutputStream bos = new BufferedOutputStream(fos);
bos.write("写入到内部换从区中".getBytes());
bos.flush();
bos.close();
}
}
BufferedInputStream
java.io.BufferedInputStream extends InputStream
字节缓冲输入流
继承自父类的成员方法
构造方法
BufferedInputStream(InputStream in)
创建一个BufferedInputStream并保存其参数,即输入流in,以便将来使用
BufferedInputStream(InputStream in,int size)
创建具有缓冲区大小的BufferedInputStream并保存其参数,即输入流in,以便将来使用
参数 InputStream in 字节输入流
我们可以传递FileInputStream,缓冲流会给FileInputStream增加一个缓冲区提高FileInputStream的读取效率
int size 指定缓冲流内部缓冲区的大小,不指定则默认
使用步骤
创建FileInputStream对象,构造方法中绑定尧都区的数据源
创建BufferedInputStream对象,构造方法中传递FileInputStream对象,提高读取效率
使用BufferedInputStream对象中的方法read,读取文件
释放资源
==================
public class BufferedInput {
public static void main(String[] args) throws Exception {
FileInputStream fis = new FileInputStream("D:\\1907testjava\\day01\\c.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
//读取,一次读一个
// int len = 0;
// while((len = bis.read())!=-1){
// System.out.println(len);
// }
byte[] bytes = new byte[1024];
int len = 0;
while((len = bis.read(bytes))!=-1){
//转换为字符串,展缓有效个数。
System.out.println(new String(bytes,0,len));
}
//只要关闭缓冲流就可以了,一关闭缓冲流,基本的字节流也就关闭了
bis.close();
}
}
======================
BufferedReader
java.io.BufferedReader extends Reader
继承自父类的成员方法
构造方法
BufferedReader(Reader in)
创建一个使用默认大小输入缓冲区的缓冲字符输入流
BufferedReader(Reader in, int sz)
创建一个使用指定默认大小输入缓冲区的缓冲字符输入流
参数:
Reader in
我们可以传递FileReader,缓冲区会给FileReader增加一个缓冲区,提高读取效率
特有的成员方法
readLine() 读取一行数据,如果到达末尾返回null
========================
public class BufferedReaderDemo {
public static void main(String[] args) throws Exception{
BufferedReader br = new BufferedReader(new FileReader("D:\\1907testjava\\day01\\c.txt"));
//只有第一行是
String line = br.readLine();
System.out.println(line);
//第二行,重复的代码,可以使用循环进行优化
line = br.readLine();
System.out.println(line);
/*
* 使用while()循环,读取到null的时候结束
*
*/
String line1;
while((line1 =br.readLine())!=null){
System.out.println(line1);
}
br.close();
}
}
=======================
BufferedWriter
java.io.BufferedWriter extends Writer
BufferedWriter:字符换从输出流
继承自父类的共性成员方法
构造方法
BufferedWriter(Writer out)
创建一个使用默认大小的输出缓冲区的缓冲字符输出流
BufferedWriter(Writer out,int sz)
创建一个使用默认给定大小的输出缓冲区的缓冲字符输出流
参数: Writer out 字符输出流
我么传递FileWriter,缓冲区会给FileWriter增加一个缓冲区,提高写入效率
int sz 指定缓冲区的大小
特有成员方法
void newLine() 写一个行分隔符
====================
public class BufferWriter {
public static void main(String[] args) throws Exception {
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\1907testjava\\day01\\c.txt"));
for (int i = 0; i < 10; i++) {
bw.write("黑马程序员");
//特有的成员方法换行。
bw.newLine();
}
bw.flush();
bw.close();
}
}
=================
文件复制
明确; 数据源
数据的目的地
步骤: 创建一个字节缓冲输入流对象,构造方法中绑定要读取的数据源
创建一个字节缓冲输出流对象,构造方法中绑定要写入的目的地
使用字节缓冲输入流中的方法read读取文件
使用字节缓冲输出流中的方法write,把读取到的字节写入到目的地的文件中
释放资源
===================
public class FileCopy {
public static void main(String[] args) throws Exception {
long s = System.currentTimeMillis();
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\1907testjava\\day01\\c.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\1907testjava\\day02\\c.txt"));
//一次读取一个字节
// int len = 0;
// while((len =bis.read())!=-1){
// bos.write(len);
// }
//使用数组
byte[] bytes = new byte[1024];
int len = 0;
while((len = bis.read(bytes))!=-1){
bos.write(bytes,0,len);
}
bos.close();
bis.close();
long e = System.currentTimeMillis();
System.out.println("耗时"+(e-s));
}
}
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.HashMap;
/*
* 对文本进行排序
* 创建Map集合K存储文本序号,v存储每行的文本
* 创建字符缓冲输入流对象,构造方法中绑定字符输入流
* 创建字符缓冲输出流对象,构造方法中绑定字符输出流
* 使用字符缓冲输入流中的方法readLine逐行读取
* 对读取到的文本进行切割,获取行中的序号和文本内容
* 然后存储到HashMap集合中key序号是有序的,会自动排序
* 遍历集合,获取每一个键值对
* 把每一个键值对拼接为一个文本行
* 把拼接好的文本,使用字符缓冲刘中的方法write,写入到文件中
* 释放资源
*
*/
public class DemoTest {
public static void main(String[] args) throws Exception {
HashMap<String,String> map = new HashMap<>();
BufferedReader br = new BufferedReader(new FileReader("D:\\1907testjava\\day01\\e.txt"));
BufferedWriter bw =new BufferedWriter(new FileWriter("D:\\1907testjava\\day01\\f.txt"));
//逐行读取
String line;
while((line = br.readLine())!=null){
//对文本进行切割
String[] arr = line.split("\\:");
//键和值,0是每行的序号,1是每行的文本
map.put(arr[0], arr[1]);
}
//遍历集合
for (String key : map.keySet()) {
String value = map.get(key);
line =key + ":" + value;
bw.write(line);
//读的时候不会把换行符号读出来,所以需要自己写。
bw.newLine();
}
bw.close();
br.close();
}
}
编码
编码 : 按照某种规则,将字符存储到计算机中,称之为编码 字符 --> 字节
解码 : 将存储在计算机中的二进制按照 某种规则解析显示出来,称为解码 字节–> 字符
字符编码:
一套自然语言的字符与二进制数之间的对应规则
字符集:
也叫编码表,是一个系统支持的所有字符的集合,包括各国家文字,标点符号,图形符号,数字等
ASCII给予拉丁文字,用于显示现代英语
ISO-8859-1用于欧洲语言的显示,单字节编码,兼容ASCII编码
GBxxx字符集
GB2312简体中文码表,兼容ASCII编码
GBK最常用的支持繁体汉字和日韩汉字,两个字节一个中文
GB18030最新的中文码表,支持少数民族的汉字
Unicode字符集,万国码
UTF-8 三个字节一个中文
FileReader可以读取默认UTF-8编码格式的文件
但是读取系统默认编码中文GBK会产生乱码
======================
public class DemoCode {
public static void main(String[] args) throws Exception {
FileReader fr = new FileReader("D:\\1907testjava\\day01\\我是GBK格式文本.txt");
int len = 0;
while((len =fr.read())!=-1){
System.out.println((char)len);
}
fr.close();
}
}