除IO流外其他的流的简单介绍

数据流：

分为数据输入流（DateInputStream）和数据输出流（DateOutputStream）

 

下面来看数据流的读写：

package com.westos.Other;
 
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
 
/**
 *数据流:针对Java基本类型的数据进行读写操作
 *数据输入流:DataInputStream 
 *数据输出流:DataOutputStream 
 */
public class DateStreamDome {
 
public static void main(String[] args) throws Exception {

read();
}
 
private static void read() throws IOException   {
//创建数据输入流
DataInputStream dis=new DataInputStream(new FileInputStream("d.txt"));

//读取数据
int i = dis.readInt();
boolean flag = dis.readBoolean();
double l = dis.readDouble();
char c = dis.readChar();
float f = dis.readFloat();

//关闭数据
dis.close();

//获取数据
System.out.println(i);
System.out.println(flag);
System.out.println(l);
System.out.println(c);
System.out.println(f);
}

private static void write() throws IOException{
//创建数据输出流
DataOutputStream dos=new DataOutputStream(new FileOutputStream("d.txt"));

//写数据
dos.writeInt(73);
dos.writeDouble(13.25);
dos.writeChar('a');
dos.writeFloat(12.45f);
dos.writeBoolean(true);

//关闭资源
dos.close();
}
}

内存操作流：

内存操作流一般用来临时存储文件，分为：

内存操作输出流：byteArrayOutputStream:该流不需要关闭资源

  构造方法:ByteArrayOutputStream() 

内存操作输入流:byteArrayInputStream

  构造方法：ByteArrayInputStream(byte[] buf)

内存操作流:一个程序结束后,那么这些程序的变量,就会从内存消失(马上消失的这些数据进行读取写入)

 

package com.westos.Other;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
 
public class byteArrayStreamDome {
 
public static void main(String[] args) throws IOException {

//创建内存操作输出流
ByteArrayOutputStream baos=new ByteArrayOutputStream();

//写数据
baos.write("hello".getBytes());
baos.write("world".getBytes());

byte[] array = baos.toByteArray();
//创建内存操作输出流
ByteArrayInputStream bais=new ByteArrayInputStream(array);

//读取数据:一次读取一个字节
int len=0;
while((len=bais.read())!=-1) {
System.out.print((char) len);
}
//关闭资源
bais.close();
}
}

打印流：

打印流分为字符打印流和字节打印流

字符打印流：（只针对于输出流）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)

例如：

package com.westos.Other;
 
import java.io.IOException;
import java.io.PrintWriter;
 
public class PrintWriterDome {
 
public static void main(String[] args) throws IOException {

//创建字符打印流对象
PrintWriter pw=new PrintWriter("e.txt");

//这个打印没有换行
/*pw.write("hello");
pw.write("world");
pw.write("java");*/

//打印数据，这个打印可以实现自动换行
pw.println("hello");
pw.println("world");
pw.println("java");

//关闭资源
pw.close();
}
}

 

我们的字符打印流有一个构造方法可以实现自动刷新，让我们用字符打印流去实现文件之间的copy

例如：

package com.westos.Other;
 
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
 
/**
 * @author 杰哥
 *使用字符缓冲输入流和字符打印流来copy文件
 */
public class CopyDome {
 
public static void main(String[] args) throws IOException {

//创建字符缓冲输入流
BufferedReader br=new BufferedReader(new FileReader("file.txt"));
//创建字符打印流,这样的对象可以实现自动刷新
PrintWriter pw=new PrintWriter(new FileWriter("f.txt"),true);

//一次读取一行
String str=null;
while((str=br.readLine())!=null) {
pw.println(str);
}

//关闭资源
br.close();
pw.close();
}
}

 

字节打印流：标准的输入输出流

标准的输入流：

InputStream in=System.In

标准的输出流：

OutputStream out=System.out

在jdk5以后，添加了Scanner类，可以实现键盘录入的功能

我们还可以通过流来实现第二种键盘录入的方法

 

例如：

package com.westos.Other;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
/**
 * @author 杰哥
 *通过标准的输入流与字符缓冲输出流实现另一种键盘录入的功能
 */
public class SystemStreamDome {
 
public static void main(String[] args) throws IOException {

/*//创建一个标准输入流
InputStream in=System.in;
//再创建一个字符转换流对象
InputStreamReader isr=new InputStreamReader(in);
//创建一个字符缓冲输入流对象
BufferedReader br=new BufferedReader(isr);*/

//我们可以直接用匿名对象实现一步完成
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

//来实现键盘录入的功能，当你需要的是字符串时
System.out.println("请您输入一个字符串...");
//调用字符缓冲输入流 的读取一行的方法
String line = br.readLine();
System.out.println("您输入的字符串是："+line);
 
//当需要你输入的是整数，并需要进行判断
int number;
while(true) {
System.out.println("请您输入一个整数...");
try {
String str=br.readLine();
//将字符串转化成整数
number = Integer.parseInt(str);
break;
} catch (NumberFormatException e) {
// e.printStackTrace();
System.out.println("只能输入整数...");
}
}
System.out.println("您输入的整数是："+number);
}
}

 

标准的输出流：这种方法我们了解就好

package com.westos.Other;
 
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
 
public class SystemOutDome {
 
public static void main(String[] args) throws IOException {

//创建标准的输出流
PrintStream out=System.out;
//去打印数据
out.println("hello");
System.out.println("-------------------");

//通过字节打印流去创建字符缓冲输出流对象
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
//写数据
bw.write("迪丽热巴");
bw.newLine();
bw.write("最美");
bw.flush();
//关闭资源 
bw.close();
}
}
运行结果：
hello
-------------------
迪丽热巴
最美

 

合并流：sequenceInputStream

构造方法1：

  public SequenceInputStream(InputStream s1, InputStream s2)

需求：将两个文件的内容复制到一个文件中

例如：

package com.westos.Other;
 
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.SequenceInputStream;
 
public class SequenceInputStreamDome {
 
public static void main(String[] args) throws Exception {
//创建两个源文件对象
InputStream in1=new FileInputStream("file.txt");
InputStream in2=new FileInputStream("f.txt");

//创建合并流对象
SequenceInputStream sis=new SequenceInputStream(in1,in2);

//创建一个字节缓冲输出流对象
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("copy.txt"));

//一次读取一个数组
byte[] ch=new byte[1024];
int len=0;
while((len=sis.read(ch))!=-1) {
bos.write(ch, 0, len);
bos.flush();
}
//关闭资源
bos.close();
sis.close();
}
}

 

构造方法2：

 public SequenceInputStream(Enumeration e)

需求：将多个文件的内容复制到一个文件中

 

例如：

package com.westos.Other;
 
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;
 
public class SequenceInputStreamDome2 {
 
public static void main(String[] args) throws Exception {
//创建一个Vector集合对象
Vector<InputStream> v=new Vector<InputStream>();

//创建三个字节输入流对象
InputStream in1=new FileInputStream("c.txt");
InputStream in2=new FileInputStream("f.txt");
InputStream in3=new FileInputStream("file.txt");

//将三个字节输入流添加到集合中
v.add(in1);
v.add(in2);
v.add(in3);

//调用elements方法,这里的返回类型正好是构造方法中需要的类型
Enumeration<InputStream> elements = v.elements();
//创建合并流对象
SequenceInputStream sis=new SequenceInputStream(elements);

//创建一个字节缓冲输出流对象
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("g.txt"));

//一次读取一个数组
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();

  }
}