javaAPI_IO流基础_其他的相关流

Posted 2021-02-03 德墨特尔

其他操作的IO流

1.操作基本数据的流

(1).概述
可以对基本的数据类型进行操作。

(2).俩个相关的读写流
数据输入流：DataInputStream
DataInputStream(InputStream in)
数据输出流：DataOutputStream
DataOutputStream(OutputStream out)

(3).一个使用的基本案例
public static void main(String[] args) throws IOException {
// 写
// write();
// 读
read();
}

private static void read() throws IOException {
// DataInputStream(InputStream in)
// 创建数据输入流对象
DataInputStream dis = new DataInputStream(
new FileInputStream("dos.txt"));

// 读数据
byte b = dis.readByte();
short s = dis.readShort();
int i = dis.readInt();
long l = dis.readLong();
float f = dis.readFloat();
double d = dis.readDouble();
char c = dis.readChar();
boolean bb = dis.readBoolean();

// 释放资源
dis.close();

System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(l);
System.out.println(f);
System.out.println(d);
System.out.println(c);
System.out.println(bb);
}

private static void write() throws IOException {
// DataOutputStream(OutputStream out)
// 创建数据输出流对象
DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt"));
// 写数据了
dos.writeByte(10);
dos.writeShort(100);
dos.writeInt(1000);
dos.writeLong(10000);
dos.writeFloat(12.34F);
dos.writeDouble(12.56);
dos.writeChar(‘a‘);
dos.writeBoolean(true);
// 释放资源
dos.close();
}

2.内存操作流
(1).概述
内存操作流：用于处理临时存储信息的，程序结束，数据就从内存中消失。

(2).相关的读写流

字节数组：
ByteArrayInputStream
ByteArrayOutputStream
字符数组：
CharArrayReader
CharArrayWriter
字符串：
StringReader
StringWriter

(3).一个使用的基本案例
public static void main(String[] args) throws IOException {
// 写数据
// ByteArrayOutputStream()
ByteArrayOutputStream baos = new ByteArrayOutputStream();

// 写数据
for (int x = 0; x < 10; x++) {
baos.write(("hello" + x).getBytes());
}

// 释放资源
// 通过查看源码我们知道这里什么都没做，所以根本需要close()
// baos.close();

// public byte[] toByteArray()
byte[] bys = baos.toByteArray();

// 读数据
// ByteArrayInputStream(byte[] buf)
ByteArrayInputStream bais = new ByteArrayInputStream(bys);

int by = 0;
while ((by = bais.read()) != -1) {
System.out.print((char) by);
}

// bais.close();
}

3.打印流

(1).打印流概述
字节流打印流 PrintStream
字符打印流 PrintWriter

(2).打印流的特点：
A:只有写数据的，没有读取数据。只能操作目的地，不能操作数据源。
B:可以操作任意类型的数据。
C:如果启动了自动刷新，能够自动刷新。
D:该流是可以直接操作文本文件的。
哪些流对象是可以直接操作文本文件的呢?
FileInputStream
FileOutputStream
FileReader
FileWriter
PrintStream
PrintWriter
看API,查流对象的构造方法，如果同时有File类型和String类型的参数，一般来说就是可以直接操作文件的。

流：
基本流：就是能够直接读写文件的
高级流：在基本流基础上提供了一些其他的功能

(3).一个打印流的基本使用
public static void main(String[] args) throws IOException {
// 作为Writer的子类使用
PrintWriter pw = new PrintWriter("pw.txt");

pw.write("hello");
pw.write("world");
pw.write("java");

pw.close();
}

(4).打印流实现自动刷新和换行[写任意数据类型]
A:自动刷新:在构造上做 PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
还是应该调用println()的方法才可以，这个时候不仅仅自动刷新了，还实现了数据的换行。

B:基本使用代码测试
public static void main(String[] args) throws IOException {
// 创建打印流对象
PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
pw.println("hello");
pw.println(true);
pw.println(100);

pw.close();
}

(5).打印流复制文本文件
/
需求：DataStreamDemo.java复制到Copy.java中
数据源：
DataStreamDemo.java -- 读取数据 -- FileReader -- BufferedReader
目的地：
Copy.java -- 写出数据 -- FileWriter -- BufferedWriter -- PrintWriter
/
public static void main(String[] args) throws IOException {
// 打印流的改进版
// 封装数据源
BufferedReader br = new BufferedReader(new FileReader(
"DataStreamDemo.java"));
// 封装目的地
PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true);

String line = null;
while((line=br.readLine())!=null){
pw.println(line);
}

pw.close();
br.close();
}

4.标准输入输出流

(1). System类中的两个成员变量：
public static final InputStream in “标准”输入流。
public static final PrintStream out “标准”输出流。

