前言：
当前各位老铁们对“netinputstream”都比较关注，大家都想要分析一些“netinputstream”的相关文章。那么小编同时在网上网罗了一些对于“netinputstream””的相关文章，希望同学们能喜欢，看官们快快来学习一下吧！概述
OutputStream抽象类, 也是超类，所以不能创建对象，提供了3个write方法来做数据的输出，和InputStream是相对应的。
public void write(byte b[ ])：将参数b中的字节写到输出流。
public void write(byte b[ ], int off, int len) ：将参数b的从偏移量off开始的len个字节写到输出流。
public abstract void write(int b) ：先将int转换为byte类型，把低字节写入到输出流中。
public void flush( ) : 将数据缓冲区中数据全部输出，并清空缓冲区。
public void close( ) : 关闭输出流并释放与流相关的系统资源。
流结束的判断：方法read()的返回值为-1时；readLine()的返回值为null时。
主要的子类：
ByteArrayOutputStream：把信息存入内存中的一个缓冲区中。
FileOutputStream：把信息存入文件中。
PipedOutputStream：实现了pipe的概念，主要在线程中使用。
FilterOutputStream过滤输出流：其他输出流的包装, 以下是其的子类。
DataOutputStream数据输出流：允许应用程序以与机器无关的方式向底层输出流写入基本Java数据类型。
PrintSteam打印流：通过PrintSteam可以将文字打印到文件或网络中去。
ObjectOutputStream基本类型输出流：该类实现了序列化的对象序列化后写入指定地方。
框架结构图
ByteArrayOutputStream 子类
ByteArrayOutputStream类实现了一个输出流，其中的数据被写入一个 byte 数组，缓冲区会随着数据的不断写入而自动增长。关闭 ByteArrayOutputStream 无效，此类的方法在关闭此流后仍可被调用，而不会产生 IOException。
构造方法：
ByteArrayOutputStream()：创建一个新的 byte 数组输出流。
ByteArrayOutputStream(int size)：创建一个新的 byte 数组输出流，它具有指定大小的缓冲区容量（以字节为单位）。
常用用法：
public void reset()：将此字节数组输出流的 count 字段重置为零，从而丢弃输出流中目前已累积的所有数据输出。
public byte[] toByteArray()：创建一个新分配的字节数组。数组的大小和当前输出流的大小，内容是当前输出流的拷贝。
public String toString()：将缓冲区的内容转换为字符串，根据平台的默认字符编码将字节转换成字符。
public void write(int w)： 将指定的字节写入此字节数组输出流。
public void write(byte []b, int off, int len)： 将指定字节数组中从偏移量 off 开始的 len 个字节写入此字节数组输出流。
public void writeTo(OutputStream outSt)：将此字节数组输出流的全部内容写入到指定的输出流参数中。
例子 写入简单数据输出:
public class ByteArrayOutputStreamTest {
public static void main(String[] args) {
int a = 0;
int b = 1;
int c = 2;
ByteArrayOutputStream bout = new ByteArrayOutputStream();
bout.write(a);
bout.write(b);
bout.write(c);
byte[] buff = bout.toByteArray();
for (int i = 0; i < buff.length; i++) {
System.out.println(buff[i]);
}
ByteArrayInputStream bin = new ByteArrayInputStream(buff);
int d;
while ((d = bin.read()) != -1) {
System.out.println(d);
}
}
}
FileOutputStream子类
使用FileOutputStream写入文件的过程同使用FileInputStream过程相同，都是先用File类打开本地文件，实例化输入输出流，然后调用流的读写方法读取或写入数据，最后关闭流。
构造方法：
FileOutputStream(File file) 创建文件输出流以写入由指定的 File对象表示的文件。
FileOutputStream(File file, boolean append) 创建文件输出流以写入由指定的 File对象表示的文件。
FileOutputStream(FileDescriptor fdObj) 创建文件输出流以写入指定的文件描述符，表示与文件系统中实际文件的现有连接。
FileOutputStream(String name) 创建文件输出流以指定的名称写入文件。
FileOutputStream(String name, boolean append) 创建文件输出流以指定的名称写入文件。
常用方法：
void close() 关闭此文件输出流并释放与此流相关联的任何系统资源。
protected void finalize() 清理与文件的连接，并确保当没有更多地引用此流时，将调用此文件输出流的 close方法。
FileChannel getChannel() 返回与此文件输出流相关联的唯一的FileChannel对象。
FileDescriptor getFD() 返回与相关流的文件描述符。
void write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。
void write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。
void write(int b) 将指定的字节写入此文件输出流。
例子1 把固定数据输出到固定文件
public class ByteArrayOutputStreamTest {
public static void main(String[] args) {
String path = "D:\\test.txt";
FileOutputStream fileOutputStream = null;
try {
fileOutputStream = new FileOutputStream(path);
String test= "越努力越幸运。";
fileOutputStream.write(test.getBytes());
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
例子2 文件复制
public class ByteArrayOutputStreamTest {
public static void main(String[] args) {
try {
in=new FileInputStream("D:\\test1.png");
out=new FileOutputStream("D:\\test2.png");
int c;
while((c=in.read())!=-1)
out.write(c);
} catch (Exception ex) {
System.out.println(ex.toString());
} finally {
try {
in.close();
} catch (IOException ioEx) {
System.out.println(ioEx.toString());
}
try {
out.close();
} catch (IOException ioEx) {
System.out.println(ioEx.toString());
}
}
}
}
PipedOutputStream子类
PipedOutputStream和PipedInputStream分别是管道输出流和管道输入流。
它们的作用是让多线程可以通过管道进行线程间的通讯。在使用管道通信时，必须将PipedOutputStream和PipedInputStream配套使用。
使用管道通信时，大致的流程是：我们在线程A中向PipedOutputStream中写入数据，这些数据会自动的发送到与PipedOutputStream对应的PipedInputStream中，进而存储在PipedInputStream的缓冲中；此时，线程B通过读取PipedInputStream中的数据。就可以实现，线程A和线程B的通信。
构造函数
public PipedOutputStream()
public PipedOutputStream(PipedInputStream snk)
参数说明 snk:要连接的管道输入流。
主要方法
public void write(int b) 将指定的字节写入管道输出流
public void write(byte[] b,int off,int len) 将指定的字节写入此字节数组输出流,此方法继承于OutputStream,可参考OutputStream.write
public void close()
public void flush()
例子1 数据写入输出：
class Write implements Runnable
{
private PipedOutputStream out;
Write(PipedOutputStream out)
{
this.out = out;
}
public void run()
{
try
{
Thread.sleep(1000);
out.write("欢迎来到 ;.getBytes());
out.close();
}
catch(Exception e)
{}
}
}
class Read implements Runnable
{
private PipedInputStream in ;
Read(PipedInputStream in )
{
this.in = in ;
}
public void run()
{
try
{
byte[] buf = new byte[1024];
int len = in .read(buf);
String s = new String(buf, 0, len);
System.out.println("读取到的数据：" + s); in .close();
}
catch(IOException e)
{}
}
}
public static void main(String[] args)
{
PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();
in.connect(out); // 管道连接
Read r = new Read( in );
Write w = new Write(out);
new Thread(r).start();
new Thread(w).start();
}
例子2 消息通信：
public class Sender extends Thread {
private PipedOutputStream pos = new PipedOutputStream();
public Sender(PipedOutputStream pos) {
this.pos = pos;
}
@Override
public void run() {
sendShortMessage();
}
// 发送消息
public void sendShortMessage() {
try {
pos.write("你好!".getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
pos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public class Reciver extends Thread {
private PipedInputStream pis = new PipedInputStream();
public Reciver(PipedInputStream pis) {
this.pis = pis;
}
@Override
public void run() {
byte[] buf = new byte[2048];
try {
pis.read(buf);
pis.close();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("Reciver :" + new String(buf));
}
}
public class PipedConnectTest {
public static void main(String[] args) throws IOException {
PipedOutputStream pipedOutputStream = new PipedOutputStream();
PipedInputStream pipedInputStream = new PipedInputStream();
Sender sender = new Sender(pipedOutputStream);
Reciver reciver = new Reciver(pipedInputStream);
pipedInputStream.connect(pipedOutputStream);
sender.start();
reciver.start();
}
}
FilterOutputStream 子类
过滤字节输出流、与此类是过滤输出流的所有类的超类。这些流位于已存在的输出流（基础输出流）之上，它们将已存在的输出流作为其基本数据接收器，但可能直接传输数据或提供一些额外的功能。
FilterOutputStream 类本身只是简单地重写那些将所有请求传递给所包含输出流的 OutputStream 的所有方法。FilterOutputStream 的子类可进一步地重写这些方法中的一些方法，并且还可以提供一些额外的方法和字段。
FilterOutputStream 类的常用子类有：
BufferedOutputStream：提供了对OutputStream 的缓冲功能，内部提供缓冲区存储数据，这样避免数据直接写入流，从而提高性能。
DataOutputStream：可以将原始Java数据类型写入到流中，然后应用可以使用 DataInputStream 来读取数据。
PrintStream：以合适的格式打印任何数据类型值。
构造方法：
public FilterOutputStream(OutputStream out)
常用方法：
void write(byte b);将一个字节写入到当前输出流管道中。
void write(byte[] b);将字节数组b中所有字节写入到当前输出流管道中。
void write(byte[] b, int off, int len);将字节数组b从下标off开始、len个字节写入当前输出流管道中
void flush();flush当前流、将当前流中的所有数据冲刷到目的地中。
void close();关闭当前流、释放与当前流有关的所有资源。
DataOutputStream 输出例子
public class DataOutputStreamTest {
public static void main(String[] args) {
try {
File file = new File("E:\\out.txt");
FileOutputStream out = new FileOutputStream(file);
DataOutputStream dos = new DataOutputStream(out);
dos.writeInt(100);
dos.writeBytes("Hello world!");
dos.writeUTF("世界，你好！");
}
catch (FileNotFoundException e) {
System.out.println("文件不存在");
}
catch (IOException e) {
System.out.println("写入过程存在异常");
}
}
}
PrintStream
PrintStream为其他输出流添加了功能，使它们能够方便地打印各种数据值和表示形式。
构造方法：
PrintStream(File file)：输出的目的地是一个文件
PrintStream(OutputStream out)：输出的目的地是一个字节流
PrintStream(String fileName)：输出的目的地是文件路径
PrintStream 继承自父类的成员方法：
public void close():关闭此输出流并释放此流相关联的任何系统资源
public void flush():刷新此流并强制任何缓冲流的输出字节被写出。
public void write(byte[] b):将b.Length字节从指定的字节写入此输出流。
public void write(byte[] b,int off,int len):从指定的字节数组写入len字节，从偏移量off开始输出到此输出流。
public abstract void write(int b):将指定的字节流输出
PrintStream例子：
public class PrintStreamTest {
public static void main(String arg[]) throws IOException {
PrintStream ps=new PrintStream("D:\\a.txt");
ps.write(97);
ps.println(97);
ps.println("HelloWorld");
close();
}
}
标签： #netinputstream
