bufferedinputstream,构造BufferedInputStream的合适参数是哪个？

bufferedinputstream,构造BufferedInputStream的合适参数是哪个？详细介绍

本文目录一览： 关于BufferedInputStream和FileInputStream的区别

一、数据处理方式不同
1、BufferedInputStream：内部缓冲区当read时会先把缓冲区填满(默认缓冲区是8192)，然后下次读取是直接从缓冲区读取。当读取的位置大于缓冲区时会再一次加载缓冲区。
2、FileInputStream：会直接读取文件，不经过缓冲。
二、内部方法不同
1、BufferedInputStream：copyWithBufferedStream方法实现了使用BufferedInputStream和BufferedOutputStream复制文件。
2、FileInputStream：copyWithFileStream方法实现了使用FileInputStream和FileOutputStream复制文件。
三、使用规则不同
1、BufferedInputStream：套在某个其他的InputStream外，起着缓存的功能，用来改善里面那个InputStream的性能。
2、FileInputStream：读取一个文件来作InputStream。所以可以把BufferedInputStream套在FileInputStream外，来改善FileInputStream的性能。
参考资料来源：百度百科-字节流
参考资料来源：百度百科-数据流
BufferedInputStream是套在某个其他的InputStream外，起着缓存的功能，用来改善里面那个InputStream的性能（如果可能的话），它自己不能脱离里面那个单独存在。FileInputStream是读取一个文件来作InputStream。所以你可以把BufferedInputStream套在FileInputStream外，来改善FileInputStream的性能。
FileInputStream与BufferedInputStream区别：
FileInputStream是字节流，BufferedInputStream是字节缓冲流，使用BufferedInputStream读资源比FileInputStream读取资源的效率高（BufferedInputStream的read方法会读取尽可能多的字节），且FileInputStream对象的read方法会出现阻塞；
FileInputStream与FileReader区别：
FileInputStream是字节流，FileReader是字符流，用字节流读取中文的时候，可能会出现乱码，而用字符流则不会出现乱码，而且用字符流读取的速度比字节流要快；
ObjectOutputStream与ByteArrayOutputStream的区别：
ObjectOutputStream可以将java对象写入outputstream流中（序列化），然后进行持久化，此对象必须是实现了java.io.Serializable 接口；
ByteArrayOutputStream是将数据写入byte数组中；
了解“堵塞”的意思吧！
假设一个文件的长度是100个字节，要将之读取到内存中，再假设您每次只读取10个字节，那么读完整个文件是不是读取10次的呀？
假设老板让你完成100件事情，老板说，你每天只完成10件就可以了，难道你非得等到第十天才完成第100件事情吗？有一天您在中午下班前就完成了10件事情，下午您不妨多干一点，那么也许在第9天的时候就完成了100件事情。
同理，BufferedInputStream有可能会读取比您规定的更多的东西到内存，以减少访问IO的次数，
总之您要记住一句话，访问IO的次数越少，性能就越高，原因就在于CPU和内存的速度》》》》远大于硬盘或其他外部设备的速度。
换一个不太恰当的例子来说，您和您的朋友一起去登山，你朋友太不给力了，走一会儿就要休息，而您呢，您的体力比他要好的多，根本不需要休息，所以每当他休息的时候，您得等着他，您那时候什么也干不了，这就叫堵塞，堵塞就是说您有能力干某事，但是迫于某种原因您什么也干不了，只能干等。所以您朋友休息的次数越少，你们两个到达山顶所花费的时间就越少。CPU访问硬盘的次数越少，程序就越快。BufferedInputStream在小型文件中的性能优势无法体现出来，假设您将以个2G大小的文件从D盘完全复制到E盘，性能之优势便展露无疑！
我使用过程，目前最大的区别在于【BufferedInputStream】支持读取外网文件
区别：FileInputStream是字节流，BufferedInputStream是字节缓冲流，使用BufferedInputStream读资源比FileInputStream读取资源的效率高（BufferedInputStream的read方法会读取尽可能多的字节），且FileInputStream对象的read方法会出现阻塞。
1、FileInputStream，直接操作本机I/O,把持着一个文件的句柄，说白了它是面向文件的。
2、BufferedInputStream,它只是面向字节流的，你可以不使用它，自己创建数组，将字节放在里面，也就缓存在jvm内存里，之后操作内存数据。
3、BufferedInputStream是套在某个其他的InputStream外，起着缓存的功能，用来改善里面那个InputStream的性能（如果可能的话），它自己不能脱离里面那个单独存在。
4、FileInputStream是读取一个文件来做InputStream。所以你可以把BufferedInputStream套在FileInputStream外，来改善FileInputStream的性能。
扩展资料
FileInputStream是Java语言中抽象类InputStream用来具体实现类的创建对象。FileInputStream可以从文件系统中的某个文件中获得输入字节，获取的文件可用性取决于主机环境。
FileInputStream的构造方法需要指定文件的来源，通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
参考资料：百度百科－FileInputStream

