Java中的IO流（一）：
https://blog.csdn.net/Veer_c/article/details/103833045
Java中的IO流（二）：
https://blog.csdn.net/Veer_c/article/details/103833423
Java中的IO流（三）：
https://blog.csdn.net/Veer_c/article/details/103833811

LineNumberReader：
public int getLineNumber():获取行号
public void setLineNumber(int lineNumber):设置起始行号
String readLine()：读取一行
注意：如果你没有设置行号的，默认从0开始，如果设置行号后，则从设置的行号开始算起。
案例：读取文件，每次读取一行打印并且加上行号

package com.edu_01;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;
public class LineNumberReaderDemo {public static void main(String[] args) throws IOException {//创建LineNumberReader对象//public LineNumberReader(Reader in)LineNumberReader lnr = new LineNumberReader(new FileReader("a.txt"));//默认起始行号从0开始//一次读取一行String line;while ((line = lnr.readLine())!=null) {//打印每一行的行号和内容System.out.println(lnr.getLineNumber()+":"+line);}//关流lnr.close();}
}

操作基本数据类型的流
可以操作基本类型的流对象。
DataInputStream:读数据
DataOutputStream:写数据
注意：读写顺序必须一致，即当你向文件中写入数据的时候，写的什么数据类型，读的时候就必须用什么数据类型去读，不然会出现错误。
案例：给流中写基本类型的数据，并且读取。

public class DataOutputStreamDemo {public static void main(String[] args) throws IOException {//写数据//write();read();}private static void read() throws IOException {//DataInputStream:读数据//创建对象：public DataInputStream(InputStream in)DataInputStream dis = new DataInputStream(new FileInputStream("dos.txt"));//读数据了,按什么顺序写入就必须按照什么顺序读出来System.out.println(dis.readByte());System.out.println(dis.readShort());System.out.println(dis.readInt());System.out.println(dis.readLong());System.out.println(dis.readChar());System.out.println(dis.readFloat());System.out.println(dis.readDouble());System.out.println(dis.readBoolean());//关流dis.close();}private static void write() throws IOException {//public DataOutputStream(OutputStream out)DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt"));//给流关联的文件中写入基本类型的数据dos.writeByte(20);dos.writeShort(200);dos.writeInt(2000);dos.writeLong(20000L);dos.writeChar(97);dos.writeFloat(12.34F);dos.writeDouble(23.34);dos.writeBoolean(true);//关流dos.close();}
}

内存操作流：解决临时数据存储的问题。
操作字节数组(演示着一个案例即可)
ByteArrayInputStream
ByteArrayOutputStream
byte[] toByteArray() 将之前写入内存的流转换成字节数组
注意：在写入文件的时候，是直接将文件写入内存中，写的时候可以用不同的方式，在读取的时候，必须将写入文件的数据封装成相应的数组，这样才能读取出来的。
操作字符数组
CharArrayReader
CharArrayWrite
操作字符串
StringReader
StringWriter
操作字节数组
ByteArrayInputStream
ByteArrayOutputStream
将数据写到流中保存在内存，并且读取

package com.edu_03;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
public class ByteArrayOutputStreamDemo {public static void main(String[] args) throws IOException {//给内存中写数据public ByteArrayOutputStream()ByteArrayOutputStream baos = new ByteArrayOutputStream();//给内存中调用方法写数据baos.write("hello".getBytes());//将写入内存中的数据读取出来byte[] buf = baos.toByteArray();//调用这个方法，将之前写入内存中的数据存储到字节数组中ByteArrayInputStream bais = new ByteArrayInputStream(buf);//将刚才存储到字节数组中的内容关联上bais//只有这样之后，我们才可以直接从bais中读取我们想要的内容//一次读取一个字节int by;while ((by=bais.read())!=-1) {System.out.print((char)by);}//关流bais.close();baos.close();}
}

打印流：
字节打印流 PrintStream
字符打印流 PrintWriter
特点：
A:只能操作目的地，不能操作数据源
B:可以操作任意类型的数据
C:如果启动了自动刷新，能够自动刷新
D:可以操作文件的流
注意：可以直接操作的流：看流对象的API,如果其构造方法同时有File和String类型的参数，就可以直接操作文件。
案例1：利用字符打印流给文件中书写数据（String类型），需要手动刷新。

package com.edu_04;
import java.io.IOException;
import java.io.PrintWriter;
public class PrintWriterDemo {public static void main(String[] args) throws IOException {//使用打印流给文件中写入hello,java,world//public PrintWriter(String fileName)PrintWriter pw = new PrintWriter("pw.txt");//给流关联的文件中写数据pw.write("hello");pw.write("java");pw.write("world");//刷新pw.flush();//3.关流pw.close();}
}

此时，我们没有开启自动刷新功能。
如何启动自动刷新：利用构造
PrintWriter(OutputStream out, boolean autoFlush)
PrintWriter(Writer out, boolean autoFlush)
boolean autoFlush :需要传递一个Boolean类型的参数，当传递进来的参数为True时，表示自动刷新已经开始。
如果启用了自动刷新，则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作。
println():如果启动了自动刷新，能够实现刷新，而且还实现了自动换行。
案例2：利用字符流给文件中写数据（int类型，boolean类型），启动自动刷新。

package com.edu_04;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class PrintWriterDemo2 {public static void main(String[] args) throws IOException {//创建字符打印流对象，并开启自动刷新//public PrintWriter(Writer out,boolean autoFlush)PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);//给流中写数据//pw.write("hello");//pw.write("java");//注意：如果已经开启了自动刷新功能，必须调用则 println、printf 或 format的时候，才可以实现自动刷新pw.println("hello");pw.println("java");pw.println("world");//调用println这个方法给文件中写数据，1.写数据  2.换行  3.刷新//可以操作任意类型的数据pw.println(true);pw.println(12.34);//关流pw.close();}
}

强调：实现自动刷新必须要俩个条件：
1，必须利用
PrintWriter(OutputStream out, boolean autoFlush)
PrintWriter(Writer out, boolean autoFlush) 的构造方法
2.必须在调用 println、printf 或 format 的其中一个方法时才可以开启自动刷新
当调用上面三个其中一个方法时，他会完成的操作是：
1.写入代码 2.换行 3 .自动刷新

标准输入输出流
System类下有这样的两个成员变量：
标准输入流：public static final InputStream in
标准输出流：public static final PrintStream out
案例1：利用标注输入流进行键盘录入，录入后读取流并打印在控制台

package com.edu_05;
import java.io.IOException;
import java.io.InputStream;
public class SystemIn {public static void main(String[] args) throws IOException {// public static final InputStream in  //将键盘录入的数据封装在了输入流中//Scanner sc = new Scanner(System.in);InputStream is = System.in;//将键盘录入的数据从输入流中读取出来int by;while ((by=is.read())!=-1) {System.out.print((char)by);}//关流is.close();}
}

案例2：用IO流实现键盘录入，一次读取一行数据。
分析：由于是每次读取一行，所以我们可以BuffferedReader()
InputStream is = System.in;
此时读取的是字节流，而BufferedReader()需要的是字符流，所以传递进来的参数必须是字符流，因此我们需要将字节流转换成字符流 InputStreamReader()

package com.edu_05;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class SystemIn2 {public static void main(String[] args) throws IOException {/* 案例2：用IO流实现键盘录入，一次读取一行数据* InputStream is = System.in;* InputSreamReader isr = new InputStreamReader(is)* BufferedReader br = new BufferedReader(isr);   *///将上面的分析写为一部BufferedReader br = new BufferedReader(new InputStreamReader(System.in));//一次读取一行数据System.out.println("请输入你的姓名");String name = br.readLine();System.out.println("请输入你的年龄");String age = br.readLine();System.out.println(name+":"+age);}
}

案例：解析输出语句System.out.println(“helloworld”);

package com.edu_05;
import java.io.PrintStream;
/*  标准输出流：*  public static final PrintStream out   */
public class SystemOut {public static void main(String[] args) {//      PrintStream ps = System.out;
//      ps.println(true);//上面两行合并为一行,底层调用的字节打印流中的方法System.out.println(true);}
}

注意：这句语句的本质是System中有一个out的静态字段，所以我们可以通过System调用out字段，返回一个标准的输出类，然后再调用println（）方法，打印数据

合并流：SequenceInputStream类可以将多个输入流串流在一起，合并为一个输入流，因此，该流也被称为合并流。
构造：
SequenceInputStream(InputStream s1, InputStream s2) ：将s1和s2合并成一个输入流，先读取s1后读取s2
案例1：
我要把DataStreamDemo.java和ByteArrayStreamDemo.java写到一个文件Copy.java
数据源：
DataStreamDemo.java
ByteArrayStreamDemo.java
目的地：
Copy.java
package com.edu_06;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
public class SequenceInputStreamDemo {public static void main(String[] args) throws IOException {//创建合并流对象//SequenceInputStream(InputStream s1, InputStream s2) ：将s1和s2合并成一个输入流，先读取s1后读取s2//将两个数据源合而为一SequenceInputStream sis = new SequenceInputStream(new FileInputStream("PrintWriterDemo.java"), new FileInputStream("SystemIn2.java"));//封装目的地FileOutputStream fos = new FileOutputStream("copy2.java");//一下读写一个字节数组byte[] buf = new byte[1024];int len;while ((len=sis.read(buf))!=-1) {//读多少写多少fos.write(buf, 0, len);}//关流fos.close();sis.close();}
}

对象的序列化和反序列化
序列化流：把对象按照流一样的方式写到文件或者在网络中传输。
反序列化流：把文件或者网络中的流对象数据还原对象。
ObjectOutputStream：序列化流
writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。
ObjectInputStream：反序列化流
Object readObject() 从 ObjectInputStream 读取对象。

//1.先创建出一个学生类
package com.edu_07;
import java.io.Serializable;
public class Studnet implements Serializable{//实现这个接口不需要实现任何方法，这个接口说白了就是仅仅给Student类，打上了一个可以被序列化的标示private String name;private int 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;}public Studnet(String name, int age) {super();this.name = name;this.age = age;}public Studnet() {super();// TODO Auto-generated constructor stub}@Overridepublic String toString() {return "Studnet [name=" + name + ", age=" + age + "]";}
}
//2. 利用序列化流将对象写入文本中
package com.edu_07;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class ObjectOutputStreamDemo {public static void main(String[] args) throws IOException {//创建序列化流对象//public ObjectOutputStream(OutputStream out)ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));//创建一个学生对象，将学生对象写入文件中Studnet s = new Studnet("刘德华", 50);oos.writeObject(s);// java.io.NotSerializableException//类通过实现 java.io.Serializable 接口以启用其序列化功能//关流oos.close();}
}
//3.利用反序列化流将存储到文件的对象读取出来
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class ObjectInputStreamDemo {public static void main(String[] args) throws Exception {//创建反序列化流对象ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));//读取文件中存储的对象，以实现反序列化//readObject()Object object = ois.readObject();System.out.println(object);//关流ois.close();}
}

注意：如果一个类不是实现Serializable接口无法把实例化，会抛出异常java.io.NotSerializableException类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化，所以我们可以通过让对象的所属类来实现序列化接口。

Properties
Properties:Properties 类表示了一个持久的属性集,属性列表中每个键及其对应值都是一个字符串。
特点：Properties 可保存在流中或从流中加载。
案例：使用map集合的put方法给集合中存储数据并且遍历

package com.edu_08;
import java.util.Properties;
import java.util.Set;
public class ProppertiesDemo {public static void main(String[] args) {//创建Properties对象，本质上上是一个map几个，但是键值都是String类型Properties prop = new Properties();//给对象中存储元素prop.put("zhangjie", "xiena");prop.put("huangxiaoming", "baby");prop.put("wanglaoshi", "zhangziyi");//map集合遍历//获取键的集合Set<Object> keys = prop.keySet();for (Object key : keys) {System.out.println(key+":"+prop.get(key));}}
}

Properties的特有功能：
添加元素
public Object setProperty(String key,String value)
获取元素
public String getProperty(String key)
public Set stringPropertyNames()
案例：使用它的特有功能添加元素并遍历

package com.edu_08;
import java.util.Properties;
import java.util.Set;
public class PropertiesDemo2 {public static void main(String[] args) {//创建Properties这个集合Properties prop = new Properties();//调用public Object setProperty(String key,String value)prop.setProperty("huangxiaoming", "baby");prop.setProperty("dengchao", "sunli");prop.setProperty("libai", "wanglun");//1.获取所有键的集合//public Set<String> stringPropertyNames()Set<String> keys = prop.stringPropertyNames();//遍历键，根据键找值for (String key : keys) {System.out.println(key+":"+prop.getProperty(key));}}
}

可以和IO流进行结合使用：
把文件中的数据加载到集合中。注意：文件中的数据必须是键值对象形式的（例如：String1=String2)
public void load(InputStream inStream)
public void load(Reader reader)
案例：创建一个键值对文件，将文件中的键值对加载到集合中，输出集合

package com.edu_08;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
public class PropertiesDemo3 {public static void main(String[] args) throws IOException {//创建集合Properties prop = new Properties();//将文件中的键值对，加载到集合中prop.load(new FileReader("prop.txt"));//遍历集合Set<String> keys = prop.stringPropertyNames();for (String key : keys) {System.out.println(key+":"+prop.getProperty(key));}}
}

把集合中的数据存储到文本文件中，并且是按照键值对形式存储的。
public void store(OutputStream out,String comments)
public void store(Writer writer,String comments)
案例：将创建的键值对集合加载到文件中

package com.edu_08;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
public class PropertiesDemo4 {public static void main(String[] args) throws IOException {//创建集合Properties prop = new Properties();//给集合中存储数据prop.setProperty("liudehua", "50");prop.setProperty("liming", "60");prop.setProperty("zhangxueyou", "40");//将集合中的元素，存储到文本文件中prop.store(new FileWriter("prop2.txt"), "name=age");}
}

案例：我有一个文本文件，我知道数据是键值对形式的，但是不知道内容是什么。请写一个程序判断是否有“lisi”这样的键存在，如果有就改变其值为”100”。
分析：
1.我们可以先将文本加载到集合中，然后获取所有的键的集合
2.在判断集合中是否有这样的键，如果有的话，重新给集合中添加这样的键值对，
3.最后将修改后的集合，写入到文本中

package com.edu_09;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
public class PropTest {public static void main(String[] args) throws IOException {/*           zhangsan=3lisi=4wangwu=51.创建集合对象2.将文件中的键值对加载到集合中3.获取多有的键的集合，遍历，判断4.如果存在lisi，的话，给集合中重新存储键值对lisi=1005.将集合中的数据存储到文件中   *///1.创建集合对象Properties prop = new Properties();// 2.将文件中的键值对加载到集合中prop.load(new FileReader("prop3.txt"));//3.获取多有的键的集合，遍历，判断Set<String> keys = prop.stringPropertyNames();// 4.如果存在lisi，的话，给集合中重新存储键值对lisi=100for (String key : keys) {if ("lisi".equals(key)) {prop.setProperty(key, "100");}}//5.将集合中的数据存储到文件中prop.store(new FileWriter("prop3.txt"), null);}

案例：我有一个猜数字小游戏的程序，请写一个程序实现在测试类中只能用分超过5次提示：游戏试玩已结束，请付费。
分析：
1.先创建一个运行游戏的类，注意一定是静态的，因为只有静态才能调用静态。
2.创建一个文本，里面存入count=1,然后将文本加载到集合中。
3.然后将取出的文本，获取count对应的次数。
4. 判断，如果次数大于0，就开始执行游戏，每运行一次后，次数加一，然后添加到集合中。
5，将集合中数据，加载到文本中。

  // 1.创建以游戏类，
package com.edu_01;
import java.util.Scanner;
public class GuessNumber {public static void startGame(){int ran = (int) (Math.random()*100+1);Scanner sc = new Scanner(System.in);while (true) {System.out.println("请输入你猜测得数字");int number = sc.nextInt();if (number>ran) {System.out.println("大了");}else if (number<ran) {System.out.println("小了");}else if (number==ran) {System.out.println("猜对了");break;}}}
}
// 2.创建测试类package com.edu_01;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
public class PropTest {public static void main(String[] args) throws IOException {//1.将文件中的键值对加载到集合中Properties prop = new Properties();prop.load(new FileReader("count.txt"));//2.拿出已经玩耍的次数做判断String count = prop.getProperty("count");//将String类型转换为int类型int number = Integer.parseInt(count);if (number>4) {System.out.println("次数已到，请付费");}else {//开启游戏GuessNumber.startGame();number++;//将自增的次数重新存储到文件中prop.setProperty("count", number+"");//将新的prop集合存储到文件中prop.store(new FileWriter("count.txt"), null);}}
}

路阻且长之Java学习：

API中的重要类（一）：
https://blog.csdn.net/Veer_c/article/details/103803248
API中的重要类（二）：
https://blog.csdn.net/Veer_c/article/details/103807515
API中的重要类（三）：
https://blog.csdn.net/Veer_c/article/details/103808054

Java多线程（一）：
https://blog.csdn.net/Veer_c/article/details/103842078
Java多线程（二）：
https://blog.csdn.net/Veer_c/article/details/103842263
Java多线程（三）：
https://blog.csdn.net/Veer_c/article/details/103842317
Java多线程（四）：
https://blog.csdn.net/Veer_c/article/details/103842602

网络编程上（UDP）：
https://blog.csdn.net/Veer_c/article/details/103843591
网络编程下（TCP）：
https://blog.csdn.net/Veer_c/article/details/103843825

MySQL数据库（一）：
https://blog.csdn.net/Veer_c/article/details/103844059
MySQL数据库（二）：
https://blog.csdn.net/Veer_c/article/details/103844537
MySQL数据库（三）：
https://blog.csdn.net/Veer_c/article/details/103844739

JDBC技术（一）：
https://blog.csdn.net/Veer_c/article/details/103845176
JDBC技术（二）：
https://blog.csdn.net/Veer_c/article/details/103879890
JDBC技术（三）：
https://blog.csdn.net/Veer_c/article/details/103880021
JDBC技术（四）：
https://blog.csdn.net/Veer_c/article/details/103882264

HTML的基础框架（一）：
https://blog.csdn.net/Veer_c/article/details/103882385
HTML的基础框架（二）：
https://blog.csdn.net/Veer_c/article/details/103882684

CSS入门（一）
https://blog.csdn.net/Veer_c/article/details/103882856
CSS入门（二）：
https://blog.csdn.net/Veer_c/article/details/103883102

JavaScript实用案例与常见问题（一）：
https://blog.csdn.net/Veer_c/article/details/103894959
JavaScript实用案例及常见问题（二）：
https://blog.csdn.net/Veer_c/article/details/103895166

BOM编程详解：
https://blog.csdn.net/Veer_c/article/details/103895433

IO流的小细节（很小很细很重要）相关推荐

JavaScript篇---星空背景（有很多小细节和小知识点）
先来看一下效果吧星星闪耀,大小不一:鼠标hover时会放大旋转只需要一张静态的星星图片,就可以通过JS和CSS结合实现这样的效果虽然有些细节,但还是比较简单的 <!DOCTYPE html ...
css 的小细节，小总结
CSS的一些零碎总结 1.CSS 伪元素用于向某些选择器设置特殊效果(用来当作一个东西的,跟一个元素差不多,但不是元素). ① :frist-line伪元素:用于向文本首行设置特殊样式,但是只能用于块 ...
java数据通道抽象为流_【java】IO流
对于java的IO流的理解很长时间来都是很乱,包括学习其他的语言对这一块知识也都算是一个盲点.更多的时候一提到读取保存数据就是使用数据库.这一次学习了IO流,自己又解决了一个很大的盲点. IO流为我们 ...
java IO流进阶模拟上传头像系统详解
目录一.前言: 二.思路: PS:直接看代码中的注释也可以. ①分析: ②总结: 三.代码: ①准备工作: ②代码演示: ③运行效果: 四.撒❀: 一.前言: 这篇文章是对之前java IO流基础 ...
说说瀑布流式网站里那些可人的小细节
瀑布流式布局,想必设计师们已不再陌生,随着pinterest自2011年开始走红,瀑布流式的布局被越来越多的网站所使用.花瓣网.堆糖网.布兜.发现啦,美丽说,蘑菇街,人人逛街,凡客达人等,复制Pint ...
小码笔记17：IO流
小码笔记:IO流一.File类 1.构造方法 2.常用成员变量 3.常用方法 4.递归 5.文件过滤器二.IO流概述 1.分类选择 2.IO异常的处理 3.Properties属性集三.字节流 ...
普通话水平测试这软件很准靠谱吗,普通话考试小细节，你知道多少？
原标题:普通话考试小细节,你知道多少? 一级(标准的普通话) 一级甲等(测试得分:97分-100分之间)一级乙等(测试得分:92分-96.99分之间) 二级(比较标准的普通话) 二级甲等(测试得分:8 ...
【Java基础】IO流概述分类、字节流写数据、字节流写数据的三种方式及写数据的两个小问题
目录一.IO流概述和分类二.字节流写数据三.字节流写数据的三种方式四.字节流写数据的两个小问题一.IO流概述和分类 IO流介绍: ● IO:输入/输出(Input/Output) ● 流:是 ...
玩转运营抖音引流，不可忽视的小细节
元旦来到,幸福照耀,过去忘掉,烦恼不要,忧愁赶跑,快乐拥抱,开心来找,平安抓牢,团圆紧靠,一切好运,一切祝福,元旦佳节,向你报到,祝你元旦一切称心如意. 为了和大家聊聊更多的干货,六六青年今天没有休息 ...

IO流的小细节（很小很细很重要）

路阻且长之Java学习：

IO流的小细节（很小很细很重要）相关推荐

最新文章

热门文章