1.内存操作流
适用于临时存储文件
内存操作输入流:byteArrayInputStreamByteArrayInputStream(byte[] buf)
内存操作输出流: byteArrayOutputStream
构造方法:ByteArrayOutputStream()
内存操作流:一个程序结束后,那么这些程序的变量,就会从内存消失(马上消失的这些数据进行读取写入)
public class ByteStreamDemo {
public static void main(String[] args) throws IOException {
//创建内存操作输出流对象
ByteArrayOutputStream baos = new ByteArrayOutputStream() ;
for(int x = 0 ; x <10 ; x ++) {
baos.write(("hello"+x).getBytes());
}
//释放资源
/**
* 源码:
* public void close() throws IOException {
* }
*/
//baos.close(); 该流不需要关闭
//从内存中将内从中的数据显到控制台上
//public byte[] toByteArray():构造一个字符串
byte[] bys = baos.toByteArray() ;
//创建内存操作输入流对象
ByteArrayInputStream bais = new ByteArrayInputStream(bys) ;
//一次读取一个字节
int by = 0 ;
while((by=bais.read())!=-1) {
System.out.print((char)by);
}
//bais.close();该流不需要关闭
}
}
2.数据流
针对Java基本类型的数据进行读写操作
数据输入流:DataInputStream数据输出流:DataOutputStream
public class DataStream {
public static void main(String[] args) throws Exception {
// write() ;
read() ;
}
//读
private static void read() throws Exception {
DataInputStream dis = new DataInputStream(new FileInputStream("dos.txt")) ;
//读
int i = dis.readInt() ;
short s = dis.readShort() ;
byte b = dis.readByte() ;
double d = dis.readDouble() ;
float f = dis.readFloat();
boolean flag = dis.readBoolean() ;
char ch = dis.readChar() ;
dis.close();
System.out.println(i);
System.out.println(s);
System.out.println(b);
System.out.println(d);
System.out.println(f);
System.out.println(flag);
System.out.println(ch);
}
//写
private static void write() throws Exception {
DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt")) ;
//给流中写入数据
dos.writeInt(10);
dos.writeShort(100);
dos.writeByte(120);
dos.writeDouble(13.34);
dos.writeFloat(12.56F);
dos.writeBoolean(true);
dos.writeChar('a');
//关闭资源
dos.close();
}
}
3.打印流
字符打印流(针对文本进行操作:PrintWriter)字节打印流(printStream 和标准输出流有关系 System.out;)
PrintWriter:属于输出流
1)只能写数据(只能针对目的地文件进行操作),不能读数据(不能针对源文件进行操作)
2)可以针对文件直接进行操作
如果一个类中的构造方法里面有File对象或者String类型数据,这个类可以对文本文件直接操作
FileInputStream
FileOutputStream
FileWriter
FileReader..
PrintWriter
3)自动刷新功能::PrintWriter(OutputStream out/Writer out,boolean autoflush);第二个参数如果是true 表示启动自动刷新功能
4)打印的方法:print(XXX x)/println(XXX xx)
public class PrintWriterDemo {
public static void main(String[] args) throws IOException {
//创建一个字符打印流对象
PrintWriter pw = new PrintWriter(new FileWriter("pw.txt")) ;
//写数据
/*pw.write("hello");
pw.write("world");
pw.write("java");*/
pw.println("hello");//本身自动换行并且向pw.txt文件打印内容
pw.flush(); //本身在构造的时候,就可以启动自动刷新
//关闭流
pw.close();
}
}
输出一个文本文件,启动自动刷新功能
public class PrintWriterDemo2 {
public static void main(String[] args) throws IOException {
//创建一个字符打印流对象,启动自动刷新
PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true) ;
//加入换行
pw.println("hello");
pw.println("world");
pw.println("java");
//关闭
pw.close();
}
}
需求:复制文件
源文件:StringDemo.java --->BufferedReader
目的文件:Copy.java ----->PrintWriter
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
//封装文件
BufferedReader br = new BufferedReader(new FileReader("StringDemo.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.标准的输入输出流
InputStream in = System.inPrintStream out = Syste.out ;
jdk5以后,Java--->Scanner(InputStream in)
键盘录入
1)Scanner
2)BufferedReader里面包装字符转换输入流,包装System.in
public class SystemInDemo {
public static void main(String[] args) throws IOException {
//标准输入流
//分布走
//创建输入流对象
/*InputStream in = System.in ;
//使用这个类最终可不可实现一次读取一行?readLine()
//想要实现一次读取一行,使用BufferedReader
//构造BufferedReader流对象
//BufferedReader br = new BufferedReader(in) ; //不能直接将字节流使用BufferedReader进行包装
//构造一个字符转换输入流对象
InputStreamReader isr = new InputStreamReader(in) ;
BufferedReader br = new BufferedReader(isr) ;*/
//另一种键盘录入的方式:使用流的方式
//Java的装饰者模式
BufferedReader br = new BufferedReader(
new InputStreamReader(
System.in)) ;
System.out.println("请输入一个字符串:");
String line = br.readLine() ;
System.out.println("您输入的字符串是:"+line);
System.out.println("请输入一个整数:");
String str = br.readLine() ;
int num = Integer.parseInt(str) ;
System.out.println("输入的整数是:"+num);
}
}
标准输出流
PrintStream ps = System.out ;
使用BufferedWriter 去包装System.out
public class SystemOutDemo {
public static void main(String[] args) throws IOException {
System.out.println("我爱高圆圆");
System.out.println("-------------");
PrintStream ps = System.out ;
//PrintStream的功能
//public void println(String x)
ps.println("我爱高圆圆");
ps.println();
//ps.print() ;没有该功能
System.out.println("---------------------------");
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out)) ;
bw.write("hello");
bw.newLine();
bw.write("world");
bw.newLine();
bw.write("java");
bw.newLine();
bw.flush();
bw.close();
}
}
5.合并流
SequenceInputStream 表示其他输入流的逻辑串联(合并流)
构造方法public SequenceInputStream(InputStream s1, InputStream s2)
复制文件
a.txt----->b.txt
c.txt----->d.txt
现在的需求:
a.txt+b.txt--->c.txt
StringDemo.java+SystemInDemo.java---->Copy.java
public class SequenceInputStreamDemo {
public static void main(String[] args) throws IOException {
//封装源文件
InputStream in1 = new FileInputStream("StringDemo.java") ;
InputStream in2 = new FileInputStream("SystemInDemo.java") ;
//创建合并流对象
SequenceInputStream sis = new SequenceInputStream(in1, in2) ;
//创建一个字节缓冲输入流对象
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.flush(); //读图片文件的时候
}
//关闭资源
sis.close();
bos.close();
}
}
sequenceInputStream另一种构造方式
public SequenceInputStream(Enumeration e)
将多个输入流对象进行合并
a.txt+b.txt+c.txt--->d.txt
public class SequenceInputStreamDemo2 {
public static void main(String[] args) throws IOException {
//StringDemo.java+SystemInDemo.java+PrintWriterDemo.java--->Copy.java文件中
//定义一个集合Vector
Vector<InputStream> v = new Vector<InputStream>() ;
//使用InputStream封装文件
InputStream s1 = new FileInputStream("StringDemo.java") ;
InputStream s2 = new FileInputStream("SystemInDemo.java") ;
InputStream s3 = new FileInputStream("PrintWriterDemo.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.flush();
}
//关闭资源
bos.close();
sis.close();
}
}