构造BufferedInputStream的合适参数是哪个？

1.D 2.CD 3.C 4.ABC 5.AD 6.D 7.BCD 8.AC 9.BCD 10.ACD
BufferedInputStream(InputStream in)
创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
BufferedInputStream(InputStream in, int size)
创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
又因为下面的 FileInputStream 是 InputStream 的子类.所以先用下面的构造.然后组合.
如: new BufferedInputStream( new FileInputStream("my.txt"));
FileInputStream(File file)
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
FileInputStream(FileDescriptor fdObj)
通过使用文件描述符 fdObj 创建一个 FileInputStream，该文件描述符表示到文件系统中某个实际文件的现有连接。
FileInputStream(String name)
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

关于BufferedInputStream和FileInputStream的区别

BufferedInputStream是套在某个其他的InputStream外，起着缓存的功能，用来改善里面那个InputStream的性能（如果可能的话），它自己不能脱离里面那个单独存在。FileInputStream是读取一个文件来作InputStream。所以你可以把BufferedInputStream套在FileInputStream外，来改善FileInputStream的性能。
FileInputStream与BufferedInputStream区别：
FileInputStream是字节流，BufferedInputStream是字节缓冲流，使用BufferedInputStream读资源比FileInputStream读取资源的效率高（BufferedInputStream的read方法会读取尽可能多的字节），且FileInputStream对象的read方法会出现阻塞；
FileInputStream与FileReader区别：
FileInputStream是字节流，FileReader是字符流，用字节流读取中文的时候，可能会出现乱码，而用字符流则不会出现乱码，而且用字符流读取的速度比字节流要快；
ObjectOutputStream与ByteArrayOutputStream的区别：
ObjectOutputStream可以将java对象写入outputstream流中（序列化），然后进行持久化，此对象必须是实现了java.io.Serializable 接口；
ByteArrayOutputStream是将数据写入byte数组中；
了解“堵塞”的意思吧！
假设一个文件的长度是100个字节，要将之读取到内存中，再假设您每次只读取10个字节，那么读完整个文件是不是读取10次的呀？
假设老板让你完成100件事情，老板说，你每天只完成10件就可以了，难道你非得等到第十天才完成第100件事情吗？有一天您在中午下班前就完成了10件事情，下午您不妨多干一点，那么也许在第9天的时候就完成了100件事情。
同理，BufferedInputStream有可能会读取比您规定的更多的东西到内存，以减少访问IO的次数，
总之您要记住一句话，访问IO的次数越少，性能就越高，原因就在于CPU和内存的速度》》》》远大于硬盘或其他外部设备的速度。
换一个不太恰当的例子来说，您和您的朋友一起去登山，你朋友太不给力了，走一会儿就要休息，而您呢，您的体力比他要好的多，根本不需要休息，所以每当他休息的时候，您得等着他，您那时候什么也干不了，这就叫堵塞，堵塞就是说您有能力干某事，但是迫于某种原因您什么也干不了，只能干等。所以您朋友休息的次数越少，你们两个到达山顶所花费的时间就越少。CPU访问硬盘的次数越少，程序就越快。BufferedInputStream在小型文件中的性能优势无法体现出来，假设您将以个2G大小的文件从D盘完全复制到E盘，性能之优势便展露无疑！

FileInputStream和BufferedInputStream read()的区别

