其他流
序列流
一.什么是序列流
- 序列流可以把多个字节输入流整合成一个，从序列流中读取数据时，将从整合的第一个流开始读，读完一个之后继续读第二个，以此类推
二.使用方式
- 整合两个输入流：SequenceInputstream(InputStream,InputStream)
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;
import javax.sound.midi.Sequence;
public class Demo1_SequenceInputStream {
public static void main(String[] args) throws IOException {
//整合两个：SequenceInputstream(InputStream,InputStream)
FileInputStream fis1 = new FileInputStream("a.txt");
FileInputStream fis2 = new FileInputStream("b.txt");
SequenceInputStream sis = new SequenceInputStream(fis1,fis2);
FileOutputStream fos = new FileOutputStream("c.txt");
int b;
while((b = sis.read()) != -1) {
fos.write(b);
}
sis.close(); //sis在关闭的时候，会将构造方法中传入的流对象也都关闭
fos.close();
}
}
- 整合多个输入流：SequenceInputstream(Enumeration<? extends InputStream> e)
运用运用Vector集合中的枚举的elements方法获取集合中的枚举
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;
import javax.sound.midi.Sequence;
public class Demo1_SequenceInputStream {
public static void main(String[] args) throws IOException {
//整合多个输入流：SequenceInputstream(Enumeration<? extends InputStream> e)
FileInputStream fis1 = new FileInputStream("a.txt");
FileInputStream fis2 = new FileInputStream("b.txt");
FileInputStream fis3 = new FileInputStream("c.txt");
Vector<FileInputStream> v = new Vector<>();
v.add(fis1);
v.add(fis2);
v.add(fis3);
Enumeration<FileInputStream> en = v.elements();
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos = new FileOutputStream("d.txt");
int c;
while((c = sis.read()) != -1) {
fos.write(c);
}
sis.close();
fos.close();
}
}
内存输出流
一.什么是内存输出流?
- 该输出流可以向内存中写数据，把内存当作一个缓冲器，写出之后一次性获取所有数据
二.使用方式
- 创建对象：new ByteArrayOutputStream()
- 写出数据：write(int),write(byte[])
- 获取数据：toByteArray(),toString
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Demo2_ByteArrayOutputStream {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("e.txt");
ByteArrayOutputStream baos = new ByteArrayOutputStream();//在内存中创建了可以增长的内存数组
int b;
while((b = fis.read()) != -1) {
baos.write(b); //将读取到的数据逐个写到内存中
}
//第一种toByteArray
//byte[] arr = baos.toByteArray(); //将缓冲区的数据全部或取出来，并赋值给arr数组
//System.out.println(new String(arr));
//第二种toString
System.out.println(baos.toString());
//将缓冲区的内容转换为字符串，在输出语句中可以省略调用toString方法
fis.close();
}
}
随机访问流
一.RandomAccessFile概述
- RandomAccessFile类不属于流，是Object类的子类，但它融合了InputStream和OutputStream的功能
- 支持对随机访问文件的读取和写入
二.方法
- read()：读取文件
- write()：写入文件
- seek()：在指定位置设置指针
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
public class Demo3_RandomAccessFile {
public static void main(String[] args) throws IOException {
RandomAccessFile raf = new RandomAccessFile("g.txt", "rw");
raf.write(97);
//int x = raf.read();
//System.out.println(x);
raf.seek(10);//在指定位置设置指针
raf.write(98);//b
raf.close();
}
}
对象操作流（游戏存档读档）
一.什么是对象操作流
- 该流可以将一个对象写出，或者读取一个对象到程序中，也就是执行了序列化和反序列化的操作
二.使用方法
1.ObjectOutputStream（序列化）
- 写出：new ObjectOutputStream(OutputStream),writeObject()
2.ObjectInputStream（反序列化）
- 读入：new ObjectInputStream(InputStream),readObject()
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import com.heima.bean.Person;
public class Demo4_ObjectOutputStream {
public static void main(String[] args) throws IOException {
Person p1 = new Person("张三",23);
Person p2 = new Person("李四",24);//要写出的对象必须实现Serializable接口才能被实例化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));
oos.writeObject(p1);
oos.writeObject(p2);
oos.close();
}
}
public class Demo5_ObjectInputStream {
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();
//Person p3 = (Person)ois.readObject();当文件读取到了末尾时出现EOFException
System.out.println(p1);
System.out.println(p2);
ois.close();
}
}
数据输入输出流
1.什么是数据输入输出流
- DataInputStream,DataOutputStream可以按照基本数据类型大小读写数据
- 例如按long大小写出一个数字，写出时该数据占8字节，读取时也可按照long类型读取，一次读取8个字节
使用字节流读取数字会出现错误
public static void demo1() throws FileNotFoundException, IOException {//写入数据
FileOutputStream fos = new FileOutputStream("h.txt");
fos.write(997);//00000000 00000000 00000011 11100101 int类型的997
fos.write(998);//写的时候会将前3个8位砍掉 11100101 读的时候又补上3个8位
fos.write(999);//00000000 00000000 00000000 11100101 int类型的229
fos.close();
}
public static void demo2() throws FileNotFoundException, IOException {//读取数据
FileInputStream fis = new FileInputStream("h.txt");
int x = fis.read();
int y = fis.read();
int z = fis.read();
System.out.println(x);//229
System.out.println(y);
System.out.println(z);
fis.close();
}
2.使用方式
- DataOutputStream(OutputStream),writeInt(),writeLong()
- DataInputStream(InputStream),readInt(),readLong()
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo6_Data {
public static void main(String[] args) throws IOException {
//demo3();
DataInputStream dis = new DataInputStream(new FileInputStream("h.txt"));
int x = dis.readInt();
int y = dis.readInt();
int z = dis.readInt();
System.out.println(x);//997
System.out.println(y);
System.out.println(z);
dis.close();
}
public static void demo3() throws FileNotFoundException, IOException {
DataOutputStream dos = new DataOutputStream(new FileOutputStream("h.txt"));
dos.writeInt(997);
dos.writeInt(998);
dos.writeInt(999);
dos.close();
}
打印流
1.什么是打印流
- 该流可以很方便地将对象的toString()结果打印，并且自动加上换行，而且可以使用自动刷出的模式
- Sysyem.out就是一个PrintStream，其默认向控制台输出信息
2.使用方式
- 打印：print(),println()
- 自动刷出：PrintWriter(OutputStream out,boolean autoFlush,String encoding)
- 打印流只操作数据目的
PrintStream和PrintWriter分别打印的是字节流和字符流
只操作数据目的
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import com.heima.bean.Person;
public class Demo7_PrintStream {
public static void main(String[] args) throws IOException {
//demo1();
PrintWriter pw = new PrintWriter(new FileOutputStream("f.txt"),true);
pw.println(97); //自动刷出功能只针对println方法
//pw.write(97);
//pw.print(97);
//pw.close();
}
public static void demo1() {
System.out.println("aaa");
PrintStream ps = System.out;//获取标注输出流
ps.println(97); //底层通过Integer.toString()将97转成字符串并打印
ps.write(97); //查找码表,找到对应的a并打印
Person p1 = new Person("张三", 23);
ps.println(p1); //默认调用pl的toString方法
Person p2 = null;
ps.println(p2); //打印引用数据类型，如果是null就打印null，如果不是null就打印toString方法
ps.close();
}
}
标准输入输出流
1.什么是标准输入输出流
- System.in是InputStream，标准输入流，默认可以从键盘输入读取字节数据
- System.out是PrintStream，标准输出流，默认可以向Console中输出字符和字节数据
2.修改标准输入输出流
- 修改输入流：System.setIn(InputStream)
- 修改输出流：System.setOut(PrintStream)
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
public class Demo8_SystemInOut {
public static void main(String[] args) throws IOException {
//demo1();
System.setIn(new FileInputStream("a.txt")); //改变标准输入流
System.setOut(new PrintStream("b.txt")); //改变标准输出流
InputStream is = System.in; //获取标准的键盘输入流，默认指向键盘，改变后指向文件
PrintStream ps = System.out; //获取标准输出流，默认指向的是控制台，改变后指向文件
int b;
while((b = is.read()) != -1) {
ps.write(b);
}
System.out.println(); //也是一个输出流，不用关，因为没有和键盘上的文件产生关联的管道
is.close();
ps.close();
}
public static void demo1() throws IOException {
InputStream is = System.in;
int x = is.read();
System.err.println(x);
is.close();
InputStream is2 = System.in;//因为标准输入流已经关闭所以再创建对象就没有意义了
int y = is2.read();
System.out.println(y);
}
}
两种键盘录入
1.BufferedReader的readLine()方法
- BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
2.Scanner
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
public class Demo9_SystemIn {
public static void main(String[] args) throws IOException {
//第一种键盘录入
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line = br.readLine();
System.out.println(line);
br.close();
//第二种键盘录入
Scanner sc = new Scanner(System.in);
String line1 = sc.nextLine();
System.out.println(line1);
sc.close();
}
}
Properties
一.Properties的概述(Hashtable的子类)
- Properties 类表示了一个持久的属性值
- Properties 可保存在流中或从流中加载
- 属性列表中每个键和对应的值都是字符串
二.Properties的特殊功能
- public Object setProperty(String key, String value);
- public String getProperty(String key);
- public Enumeration stringPropertyNames();
三.Properties的load()和store()功能
- load()：读取文件
- store()：写文件
案例演示
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.Properties;
public class Demo10_Properties {
public static void main(String[] args) throws FileNotFoundException, IOException {
//demo1();
//demo2();
Properties prop = new Properties();
System.out.println("读取前：" + prop);
prop.load(new FileInputStream("config.properties"));
prop.setProperty("tel", "18912345678");
prop.store(new FileOutputStream("config.properties"), null);//第二个参数是用来描述文件列表的,如果不描述可以传null
System.out.println("读取后：" + prop);
}
public static void demo2() {
Properties prop = new Properties();
prop.setProperty("name", "张三"); //设置键和值
prop.setProperty("tel", "18912345678");
//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);
}
}
public static void demo1() {
//Properties作为Map集合的使用
Properties prop = new Properties();
prop.put("abc", 123);
System.out.println(prop);
}
}
扫一扫
235
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
