java中的输入流

⑴ java字节输入流什么意思输入的是字节，输出的是字符

实现上 字节输出流是继承OutputStream 而字符输出流继承OutputStreamWriter
应用上 字符流是专门用来处理文字的，包含了对多国语言的支持，而字节流主要是用来处理文字以外的如binary文件。

⑵ Java如何把字符串转化为输入流

//txt为TextArea内的字符串
try{
InputStream
myIn=new
ByteArrayInputStream(txt.getBytes());
//将System.in转化为面向字符的流
InputStreamReader
ir
=
new
InputStreamReader(myIn);
in
=
new
BufferedReader(ir);//为输入流提供缓冲区
while
((s
=
in.readLine())
!=
"bye")
System.out.println("Read:
"
+
s);
}
catch(IOException
e)
{System.out.println("Error!
");}
}

⑶ 输入流的java的输入流

当然，我们经常想做的一件事情是将格式化的输出打印到控制台，但那已在第5章创建的com.bruceeckel.tools中得到了简化。第1到第4部分演示了输入流的创建与使用（尽管第4部分展示了将输出流作为一个测试工具的简单应用）。1.缓冲的输入文件为打开一个文件以便输入，需要使用一个FileInputStream，同时将一个String或File对象作为文件名使用。为提高速度，最好先对文件进行缓冲处理，从而获得用于一个BufferedInputStream的构建器的结果句柄。为了以格式化的形式读取输入数据，我们将那个结果句柄赋给用于一个DataInputStream的构建器。DataInputStream是我们的最终（final）对象，并是我们进行读取操作的接口。在这个例子中，只用到了readLine()方法，但理所当然任何DataInputStream方法都可以采用。一旦抵达文件末尾，readLine()就会返回一个null（空），以便中止并退出while循环。“Strings2”用于聚集完整的文件内容（包括必须添加的新行，因为readLine()去除了那些行）。随后，在本程序的后面部分中使用s2。最后，我们调用close()，用它关闭文件。从技术上说，会在运行finalize()时调用close()。而且我们希望一旦程序退出，就发生这种情况（无论是否进行垃圾收集）。然而，Java1.0有一个非常突出的错误（Bug），造成这种情况不会发生。在Java1.1中，必须明确调用System.runFinalizersOnExit(true)，用它保证会为系统中的每个对象调用finalize()。然而，最安全的方法还是为文件明确调用close()。2.从内存输入这一部分采用已经包含了完整文件内容的Strings2，并用它创建一个StringBufferInputStream（字串缓冲输入流）——作为构建器的参数，要求使用一个String，而非一个StringBuffer）。随后，我们用read()依次读取每个字符，并将其发送至控制台。注意read()将下一个字节返回为int，所以必须将其造型为一个char，以便正确地打印。3.格式化内存输入StringBufferInputStream的接口是有限的，所以通常需要将其封装到一个DataInputStream内，从而增强它的能力。然而，若选择用readByte()每次读出一个字符，那么所有值都是有效的，所以不可再用返回值来侦测何时结束输入。相反，可用available()方法判断有多少字符可用。下面这个例子展示了如何从文件中一次读出一个字符：//:TestEOF.java////abyteatatime.importjava.io.*;publicclassTestEOF{publicstaticvoidmain(String[]args){try{DataInputStreamin=newDataInputStream(newBufferedInputStream(newFileInputStream("TestEof.java")));while(in.available()!=0)System.out.print((char)in.readByte());}catch(IOExceptione){System.err.println("IOException");}}}///:~注意取决于当前从什么媒体读入，avaiable()的工作方式也是有所区别的。它在字面上意味着“可以不受阻塞读取的字节数量”。对一个文件来说，它意味着整个文件。但对一个不同种类的数据流来说，它却可能有不同的含义。因此在使用时应考虑周全。为了在这样的情况下侦测输入的结束，也可以通过捕获一个违例来实现。然而，若真的用违例来控制数据流，却显得有些大材小用。4.行的编号与文件输出这个例子展示了如何LineNumberInputStream来跟踪输入行的编号。在这里，不可简单地将所有构建器都组合起来，因为必须保持LineNumberInputStream的一个句柄（注意这并非一种继承环境，所以不能简单地将in4造型到一个LineNumberInputStream）。因此，li容纳了指向LineNumberInputStream的句柄，然后在它的基础上创建一个DataInputStream，以便读入数据。这个例子也展示了如何将格式化数据写入一个文件。首先创建了一个FileOutputStream，用它同一个文件连接。考虑到效率方面的原因，它生成了一个BufferedOutputStream。这几乎肯定是我们一般的做法，但却必须明确地这样做。随后为了进行格式化，它转换成一个PrintStream。用这种方式创建的数据文件可作为一个原始的文本文件读取。标志DataInputStream何时结束的一个方法是readLine()。一旦没有更多的字串可以读取，它就会返回null。每个行都会伴随自己的行号打印到文件里。该行号可通过li查询。可看到用于out1的、一个明确指定的close()。若程序准备掉转头来，并再次读取相同的文件，这种做法就显得相当有用。然而，该程序直到结束也没有检查文件IODemo.txt。正如以前指出的那样，如果不为自己的所有输出文件调用close()，就可能发现缓冲区不会得到刷新，造成它们不完整。

⑷ java中 什么是输出 输入流

程序操作的数据都应该是在内存里面，内存是你操作的主对象，把数据从其他资源里面传送到内存里面，就是输入，反之，把数据从内存传送到其他资源，就是输出。
读文件
BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream("infilename")));
不管从磁盘读，从网络读，或者从键盘读，读到内存，就是InputStream。
写文件
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("outfilename")));
不管写到磁盘，写到网络，或者写到屏幕，都是OuputStream