FileInputStream是字节流，BufferedInputStream是字节缓冲流，使用BufferedInputStream读资源比FileInputStream读取资源的效率高（BufferedInputStream的read方法会读取尽可能多的字节），且FileInputStream对象的read方法会出现阻塞；
在FileInputStream里有一个说明是说此方法将阻塞，意思就是说在你读一个文件输入流的时候，当读到某个位置的时候，如果做一些其他处理（比如说接受一部分字节做一些处理等等）这个时候输入流在什么位置就是什么位置，不会继续往下读，而BufferedInputStream虽然也有一个read方法，但是从名字就可以看出，它带有一个缓冲区，它是一个非阻塞的方法，在你读到某个位置的时候，做一些处理的时候，输入流可能还会继续读入字节，这样就达到了缓冲的效果。
对于性能要求不高的时候，用哪个都无所谓，但是如果有性能要求，建议还是用BufferedInputStream。
我觉得可能是不太了解“堵塞”的意思。
假设一个文件的长度是100个字节，要将之读取到内存中，再假设您每次只读取10个字节，那么读完整个文件是不是读取10次的呀?
假设老板让你完成100件事情，老板说，你每天只完成10件就可以了，难道你非得等到第十天才完成第100件事情吗?有一天您在中午下班前就完成了10件事情，下午您不妨多干一点，那么也许在第9天的时候就完成了100件事情。
同理，BufferedInputStream有可能会读取比您规定的更多的东西到内存，以减少访问IO的次数，
总之您要记住一句话，访问IO的次数越少，性能就越高，原因就在于CPU和内存的速度》》》》远大于硬盘或其他外部设备的速度。
换一个不太恰当的例子来说，您和您的朋友一起去登山，你朋友太不给力了，走一会儿就要休息，而您呢，您的体力比他要好的多，根本不需要休息，所以每当他休息的时候，您得等着他，您那时候什么也干不了，这就叫堵塞，堵塞就是说您有能力干某事，但是迫于某种原因您什么也干不了，只能干等。所以您朋友休息的次数越少，你们两个到达山顶所花费的时间就越少。CPU访问硬盘的次数越少，程序就越快。BufferedInputStream在小型文件中的性能优势无法体现出来，假设您将以个2G大小的文件从D盘完全复制到E盘，性能之优势便展露无疑!
你也看到了，在FileInputStream里有一个说明是说此方法将阻塞，意思就是说在你读一个文件输入流的时候，当读到某个位置的时候，如果做一些其他处理（比如说接受一部分字节做一些处理等等）这个时候输入流在什么位置就是什么位置，不会继续往下读，而BufferedInputStream虽然也有一个read方法，但是从名字就可以看出，它带有一个缓冲区，它是一个非阻塞的方法，在你读到某个位置的时候，做一些处理的时候，输入流可能还会继续读入字节，这样就达到了缓冲的效果。
对于性能要求不高的时候，用哪个都无所谓，但是如果有性能要求，建议你还是用BufferedInputStream。

bufferedinputstream怎么设置编码

BufferedInputStream和BufferedOutputStream是过滤流,需要使用已存在的节点来构造,即必须先有InputStream或OutputStream,相对直接读写,这两个流提供带缓存的读写,提高了系统读写效率性能.BufferedInputStream读取的是字节byte,因为一个汉字占两个字节,而当中英文混合的时候,有的字符占一个字节,有的字符占两个字节,所以如果直接读字节,而数据比较长,没有一次读完的时候,很可能刚好读到一个汉字的前一个字节,这样,这个中文就成了乱码,后面的数据因为没有字节对齐,也都成了乱码.所以我们需要用BufferedReader来读取,它读到的是字符,所以不会读到半个字符的情况,不会出现乱码.
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
package com.pocketdigi;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

public static void main(String[] args) throws IOException {
File f = new File("d:/a.txt");
FileOutputStream fos = new FileOutputStream(f);
// 构建FileOutputStream对象,文件不存在会自动新建
BufferedOutputStream bos = new BufferedOutputStream(fos);
bos.write("1我是中文".getBytes());
bos.close();
// 关闭输出流,写入数据,如果下面还要写用flush();
// 因为是BufferOutputStream链接到FileOutputStream,只需关闭尾端的流
// 所以不需要关闭FileOutputStream;
FileInputStream fis = new FileInputStream(f);
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedReader reader = new BufferedReader (new InputStreamReader(bis));
//之所以用BufferedReader,而不是直接用BufferedInputStream读取,是因为BufferedInputStream是InputStream的间接子类,
//InputStream的read方法读取的是一个byte,而一个中文占两个byte,所以可能会出现读到半个汉字的情况,就是乱码.
//BufferedReader继承自Reader,该类的read方法读取的是char,所以无论如何不会出现读个半个汉字的.
StringBuffer result = new StringBuffer();
while (reader.ready()) {
result.append((char)reader.read());
}
System.out.println(result.toString());
reader.close();

}
}