InputStream is = System.in;
PrintStream ps = System.out;

//由此可见:以前的System.out.println();其实是这里面的PrintStream ps调用了Println()方法输出的。

(2).基本使用代码测试
public static void main(String[] args) {
// 有这里的讲解我们就知道了，这个输出语句其本质是IO流操作，把数据输出到控制台。
System.out.println("helloworld");

// 获取标准输出流对象
PrintStream ps = System.out;
ps.println("helloworld");

ps.println();
// ps.print();//这个方法不存在
}

5.合并流

(1).概述
该流的出现是为了解决一个问题，就是把俩个文件中的数据合并到一个文件中去，如把a.txt和b.txt内容合并到c.txt中，这一个时候就出现了
合并流。
SequenceInputStream类可以将多个输入流串流在一起，合并为一个输入流，因此，该流也被称为合并流

(2).SequenceInputStream的构造方法
SequenceInputStream(InputStream s1, InputStream s2)
SequenceInputStream(Enumeration<? extends InputStream> e)


(3).一个基本的合并流使用案例
public static void main(String[] args) throws IOException {
// SequenceInputStream(InputStream s1, InputStream s2)
// 需求：把ByteArrayStreamDemo.java和DataStreamDemo.java的内容复制到Copy.java中
InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
InputStream s2 = new FileInputStream("DataStreamDemo.java");
SequenceInputStream sis = new SequenceInputStream(s1, s2);
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("Copy.java"));

// 如何写读写呢，其实很简单，你就按照以前怎么读写，现在还是怎么读写
byte[] bys = new byte[1024];
int len = 0;
while ((len = sis.read(bys)) != -1) {
bos.write(bys, 0, len);
}

bos.close();
sis.close();
}

(4).使用合并流复制多个文件案例
public static void main(String[] args) throws IOException {

// 需求：把下面的三个文件的内容复制到Copy.java中
// ByteArrayStreamDemo.java,CopyFileDemo.java,DataStreamDemo.java
// SequenceInputStream(Enumeration e)
// 通过简单的回顾我们知道了Enumeration是Vector中的一个方法的返回值类型。
// Enumeration<E> elements()
Vector<InputStream> v = new Vector<InputStream>();
InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
InputStream s2 = new FileInputStream("CopyFileDemo.java");
InputStream s3 = new FileInputStream("DataStreamDemo.java");
v.add(s1);
v.add(s2);
v.add(s3);
Enumeration<InputStream> en = v.elements();
SequenceInputStream sis = new SequenceInputStream(en);
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("Copy.java"));

// 如何写读写呢，其实很简单，你就按照以前怎么读写，现在还是怎么读写
byte[] bys = new byte[1024];
int len = 0;
while ((len = sis.read(bys)) != -1) {
bos.write(bys, 0, len);
}

bos.close();
sis.close();
}

6.序列化流和反序列化流

(1).概述
序列化流：把对象按照流一样的方式存入文本文件或者在网络中传输。对象 -- 流数据(ObjectOutputStream)
反序列化流:把文本文件中的流对象数据或者网络中的流对象数据还原成对象。流数据 -- 对象(ObjectInputStream)

(2).一个序列化流和反序列化的基本操作
A：创建一个对象

/*
* NotSerializableException:未序列化异常
*
* 类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
* 该接口居然没有任何方法，类似于这种没有方法的接口被称为标记接口。
*
* java.io.InvalidClassException:
* cn.itcast_07.Person; local class incompatible:
* stream classdesc serialVersionUID = -2071565876962058344,
* local class serialVersionUID = -8345153069362641443
*
* 为什么会有问题呢?
* Person类实现了序列化接口，那么它本身也应该有一个标记值。
* 这个标记值假设是100。
* 开始的时候：
* Person.class -- id=100
* wirte数据： oos.txt -- id=100
* read数据: oos.txt -- id=100
*
* 现在：
* Person.class -- id=200
* wirte数据： oos.txt -- id=100
* read数据: oos.txt -- id=100
* 我们在实际开发中，可能还需要使用以前写过的数据，不能重新写入。怎么办呢?
* 回想一下原因是因为它们的id值不匹配。
* 每次修改java文件的内容的时候,class文件的id值都会发生改变。
* 而读取文件的时候，会和class文件中的id值进行匹配。所以，就会出问题。
* 但是呢，如果我有办法，让这个id值在java文件中是一个固定的值，这样，你修改文件的时候，这个id值还会发生改变吗?
* 不会。现在的关键是我如何能够知道这个id值如何表示的呢?
* 不用担心，你不用记住，也没关系，点击鼠标即可。
* 你难道没有看到黄色警告线吗?
*
* 我们要知道的是：
* 看到类实现了序列化接口的时候，要想解决黄色警告线问题，就可以自动产生一个序列化id值。
* 而且产生这个值以后，我们对类进行任何改动，它读取以前的数据是没有问题的。
*
* 注意：
* 我一个类中可能有很多的成员变量，有些我不想进行序列化。请问该怎么办呢?
* 使用transient关键字声明不需要序列化的成员变量
*/
public class Person implements Serializable {
private static final long serialVersionUID = -2071565876962058344L;

private String name;

// private int age;

//transient不被序列化关键字
private transient int age;

// int age;

public Person() {
super();
}

public Person(String name, int age) {
super();
this.name = name;
this.age = 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;
}

@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}