⑸ java如何使用字节输入流抽象类InputStream

InputStream 类是字节输入流的抽象类，定义了操作输入流的各种方法，这些方法如表：

返回
方法
说明

int available() 返回当前输入流的数据读取方法可以读取的有效字节数量
Abstract int read() 从当前数据流中读取一个字节。若已达到流结尾，则返回-1
int read(byte[ ] bytes) 从当前输入流读取一定的byte数据，并存取在数组中，然后返回读取的byte数据的数量，若已到达流结尾，则返回-1。
void reset() 将当前的输入流重新定位到最后一次调用mark()方法时的位置
void mark(int readlimit) 在当前输入流中做标记位置，当调用reset()方法时将返回到该位置，从标记位置开始，到再读入readlimit个字符为止，这个标记都维持有效。
Boolean markSupported() 测试当前输入流是否支持mark()和reset()方法，只要其中一个不支持，则返回false
long skip(long n) 跳过和丢弃当前输入的n个字节数据
void close() 关闭当前输入流，并释放任何与之相关联的系统资源

⑹ java怎么区分输入流和输出流

这个是依照内存为标准的，以加载磁盘上的文件到内存为例， 首先你必须把 磁盘上的文件，加载到 内存中，这个就是输入到内存， 你把内存里的文件，写到磁盘上，这个是把内存输出到磁盘上， 以内存为标准，写进内存，就是输入， 内存本身有内容，输出到别的地方，就是输出，一些网络的输入输出流，跟这个是一样的概念，以 客户端发送HTTP请求为例，客户端准备好了HTTP请求的内容，发送给服务器，这个就是输出流， 服务器返回一些内容，写进你本地的内存，这个就是输入，但是对于服务器来说，这个又是不一样的，你的请求对服务器来说，是输入，服务器给你的内容就是输出了。一端的输入，对于另一端来说就是输出，一端的输出，对另一端就是输入。

⑺ Java里那个输入流和输出流怎么用

//java中使用文件输入流和文件输出流进行文件读写的用例！
Java
packagecom.test.io;

importjava.io.File;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.OutputStream;

/**
*
*@author亚当爱上java
*用例内容：文件输入流和文件输入流结合用例，字节流方式
*时间：2010-06-20
*注意事项：文件输入流和文件输出流都是相对与内存来说的，例如通过程序读取文件时往内存输入数据就是文件输入流
*/