Java 中 BufferedInputStream 到底有什么用？怎么感觉它很多余呢？

其实看使用场景，一次性读取将整个文件都加入的内存中很慢，多次读取但是每次读取字节太小也会很慢，这个速度需要一个调试权衡的过程，一般情况下8092是个比较适中的读取数组大小。其实BufferedInputStream的确有缓冲的实现，但是文件流的读取速度和缓冲关系不大，关系最大的是8092，如果将8092改成16的话就慢多了。你如果用FileInputStream读取文件每次读取数组大小也是8092，那么也不会比BufferedInputStream慢。当然缓冲流BufferedInputStream的使用场景肯定有的，而且很多，比如视频播放，音乐播放这些多媒体的场景就非常适合用缓冲流，而文件下载上传复制拷贝这些场景直接使用FileInputStream就行了
在bufferedinputstream的read函数实现当中，读多个字符是使用System.arraycopy( src, srcPos, dest, destPos, length )这个函数，意思是直接将一片内存进行拷贝过去，而不是像其他的read函数一样一次只拷贝一个字节或字符。这样就快了很多。
为什么不直接把自己buffer 写进去，感觉还是这样快!
有想法就是最好的,但是不要光感觉,你是不是可以做一些测试呢?just do it!
FileInputStream 里面的read(buffer)方法，直接读取到自己的buffer 里面
这个是读取到一个数组里面，jvm里面创建一个新对象都需要耗费时间的，而且每一次read都要执行I/O操作，比较慢。
BufferedInputStream在你创建对象的时候就已经建立好缓冲区数组拉，一定程度上可以减少java生成新对象消费的时间。另外用buffered好处，可以参考API...
作为另一种输入流，BufferedInputStream 为添加了功能，即缓冲输入和支持 mark 和 reset 方法的能力。创建 BufferedInputStream 时即创建了一个内部缓冲区数组。读取或跳过流中的各字节时，必要时可根据所包含的输入流再次填充该内部缓冲区，一次填充多个字节。mark 操作记录输入流中的某个点，reset 操作导致在从所包含的输入流中获取新的字节前，再次读取自最后一次 mark 操作以来所读取的所有字节。

怎么理解java中BufferedInputStream的缓冲作用，就这张图中的一段代码来说，

BufferedInputStream主要是内存缓冲区，文件的读取是先将文件读取到内存中。如有程序部署是机器资源限制不可能分配很大内存，如果读取超大文件很容易造成内存溢出BufferedInputStream是将文件的一部分（大小有你指定）缓冲到内存，程序处理完后继续缓存下一个指定大小，直到全部读取。

Java：BufferedInputStream这种用法看不懂，求解

/***
* @author outofmemory.cn*/
public class Main {/**
* 从文件中读取文本*/
public void readFromFile(String filename) {
BufferedInputStream bufferedInput = null;
byte[] buffer = new byte[1024];try {
//创建BufferedInputStream 对象
bufferedInput = new BufferedInputStream(new FileInputStream(filename));
int bytesRead = 0;
//从文件中按字节读取内容，到文件尾部时read方法将返回-1
while ((bytesRead = bufferedInput.read(buffer)) != -1) {
//将读取的字节转为字符串对象
String chunk = new String(buffer, 0, bytesRead);
System.out.print(chunk);}
} catch (FileNotFoundException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
} finally {
//关闭 BufferedInputStreamtry {
if (bufferedInput != null)
bufferedInput.close();
} catch (IOException ex) {
ex.printStackTrace();}}}/**
* @param args 命令行参数*/
BufferedInputStream 是有缓冲的 如果按一般的demo是用法是不使用缓冲区的，而且实际使用缓冲会因为填充缓冲区反倒比直接读的要慢。
BufferedInputStream的缓冲是为了重复读取流的，使用前需要先用mark方法指定缓冲数组的大小，然后每次读流的时候 BufferedInputStream 会自动把的读取的字节充填进缓冲数组，当调用reset方法后就能通过read方法重新读取标记过的流。

