- - - - - - - - - - - - - - -
写在前面
- - - - - - - - - - - - - - -
- 1.概念
- IO流用来处理设备之间的数据传输
- Java对数据的操作是通过流的方式
- Java用于操作流的类都在IO包中
- 流按流向分为两种：输入流，输出流
- 流按操作类型分为两种：
- 字节流 : 字节流可以操作任何数据，因为在计算机中任何数据都是以字节的形式存储的
- 字符流 : 字符流只能操作纯字符数据，比较方便
- 2.IO流常用父类
- 字节流的抽象父类：
InputStreamOutputStream
- 字符流的抽象父类：
ReaderWriter
- 字节流的抽象父类：
- 3.IO程序书写
- 使用前，导入IO包中的类
- 使用时，进行IO异常处理
- 使用后，释放资源
- - - - - - - - - - - - - - -
目 录
- - - - - - - - - - - - - - -
4.实现了缓冲区的BufferedInputStream和BufferOutputStream
25.定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)
38.Properties的load()和store()功能
- - - - - - - - - - - - - - -
read()一次读取一个字节
FileInputStream fis = new FileInputStream("乌合之众.txt");
//创建一个文件输入流对象，并关联乌合之众.txt
int b;
//定义变量，记录每次读到的字节
while((b = fis.read()) != -1) {
//将每次读到的字节赋值给b并判断是否是-1
System.out.println(b);
//打印每一个字节
}
fis.close();
//关闭流释放资源
read()方法返回值为什么是int
read()方法读取的是一个字节，为什么返回是int，而不是byte- 因为字节输入流可以操作任意类型的文件，比如图片音频等，这些都是以二进制形式的存储的，如果每次读取都返回
byte，有可能在读到中间的时候遇到11111111，那么这11111111是byte类型的-1，程序是遇到-1就会停止，后面的数据就读不到了。所以在读取的时候用int类型接收，会在其前面补上24个0凑足4个字节，那么byte类型的-1就变成int类型的255了这样可以保证整个数据读完，而结束标记的-1就是int类型。
定义小数组实现缓冲
-
write(byte[] b) -
write(byte[] b， int off， int len)写出有效的字节个数 -
定义小数组的标准格式
FileInputStream fis = new FileInputStream("李志 - 梵高先生.flac");
FileOutputStream fos = new FileOutputStream("梵高先生.flac");
int len;
byte arr[] = new byte[8*1024];
//自定义字节数组
while((len=fis.read(arr))!=-1){
fos.write(arr， 0， len);
//写出字节数组写出有效个字节个数
}
fis.close();
fos.close();
实现了缓冲区的BufferedInputStream和BufferOutputStream
-
BufferedInputStreamBufferedInputStream内置了一个缓冲区(数组)- 从
BufferedInputStream中读取一个字节时，BufferedInputStream会一次性从文件中读取8192个， 存在缓冲区中， 然后返回给程序一个字符。 - 程序再次读取时， 就不用找文件了， 直接从缓冲区中获取。
- 直到缓冲区中所有的都被使用过， 才重新从文件中读取
8192个
-
BufferedOutputStreamBufferedOutputStream也内置了一个缓冲区(数组)- 程序向流中写出字节时， 不会直接写到文件， 先写到缓冲区中，
- 直到缓冲区写满，
BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。
-
组合流过滤器实现拷贝
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("李志 - 梵高先生.flac"));
//创建缓冲区对FileInputStream对象的装饰
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("2004-梵高先生.flac"));
//创建缓冲区对FileOutputStream对象的装饰
int b;
while((b = bis.read()) != -1) {
bos.write(b);
}
bis.close();//只关装饰后的对象即可
bos.close();
- 小数组的读写和带
Buffered的读取哪个更快?- 定义小数组如果是
8192个字节大小和Buffered比较的话，定义小数组会略胜一筹，因为读和写操作的是同一个数组，而Buffered操作的是两个数组.
- 定义小数组如果是
flush方法和close方法
flush()方法- 用来刷新缓冲区的，刷新后可以再次写出
close()方法- 用来关闭流释放资源的的，如果是带缓冲区的流对象的
close()方法，不但会关闭流，还会再关闭流之前刷新缓冲区，关闭后不能再写出
- 用来关闭流释放资源的的，如果是带缓冲区的流对象的
字节流读写中文
- 字节流读取中文的问题
- 字节流在读中文的时候有可能会读到半个中文，造成乱码
- 字节流写出中文的问题
- 字节流直接操作的字节，所以写出中文必须将字符串转换成字节数组
- 写出回车换行 write(" ".getBytes());
## ~~**流的标准处理异常代码1.6版本及其以前**~~
- try finally嵌套
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("from.txt");
fos = new FileOutputStream("to.txt");
int b;
while((b = fis.read()) != -1) {
fos.write(b);
}
} finally {
try {
if(fis != null)
fis.close();
}finally {
if(fos != null)
fos.close();
}
}
流的标准处理异常代码1.7版本之后
- try close
try(
FileInputStream fis = new FileInputStream("from.txt");
FileOutputStream fos = new FileOutputStream("to.txt");
){
int b;
while((b = fis.read()) != -1) {
fos.write(b);
}
}
- 在try()中创建的流对象必须实现了AutoCloseable这个接口，如果实现了，在try后面的
{. . .}执行后就会自动调用流对象的close方法将流关掉.
拷贝文件
- 在控制台录入文件的路径，将文件拷贝到当前项目下
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个文件路径");
String line = sc.nextLine(); //将键盘录入的文件路径存储在line中
File file = new File(line); //封装成File对象
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(file.getName());
int len;
byte[] arr = new byte[8192]; //定义缓冲区
while((len = fis.read(arr)) != -1) {
fos.write(arr，0，len);
}
fis.close();
fos.close();
## **录入数据拷贝到文件**
- 将键盘录入的数据拷贝到当前项目下的text.txt文件中，键盘录入数据当遇到quit时就退出
Scanner sc = new Scanner(System.in);
FileOutputStream fos = new FileOutputStream("text.txt");
System.out.println("请输入:");
while(true) {
String line = sc.nextLine();
if("quit".equals(line))
break;
fos.write(line.getBytes());
fos.write("
".getBytes());
}
fos.close();
## **字符流 FileReader**
-
字符流是什么
- 字符流是可以直接读写字符的IO流
- 字符流读取
字符， 就要先读取到字节数据， 然后转为字符. 如果要写出字符， 需要把字符转为字节再写出.
-
FileReader
- FileReader类的read()方法可以按照字符大小读取
FileReader fr = new FileReader("from.txt");
//创建输入流对象，关联from.txt
int ch;
while((ch = fr.read()) != -1) {
//将读到的字符赋值给ch
System.out.println((char)ch);
//将读到的字符强转后打印
}
fr.close();
//关流
## **字符流 FileWriter**
- FileWriter类的write()方法可以自动把
字符转为字节写出
FileWriter fw = new FileWriter("to.txt");
fw.write("write");
fw.close();
## **字符流的拷贝**
FileReader fr = new FileReader("from.txt");
FileWriter fw = new FileWriter("to.txt");
int ch;
while((ch = fr.read()) != -1) {
fw.write(ch);
}
fr.close();
fw.close();
什么情况下使用字符流
- 字符流也可以拷贝文本文件， 但不推荐使用。因为读取时会把字节转为字符， 写出时还要把字符转回字节。
- 程序需要读取一段文本， 或者需要写出一段文本的时候可以使用字符流。读取的时候是按照字符的大小读取的，不会出现读取半个中文，造成乱码的情况。写出的时候可以直接将字符串写出，不用转换为字节数组。
字符流是否可以拷贝非纯文本的文件
- 不可以拷贝非纯文本的文件
- 因为在读的时候会将字节转换为字符，在转换过程中，可能找不到对应的字符，就会用
"?"代替，写出的时候会将"?"字符转换成字节写出去。如此这般，写出之后的文件就错乱了。
- 因为在读的时候会将字节转换为字符，在转换过程中，可能找不到对应的字符，就会用
自定义字符数组的拷贝
FileReader fr = new FileReader("form.txt");
//创建字符输入流，关联aaa.txt
FileWriter fw = new FileWriter("to.txt");
//创建字符输出流，关联bbb.txt
int len;
char[] arr = new char[1024*8];
//创建字符数组
while((len = fr.read(arr)) != -1) {
//将数据读到字符数组中
fw.write(arr， 0， len);
//从字符数组将数据写到文件上
}
fr.close();
//关流释放资源
fw.close();
## **带缓冲的字符流**
BufferedReader的read()方法读取字符时会一次读取若干字符到缓冲区， 然后逐个返回给程序， 减少读取次数， 以期提高效率。BufferedWriter的write()方法写出字符时会先写到缓冲区， 缓冲区写满时才会写到文件， 减少写入次数， 以期提高效率。
BufferedReader br = new BufferedReader(new FileReader("form.txt"));
//创建字符输入流对象，关联aaa.txt
BufferedWriter bw = new BufferedWriter(new FileWriter("to.txt"));
//创建字符输出流对象，关联bbb.txt
int ch;
while((ch = br.read()) != -1) {
//read一次，会先将缓冲区读满，从缓冲去中一个一个的返给临时变量ch
bw.write(ch);
//write一次，是将数据装到字符数组，装满后再一起写出去
}
br.close();
//关流
bw.close();
readLine()和newLine()方法
BufferedReader的readLine()方法可以读取一行字符(不包含换行符号)BufferedWriter的newLine()可以输出一个跨平台的换行符号" "
BufferedReader br = new BufferedReader(new FileReader("aaa.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("bbb.txt"));
String line;
while((line = br.readLine()) != null) {
bw.write(line);
//bw.write(""); //只支持windows系统
bw.newLine(); //跨平台的
}
br.close();
bw.close();
LineNumberReader
LineNumberReader是BufferedReader的子类， 具有相同的功能， 并且可以统计行号- 调用
getLineNumber()方法可以获取当前行号 - 调用
setLineNumber()方法可以设置当前行号
- 调用
LineNumberReader lnr = new LineNumberReader(new FileReader("form.txt"));
String line;
lnr.setLineNumber(100); //设置行号
while((line = lnr.readLine()) != null) {
System.out.println(lnr.getLineNumber() + ":" + line);//获取行号
}
lnr.close();
装饰设计模式
interface Coder {
public void code();
}
class Persion implements Coder {
@Override
public void code() {
System.out.println("It's none of my business during the daytime");
System.out.println("Write java at night");
}
}
class XPersion implements Coder {
private Persion s;
//被包装的类的引用
public XPersion (Persion s) {
//构造方法将被包装的对象作为参数传入
this.s = s;
}
@Override
public void code() {
//对其原有功能进行升级
s.code();
System.out.println("Get cervical spondum buff");
System.out.println("......");
System.out.println("sudden death");
System.out.println("......");
}
}
使用指定的码表读写字符
- FileReader是使用默认码表读取文件， 如果需要使用指定码表读取， 那么可以使用
InputStreamReader(字节流，编码表) - FileWriter是使用默认码表写出文件， 如果需要使用指定码表写出， 那么可以使用
OutputStreamWriter(字节流，编码表)
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("UTF-8.txt")， "UTF-8"));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("GBK.txt")， "GBK"));
int ch;
while((ch = br.read()) != -1) {
bw.write(ch);
}
br.close();
bw.close();
序列流
- 1.什么是序列流
- 序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推.
- 2.使用方式
- 整合两个:
SequenceInputStream(InputStream, InputStream)
- 整合两个:
FileInputStream fis1 = new FileInputStream("a.txt");
//创建输入流对象,关联a.txt
FileInputStream fis2 = new FileInputStream("b.txt");
//创建输入流对象,关联b.txt
SequenceInputStream sis = new SequenceInputStream(fis1, fis2);
//将两个流整合成一个流
FileOutputStream fos = new FileOutputStream("c.txt");
//创建输出流对象,关联c.txt
int b;
while((b = sis.read()) != -1) {
//用整合后的输入流
fos.write(b);
//写到指定文件上
}
sis.close();
fos.close();
序列流整合多个
- 整合多个:
SequenceInputStream(Enumeration)
FileInputStream fis1 = new FileInputStream("a.txt");
//创建输入流对象,关联a.txt
FileInputStream fis2 = new FileInputStream("b.txt");
//创建输入流对象,关联b.txt
FileInputStream fis3 = new FileInputStream("c.txt");
//创建输入流对象,关联c.txt
Vector<InputStream> v = new Vector<>();
//创建vector集合对象
v.add(fis1);
//将流对象添加
v.add(fis2);
v.add(fis3);
Enumeration<InputStream> en = v.elements();
//获取枚举引用
SequenceInputStream sis = new SequenceInputStream(en);
//en传递给SequenceInputStream的构造方法
FileOutputStream fos = new FileOutputStream("d.txt");
int b;
while((b = sis.read()) != -1) {
fos.write(b);
}
sis.close();
fos.close();
内存输出流
- 1.什么是内存输出流
- 该输出流可以向内存中写数据, 把内存当作一个缓冲区, 写出之后可以一次性获取所有数据
- 2.使用方式
- 创建对象:
new ByteArrayOutputStream() - 写出数据:
write(int), write(byte[]) - 获取数据:
toByteArray()
- 创建对象:
FileInputStream fis = new FileInputStream("a.txt");
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int b;
while((b = fis.read()) != -1) {
baos.write(b);
}
//byte[] newArr = baos.toByteArray();
//将内存缓冲区中所有的字节存储在newArr中
//System.out.println(new String(newArr));
System.out.println(baos);
fis.close();
定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)
FileInputStream fis = new FileInputStream("a.txt");
//创建字节输入流,关联a.txt
ByteArrayOutputStream baos = new ByteArrayOutputStream();
//创建内存输出流
byte[] arr = new byte[5];
//创建字节数组,大小为5
int len;
while((len = fis.read(arr)) != -1) {
//将文件上的数据读到字节数组中
baos.write(arr, 0, len);
//将字节数组的数据写到内存缓冲区中
}
System.out.println(baos);
//将内存缓冲区的内容转换为字符串打印
fis.close();
对象操作流ObjecOutputStream
- 1.什么是对象操作流
- 该流可以将一个对象写出, 或者读取一个对象到程序中. 也就是序列化和反序列化的操作.
- 2.使用方式
- 写出:
new ObjectOutputStream(OutputStream)，writeObject()
- 写出:
public class ObjectOutputStream {
/**
* @param args
* @throws IOException
* 将对象写出,序列化
*/
public static void main(String[] args) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));//创建对象输出流
oos.writeObject(p1);
oos.writeObject(p2);
oos.close();
}
}
对象操作流ObjectInputStream
- 读取:
new ObjectInputStream(InputStream),readObject()
public class ObjectInputStream {
/**
* @param args
* @throws IOException
* @throws ClassNotFoundException
* @throws FileNotFoundException
* 读取对象,反序列化
*/
public static void main(String[] args) throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e.txt"));
Person p1 = (Person) ois.readObject();
Person p2 = (Person) ois.readObject();
System.out.println(p1);
System.out.println(p2);
ois.close();
}
}
对象操作流优化
- 将对象存储在集合中写出
Person p1 = new Person("Tom", 20);
Person p2 = new Person("Jerry", 22);
Person p3 = new Person("Jack", 10);
Person p4 = new Person("Herry", 20);
ArrayList<Person> list = new ArrayList<>();
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("f.txt"));
oos.writeObject(list);
//写出集合对象
oos.close();
- 读取到的是一个集合对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("f.txt"));
ArrayList<Person> list = (ArrayList<Person>)ois.readObject();
//泛型在运行期会被擦除,索引运行期相当于没有泛型
//想去掉黄色可以加注解@SuppressWarnings("unchecked")
for (Person person : list) {
System.out.println(person);
}
ois.close();
id号
- 要写出的对象必须实现Serializable接口才能被序列化
- 不用必须加id号
打印流的概述和特点
- 1.什么是打印流
- 该流可以很方便的将对象的
toString()结果输出, 并且自动加上换行, 而且可以使用自动刷出的模式 System.out就是一个PrintStream, 其默认向控制台输出信息
- 该流可以很方便的将对象的
PrintStream ps = System.out;
ps.println(97);
//底层用的是Integer.toString(x),将x转换为数字字符串打印
ps.println("a string");
ps.println(new Person("Tom", 20));
Person p = null;
ps.println(p); //如果是null,就返回null,如果不是null,就调用对象的toString()
- 2.使用方式
- 打印:
print(),println() - 自动刷出:
PrintWriter(OutputStream out, boolean autoFlush, String encoding)
- 打印:
PrintWriter pw = new PrintWriter(new FileOutputStream("g.txt"), true);
//如果为 true，则 println、printf 或 format 方法将刷新输出缓冲区
pw.write(97);
pw.print("Hello");
pw.println("你好");
pw.close();
标准输入输出流概述和输出语句
- 1.什么是标准输入输出流
System.in是InputStream, 标准输入流, 默认可以从键盘输入读取字节数据System.out是PrintStream, 标准输出流, 默认可以向Console中输出字符和字节数据
- 2.修改标准输入输出流
- 修改输入流:
System.setIn(InputStream) - 修改输出流:
System.setOut(PrintStream)
- 修改输入流:
System.setIn(new FileInputStream("a.txt"));
//修改标准输入流
System.setOut(new PrintStream("b.txt"));
//修改标准输出流
InputStream in = System.in;
//获取标准输入流
PrintStream ps = System.out;
//获取标准输出流
int b;
while((b = in.read()) != -1) {
//从a.txt上读取字节
ps.write(b);
//将数据写到b.txt上
}
in.close();
ps.close();
修改标准输入输出流拷贝图片
System.setIn(new FileInputStream("png.png"));
//改变标准输入流
System.setOut(new PrintStream("copy.png"));
//改变标准输出流
InputStream is = System.in;
//获取标准输入流
PrintStream ps = System.out;
//获取标准输出流
int len;
byte[] arr = new byte[1024 * 8];
while((len = is.read(arr)) != -1) {
ps.write(arr, 0, len);
}
is.close();
ps.close();
两种方式实现键盘录入
- A:
BufferedReader的readLine方法。BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
- B:
Scanner
随机访问流概述和读写数据
-
A:随机访问流概述
RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。- 支持对随机访问文件的读取和写入。
-
B:
read(),write(),seek()
数据输入输出流
- 1.什么是数据输入输出流
DataInputStream,DataOutputStream可以按照基本数据类型大小读写数据- 例如按Long大小写出一个数字, 写出时该数据占8字节. 读取的时候也可以按照Long类型读取, 一次读取8个字节.
- 2.使用方式
DataOutputStream(OutputStream),writeInt(),writeLong()DataInputStream(InputStream),readInt(),readLong()
DataOutputStream dos = new DataOutputStream(new FileOutputStream("b.txt"));
dos.writeInt(998);
dos.writeInt(1998);
dos.writeInt(2998);
dos.close();
DataInputStream dis = new DataInputStream(new FileInputStream("b.txt"));
int x = dis.readInt();
int y = dis.readInt();
int z = dis.readInt();
System.out.println(x);
System.out.println(y);
System.out.println(z);
dis.close();
Properties的概述和作为Map集合的使用
- A:Properties的概述
- Properties 类表示了一个持久的属性集。
- Properties 可保存在流中或从流中加载。
- 属性列表中每个键及其对应值都是一个字符串。
Properties prop = new Properties();
prop.put("abc", 123);
System.out.println(prop);
获取Properties中的每一个键
- A:Properties的特殊功能
public Object setProperty(String key,String value)public String getProperty(String key)public Enumeration<String> stringPropertyNames()
Properties prop = new Properties();
prop.setProperty("name", "Tom");
prop.setProperty("tel", "18000000000");
//System.out.println(prop);
Enumeration<String> en = (Enumeration<String>) prop.propertyNames();
while(en.hasMoreElements()) {
String key = en.nextElement(); //获取Properties中的每一个键
String value = prop.getProperty(key); //根据键获取值
System.out.println(key + "="+ value);
}
Properties的load()和store()功能
Properties prop = new Properties();
prop.load(new FileInputStream("config.properties"));
//将文件上的键值对读取到集合中
prop.setProperty("tel", "18912345678");
prop.store(new FileOutputStream("config.properties"), null);
//第二个参数是对列表参数的描述,可以给值,也可以给null
System.out.println(prop);
Output:
{tel=18912345678}
ZIP文档
private static void zipdemo1() throws IOException {
try (
ZipInputStream zin = new ZipInputStream(new FileInputStream("code.zip"));
ByteArrayOutputStream baos = new ByteArrayOutputStream();//内存输入流
) {
ZipEntry entry;
int len;
byte arr[] = new byte[1024];
while ((entry = zin.getNextEntry()) != null) {
String name = entry.getName();//压缩项目的文件名
System.out.println("文件"+name+"
解压后大小："+entry.getSize());
while ((len = zin.read(arr)) != -1) {//读取数据内容
baos.write(arr, 0, len);//内容写入内存输入流
}
System.out.println("缓冲区大小："+baos.size());
System.out.println(baos);
baos.reset();//将此 byte 数组输出流的 count 字段重置为零，从而丢弃输出流中目前已累积的所有输出
zin.closeEntry();
}
}
}
Output:
文件code.txt
解压后大小：29
缓冲区大小：29
AW9C2-JN9T2-H5CBV-24QT7-G4YB8
文件code1.txt
解压后大小：39
缓冲区大小：39
激活码：W9WW6-JN9W2-M8CTX-24QR7-M4HB8
——@guoyangde http://www.cnblogs.com/LittleTreasureBox/p/8904016.html