B:测试代码

public class ObjectStreamDemo {
public static void main(String[] args) throws IOException,
ClassNotFoundException {
// 由于我们要对对象进行序列化，所以我们先自定义一个类
// 序列化数据其实就是把对象写到文本文件
// write();

read();
}

private static void read() throws IOException, ClassNotFoundException {
// 创建反序列化对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
"oos.txt"));

// 还原对象
Object obj = ois.readObject();

// 释放资源
ois.close();

// 输出对象
System.out.println(obj);
}

private static void write() throws IOException {
// 创建序列化流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
"oos.txt"));

// 创建对象
Person p = new Person("林青霞", 27);

// public final void writeObject(Object obj)
oos.writeObject(p);

// 释放资源
oos.close();
}
}

 

7.Properties[*****]

(1).Properties概述
Properties:属性集合类。是一个可以和IO流相结合使用的集合类。
Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串
是Hashtable的子类，说明是一个Map集合。

//注意：Properties不是IO流的一部分，是属于集合的一部分。

(2).Properties的特有功能
public Object setProperty(String key,String value):设置键以及值，其实就是添加
public String getProperty(String key)：获取元素
public Set<String> stringPropertyNames():获取所有的键的集合

(3).Properties的特有功能测试

public static void main(String[] args) {
// 创建集合对象
Properties prop = new Properties();
// 添加元素
prop.setProperty("张三", "30");
prop.setProperty("李四", "40");
prop.setProperty("王五", "50");

// public Set<String> stringPropertyNames():获取所有的键的集合
Set<String> set = prop.stringPropertyNames();
for (String key : set) {
String value = prop.getProperty(key);
System.out.println(key + "---" + value);
}
}

(4).Properties和IO流的结合使用

A:相关方法:
public void load(Reader reader):把文件中的数据读取到集合中
public void store(Writer writer,String comments):把集合中的数据存储到文件

//注意:
这里的集合必须是Properties集合
该功能就是可以存储一个进度，把一些信息存储到一个文件中，下次点击的时候加载这一个文件即可。

B:Properties的俩个功能测试
public class PropertiesDemo3 {
public static void main(String[] args) throws IOException {
// myLoad();

myStore();
}

private static void myStore() throws IOException {
// 创建集合对象
Properties prop = new Properties();

prop.setProperty("林青霞", "27");
prop.setProperty("武鑫", "30");
prop.setProperty("刘晓曲", "18");

//public void store(Writer writer,String comments):把集合中的数据存储到文件
Writer w = new FileWriter("name.txt");
prop.store(w, "helloworld");
w.close();
}

private static void myLoad() throws IOException {
Properties prop = new Properties();

// public void load(Reader reader):把文件中的数据读取到集合中
// 注意：这个文件的数据必须是键值对形式
Reader r = new FileReader("prop.txt");
prop.load(r);
r.close();

System.out.println("prop:" + prop);
}

(5).properties的一个使用案例:

/*
* 我有一个文本文件(user.txt)，我知道数据是键值对形式的，但是不知道内容是什么。
* 请写一个程序判断是否有“lisi”这样的键存在，如果有就改变其实为”100”
*
* 分析：
* A:把文件中的数据加载到集合中
* B:遍历集合，获取得到每一个键
* C:判断键是否有为"lisi"的，如果有就修改其值为"100"
* D:把集合中的数据重新存储到文件中
*/
public class PropertiesTest {
public static void main(String[] args) throws IOException {
// 把文件中的数据加载到集合中
Properties prop = new Properties();
Reader r = new FileReader("user.txt");
prop.load(r);
r.close();

// 遍历集合，获取得到每一个键
Set<String> set = prop.stringPropertyNames();
for (String key : set) {
// 判断键是否有为"lisi"的，如果有就修改其值为"100"
if ("lisi".equals(key)) {
prop.setProperty(key, "100");
break;
}
}

// 把集合中的数据重新存储到文件中
Writer w = new FileWriter("user.txt");
prop.store(w, null);
w.close();
}
}