inputstream和fileinputstream的区别

　　FileInputStream与BufferedInputStream区别：
　　FileInputStream是字节流，BufferedInputStream是字节缓冲流，使用BufferedInputStream读资源比FileInputStream读取资源的效率高（BufferedInputStream的read方法会读取尽可能多的字节），且FileInputStream对象的read方法会出现阻塞；
　　
　　FileInputStream与FileReader区别：
　　FileInputStream是字节流，FileReader是字符流，用字节流读取中文的时候，可能会出现乱码，而用字符流则不会出现乱码，而且用字符流读取的速度比字节流要快；
　　
　　ObjectOutputStream与ByteArrayOutputStream的区别：
　　ObjectOutputStream可以将java对象写入outputstream流中（序列化），然后进行持久化，此对象必须是实现了java.io.Serializable 接口；
　　ByteArrayOutputStream是将数据写入byte数组中；

java 输入输出流 （被采纳为答案者加100分）

Input和Output 1. stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。在Java的IO中，所有的stream（包括Input和Out stream）都包括两种类型： 1.1 以字节为导向的stream 以字节为导向的stream，表示以字节为单位从stream中读取或往stream中写入信息。以字节为导向的stream包括下面几种类型： 1) input stream： 1) ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用 2) StringBufferInputStream：把一个String对象作为InputStream 3) FileInputStream：把一个文件作为InputStream，实现对文件的读取操作 4) PipedInputStream：实现了pipe的概念，主要在线程中使用 5) SequenceInputStream：把多个InputStream合并为一个InputStream 2) Out stream 1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中 2) FileOutputStream：把信息存入文件中 3) PipedOutputStream：实现了pipe的概念，主要在线程中使用 4) SequenceOutputStream：把多个OutStream合并为一个OutStream 1.2 以Unicode字符为导向的stream 以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。以Unicode字符为导向的stream包括下面几种类型： 1) Input Stream 1) CharArrayReader：与ByteArrayInputStream对应 2) StringReader：与StringBufferInputStream对应 3) FileReader：与FileInputStream对应 4) PipedReader：与PipedInputStream对应 2) Out Stream 1) CharArrayWrite：与ByteArrayOutputStream对应 2) StringWrite：无与之对应的以字节为导向的stream 3) FileWrite：与FileOutputStream对应 4) PipedWrite：与PipedOutputStream对应 以字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类实现的功能相同，字是在操作时的导向不同。 如CharArrayReader：和ByteArrayInputStream的作用都是把内存中的一个缓冲区作为InputStream使用，所不同的是前者每次从内存中读取一个字节的信息，而后者每次从内存中读取一个字符。 1.3 两种不现导向的stream之间的转换 InputStreamReader和OutputStreamReader：把一个以字节为导向的stream转换成一个以字符为导向的stream。 2. stream添加属性 2.1 “为stream添加属性”的作用 运用上面介绍的Java中操作IO的API，我们就可完成我们想完成的任何操作了。但通过FilterInputStream和FilterOutStream的子类，我们可以为stream添加属性。下面以一个例子来说明这种功能的作用。 如果我们要往一个文件中写入数据，我们可以这样操作： FileOutStream fs = new FileOutStream(“test.txt”); 然后就可以通过产生的fs对象调用write()函数来往test.txt文件中写入数据了。但是，如果我们想实现“先把要写入文件的数据先缓存到内存中，再把缓存中的数据写入文件中”的功能时，上面的API就没有一个能满足我们的需求了。但是通过FilterInputStream和FilterOutStream的子类，为FileOutStream添加我们所需要的功能。 2.2 FilterInputStream的各种类型 2.2.1 用于封装以字节为导向的InputSt
其中BufferedInputStream是FileInputStream的子类,你可以理解成同样处理一个文件，BufferedInputStream效率更高,原因是BufferedInputStream采用了更高效的字节流处理方式,
BufferedInputStream才用缓冲流把内在的缓冲器连接到I/O流，允许java程序对多个字节同时操作，这样就提高了效率。
inputstreamreader的构造函数带两个参数,一是关联到的文件,二是字符解码方式. 所以实际上通过inputstreamreader实例读出来的东西已经不是磁盘上原始的字节数据了,而是根据你指定的解码方式(如果你没有指定,则使用系统缺省的,win2000下是gbk/gb2312)把字节流转换成了字符流,注意字节流和字符流的区别,一个字节就是8比特位(32位机器上),而一个字符含多少字节则与不同的编码/解码方式有关了,如gbk是一字节,utf-8是1-3的变长字节,utf-16是2个定长字节.
　　 于是值得你注意的就是当你用inputstreamreader读文件时,你应该知道该文件被存储时是用什么方式编码的,否则你指定错了解码方式,读出来的就是乱码.但是退一步来说,在全英文环境下,问题也没这严重.因为所有的字符集在前七位上都是与ascii兼容的(我猜的,也许有的不是),然而当你的程序涉及中文字符时,肯定是会出错了.
　　 那么fileinputstream的特点呢?它的构造函数就一个,即关联到的文件,既然没有指定解码方式,那它所做的就是只以字节流的方式读出文件而不做任何处理, 你应该用一个字节数组来接受它,对该数组你以后还可以做任何想做的操作。
给你个例子，自己去测试
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.*;

