1、是文件： FileInputStream, FileOutputStream, FileReader, FileWriter
2、是byte[]：ByteArrayInputStream, ByteArrayOutputStream
3、是Char[]: CharArrayReader, CharArrayWriter
4、是String: StringBufferInputStream, StringReader, StringWriter
5、网络数据流：InputStream, OutputStream, Reader, Writer
二、按是否格式化输出分：
要格式化输出：PrintStream, PrintWriter
三、按是否要缓冲分：
要缓冲：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
决定使用哪个类以及它的构造进程的一般准则如下（不考虑特殊需要）：
第二，是输入还是输出? 输入流：InputStream Reader。输出流：OutputStream Writer。
第三，是否需要转换流：InputStreamReader, OutputStreamWriter?
第四，数据来源（去向）是什么：文件？内存？网络？
第五，是否要缓冲：bufferedReader （特别注明：一定要注意的是readLine()是否有定义，有什么比read, write更特殊的输入或输出方法）
第六，是否要格式化输出：print?
File类常见方法：
1，创建。 boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。
boolean mkdir():创建文件夹。
boolean mkdirs():创建多级文件夹。
2，删除。 boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。
void deleteOnExit();在程序退出时删除指定文件。
3，判断。 boolean exists() :文件是否存在.
isFile():
isDirectory();
isHidden();
isAbsolute();
4，获取信息。 getName():
getPath():
getParent():
getAbsolutePath()
long lastModified()
long length()
列出指定目录下文件或者文件夹，包含子目录中的内容。因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。 在列出过程中出现的还是目录的话，还可以再次调用本功能。 也就是函数自身调用自身。 这种表现形式，或者编程手法，称为递归。
递归要注意：
1，限定条件。
2，要注意递归的次数。尽量避免内存溢出。
删除一个带内容的目录。 原理： 在window中，删除目录从里面往外删除的。既然是从里往外删除。就需要用到递归。
编码：字符串——>字节数组。
解码：字节数组——>字符串。
常见的编码表
ASCII：美国标准信息交换码。
用一个字节的7位可以表示。
ISO8859—1：拉丁码表。欧洲码表
用一个字节的8位表示。
GB2312：中国的中文编码表。
GBK：中国的中文编码表升级，融合了更多的中文文字符号。
Unicode：国际标准码，融合了多种文字。
所有文字都用两个字节来表示,Java语言使用的就是unicode
UTF—8：最多用三个字节来表示一个字符。
......
FileWriter fw = null;
try{
//创建流对象，建立数据存放文件
FileWriter fw = new FileWriter(“Test.txt”);
//调用流对象的写入方法，将数据写入流
fw.write("text");
}
catch (IOException e){
System.out.println(e.toString());
}
finally{
If(fw!=null)
try{
//关闭流资源，并将流中的数据清空到文件中
fw.close();
}
catch (IOException e){
System.out.println(e.toString());
}
}
字符流——读取文件
FileReader fr = null;
try{
//建立一个流对象，将已存在的一个文件加载进流
FileReader fr = new FileReader("c:\test.txt");
//创建一个临时存放数据的数组
char[] buf = new char[1024];
//调用流对象的读取方法将流中的数据读入到数组中 fr.read(buf)
int len= 0;
while((len=fr.read(buf))!=—1){
System.out.println(new String(buf,0,len));
}
}
catch (IOException e){
System.out.println("read—Exception :"+e.toString());
}
finally{
if(fr!=null){
try{
fr.close();
}
catch (IOException e){
System.out.println("close—Exception :"+e.toString());
}
}
练习：Copy一个文本文件。
复制的原理：
其实就是将E盘下的文件数据存储到F盘的一个文件中。
步骤：
1，在F盘创建一个文件。用于存储E盘文件中的数据。
2，定义读取流和E盘文件关联。
3，通过不断的读写完成数据存储。
4，关闭资源。
public class copy {
public static void main(String[] args) {
FileWriter fw = null;
FileReader fr = null;
try {
fw = new FileWriter("f:\123.txt");
fr = new FileReader("e:\1.txt");
char[] buf = new char[1024];
int len = 0;
while((len=fr.read(buf))!=—1){
fw.write(new String(buf, 0, len));
}
} catch (IOException e) {
throw new RuntimeException("读写失败");
}
finally{
if(fr!=null){
try {
fr.close();
} catch (Exception e2) {
}
}
if(fw!=null){
try {
fw.close();
} catch (Exception e2) {
}
}
}
}
}
缓冲区对数据读写提高了效率不要忘了刷新
BufferedWriter中有一个newLine跨平台的换行符
BufferedReader中有一个readLine读一行
练习:
• 模拟一个BufferedReader类。
public class qw1 {
public static void main(String[] args) throws IOException {
BufferedWriter bufw = null;
BufferedReader bufr = null;
try {
bufw = new BufferedWriter(new FileWriter("f:\123.txt"));
bufr = new BufferedReader(new FileReader("e:\1.txt"));
String len = null;
while((len=bufr.readLine())!=null){
bufw.write(len);
//换行
bufw.newLine();
bufw.flush();
}
} catch (IOException e) {
throw new RuntimeException("读写失败");
}
finally{
if(bufr!=null){
try {
bufr.close();
} catch (Exception e2) {
throw new RuntimeException("读取关闭失败");
}
}
if(bufw!=null){
try {
bufw.close();
} catch (Exception e2) {
throw new RuntimeException("写入关闭失败");
}
}
}
}
}
• 模拟一个LineNumberReader类
public static void main(String[] args) throws IOException{
LineNumberReader lnr = new LineNumberReader(new FileReader("e:\3.txt"));
String line = null;
lnr.setLineNumber(10);
while((line = lnr.readLine())!=null){
System.out.println(lnr.getLineNumber()+":"+line);
}
}
复制MP3
public static void main(String[] args) throws Exception {
BufferedInputStream bufis = new BufferedInputStream(
new FileInputStream("F:\1.mp3"));
BufferedOutputStream bufos = new BufferedOutputStream(
new FileOutputStream("F:\4.mp3"));
int line = 0;
long start = System.currentTimeMillis();
while ((line = bufis.read()) != -1) {
bufos.write(line);
}
long end = System.currentTimeMillis();
System.out.println(end - start);
bufis.close();
bufos.close();
}
练习：Copy一个Jpg文件。
复制一个图片
思路：
1，用字节读取流对象和图片关联。
2，用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。
3，通过循环读写，完成数据的存储。
4，关闭资源。
public static void main(String[] args) {
FileOutputStream fos = null;
FileInputStream fis = null;
try {
fos=new FileOutputStream("f:\111.jpg");
fis=new FileInputStream("e:\1.jpg");
byte[] byt = new byte[1024];
int len =0;
while((len=fis.read(byt))!=—1){
fos.write(byt,0,len);
}
} catch (Exception e) {
throw new RuntimeException("复制文件失败");
}
finally{
try {
if(fis!=null){
fis.close();
}
} catch (Exception e) {
throw new RuntimeException("读取关闭失败");
}
try {
if(fos!=null){
fos.close();
}
} catch (Exception e) {
throw new RuntimeException("写入关闭失败");
}
}
}
练习：键盘录入（读取写入，转换流）
public static void main(String[] args) throws IOException
{
//获取键盘录入对象。
// InputStream in = System.in;
//将字节流对象转成字符流对象，使用转换流。InputStreamReader
// InputStreamReader isr = new InputStreamReader(in);
//为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader
//BufferedReader bufr = new BufferedReader(isr);
//键盘的最常见写法。
//InputStreamReader是字节流对象转成字符流对象
1： //BufferedReader
bufr =
new BufferedReader(new InputStreamReader(System.in));
//OutputStream out = System.out;
//OutputStreamWriter osw = new OutputStreamWriter(out);
//BufferedWriter bufw = new BufferedWriter(osw);
//OutputStreamWriter是字符流通向字节流的桥梁
2： BufferedWriter bufw =
new BufferedWriter(new OutputStreamWriter(System.out));
String line = null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
//System.out.println(line.toUpperCase());
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
}
练习：将一个图片文件中的数据存储到另一个文件中。复制文件。
public static void main(String[] args) throws Exception {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("e:\tupian\1.bmp"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("f:\12345\li.bmp"));
byte[] byt = new byte[1024];
int len = 0;
while((len=bis.read(byt))!=—1){
bos.write(byt, 0, len);
}
bis.close();
bos.close();
}
练习：递归
• 列出一个文件夹下所有的子文件夹以及子文件
public class aListing {
public static void main(String[] args) {
File dir = new File("D:\黑马_JavaEE+3G Android");
List<File> list = new ArrayList<File>();
listing(dir,list);
//System.out.println(list.size());
File file = new File(dir,"javaListing.txt");
writerToFile(list,file.toString());
}
public static void listing(File dir,List<File> list){
File[] files = dir.listFiles();
for(File file : files){
if(file.isDirectory())
listing(file,list);
else
if(file.getName().endsWith(".java"))
list.add(file);
}
}
public static void writerToFile(List<File> list,String javaListing){
BufferedWriter bufw = null;
try {
bufw = new BufferedWriter(new FileWriter(javaListing));
for(File f : list){
f.getAbsolutePath();
bufw.write(f.getAbsolutePath());
bufw.newLine();
bufw.flush();
}
} catch (Exception e) {
throw new RuntimeException("失败");
}
finally{
if(bufw!=null){
try {
bufw.close();
} catch (IOException e) {
throw new RuntimeException("失败");
}
}
}
}
}
出处：http://www.cnblogs.com/In-order-to-tomorrow/p/3528535.html