Ⅰ java输入输出流怎么写，
stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。在Java的IO中，所有的stream（包括Inputstream和Out stream）都包括两种类型：
(1)字节流
表示以字节为单位从stream中读取或往stream中写入信息，即io包中的inputstream类和outputstream类的派生类。通常用来读取二进制数据，如图象和声音。
（2）字符流
以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。
区别：
Reader和Writer要解决的，最主要的问题就是国际化。原先的I/O类库只支持8位的字节流，因此不可能很好地处理16位的Unicode字符流。Unicode是国际化的字符集(更何况Java内置的char就是16位的Unicode字符)，这样加了Reader和Writer之后，所有的I/O就都支持Unicode了。此外新类库的性能也比旧的好。
但是，Read和Write并不是取代InputStream和OutputStream，有时，你还必须同时使用"基于byte的类"和"基于字符的类"。为此，它还提供了两个"适配器(adapter)"类。InputStreamReader负责将InputStream转化成Reader，而OutputStreamWriter则将OutputStream转化成Writer。
一．流的层次结构
定义：
（1） java将读取数据对象成为输入流，能向其写入的对象叫输出流。结构图如下：输入流：
输出流
二．InputStream类
inputstream类和outputstream类都为抽象类，不能创建对象，可以通过子类来实例化。
InputStream是输入字节数据用的类，所以InputStream类提供了3种重载的read方法.Inputstream类中的常用方法：
（1） public abstract int read( )：读取一个byte的数据，返回值是高位补0的int类型值。
（2） public int read(byte b[ ])：读取b.length个字节的数据放到b数组中。返回值是读取的字节数。该方法实际上是调用下一个方法实现的
（3） public int read(byte b[ ], int off, int len)：从输入流中最多读取len个字节的数据，存放到偏移量为off的b数组中。
（4） public int available( )：返回输入流中可以读取的字节数。注意：若输入阻塞，当前线程将被挂起，如果InputStream对象调用这个方法的话，它只会返回0，这个方法必须由继承InputStream类的子类对象调用才有用，
（5） public long skip(long n)：忽略输入流中的n个字节，返回值是实际忽略的字节数, 跳过一些字节来读取
（6） public int close( ) ：我们在使用完后，必须对我们打开的流进行关闭.
三．OutputStream类
OutputStream提供了3个write方法来做数据的输出，这个是和InputStream是相对应的。
1. public void write(byte b[ ])：将参数b中的字节写到输出流。
2. public void write(byte b[ ], int off, int len) ：将参数b的从偏移量off开始的len个字节写到输出流。
3. public abstract void write(int b) ：先将int转换为byte类型，把低字节写入到输出流中。
4. public void flush( ) : 将数据缓冲区中数据全部输出，并清空缓冲区。
5. public void close( ) : 关闭输出流并释放与流相关的系统资源。
注意：
1. 上述各方法都有可能引起异常。
2. InputStream和OutputStream都是抽象类，不能创建这种类型的对象。
四．FileInputStream类
FileInputStream类是InputStream类的子类，用来处理以文件作为数据输入源的数据流。使用方法：
方式1：
File fin=new File("d:/abc.txt");
FileInputStream in=new FileInputStream(fin);
方式2：
FileInputStream in=new
FileInputStream("d: /abc.txt");
方式3：
构造函数将 FileDescriptor()对象作为其参数。
FileDescriptor() fd=new FileDescriptor();
FileInputStream f2=new FileInputStream(fd);
五．FileOutputStream类
FileOutputStream类用来处理以文件作为数据输出目的数据流；一个表示文件名的字符串，也可以是File或FileDescriptor对象。
创建一个文件流对象有两种方法：
方式1：
File f=new File("d:/abc.txt");
FileOutputStream out=new FileOutputStream (f);
方式2：
FileOutputStream out=new
FileOutputStream("d:/abc.txt");
方式3：构造函数将 FileDescriptor()对象作为其参数。
FileDescriptor() fd=new FileDescriptor();
FileOutputStream f2=new FileOutputStream(fd);
方式4：构造函数将文件名作为其第一参数，将布尔值作为第二参数。
FileOutputStream f=new FileOutputStream("d:/abc.txt",true);
注意：
（1）文件中写数据时，若文件已经存在，则覆盖存在的文件；（2）的读/写操作结束时，应调用close方法关闭流。
举例：2-1
六．File类
File类与InputStream / OutputStream类同属于一个包，它不允许访问文件内容。
File类主要用于命名文件、查询文件属性和处理文件目录。
举例：2-2
七．从一个流构造另一个流
java的流类提供了结构化方法，如，底层流和高层过滤流。
而高层流不是从输入设备读取，而是从其他流读取。同样高层输出流也不是写入输出设备，而是写入其他流。
使用"分层对象(layered objects)"，为单个对象动态地，透明地添加功能的做法，被称为Decorator Pattern。Decorator模式要求所有包覆在原始对象之外的对象，都必须具有与之完全相同的接口。这使得decorator的用法变得非常的透明--无论对象是否被decorate过，传给它的消息总是相同的。这也是Java I/O类库要有"filter(过滤器)"类的原因：抽象的"filter"类是所有decorator的基类。Decorator模式常用于如下的情形：如果用继承来解决各种需求的话，类的数量会多到不切实际的地步。Java的I/O类库需要提供很多功能的组合，于是decorator模式就有了用武之地。
为InputStream和OutputStream定义decorator类接口的类，分别是FilterInputStream和FilterOutputStream。
7.1 FilterInputStream
FilterInputStream的种类
类
功能
构造函数的参数
用法
DataInputStream
与DataOutputStream配合使用，这样你就能以一种"可携带的方式(portable fashion)"从流里读取primitives了（int，char，long等）
InputStream
包含了一整套读取primitive数据的接口。
BufferedInputStream
用这个类来解决"每次要用数据的时候都要进行物理读取"的问题。你的意思是"用缓冲区。"
InputStream，以及可选的缓冲区的容量
它本身并不提供接口，只是提供一个缓冲区。需要连到一个"有接口的对象(interface object)"。
LineNumberInputStream
跟踪输入流的行号；有getLineNumber( )和setLineNumber(int)方法
InputStream
只是加一个行号，所以还得连一个"有接口的对象"。
PushbackInputStream
有一个"弹压单字节"的缓冲区(has a one byte push-back buffer)，这样你就能把最后读到的那个字节再压回去了。
InputStream
主要用于编译器的扫描程序。可能是为支持Java的编译器而设计的。用的机会不多。
FilterOutputStream的种类
类
功能
构造函数的参数
用法
DataOutputStream
与DataInputStream配合使用，这样你就可以用一种"可携带的方式(portable fashion)"往流里写primitive了(int, char, long,等)
OutputStream
包括写入primitive数据的全套接口。
PrintStream
负责生成带格式的输出(formatted output)。DataOutputStrem负责数据的存储，而PrintStream负责数据的显示。
一个OutputStream以及一个可选的boolean值。这个boolean值表示，要不要清空换行符后面的缓冲区。
应该是OutputStream对象的最终包覆层。用的机会很多。
BufferedOutputStream
用 这个类解决"每次往流里写数据，都要进行物理操作"的问题。也就是说"用缓冲区"。用flush( )清空缓冲区。
OutputStream， 以及一个可选的缓冲区大小
本身并不提供接口，只是加了一个缓冲区。需要链接一个有接口的对象。
DataInputStream类对象可以读取各种类型的数据。
DataOutputStream类对象可以写各种类型的数据；
创建这两类对象时，必须使新建立的对象指向构造函数中的参数对象。例如：
FileInputStream in=new FileInputStream("d:/abc.txt");
DataInputStream din=new DataInputStream(in);
7.2BufferInputStream和bufferOutputStream
允许程序在不降低系统性能的情况下一次一个字节的从流中读取数据。
BufferInputstream定义了两种构造函数
（1） BufferInputStream b= new BufferInputstream(in);
（2） BufferInputStream b=new BufferInputStream(in,size)
第二个参数表示指定缓冲器的大小。
同样BufferOutputStream也有两种构造函数。一次一个字节的向流中写数据。
7.3printstream
用于写入文本或基本类型
两种构造函数方法：
PrintStream ps=new PrintStream(out);
PrintStream ps=new PrintStream(out, autoflush)
第二个参数为布尔值，控制每次输出换行符时java是否刷新输出流。
八．字符流的读取和写入
java.io.Reader 和 java.io.InputStream 组成了 Java 输入类。Reader 用于读入16位字符，也就是 Unicode 编码的字符；而 InputStream 用于读入 ASCII 字符和二进制数据。
Reader的体系结构
（1） FileReader
FileReader主要用来读取字符文件，使用缺省的字符编码，有三种构造函数：
--将文件名作为字符串
FileReader f=new FileReader(“c:/temp.txt”);
--构造函数将File对象作为其参数。
File f=new file(“c:/temp.txt”);
FileReader f1=new FileReader(f);
--构造函数将FileDescriptor对象作为参数
FileDescriptor() fd=new FileDescriptor()
FileReader f2=new FileReader(fd);
(2) charArrayReader
将字符数组作为输入流,构造函数为：
public CharArrayReader(char[] ch);
(3) StringReader
读取字符串，构造函数如下：
public StringReader(String s);
(4) InputStreamReader
从输入流读取字节，在将它们转换成字符。
Public inputstreamReader(inputstream is);
(5) FilterReader
允许过滤字符流
protected filterReader(Reader r);
(6) BufferReader
接受Reader对象作为参数，并对其添加字符缓冲器，使用readline()方法可以读取一行。
Public BufferReader(Reader r);
Writer类体系结构
（1） FileWrite
将字符类型数据写入文件，使用缺省字符编码和缓冲器大小。
Public FileWrite(file f);
(2)chararrayWrite()
将字符缓冲器用作输出。
Public CharArrayWrite();
(3) PrintWrite
生成格式化输出
public PrintWriter(outputstream os);
(4) filterWriter
用于写入过滤字符流
protected FilterWriter(Writer w);
FilterOutputStream的种类
类
功能
构造函数的参数
用法
DataOutputStream
与DataInputStream配合使用，这样你就可以用一种"可携带的方式(portable fashion)"往流里写primitive了(int, char, long,等)
OutputStream
包括写入primitive数据的全套接口。
PrintStream
负责生成带格式的输出(formatted output)。DataOutputStrem负责数据的存储，而PrintStream负责数据的显示。
一个OutputStream以及一个可选的boolean值。这个boolean值表示，要不要清空换行符后面的缓冲区。
应该是OutputStream对象的最终包覆层。用的机会很多。
BufferedOutputStream
用 这个类解决"每次往流里写数据，都要进行物理操作"的问题。也就是说"用缓冲区"。用flush( )清空缓冲区。
OutputStream， 以及一个可选的缓冲区大小
本身并不提供接口，只是加了一个缓冲区。需要链接一个有接口的对象。
DataInputStream类对象可以读取各种类型的数据。
DataOutputStream类对象可以写各种类型的数据；
创建这两类对象时，必须使新建立的对象指向构造函数中的参数对象。例如：
FileInputStream in=new FileInputStream("d:/abc.txt");
DataInputStream din=new DataInputStream(in);
7.2BufferInputStream和bufferOutputStream
允许程序在不降低系统性能的情况下一次一个字节的从流中读取数据。
BufferInputstream定义了两种构造函数
（1） BufferInputStream b= new BufferInputstream(in);
（2） BufferInputStream b=new BufferInputStream(in,size)
第二个参数表示指定缓冲器的大小。
同样BufferOutputStream也有两种构造函数。一次一个字节的向流中写数据。
7.3printstream
用于写入文本或基本类型
两种构造函数方法：
PrintStream ps=new PrintStream(out);
PrintStream ps=new PrintStream(out, autoflush)
第二个参数为布尔值，控制每次输出换行符时java是否刷新输出流
Ⅱ java怎么输出
java控制台输出由print( ) 和 println( )来完成最为简单。这两种方法由rintStream(System.out引用的对象类型)定义。尽管System.out是一个字节流，用它作为简单程序的输出是可行的。因为PrintStream是从OutputStream派生的输出流，它同样实现低级方法write()，write()可用来向控制台写数据。PrintStream 定义的write( )的最简单的形式如下：
void write(int byteval)
该方法按照byteval指定的数目向文件写字节。尽管byteval 定义成整数，但只有低位的8个字节被写入。下面的短例用 write()向屏幕输出字符“A”，然后是新的行。
// Demonstrate System.out.write().
class WriteDemo {
public static void main(String args[]) {
int b;
b = 'A';
System.out.write(b);
System.out.write(' ');
}
}
一般不常用write()来完成向控制台的输出（尽管这样做在某些场合非常有用），因为print()和println() 更容易用。
四、PrintWriter类
尽管Java允许用System.out向控制台写数据，但建议仅用在调试程序时或在例程中。对于实际的程序，Java推荐的向控制台写数据的方法是用PrintWriter流。PrintWriter是基于字符的类。用基于字符类向控制台写数据使程序更为国际化。PrintWriter定义了多个构造函数，这里所用到的一个如下：
PrintWriter(OutputStream outputStream, boolean flushOnNewline)
outputStream是OutputStream类的对象，flushOnNewline控制Java是否在println()方法被调用时刷新输出流。如果flushOnNewline为true，刷新自动发生，若为false，则不发生。
PrintWriter支持所有类型（包括Object）的print( )和println( )方法，这样，就可以像用ystem.out那样用这些方法。如果遇到不同类型的情况，PrintWriter方法调用对象的toString()方法并打印结果。用PrintWriter向外设写数据，指定输出流为System.out并在每一新行后刷新流。例如这行代码创建了与控制台输出相连的PrintWriter类。
PrintWriter pw = new PrintWriter(System.out, true);
下面的应用程序说明了用PrintWriter处理控制台输出的方法：
// Demonstrate PrintWriter
import java.io.*;
public class PrintWriterDemo {
public static void main(String args[]) {
PrintWriter pw = new PrintWriter(System.out, true);
pw.println("This is a string");
int i = -7;
pw.println(i);
double d = 4.5e-7;
pw.println(d);
}
}
该程序的输出如下：
This is a string
-7
4.5E-7
Ⅲ java如何使用文件字节输出流类：FileOutputStream
文件字节输出流关联指定文件路径的文件，数据通过文件字节输出流以字节为单位输出并保存到文件中。文件字节输出流继承自OutputStream类，并实现OutputStream类的各种方法。
文件字节输出流的构造方法语法如下：
语法1：以File对象为参数创建FileOutputStream实例
语法2：以文件对象的绝对路径为参数创建FIleOutputStream实例
Ⅳ java如何使用字节输出流抽象类OutputStream类
OutputStream定义了输出流的各种方法，如下表：
返回
方法
说明
void write(byte[ ] b) 将byte[ ] 数组中的数据写入当前输出流
void write(byte[] b ,int off, int len) 将byte[ ]数组下标off开始的len长度的数据写入当前输出流
Abstract void write（int b) 写入一个byte数据到当前输出流
void flush() 刷新当前输出流，并强制写入所有缓冲的字节数据
void close（） 关闭当前输出流
Ⅳ 6 请简述java io中stream流和read流的区别，并分别列举2个常用的stream流和read流
Java 流在处理上分为字符流和字节流。字符流处理的单元为 2 个字节的 Unicode 字符，分别操作字符、字符数组或字符串，而字节流处理单元为 1 个字节，操作字节和字节数组。
Java 内用 Unicode 编码存储字符，字符流处理类负责将外部的其他编码的字符流和 java 内 Unicode 字符流之间的转换。而类 InputStreamReader 和 OutputStreamWriter 处理字符流和字节流的转换。字符流（一次可以处理一个缓冲区）一次操作比字节流（一次一个字节）效率高。
( 一 )以字节为导向的 stream------InputStream/OutputStream
InputStream 和 OutputStream 是两个 abstact 类，对于字节为导向的 stream 都扩展这两个鸡肋（基类 ^_^ ） ;
1、 InputStream
1.1
ByteArrayInputStream -- 把内存中的一个缓冲区作为 InputStream 使用 .
construct---
(A)ByteArrayInputStream(byte[]) 创建一个新字节数组输入流（ ByteArrayInputStream ），它从指定字节数组中读取数据（ 使用 byte 作为其缓冲区数组）
(B)---ByteArrayInputStream(byte[], int, int) 创建一个新字节数组输入流，它从指定字节数组中读取数据。
---mark:: 该字节数组未被复制。
1.2
StringBufferInputStream -- 把一个 String 对象作为 InputStream .
construct---
StringBufferInputStream(String) 据指定串创建一个读取数据的输入流串。
注释：不使用 StringBufferInputStream 方法。此类不能将字符正确的转换为字节。
同 JDK 1.1 版中的类似，从一个串创建一个流的最佳方法是采用 StringReader 类。
1.3
FileInputStream -- 把一个文件作为 InputStream ，实现对文件的读取操作
construct---
(A)FileInputStream(File name) 创建一个输入文件流，从指定的 File 对象读取数据。
(B)FileInputStream(FileDescriptor) 创建一个输入文件流，从指定的文件描述器读取数据。
(C)-FileInputStream(String name) 创建一个输入文件流，从指定名称的文件读取数据。
method ---- read() 从当前输入流中读取一字节数据。
read(byte[]) 将当前输入流中 b.length 个字节数据读到一个字节数组中。
read(byte[], int, int) 将输入流中 len 个字节数据读入一个字节数组中。
1.4
PipedInputStream ：实现了 pipe 的概念，主要在线程中使用 . 管道输入流是指一个通讯管道的接收端。
一个线程通过管道输出流发送数据，而另一个线程通过管道输入流读取数据，这样可实现两个线程间的通讯。
construct---
PipedInputStream() 创建一个管道输入流，它还未与一个管道输出流连接。
PipedInputStream(PipedOutputStream) 创建一个管道输入流 , 它已连接到一个管道输出流。
1.5
SequenceInputStream ：把多个 InputStream 合并为一个 InputStream . “序列输入流”类允许应用程序把几个输入流连续地合并起来，
并且使它们像单个输入流一样出现。每个输入流依次被读取，直到到达该流的末尾。
然后“序列输入流”类关闭这个流并自动地切换到下一个输入流。
construct---
SequenceInputStream(Enumeration) 创建一个新的序列输入流，并用指定的输入流的枚举值初始化它。
SequenceInputStream(InputStream, InputStream) 创建一个新的序列输入流，初始化为首先 读输入流 s1, 然后读输入流 s2 。
2、 OutputSteam
2.1
ByteArrayOutputStream ： 把信息存入内存中的一个缓冲区中 . 该类实现一个以字节数组形式写入数据的输出流。
当数据写入缓冲区时，它自动扩大。用 toByteArray() 和 toString() 能检索数据。
constructor
(A)--- ByteArrayOutputStream() 创建一个新的字节数组输出流。
(B)--- ByteArrayOutputStream() 创建一个新的字节数组输出流。
(C)--- ByteArrayOutputStream(int) 创建一个新的字节数组输出流，并带有指定大小字节的缓冲区容量。
toString(String) 根据指定字符编码将缓冲区内容转换为字符串，并将字节转换为字符。
write(byte[], int, int) 将指定字节数组中从偏移量 off 开始的 len 个字节写入该字节数组输出流。
write(int) 将指定字节写入该字节数组输出流。
writeTo(OutputStream) 用 out.write(buf, 0, count) 调用输出流的写方法将该字节数组输出流的全部内容写入指定的输出流参数。
2.2
FileOutputStream: 文件输出流是向 File 或 FileDescriptor 输出数据的一个输出流。
constructor
(A)FileOutputStream(File name) 创建一个文件输出流，向指定的 File 对象输出数据。
(B)FileOutputStream(FileDescriptor) 创建一个文件输出流，向指定的文件描述器输出数据。
(C)FileOutputStream(String name) 创建一个文件输出流，向指定名称的文件输出数据。
(D)FileOutputStream(String, boolean) 用指定系统的文件名，创建一个输出文件。
2.3
PipedOutputStream: 管道输出流是指一个通讯管道的发送端。一个线程通过管道输出流发送数据，
而另一个线程通过管道输入流读取数据，这样可实现两个线程间的通讯。
constructor
(A)PipedOutputStream() 创建一个管道输出流，它还未与一个管道输入流连接。
(B)PipedOutputStream(PipedInputStream) 创建一个管道输出流，它已连接到一个管道输入流。
( 二 )以字符为导向的 stream Reader/Writer
以 Unicode 字符为导向的 stream ，表示以 Unicode 字符为单位从 stream 中读取或往 stream 中写入信息。
Reader/Writer 为 abstact 类
以 Unicode 字符为导向的 stream 包括下面几种类型：
Reader
1.1
CharArrayReader ：与 ByteArrayInputStream 对应此类实现一个可用作字符输入流的字符缓冲区
constructor
CharArrayReader(char[]) 用指定字符数组创建一个 CharArrayReader 。
CharArrayReader(char[], int, int) 用指定字符数组创建一个 CharArrayReader
1.2
StringReader ： 与 StringBufferInputStream 对应其源为一个字符串的字符流。
StringReader(String) 创建一新的串读取者。
1.3
FileReader ： 与 FileInputStream 对应
1.4
PipedReader ：与 PipedInputStream 对应
2. Writer
2.1 CharArrayWrite ： 与 ByteArrayOutputStream 对应
2.2 StringWrite ：无与之对应的以字节为导向的 stream
2.3 FileWrite ： 与 FileOutputStream 对应
2.4 PipedWrite ：与 PipedOutputStream 对应
3、两种不同导向的 stream 之间的转换
3.1
InputStreamReader 和 OutputStreamReader ：
把一个以字节为导向的 stream 转换成一个以字符为导向的 stream 。
InputStreamReader 类是从字节流到字符流的桥梁：它读入字节，并根据指定的编码方式，将之转换为字符流。
使用的编码方式可能由名称指定，或可接受的缺省编码方式。
InputStreamReader 的 read() 方法之一的每次调用，可能促使从基本字节输入流中读取一个或多个字节。
为了达到更高效率，考虑用 BufferedReader 封装 InputStreamReader ，
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
例如： // 实现从键盘输入一个整数
view plain to clipboardprint?
String s = null;
InputStreamReader re = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(re);
try {
s = br.readLine();
System.out.println("s= " + Integer.parseInt(s));
br.close();
}
catch (IOException e)
{
e.printStackTrace();
}
catch (NumberFormatException e)// 当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。
{
System.out.println(" 输入的不是数字 ");
}
String s = null; InputStreamReader re = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(re); try { s = br.readLine(); System.out.println("s= " + Integer.parseInt(s)); br.close(); } catch (IOException e) { e.printStackTrace(); } catch (NumberFormatException e)// 当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。 { System.out.println(" 输入的不是数字 "); }
InputStreamReader(InputStream) 用缺省的字符编码方式，创建一个 InputStreamReader 。
InputStreamReader(InputStream, String) 用已命名的字符编码方式，创建一个 InputStreamReader 。
OutputStreamWriter 将多个字符写入到一个输出流，根据指定的字符编码将多个字符转换为字节。
每个 OutputStreamWriter 合并它自己的 CharToByteConverter, 因而是从字符流到字节流的桥梁。
（三）Java IO 的一般使用原则：
一、按数据来源（去向）分类：
1 、是文件： FileInputStream, FileOutputStream, ( 字节流 )FileReader, FileWriter( 字符 )
2 、是 byte[] ： ByteArrayInputStream, ByteArrayOutputStream( 字节流 )
3 、是 Char[]: CharArrayReader, CharArrayWriter( 字符流 )
4 、是 String: StringBufferInputStream, StringBufferOuputStream ( 字节流 )StringReader, StringWriter( 字符流 )
5 、网络数据流： InputStream, OutputStream,( 字节流 ) Reader, Writer( 字符流 )
二、按是否格式化输出分：
1 、要格式化输出： PrintStream, PrintWriter
三、按是否要缓冲分：
1 、要缓冲： BufferedInputStream, BufferedOutputStream,( 字节流 ) BufferedReader, BufferedWriter( 字符流 )
四、按数据格式分：
1 、二进制格式（只要不能确定是纯文本的） : InputStream, OutputStream 及其所有带 Stream 结束的子类
2 、纯文本格式（含纯英文与汉字或其他编码方式）； Reader, Writer 及其所有带 Reader, Writer 的子类
五、按输入输出分：
1 、输入： Reader, InputStream 类型的子类
2 、输出： Writer, OutputStream 类型的子类
六、特殊需要：
1 、从 Stream 到 Reader,Writer 的转换类： InputStreamReader, OutputStreamWriter
2 、对象输入输出： ObjectInputStream, ObjectOutputStream
3 、进程间通信： PipeInputStream, PipeOutputStream, PipeReader, PipeWriter
4 、合并输入： SequenceInputStream
5 、更特殊的需要： PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader
决定使用哪个类以及它的构造进程的一般准则如下（不考虑特殊需要）：
首先，考虑最原始的数据格式是什么： 原则四
第二，是输入还是输出：原则五
第三，是否需要转换流：原则六第 1 点
第四，数据来源（
Ⅵ java中有哪些常用的输入/输出流，它们的主要区别是什么
以 Stream 结尾的都是字节流，就是一个字节一个字节的读取都有些什么类 你去网络一下就知道了，很好找Input还是output 都是对于你自己的程序而言的 Input 就是输入流，对于你的程序 是有东西 输入进来了，也就是读取别人的东西output 就是输出流，对于你的程序 是把东西 输出去了，就是 把东西 写入到别人的文件里
BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter ByteArrayInputStream ByteArrayOutputStream CharArrayReader CharArrayWriter DataInputStream DataOutputStream FileInputStream FileOutputStream FileReader FileWriter FilterInputStream FilterOutputStream FilterReader FilterWriter InputStream InputStreamReader LineNumberInputStream LineNumberReader ObjectInputStream ObjectOutputStream OutputStream OutputStreamWriter PipedInputStream PipedOutputStream PipedReader PipedWriter PrintStream PrintWriter Reader StringBufferInputStream StringReader StringWriter WriterWriter和Reader为字符流 input和output为字节流至于如何确定 看名字就知道了
Ⅶ java输入输出流哪种最常用
InputStream，OutputStream，FileInputStream，FileOutputStream，字节流
Reader，Writer，FileReader，FileWriter，BufferedReader，字符流...
DataInputStream，DataOutputStream，数据流...
Ⅷ java 输入输出流 （被采纳为答案者加100分）
stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。在Java的IO中，所有的stream（包括Inputstream和Out stream）都包括两种类型：
(1)字节流
表示以字节为单位从stream中读取或往stream中写入信息，即io包中的inputstream类和outputstream类的派生类。通常用来读取二进制数据，如图象和声音。
（2）字符流
以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。
区别：
Reader和Writer要解决的，最主要的问题就是国际化。原先的I/O类库只支持8位的字节流，因此不可能很好地处理16位的Unicode字符流。Unicode是国际化的字符集(更何况Java内置的char就是16位的Unicode字符)，这样加了Reader和Writer之后，所有的I/O就都支持Unicode了。此外新类库的性能也比旧的好。
但是，Read和Write并不是取代InputStream和OutputStream，有时，你还必须同时使用"基于byte的类"和"基于字符的类"。为此，它还提供了两个"适配器(adapter)"类。InputStreamReader负责将InputStream转化成Reader，而OutputStreamWriter则将OutputStream转化成Writer。
一．流的层次结构
定义：
（1） java将读取数据对象成为输入流，能向其写入的对象叫输出流。
二．InputStream类
inputstream类和outputstream类都为抽象类，不能创建对象，可以通过子类来实例化。
InputStream是输入字节数据用的类，所以InputStream类提供了3种重载的read方法.Inputstream类中的常用方法：
（1） public abstract int read( )：读取一个byte的数据，返回值是高位补0的int类型值。
（2） public int read(byte b[ ])：读取b.length个字节的数据放到b数组中。返回值是读取的字节数。该方法实际上是调用下一个方法实现的
（3） public int read(byte b[ ], int off, int len)：从输入流中最多读取len个字节的数据，存放到偏移量为off的b数组中。
（4） public int available( )：返回输入流中可以读取的字节数。注意：若输入阻塞，当前线程将被挂起，如果InputStream对象调用这个方法的话，它只会返回0，这个方法必须由继承InputStream类的子类对象调用才有用，
（5） public long skip(long n)：忽略输入流中的n个字节，返回值是实际忽略的字节数, 跳过一些字节来读取
（6） public int close( ) ：我们在使用完后，必须对我们打开的流进行关闭.
三．OutputStream类
OutputStream提供了3个write方法来做数据的输出，这个是和InputStream是相对应的。
1. public void write(byte b[ ])：将参数b中的字节写到输出流。
2. public void write(byte b[ ], int off, int len) ：将参数b的从偏移量off开始的len个字节写到输出流。
3. public abstract void write(int b) ：先将int转换为byte类型，把低字节写入到输出流中。
4. public void flush( ) : 将数据缓冲区中数据全部输出，并清空缓冲区。
5. public void close( ) : 关闭输出流并释放与流相关的系统资源。
注意：
1. 上述各方法都有可能引起异常。
2. InputStream和OutputStream都是抽象类，不能创建这种类型的对象。
四．FileInputStream类
FileInputStream类是InputStream类的子类，用来处理以文件作为数据输入源的数据流。使用方法：
方式1：
File fin=new File("d:/abc.txt");
FileInputStream in=new FileInputStream(fin);
方式2：
FileInputStream in=new
FileInputStream("d: /abc.txt");
方式3：
构造函数将 FileDescriptor()对象作为其参数。
FileDescriptor() fd=new FileDescriptor();
FileInputStream f2=new FileInputStream(fd);
五．FileOutputStream类
FileOutputStream类用来处理以文件作为数据输出目的数据流；一个表示文件名的字符串，也可以是File或FileDescriptor对象。
创建一个文件流对象有两种方法：
方式1：
File f=new File("d:/abc.txt");
FileOutputStream out=new FileOutputStream (f);
方式2：
FileOutputStream out=new
FileOutputStream("d:/abc.txt");
方式3：构造函数将 FileDescriptor()对象作为其参数。
FileDescriptor() fd=new FileDescriptor();
FileOutputStream f2=new FileOutputStream(fd);
方式4：构造函数将文件名作为其第一参数，将布尔值作为第二参数。
FileOutputStream f=new FileOutputStream("d:/abc.txt",true);
注意：
（1）文件中写数据时，若文件已经存在，则覆盖存在的文件；（2）的读/写操作结束时，应调用close方法关闭流。
举例：2-1
六．File类
File类与InputStream / OutputStream类同属于一个包，它不允许访问文件内容。
File类主要用于命名文件、查询文件属性和处理文件目录。
举例：2-2
七．从一个流构造另一个流
java的流类提供了结构化方法，如，底层流和高层过滤流。
而高层流不是从输入设备读取，而是从其他流读取。同样高层输出流也不是写入输出设备，而是写入其他流。
使用"分层对象(layered objects)"，为单个对象动态地，透明地添加功能的做法，被称为Decorator Pattern。Decorator模式要求所有包覆在原始对象之外的对象，都必须具有与之完全相同的接口。这使得decorator的用法变得非常的透明--无论对象是否被decorate过，传给它的消息总是相同的。这也是Java I/O类库要有"filter(过滤器)"类的原因：抽象的"filter"类是所有decorator的基类。Decorator模式常用于如下的情形：如果用继承来解决各种需求的话，类的数量会多到不切实际的地步。Java的I/O类库需要提供很多功能的组合，于是decorator模式就有了用武之地。
为InputStream和OutputStream定义decorator类接口的类，分别是FilterInputStream和FilterOutputStream。
7.1 FilterInputStream
.......
具体去这里看看把，有很详细的介绍。希望对你有帮助。
Ⅸ java web response 怎样获得输出流
ServletResponse中定义了如下两个方法
getOutputStream();
getWriter();
对应获得字节流和字符流
由于HttpServletResponse继承自ServletResponse所以天生也具有以上两个获得输出流的方法
Ⅹ java IO输入输出流中的各种字节流，字符流类，我需要都记住吗，还是只要记住几个常用的呢
记住几个常用的就行了， 一般也就是用几个常用的。
字节流
字节流主要是操作byte类型数据，也byte数组为准，主要操作类就是
·字节输出流：OutputStream
·字节输入流：InputStream
字符流
在程序中一个字符等于2个字节，那么java提供了Reader、Writer两个专门操作字符流的类。
·字符输出流：Writer
·字符输入流：Reader
字节-字符转换流
OutputStreamWriter和InputStreamReader
在整个IO包中，实际上就是字节流和字符流，但是除了这两个流之外，还存在一组字节流-字符流的转换类。
[java] view plainprint?
•OutputStreamWriter：是Writer的子类，将输出的字符流转换为字节流。即：将一个字节流的输出对象变为字节流的输出对象
•InputStreamReader：是Reader的子类，将输入的字节流变为字符流，即：将一个字节流的输入对象变为字符流的输入对象。