黑马程序员——java基础之IO

　　------- android培训、java培训、期待与您交流！ ----------

1 IO流简介

O流是用于操作数据的，有两种流形式：字符流和字节流。

字节流两个基类：InputStream   OutputStream
字符流两个基类：Reader Writer

IO流中，以InputStream结尾的流都是InputStream的子类，如BufferedInputStream,FileInputStream；以OutputStream结尾的流都是OutputStream的子类，如BufferedOutputStream, DataOutputStream, FilterOutputStream，同样的以Reader和Writer结尾的流也分别是他们的子类。

2 IO流中常用的类及其用法

字符流：（可以采用缓冲技术，提高效率）
FileReader、FileWriter、BufferedReader、BufferedWriter
字节流：
InputStream  、OutputStream

在io流中读取字符流数据有两种方式：一种是一个一个读取，另一种是读取一部分将其存到缓冲区中，很明显后者有利于提高效率。

FileReader：获取源数据的字符流

用法实例：

import java.io.*;
class FileReader
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("demo.txt");//创建文件读取流对象
char[] buf = new char[1024];//定义一个字符数组，用于存储读到字符，该read(char[])返回的是读到字符个数。
int num = 0;
while((num=fr.read(buf))!=-1)//读取源文件直到结束，并打印文件。
{
System.out.println(new String(buf,0,num));
}
fr.close();
}
}

FileWriter：得到目标文件的字符流

用法实例如下：

import java.io.*;
class  FileWriterDemo
{
public static void main(String[] args) throws IOException
{
FileWriter fw = new FileWriter("demo.txt");//创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
                                                                         //而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。其实该步就是在明确数据要存放的目的地。

fw.write("abcde");//调用write方法，将字符串写入到流中。

//fw.flush();//刷新流对象中的缓冲中的数据。
//将数据刷到目的地中。

fw.close();
//关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
//将数据刷到目的地中。
//和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
}
}

标准输入输出流的应用：System.in  System.out

功能：从键盘上输入字符串，获取字符串并按行打印出来

import java.io.*;
class IoTest {

/**
* @param args
*/
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
//键盘录入的最常用的方法：
//BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));//
BufferedReader bfr = new BufferedReader(new InputStreamReader(new FileInputStream("a.txt")));//建立输入流对象

BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(System.out));//建立输出流对象，使用缓冲技术提高效率。
//BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a.txt")));

String line = null;//定义空字符串

while ((line=bfr.readLine())!=null)//一次读取一行数据
{
if("over".equals(line))//自定义结束标记
break;
bfw.write(line);
bfw.newLine();//实现换行。该行代码不仅适用于windows平台，同样linux中也没问题

bfw.flush();//刷新
//System.out.println(line.toUpperCase());//打印该行字符的大写
}
bfr.close();//关闭流对象
}
}
File类常见方法：

创建：boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。
boolean mkdir():创建文件夹。
boolean mkdirs():创建多级文件夹。
删除：
boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。
void deleteOnExit();在程序退出时删除指定文件。
判断：boolean exists() :文件是否存在.
isFile()://判断是否是文件
isDirectory();//判断是否是目录
isHidden();//判断是否隐藏
isAbsolute();//判断是否是绝对路径
获取信息：getName()://获取名字
getPath()://获取路径
getParent()://获取父目录或相对路径中的上一级目录
getAbsolutePath()// 获取绝对路径
long lastModified() 
long length() 
3 常用的功能 

a 实现文件（.txt类型）拷贝，将C盘下的文件数据存储到D盘的一个文件中。

步骤：在D盘创建一个文件。用于存储C盘文件中的数据；定义读取流和C盘文件关联；通过不断的读写完成数据存储；关闭资源。

代码如下：

import java.io.*;
class CopyText 
{
public static void main(String[] args) throws IOException
{
copy ();
}
public static void copy()//方法一 使用缓冲技术， 将获取到的数据先存入缓冲区中，然后将缓冲区中的数据写入新文件中
{
FileWriter fw = null;
FileReader fr = null;
try
{
fw = new FileWriter("SystemDemo_copy.txt");//建立源文件对象
fr = new FileReader("SystemDemo.java");//建立目标文件对象

char[] buf = new char[1024];//定义缓存

int len = 0;//在读取缓冲区的数据时使用
while((len=fr.read(buf))!=-1)
{
fw.write(buf,0,len);//只读取有效的长度的数据
}
}
catch (IOException e)
{
throw new RuntimeException("读写失败");
}
finally
{
if(fr!=null)
try

{
fr.close();//关闭读入流
}
catch (IOException e)
{
}
if(fw!=null)
try
{
fw.close();//关闭打印流
}
catch (IOException e)
{
}
}
}

//从C盘读一个字符，就往D盘写一个字符。
public static void copyoneByone()throws IOException
{
//创建目的地。
FileWriter fw = new FileWriter("RuntimeDemo_copy.txt");

//与已有文件关联。
FileReader fr = new FileReader("RuntimeDemo.java");

int ch = 0;
while((ch=fr.read())!=-1)

{
fw.write(ch);//写入字符
}
fw.close();
fr.close();
}
}

b 复制图片文件：由于图片信息不能用字符流，因此数据源是字节流、目标文件也应该是字节流。采用缓冲技术提高效率。

import java.io.*;
class  FileStream
{
public static void main(String[] args) throws IOException
{
readFile();
}

public static void readFile3()throws IOException
{
FileInputStream fis = new FileInputStream("fos.txt");//创建输入流对象
int num = fis.available();
byte[] buf = new byte[fis.available()];//定义一个刚刚好的缓冲区，这样就不用再循环了。
fis.read(buf);//读取数据
System.out.println(new String(buf));//打印数据
fis.close();//关闭流对象
}
}

c  文件的合并，其实就是有多个输入流，写入统一文件中。这时候可以采用流的合并技术，将多个源文件合并成一个输入流，再将数据写入目文件中。

代码如下：

import java.io.*;//导入包
import java.util.*;
class SequenceTest
{
public static void main(String[] args) throws IOException
{
Vector<FileInputStream> v = new Vector<FileInputStream>();

v.add(new FileInputStream("d:\\a.txt"));
v.add(new FileInputStream("d:\\b.txt"));
v.add(new FileInputStream("d:\\c.txt"));//将多个源文件合并成一个输入流

Enumeration<FileInputStream> en = v.elements();
SequenceInputStream sis = new SequenceInputStream(en);//获取新的输入流对象
FileOutputStream fos = new FileOutputStream("d:\\newfile.txt");//建立输出流对象
byte[] buf = new byte[1024];//定义缓存
int len =0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
}

4 装饰设计模式，即想要对已有的对象进行功能增强时，可以自定义新的类，将已有对象传入，在原对象基础上，提供加强功能，那么自定义的该类称为装饰类。装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。

class Person
{
public void waichu()
{
System.out.println("出门");
}
}
class SuperPerson 
{
private Person p ;
SuperPerson(Person p)
{
this.p = p;
}
public void superWaichu()//定义加强后的方法
{
System.out.println("梳洗");
System.out.println("换衣服");

p.waichu();//直接调用原来的方法

System.out.println("锁好门窗");
}
}
class  PersonDemo
{
public static void main(String[] args) 
{
Person p = new Person();//建立原对象
//p.chifan();
SuperPerson sp = new SuperPerson(p);//将对象作为参数传递给修饰类
sp.superWaichu();//调用修饰方法
}
}