publicclassFileInputOrOutput{

publicstaticvoidmain(String[]args){

//文件或者路径名的抽象表现形式,意思就是说之后如果进行操作的话就是全部在这个抽象路径名所指向的文件或者文件加中
Filefile=newFile("e:/test.txt");
Filefile2=newFile("e:/test1.txt");

//文件字节数的个数
//System.out.println(file.length());
try{

/*------------------------------------------读操作部分-----------------------------------------------*/
//文件输入流对象
InputStreamfis=newFileInputStream(file);

//文件输入流对象所读取的字节数大小
//System.out.println(fis.available());

/**
*1.按照一个字节为单位进行读取数据,弊端是遇到中文就会把中文的汉字拆开从而出现乱码
*/

////流对象读出的返回值是每次所读到的一个字符所对应的ascii码值
//inti=fis.read();
//
////如果已经读到文件尾则i==-1,此时终止循环
//while(i!=-1){
//System.out.print((char)i);
//保证每一次循环都继续往后读取一个字符，否则i的值不变会成为死循环
//i=fis.read();
//}
/**
*2.按照一个字节数组所指定的大小为单位进行读取，每次最多可以读取数组定义的大小的字节个数
*/

//每次读取都以1K字节作为单位来进行
byteb[]=newbyte[1024];

//流对象读出并返回的是每次读取字节的个数，最大每次读取自己数可以和数组b.length相同
//b中存储了每次所读取的所有数据
inti=fis.read(b);

Stringstr="";
//如果已经读到文件尾则i==-1,此时终止循环
while(i!=-1){
//把每次读取的字节数组解码为字符串
//参数1：要解码为字符的字节
//参数2：要解码的首字符的索引
//参数3：要解码的字节的个数,如果文件个数大于所设定的一次读取文件的大小时i的取值就是
//b.length,否则小于数组的字节大小时则为实际的读取出自己数的大小
str=str+newString(b,0,i);

//保证每一次都往文件的下一部分进行读取，否则i值没有变化会成为死循环
i=fis.read(b);
}

//System.out.print(str);

//关闭输入流对象
fis.close();

/*------------------------------------------写操作部分-----------------------------------------------*/
//文件输出流对象
OutputStreamfos=newFileOutputStream(file2);

//str是从file所指定的文件中读出的所有内容，将此内容写入另一个文件中
//将字符解码为字节数组
byteb2[]=str.getBytes();

//将解码后的字节数组，通过文件输出流对象写入到缓冲区中
fos.write(b);
//强制将缓冲区中的内容输出到文件中
fos.flush();
//关闭输出流对象
fos.close();

}catch(FileNotFoundExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}

}
}

⑻ java中如何做文件字节输入流

首先，我以往经验是写入字节流和输出字节流的方式一定要一致，不然写入的字节流就会出错甚至读取不到，下面是字节流的写入和读取方法：

importjava.io.*;
classTest{
publicstaticvoidmain(Stringargs[]){
FileInputStreamfis=null;
FileOutputStreamfos=null;
byte[]buffer=newbyte[100];
inttemp=0;
try{
fis=newFileInputStream("D:/wenhao/src/from.txt");
fos=newFileOutputStream("D:/wenhao/src/to.txt");
while(true){
temp=fis.read(buffer,0,buffer.length);
if(temp==-1){
break;
}
fos.write(buffer,0,temp);
}
}
catch(Exceptione){
System.out.println(e);
}
finally{
try{
fis.close();
fos.close();
}
catch(Exceptione2){
System.out.println(e2);
}
}
}
}

⑼ java中的输入输出流该怎么理解

数据流是一串连续不断的数据的集合，就象水管里的水流，在水管的一端一点一点地供水，而在水管的另一端看到的是一股连续不断的水流。数据写入程序可以是一段、一段地向数据流管道中写入数据，这些数据段会按先后顺序形成一个长的数据流。对数据读取程序来说，看不到数据流在写入时的分段情况，每次可以读取其中的任意长度的数据，但只能先读取前面的数据后，再读取后面的数据。不管写入时是将数据分多次写入，还是作为一个整体一次写入，读取时的效果都是完全一样的。
“流是磁盘或其它外围设备中存储的数据的源点或终点。”
在电脑上的数据有三种存储方式，一种是外存，一种是内存，一种是缓存。比如电脑上的硬盘，磁盘，U盘等都是外存，在电脑上有内存条，缓存是在CPU里面的。外存的存储量最大，其次是内存，最后是缓存，但是外存的数据的读取最慢，其次是内存，缓存最快。这里总结从外存读取数据到内存以及将数据从内存写到外存中。对于内存和外存的理解，我们可以简单的理解为容器，即外存是一个容器，内存又是另外一个容器。那又怎样把放在外存这个容器内的数据读取到内存这个容器以及怎么把内存这个容器里的数据存到外存中呢？
在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:
标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流等等，java中将输入输出抽象称为流，就好像水管，将两个容器连接起来。将数据冲外存中读取到内存中的称为输入流，将数据从内存写入外存中的称为输出流。
流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。

⑽ JAVA的输入输出流有多少种

有文件输出流：FileInputStream ，数据输入流：DataInputStream，缓冲输入流;BuferedInputStream,缓冲输出流：BuferedOutputStream，有文件输出流：FileoutputStream ，数据输入流：DataOutputStream等！