public class test {

/* public static void main(String[] args) {
String str=new String("Face recognition in the thermal infrared domain has received relatively little attention in the literature in comparison with recognition in visible-spectrum imagery");
StringTokenizer token=new StringTokenizer(str);
Hashtable ht=new Hashtable();
while(token.hasMoreTokens()){
String temp=new String(token.nextToken());
ht.put(temp,temp);
}
Enumeration en=ht.keys();
while(en.hasMoreElements()){
Object obj=en.nextElement();
System.out.print("KEY_NO:"+obj);
System.out.println("="+ht.get(obj));
}
}
*/

public static void main(String[] args){
try {
String file1 ="d:\\1.doc";
String file2 ="d:\\2.doc";
copyFile(file1,file2);
readFile(file2);
//fileCheck("d:\\test1.txt");
// readFile("D:\\test1.txt");
// readFileByte("D:\\test1.txt");
// readFileByFile("D:\\test1.txt");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public static void testFile() throws IOException{
copyFile("D:\\test1.txt","D:\\test2.txt");

}
public static void copyFile(String inName,String outName) throws IOException
{
File tmp = new File(outName);
if(!tmp.canRead())tmp.createNewFile();

BufferedInputStream in = new BufferedInputStream(new FileInputStream(inName));
BufferedOutputStream out= new BufferedOutputStream(new FileOutputStream(outName));
copyFile(in,out,true);
}
public static void readFile(String inName) throws IOException
{
BufferedReader read = new BufferedReader (new InputStreamReader(new FileInputStream(inName)));
String b ;
while((b=read.readLine())!=null )
print( b);
}
public static void readFileByte(String inName) throws IOException
{
BufferedInputStream read = new BufferedInputStream (new FileInputStream(inName));
int b = 0;
while((b=read.read())!=-1)
System.out.print ((char)b);
}
public static void readFileByFile(String name) throws IOException
{
File tmp = new File (name);
FileReader fr= new FileReader(tmp);
BufferedReader br = new BufferedReader(fr);
String b;
while((b=br.readLine())!=null)
print(b);

}

public static void copyFile(InputStream in ,OutputStream out, boolean close) throws IOException{
int b;
while((b=in.read())!=-1)
{
out.write(b);
}
in.close();
if(close)
out.close();
}
public static void print(Object o)
{
System.out.println(o);
}
public static void fileCheck(String name) throws IOException
{
print("---"+name+"---");
File f= new File(name);

if(!f.exists())
{
print("fle not exist!");
return;
}

print("Canonical name:"+f.getCanonicalPath());
String p= f.getParent();
if(p!=null)
print("Parent directory :"+p);

if(f.canRead())print("file can be read!");

if(f.canWrite())print("file can be writable!");

Date d = new Date();
d.setTime(f.lastModified());
print("last modified time :"+d);

if(f.isFile())
{
print("file size is :"+f.length()+" bytes");
}else if(f.isDirectory()){print("is a directry!");}
else{
print("neither a directory or a file!");
}

print("");

}
}