java 文件中先关闭什么流 java关闭流的顺序影响程序结果
今天给各位分享java 文件中先关闭什么流的知识，其中也会对java关闭流的顺序影响程序结果进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
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关闭流的顺序影响程序结果
bw是缓冲流，使用bw.write后，数据并没有直接写入txt文件中，而是在bw的缓冲区内，所以这时先关闭输出流fw,则txt中就是空的了，如果先关闭bw,则缓冲流会在内部先调用bw.flush();将缓冲区的内容输出到文件中，所以txt才有内容。要解决这个问题，需要在bw.write后显示调用bw.flush();这样先关闭那个流都一样了
Java读取文件问题
使用Java操作文本文件的方法详解
摘要:最初java是不支持对文本文件的处理的，为了弥补这个缺憾而引入了Reader和Writer两个类
最初java是不支持对文本文件的处理的，为了弥补这个缺憾而引入了Reader和Writer两个类，这两个类都是抽象类，Writer中 write(char[] ch,int off,int
length)，flush()和close()方法为抽象方法，Reader中read(char[] ch,int off,int length)和close()方法是抽象方法。子类应该分别实现他们。当我们读写文本文件的时候，采用Reader是非常方便的，比如FileReader，InputStreamReader和BufferedReader。其中最重要的类是InputStreamReader，它是字节转换为字符的桥梁。你可以在构造器重指定编码的方式，如果不指定的话将采用底层操作系统的默认编码方式，例如GBK等。当使用FileReader读取文件的时候。FileReader fr= new FileReader("ming.txt");
int ch= 0;
while((ch= fr.read())!=-1)
{
System.out.print((char)ch);
}
其中read()方法返回的是读取得下个字符。当然你也可以使用read(char[] ch,int off,int length)这和处理二进制文件的时候类似，不多说了。如果使用InputStreamReader来读取文件的时候while((ch= isr.read())!=-1)
{
System.out.print((char)ch);
}
这和FileReader并没有什么区别，事实上在FileReader中的方法都是从InputStreamReader中继承过来的。read()方法是比较好费时间的，如果为了提高效率我们可以使用BufferedReader对Reader进行包装，这样可以提高读取得速度，我们可以一行一行的读取文本，使用readLine()方法。BufferedReader br= new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt")));
String data= null;
while((data= br.readLine())!=null)
{
System.out.println(data);
}
当你明白了如何用Reader来读取文本文件的时候那么用Writer写文件同样非常简单。有一点需要注意，当你写文件的时候，为了提高效率，写入的数据会先放入缓冲区，然后写入文件。因此有时候你需要主动调用flush()方法。与上面对应的写文件的方法为：
FileWriter fw= new FileWriter("hello.txt");
String s="hello world";
fw.write(s,0,s.length());
fw.flush();OutputStreamWriter osw= new OutputStreamWriter(new FileOutputStream("hello2.txt"));
osw.write(s,0,s.length());
osw.flush();PrintWriter pw= new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3.txt")),true);
pw.println(s);
不要忘记用完后关闭流！下面是个小例子，帮助新手理解。其实有的时候java的IO系统是需要我们多记记的，不然哪天就生疏了。
import java.io.*;public class TestFile2
{
public static void main(String[] args) throws IOException
{
FileReader fr= new FileReader("ming.txt");
char[] buffer= new char[1024];
int ch= 0;
while((ch= fr.read())!=-1)
{
System.out.print((char)ch);
} InputStreamReader isr= new InputStreamReader(new FileInputStream("ming.txt"));
while((ch= isr.read())!=-1)
{
System.out.print((char)ch);
} BufferedReader br= new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt")));
String data= null;
while((data= br.readLine())!=null)
{
System.out.println(data);
} FileWriter fw= new FileWriter("hello.txt");
String s="hello world";
fw.write(s,0,s.length());
fw.flush(); OutputStreamWriter osw= new OutputStreamWriter(new FileOutputStream("hello2.txt"));
osw.write(s,0,s.length());
osw.flush(); PrintWriter pw= new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3.txt")),true);
pw.println(s);
fr.close();
isr.close();
br.close();
fw.close();
osw.close();
pw.close();
}
}
java中多种方式读文件
一、多种方式读文件内容。
1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容
4、随机读取文件内容
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.io.Reader;
public class ReadFromFile{
/**
*以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
*@param fileName文件的名
*/
public static void readFileByBytes(String fileName){
File file= new File(fileName);
InputStream in= null;
try{
System.out.println("以字节为单位读取文件内容，一次读一个字节：");
//一次读一个字节
in= new FileInputStream(file);
int tempbyte;
while((tempbyte=in.read())!=-1){
System.out.write(tempbyte);
}
in.close();
} catch(IOException e){
e.printStackTrace();
return;
}
try{
System.out.println("以字节为单位读取文件内容，一次读多个字节：");
//一次读多个字节
byte[] tempbytes= new byte[100];
int byteread= 0;
in= new FileInputStream(fileName);
ReadFromFile.showAvailableBytes(in);
//读入多个字节到字节数组中，byteread为一次读入的字节数
while((byteread= in.read(tempbytes))!=-1){
System.out.write(tempbytes, 0, byteread);
}
} catch(Exception e1){
e1.printStackTrace();
} finally{
if(in!= null){
try{
in.close();
} catch(IOException e1){
}
}
}
}
/**
*以字符为单位读取文件，常用于读文本，数字等类型的文件
*@param fileName文件名
*/
public static void readFileByChars(String fileName){
File file= new File(fileName);
Reader reader= null;
try{
System.out.println("以字符为单位读取文件内容，一次读一个字节：");
//一次读一个字符
reader= new InputStreamReader(new FileInputStream(file));
int tempchar;
while((tempchar= reader.read())!=-1){
//对于windows下，rn这两个字符在一起时，表示一个换行。
//但如果这两个字符分开显示时，会换两次行。
//因此，屏蔽掉r，或者屏蔽n。否则，将会多出很多空行。
if(((char)tempchar)!='r'){
System.out.print((char)tempchar);
}
}
reader.close();
} catch(Exception e){
e.printStackTrace();
}
try{
System.out.println("以字符为单位读取文件内容，一次读多个字节：");
//一次读多个字符
char[] tempchars= new char[30];
int charread= 0;
reader= new InputStreamReader(new FileInputStream(fileName));
//读入多个字符到字符数组中，charread为一次读取字符数
while((charread= reader.read(tempchars))!=-1){
//同样屏蔽掉r不显示
if((charread== tempchars.length)&&(tempchars[tempchars.length-1]!='r')){
System.out.print(tempchars);
}else{
for(int i=0; i<charread; i++){
if(tempchars[i]=='r'){
continue;
}else{
System.out.print(tempchars[i]);
}
}
}
}
} catch(Exception e1){
e1.printStackTrace();
}finally{
if(reader!= null){
try{
reader.close();
} catch(IOException e1){
}
}
}
}
/**
*以行为单位读取文件，常用于读面向行的格式化文件
*@param fileName文件名
*/
public static void readFileByLines(String fileName){
File file= new File(fileName);
BufferedReader reader= null;
try{
System.out.println("以行为单位读取文件内容，一次读一整行：");
reader= new BufferedReader(new FileReader(file));
String tempString= null;
int line= 1;
//一次读入一行，直到读入null为文件结束
while((tempString= reader.readLine())!= null){
//显示行号
System.out.println("line"+ line+":"+ tempString);
line++;
}
reader.close();
} catch(IOException e){
e.printStackTrace();
} finally{
if(reader!= null){
try{
reader.close();
} catch(IOException e1){
}
}
}
}
/**
*随机读取文件内容
*@param fileName文件名
*/
public static void readFileByRandomAccess(String fileName){
RandomAccessFile randomFile= null;
try{
System.out.println("随机读取一段文件内容：");
//打开一个随机访问文件流，按只读方式
randomFile= new RandomAccessFile(fileName,"r");
//文件长度，字节数
long fileLength= randomFile.length();
//读文件的起始位置
int beginIndex=(fileLength> 4)? 4: 0;
//将读文件的开始位置移到beginIndex位置。
randomFile.seek(beginIndex);
byte[] bytes= new byte[10];
int byteread= 0;
//一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
//将一次读取的字节数赋给byteread
while((byteread= randomFile.read(bytes))!=-1){
System.out.write(bytes, 0, byteread);
}
} catch(IOException e){
e.printStackTrace();
} finally{
if(randomFile!= null){
try{
randomFile.close();
} catch(IOException e1){
}
}
}
}
/**
*显示输入流中还剩的字节数
*@param in
*/
private static void showAvailableBytes(InputStream in){
try{
System.out.println("当前字节输入流中的字节数为:"+ in.available());
} catch(IOException e){
e.printStackTrace();
}
}
public static void main(String[] args){
String fileName="C:/temp/newTemp.txt";
ReadFromFile.readFileByBytes(fileName);
ReadFromFile.readFileByChars(fileName);
ReadFromFile.readFileByLines(fileName);
ReadFromFile.readFileByRandomAccess(fileName);
}
}
二、将内容追加到文件尾部
import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
*将内容追加到文件尾部
*/
public class AppendToFile{
/**
* A方法追加文件：使用RandomAccessFile
*@param fileName文件名
*@param content追加的内容
*/
public static void appendMethodA(String fileName,
String content){
try{
//打开一个随机访问文件流，按读写方式
RandomAccessFile randomFile= new RandomAccessFile(fileName,"rw");
//文件长度，字节数
long fileLength= randomFile.length();
//将写文件指针移到文件尾。
randomFile.seek(fileLength);
randomFile.writeBytes(content);
randomFile.close();
} catch(IOException e){
e.printStackTrace();
}
}
/**
* B方法追加文件：使用FileWriter
*@param fileName
*@param content
*/
public static void appendMethodB(String fileName, String content){
try{
//打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
FileWriter writer= new FileWriter(fileName, true);
writer.write(content);
writer.close();
} catch(IOException e){
e.printStackTrace();
}
}
public static void main(String[] args){
String fileName="C:/temp/newTemp.txt";
String content="new append!";
//按方法A追加文件
AppendToFile.appendMethodA(fileName, content);
AppendToFile.appendMethodA(fileName,"append end. n");
//显示文件内容
ReadFromFile.readFileByLines(fileName);
//按方法B追加文件
AppendToFile.appendMethodB(fileName, content);
AppendToFile.appendMethodB(fileName,"append end. n");
//显示文件内容
ReadFromFile.readFileByLines(fileName);
}
}
好了，文章到这里就结束啦，如果本次分享的java 文件中先关闭什么流和java关闭流的顺序影响程序结果问题对您有所帮助，还望关注下本站哦！