[置顶] 黑马程序员_IO流

----------------- android培训、java培训、期待与您交流！ ---------- 字符流的由来：

以前处理数据都是字节数据，使用字节流技术就可以完成了。
因为后期编码表的不断出现，识别某一文字的码表不唯一。比如中文，GBK，unicode都可以识别。就出出现了编码问题。
中文字节数据 gbk --> 流处理--->gbk解析可以了。

后期：容器出现这样的问题：

中文字节数据gbk --> 流处理 unicode来处理-->数据错误。
为了处理文字数据，就需要通过字节流技术+编码表相结合来完成。注意：只有文字是这样的，因为文字涉及编码问题。
其他数据比如dvd mp3 图片等是不涉及这个问题的。
虽然字节流+编码表可以解决文字数据处理问题，但是较为麻烦。为了便于使用，将字节流和编码表进行了封装，就出现了便于文字操作的流技术：字符流。
其实字符流就是：字节流+编码表。

IO的体系：
字节流两个基类：
InputStream(字节输入流) OutputStream(字节输出流)
字符流两个基类：
Reader(字符输入流) Writer(字符输出流)

学习io流体系：看顶层(父类共性功能)，用底层(子类具体对象)。
该体系的一个好处就是：
每个子类的后缀名都是所属体系的父类的名称，很容易区分所属的体系。而且每一个子类前缀名都是该子类对象的功能体现。这样我们在使用io体系中的对象时，就非常容易查找了。

需求：将一个段文字数据写入到硬盘上.
思路：

一段文字就是字符串数据。
写到硬盘上，从哪到哪呢？字符串数据在内存中，写到硬盘上，哎呦！这不是将内存中的数据搞到硬盘上，这就涉及到了设备之间的数据处理。就要用到IO技术。既然是从内存到硬盘，应该是输出流。
对于文字而言，io中提供了便捷的操作，比如字符流。
结合两者，需要输出流，需要字符流，可是使用字符输出流。Writer
具体用哪个子类对象呢？硬盘上用于存储数据的体现：文件。希望可以在Writer体系中知道可以操作文件的Writer对象。找到了具体的对象FileWriter.

两个写入流往一个文件写入数据，就如同，两个人在同时往一张纸写字一样。都是从头开始写，第二人写的会将第一个人的文字覆盖掉。

演示代码：

package com.itheima.IO;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class FileWriterDemo
{
private static final String LINE_SPARATOR = System.getProperty("line.separator");

public static void main(String[] args) throws IOException
{
printProperty();

FileWriter fw = new FileWriter("demo", true);
fw.write("hello,there!"+LINE_SPARATOR+"Damon");
fw.flush();
fw.close();
}

private static void printProperty()
{
Properties prop = System.getProperties();
Set<String> nameSet = prop.stringPropertyNames();
for(String name : nameSet)
{
String value = prop.getProperty(name);
System.out.println(name+"::"+value);
}
}
}

标准IO异常处理代码：

FileWriter fw = null;
try
{
fw = new FileWriter("k:\\demo3.txt");
fw.write("abcde");
fw.flush();
}
catch(IOException e)
{
System.out.println(e.toString());
}
finally
{
if (fw != null)
try
{
fw.close();
}
catch (IOException e)
{
// 相关的代码处理。比如说，将关闭失败的信息记录到日志文件中。
throw new RuntimeException("关闭失败");
}
}

需求：读取一个硬盘上的文本文件，将数据打印到控制台上。
思路：

读取无非就是将硬盘的数据弄到内存中。要使用到输入流。
既然是文字，可以使用字符流，一综合使用字符输入流，该体系时Reader.
既然要读取一个文本文件。可以使用 FileReader:用于读取字符文件的便捷类。

字符流的缓冲区。
BufferedReader
BufferedWriter

缓冲区给给流的操作动作(读写)提高效率.所以缓冲区的对象建立必须要有流对象。

代码演示：

package com.itheima.IO;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderDemo
{
/**
 * @param args
 * @throws IOException 
 */
public static void main(String[] args) throws IOException
{
demo_1();
demo_2();
}

private static void demo_2() throws FileNotFoundException, IOException
{
FileReader fr = new FileReader("demo");
char[] buf = new char[100];
int len = 0;
while ((len=fr.read(buf)) != -1)
{
System.out.println(new String(buf, 0, len));
}
}

private static void demo_1() throws FileNotFoundException, IOException
{
FileReader fr = new FileReader("demo");
/*int ch = fr.read();
System.out.println("ch="+ch);
*/
int ch = 0;
while ((ch=fr.read()) != -1)
{
System.out.print((char)ch);
}
fr.close();
}
}

复制文本文件代码演示：

package com.itheima.IO;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyTxtDemo
{

/**
 * @param args
 * @throws IOException 
 */
public static void main(String[] args) throws IOException
{
methed_1();
method_2();
System.out.println("OK！");
}

private static void method_2() throws FileNotFoundException, IOException
{
FileReader fr = new FileReader("demo");
FileWriter fw = new FileWriter("cptxtfile2");

char[] cbuf = new char[1024];
int len = 0;
while ((len=fr.read(cbuf)) != -1)
{
fw.write(cbuf, 0, len);
}

fr.close();
fw.close();
}

private static void methed_1() throws FileNotFoundException, IOException
{
FileReader fr = new FileReader("demo");
FileWriter fw = new FileWriter("cptxtfile");

int ch = 0;
while ((ch=fr.read()) != -1)
{
fw.write(ch);
}

fr.close();
fw.close();
}

}

标准写法，异常处理：

package com.itheima.IO;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyOfCopyTxtDemo2
{
/**
 * @param args
 */
public static void main(String[] args) 
{
FileReader fr = null;
FileWriter fw = null;
char[] cbuf = new char[1024];
int len = 0;

try
{
fr = new FileReader("demo");
fw = new FileWriter("cptxtfile3");

while ((len=fr.read(cbuf)) != -1)
{
fw.write(cbuf, 0, len);
}
}
catch (Exception e)
{
System.out.println(e.toString());
}
finally
{
if (fw != null)
try
{
fw.close();
}
catch (IOException e2)
{
throw new RuntimeException("写入关闭失败");
}

if (fr != null)
try
{
fr.close();
}
catch (IOException e2)
{
e2.printStackTrace();
}
}
}
}

[置顶] 黑马程序员_IO流

代码演示：

package cn.itcast.io.p5.mybuffer;

import java.io.IOException;
import java.io.Reader;

public class MyBufferedReader extends Reader{

/*
 * 缓冲区在定义时，必须有被缓冲的流对象。
 * 该流对象是通过构造函数传递的。 
 * 
 * 缓冲区最大的特点就是可以提高效率，
 * 原因在于对数据进行是临时存储。
 * 所以需要定义个容器(数组)。
 * 
 * 
 * 
 */
private Reader r;

private char[] buf = new char[1024];
//用于记录存储到缓冲区中字符个数的变量
private int count = 0;

//用于操作数组中的元素的角标。
private int pos = 0;

public MyBufferedReader(Reader r) {
super();
this.r = r;
}

/*
 * 定义一个读取方法，从缓冲区中读取一个字符。
 * 实现原理：
 * 1，先通过具体的流对象的read([])方法，从目的中读取一批数据存储到缓冲数组中。
 * 
 */
public int myRead() throws IOException{

//读取一批数据到缓冲数组buf中。 
//当count为0时，就从目的中取一批数据到缓冲数组。
if(count==0){
count = r.read(buf);
pos = 0;
}

if(count<0)
return -1;

char ch = buf[pos];
count--;
pos++;

return ch;

}

/*
 * 自定义一个读取一行的方法。
 * 原理：
 * 1，通过myRead方法从缓冲区中读取字符，并进行存储，
 * 当读取到的字符时换行终止符时，就将存储的数据作为字符串返回。
 */
public String myReadLine() throws IOException{

//1,定义容器。最终要变成字符串。可以使用StringBuilder
StringBuilder sb = new StringBuilder();

int ch = 0;
while((ch=myRead())!=-1){

if(ch=='\r')
continue;
if(ch=='\n')
return sb.toString();

sb.append((char)ch);
}

if(sb.length()!=0)
return sb.toString();

return null;

}


/*
 * 关闭缓冲区。
 */
public  void  myClose() throws IOException{
r.close();
}

@Override
public void close() throws IOException {
}

@Override
public int read(char[] cbuf, int off, int len) throws IOException {

return 0;
}
}

package cn.itcast.io.p5.mybuffer.demo;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

import cn.itcast.io.p5.mybuffer.MyBufferedReader;

public class MyBufferedReaderDemo {

/**
 * @param args
 * @throws IOException 
 */
public static void main(String[] args) throws IOException {

//buffferDemo();
//myBufferDemo();
readLineDemo();
myReadLineDemo();


}

private static void myReadLineDemo() throws IOException {

FileReader fr = new FileReader("buf.txt");
MyBufferedReader myBufr = new MyBufferedReader(fr);

String line = null;
while((line=myBufr.myReadLine())!=null){
System.out.println("mybuffer:"+line);
}

myBufr.myClose();
}

public static void readLineDemo() throws IOException{
FileReader fr = new FileReader("buf.txt");

BufferedReader bufr = new BufferedReader(fr);

String line = null;
while((line=bufr.readLine())!=null){
System.out.println("buffer:"+line);
}

bufr.close();
}

private static void myBufferDemo() throws IOException{

FileReader fr = new FileReader("demo.txt");
MyBufferedReader myBufr = new MyBufferedReader(fr);

int ch = 0;
while((ch=myBufr.myRead())!=-1){
System.out.println((char)ch);
}

myBufr.myClose();
}

private static void buffferDemo() throws FileNotFoundException, IOException {
FileReader fr = new FileReader("demo.txt");

BufferedReader bufr = new BufferedReader(fr);

int ch = 0;
//使用了缓冲区的一次读一个方法，从缓冲区中读取字符。
while((ch=bufr.read())!=-1){
System.out.println((char)ch);
}

bufr.close();
}

}

高效复制文本文件方法：

package com.itheima.io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CpyTxtByBufferDemo
{

public static void main(String[] args)
{
cpyTxtBufferedDemo();
}

private static void cpyTxtBufferedDemo()
{
BufferedReader bfr = null;
BufferedWriter bfw = null;

try
{
bfr = new BufferedReader(new FileReader("buf.txt"));
bfw = new BufferedWriter(new FileWriter("cpy.txt"));

String line = null;
for(;(line=bfr.readLine()) != null;)
{
bfw.write(line);
bfw.newLine();
bfw.flush();
}
} 
catch (Exception e)
{
e.printStackTrace();
}
finally
{
if (bfw != null)
try
{
bfw.close();
}
catch (Exception e)
{
throw new RuntimeException("写入关闭失败");
}

if (bfr != null)
try
{
bfr.close();
}
catch (Exception e)
{
throw new RuntimeException("读取关闭失败");
}
}
}
}

使它们能够方便地打印各种数据值表示形式.
提供了一系列的打印功能.可以打印任何数据。
它的特有的方法不抛出异常。

构造方法：
该流是一个处理目的的流对象。
目的：

File对象。可以指定字符集
字符串路径。可以指定字符集
字节输出流。可以对println方法进行自动刷新。

使用PrintStream继承的方法。write。
out.write(866); //write将接收到整数的最后一个字节写入到流。
使用PrintStream的特有方法。print.
out.print(865);//print方法，可以将参数的数据表现形式打印到目的中。原理是将97转成字符串，在write到目的。

print方法打印各种数据都会将其变成字符串。所以可以保证数据的原有表现形式。

一般不用PrintWriter定义指定的编码表。为啥呢？
因为要操作编码表有专用的对象。转换流。
而且转换流不仅可以设置写的编码表，还可以设置读的编码表

练习：

package com.itheima.io;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class StudentInfoTool
{
/**
 * 通过键盘录入获取信息，并将信息封装成学生对象，存到集合中。  
 * @throws IOException 
 */

public static Set<Student> getStudentSet() throws IOException
{ 
return getStudentSet(null);
}

public static Set<Student> getStudentSet(Comparator<Student> comp) throws IOException
{
BufferedReader br = null;
Set<Student> stuSet = null;
if (comp != null)
stuSet = new TreeSet<Student>(comp);
else
stuSet = new TreeSet<Student>();
try 
{
br = new BufferedReader(new InputStreamReader(System.in));
String line = null;
for (;(line=br.readLine()) != null;)
{
if ("over".equals(line))
break;
else
{
String[] arr = line.split(",");
Student stu = new Student(arr[0], Double.parseDouble(arr[1]), 
Double.parseDouble(arr[2]), Double.parseDouble(arr[3 ]));
stuSet.add(stu);
}
}
}
finally
{
if (br != null)
{
try
{
br.close();
}
catch (IOException e)
{
 throw new RuntimeException("关闭键盘录入失败！");
}
}
}
return stuSet;
}

// 将数据写入文件
public static void write2File(Set<Student> setStu, File dest) throws IOException
{
BufferedWriter bufw = null;
try 
{
bufw = new BufferedWriter(new FileWriter(dest));
bufw.write("name"+"\t"+"sum"+"\t"+"cn"+"\t"+"en"+"\t"+"ma");
bufw.newLine();
for (Student stu : setStu)
{
bufw.write(stu.getName()+"\t"+stu.getSum()+"\t"+stu.getCn()
+"\t"+stu.getEn()+"\t"+stu.getMa());
bufw.newLine();
bufw.flush();
}
}
finally
{
if (bufw != null) try
{
bufw.close();
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败");
}
}
}
}

package com.itheima.io;
public class Student implements Comparable<Student>
{
private String name;
private double ma,cn,en;
private double sum;
public Student()
{
super();
}

public Student(String name, double ma, double cn, double en)
{
super();
this.name = name;
this.ma = ma;
this.cn = cn;
this.en = en;
this.sum = ma + cn + en;
}

public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public double getMa()
{
return ma;
}
public void setMa(double ma)
{
this.ma = ma;
}
public double getCn()
{
return cn;
}
public void setCn(double cn)
{
this.cn = cn;
}
public double getEn()
{
return en;
}
public void setEn(double en)
{
this.en = en;
}
public double getSum()
{
return sum;
}
public void setSum(double sum)
{
this.sum = sum;
}


// 总分从小到大排序
@Override
public int compareTo(Student o)
{
double tmp = this.sum - o.sum;
return (int) (tmp==0 ? this.name.compareTo(o.getName()) : tmp);
}
}

package com.itheima.io;
import java.util.Comparator;
public class OrderByMath implements Comparator<Student>
{
public int compare(Student o1, Student o2)
{
int tmp = (int) (o1.getMa() - o2.getMa());
return tmp==0 ? o1.getName().compareTo(o2.getName()) : tmp;
}
}

package com.itheima.io;
import java.io.File;
import java.io.IOException;
import java.util.Collections;
import java.util.Comparator;
import java.util.Set;

public class Test1
{
public static void main(String[] args) throws IOException
{
//Comparator<Student> comp = Collections.reverseOrder();
Comparator<Student> comp = Collections.reverseOrder(comp = new OrderByMath());

Set<Student> set = StudentInfoTool.getStudentSet(comp);
File dir = new File("TempFile");
if (!dir.exists())
dir.mkdir();
File dest = new File(dir, "stuinfo");

StudentInfoTool.write2File(set, dest);
}
 }

File中构造时，指定的路径可以是存在的，也可以是不存在的。
//将c盘下的demo.txt封装成file对象。
File f1 = new File("c:\\demo.txt");
//将c盘下的abc文件夹封装成file对象。
File f2 = new File("c:\\abc");

1，获取文件信息。

获取名称，
获取路径。
获取大小。
获取时间。

2，判断。

是只读的不？
是隐藏的不？

3，文件的创建和删除以及该文件是否存在，文件对象自己最清楚。

具体创建，删除，是否存在等功能。

FileDemo:

package com.itheima.io;
import java.io.File;
import java.io.IOException;

public class FileDemo
{
private static final String FILE_SEPARATOR = System.getProperty("file.separator");
private static final String PATH_SEPARATOR = System.getProperty("path.separator");
private static final String LINE_SEPARATOR = System.getProperty("line.separator");
public static void main(String[] args) throws IOException
{

 System.out.println(FILE_SEPARATOR);
 System.out.println(PATH_SEPARATOR);
 System.out.println(LINE_SEPARATOR);

 fileConsDemo();
}
private static void fileConsDemo() throws IOException
{
File f1 = new File(FILE_SEPARATOR+"User"+FILE_SEPARATOR+"mskv"+FILE_SEPARATOR+"file.demo");
System.out.println(f1); // 构造时File类封装的对象可以存在或者不存在

// File类给出了路径分隔符和名称分割符的字段
File f2 = new File(File.separator+"User"+File.separator+"mskv"+File.separator+"file.demo");
System.out.println(f2);

//创建
//不存在，创建；存在，不创建。不覆盖。输出流会覆盖，若不覆盖，在构造函数中如true参数，续写
File f = new File("TempFile/FileDemo"); 
boolean b = f.createNewFile();
System.out.println(b);

// 删除
boolean b1 = f.delete();
System.out.println(b1);

//是否存在
boolean b2 = f.exists();
System.out.println(b2);

File[] roots = File.listRoots();
for (File root : roots)
{
System.out.println(root);
}
}
}

package com.itheima.io;
import java.io.File;
public class FileDemo2
{
public static void main(String[] args)
{
demo();
}

private static void demo()
{
File f = new File("TempFile");
String[] lists = f.list();
for (String list : lists)
{
System.out.println(list);
}

File file = new File("TempFile");
File[] fs = file.listFiles();
for (File ff : fs)
{
System.out.println(ff);
}
}
}

FileTest:

package com.itheima.io;
import java.io.File;
public class FileTest
{
public static void main(String[] args)
{
File dir = new File(File.separator+"Users"+File.separator+"mskv"+File.separator+"workspace");
showDir(dir, 0);
}

private static void showDir(File dir, int count)
{
System.out.println(getSeparator(count)+"DIR:"+dir);
count++;
File[] files = dir.listFiles();
if (files !=null)
for (File ff : files)
{
if (ff.isDirectory())
showDir(ff, count);
System.out.println(getSeparator(count)+ff.getName());
}
}

private static String getSeparator(int count)
{
StringBuilder sb = new StringBuilder();
for (int i=0; i<count; i++)
sb.append("-");
return sb.toString();
}
}

package com.itheima.io;
import java.io.File;
public class FileTest2
{
public static void main(String[] args)
{
// 删除一个带内容的目录
// 必须从里往外（一层一层）删
File dir = new File("/Users/mskv/Demo");
removeDir(dir);
}

public static void removeDir(File dir)
{
File[] files = dir.listFiles();
if (files != null)
for (File file : files)
{
if (file.isDirectory())
removeDir(file);
else
file.delete();
}
dir.delete();
}
}

PropertiesDemo:

package com.itheima.io;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;

public class PropertiesDemo
{
public static void main(String[] args) throws IOException
{
demo();
loadDemo();
}


private static void loadDemo() throws IOException
{
Properties prop = new Properties();
BufferedReader bfr = new BufferedReader(new FileReader("TempFile/prop"));
String line = null;
for (;(line=bfr.readLine()) != null;)
{
String[] strs = line.split("=");
prop.setProperty(strs[0], strs[1]);
}
bfr.close();
prop.list(System.out);
}


private static void demo() throws IOException
{
Properties prop = new Properties();
FileInputStream fis = new FileInputStream("TempFile/prop");
prop.load(fis);
prop.list(System.out);
fis.close();
}
}

Properties应用：

package com.itheima.io;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class PropertiesTest
{
public static void main(String[] args) throws IOException
{
// 记录软件试用次数，到期提示注册
//runDemo();
if (runDemo())
System.out.println("runing...");
else
System.out.println("试用次数结束，请注册！");
}


private static boolean runDemo() throws IOException
{
// 读取配置文件
Properties prop = new Properties();
File conf = new File("TempFile/conf");
if (!conf.exists())
conf.createNewFile();
BufferedReader br = new BufferedReader(new FileReader(conf));

// 加载到流中
prop.load(br);

// 获取运行次数
int count = 0;
String value = prop.getProperty("count");
if (value != null)
{
count = Integer.parseInt(value);
if (count > 2)
{
//System.out.println("试用次数结束，请注册！");
return false;
}
}
count++;
//System.out.println("运行"+count+"次");

// 存储次数到配置文件
prop.setProperty("count", String.valueOf(count));
BufferedWriter bw = new BufferedWriter(new FileWriter(conf));
prop.store(bw, "");

bw.close();
br.close();
return true;
}
}

装饰设计模式。
解决的问题：给已有的对象提供增强额外的功能。还不用对原有对象进行修改。
比继承更为灵活。
Writer
|--TextWriter
|--MediaWriter

现有一个体系用于各种数据的写入。
但是，发现写入效率有点低。想要对其进行效率的提高。
可以使用缓冲技术来完成的。
已有对象中的写入方法，不够高效，可以通过派生子类的形式对其进行复写，定义高效的写入动作。

通过继承的方式提高了效率。
但是对于扩展性是一个问题。而且所需的功能越多，子类就越多。
一旦加入新类，就需要为它提供高效。麻烦!
如何解决这个问题呢?优化！
既然都需要缓冲，对数据写入效率进行提高。
可以转变一下思想，这样来做，将缓冲技术单独进行封装。
哪个对象需要缓冲，就把哪个对象传递给缓冲对象即可。

class Buffer{

Buffer(TextWriter w){
}
Buffer(MediaWriter w){
}

}
为了便于扩展，可以对一组对象进行缓冲。
class BufferWriter extends Writer{
Buffer(Writer w){
}
public void write(){
}
}
体系就变成了这样：

Writer
|--TextWriter
|--MediaWriter
|--BufferWriter

BufferWriter的出现，增强了Writer体系中的功能。
这种设计方式比原理更为灵活，避免了继承的臃肿。
将这样解决方式就定义了一个名称方便于后人使用：装饰设计模式。
记住：装饰类和被装饰类都所属于同一个体系。

代码演示:

package com.itheima.io;
public class DecoratorDemo
{
public static void main(String[] args)
{
Person p = new Person();
SubPerson  sp = new SubPerson(p);
sp.eat();
}
}

class Person
{
public void eat()
{
System.out.println("吃饭");
}
}

class SubPerson
{
private Person p;
SubPerson(Person p)
{
this.p = p;
}

public void eat()
{
System.out.println("清汤");
p.eat();
System.out.println("甜点");
}
}

装饰类LineNumberReader演示：

package com.itheima.io;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;

public class LineNumberReaderDemo
{
public static void main(String[] args)
{
FileReader fr = null;
LineNumberReader lnr = null;

try
{
fr = new FileReader("TempFile//Demo");
lnr = new LineNumberReader(fr);
String line = null;
for (;(line = lnr.readLine()) != null;)
{
System.out.println(lnr.getLineNumber()+":"+line);
}
}
catch (FileNotFoundException e)
{
e.printStackTrace();
}
catch (IOException e)
{
e.printStackTrace();
}

}

FileInputStream演示：

package com.itheima.io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamDemo
{
private static FileInputStream fis;

public static void main(String[] args) throws Exception
{
//method_1();
//method_2();
// 创建一个刚刚好大小的数组缓冲区
method_3();
}

private static void method_3() throws FileNotFoundException, IOException
{
fis = new FileInputStream("TempFile//Demo");
byte[] bBuf = new byte[fis.available()];//文件过大不推荐，可能造成内存溢出
fis.read(bBuf);
System.out.println(new String(bBuf));
fis.close();
}

private static void method_2() throws FileNotFoundException, IOException
{
fis = new FileInputStream("TempFile//Demo");
byte[] bBuf = new byte[4096];
int len = 0;
for (;(len=fis.read(bBuf)) != -1;)
{
System.out.println(new String(bBuf, 0, len));
}
fis.close();
}


// 读一个打印一个
private static void method_1() throws FileNotFoundException, IOException
{
fis = new FileInputStream("TempFile//Demo");
int ch = 0;
for (;(ch=fis.read()) != -1;)
{
System.out.println("ch="+(char)ch);
}
fis.close();
}
}

字节流演示(复制mp3文件)：

package com.itheima.io;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class CpyMp3Demo
{
public static void main(String[] args) throws IOException
{
long start = System.currentTimeMillis();
//cpyMp3();
cpyMp3_2();
long end = System.currentTimeMillis();
System.out.println("时间："+(end-start)+"ms");
}

// 字节流自己的缓冲区
private static void cpyMp3_2() throws IOException
{
FileInputStream fis = new FileInputStream("TempFile//fis.mp3");
FileOutputStream fos = new FileOutputStream("TempFile//cpy.mp3");

BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);

int by = 0;
for (;(by=bis.read()) != -1;)
{
bos.write(by);
}
bos.close();
bis.close();
}

// 自定义缓冲区的方式
private static void cpyMp3() throws IOException
{
FileInputStream fis = new FileInputStream("TempFile//fis.mp3");
FileOutputStream fos = new FileOutputStream("TempFile//cpy.mp3");

byte[] bBuf = new byte[4096];
int len = 0;
for (;(len=fis.read(bBuf)) != -1;)
{
fos.write(bBuf, 0, len);
}

fos.close();
fis.close();

System.out.println("Copy OK!");
}
}

字符流与字节流的转换问题：

package com.itheima.io;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;

public class TransStreamDemo
{
public static void main(String[] args) throws IOException
{
// ReadKeyDemo2中的readKey_2()和readLine()方法一致

InputStream in = System.in;
OutputStream out = System.out;

// 字节流转为字符流。InputStreamReader，
// 字符流转为字节流，OutputStreamWriter
// BufferedReader,BufferedWriter，缓冲技术，提高效率
BufferedReader bin = new BufferedReader(new InputStreamReader(in));
BufferedWriter bout = new BufferedWriter(new OutputStreamWriter(out));

String line = null;
for (;(line=bin.readLine()) != null;)
{
if ("over".equals(line))
break;
else
{
bout.write(line);
bout.newLine();
bout.flush();
}
}
bin.close();
}
}

字符流的缓冲区。
BufferedReader
BufferedWriter
缓冲区给给流的操作动作(读写)提高效率.所以缓冲区的对象建立必须要有流对象。

字符流：
FileReader
FileWriter

BufferedReader
BuffereWriter

字节流。
InputStream OutputStream
FileInputStream FileOutputStream
BufferedInputStream BufferedOutputStream

转换流：
字节流--->字符流的桥梁。InputStreamReader
字符流--->字节流的桥梁。OutputStreamWriter

---------------------------------------
流的操作规律：

在进行数据操作时，IO包中提供了N多对象不同功能来操作设备上的数据。
在实际开发时，到底用哪个流对象来完成数据处理呢？
这是我们最为苦恼的事情。
如何明确具体用哪个流对象呢？
通过该规律就哦了。
规律就是四个明确？

1，明确源和目的。

源：InputStream Reader 一定是被读取的。
目的：OutputStream Writer 一定是被写入的。

2，处理的数据是否是纯文本的数据？

是：使用字符流。Reader Writer
否：使用字节流。 InputStream OutputStream
如果是源并且是纯文本，Reader
如果是目的并且是纯文本，Writer
到这里，两个明确确定完，就可以确定出要使用哪个体系。
接下来，就应该明确具体这个体系要使用哪个具体的对象。

3，明确数据所在的设备：
源设备：

键盘(System.in)
硬盘(FileXXX)
内存(数组)
网络(Socket)
目的设备：
显示器(控制台System.out)
硬盘(FileXXX)
内存(数组)
网络(Socket)
具体使用哪个对象就可以明确了。

4，明确是否需要额外功能？

是否需要高效？缓冲区Buffered
是否需要转换？转换流

实际需求：
需求1：复制一个文本文件。
1,明确源和目的：既有源，又有目的。

源：InputStream Reader
目的：OutputStream Writer.

2,明确是否是纯文本？是！

源：Reader
目的：Writer

3,明确具体设备:

源：硬盘(file)
目的：硬盘(file)

源对应的体系Reader中可以操作硬盘设备的对象是 FileReader
目的对应的体系Writer中可以操作硬盘设备的对象是FileWriter

直接明确具体对象并创建。
FileReader fr = new FileReader("a.txt");
FileWriter fw = new FileWriter("b.txt");

4,需要额外功能吗？

需要，高效。使用缓冲区。

BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));

需求2：复制一个图片
1,明确源和目的：既有源，又有目的。

源：InputStream Reader
目的：OutputStream Writer.

2,明确是否是纯文本？不是！

源：InputStream
目的：OutputStream

3,明确设备：

源：硬盘
目的：硬盘：

FileInputStream fis = new FileInputStream("1.jpg");
FileOutputStream fos = new FileOutputStrema("2.jpg");

需求3：读取键盘录入，存储到一个文件中。
1,明确源和目的：既有源，又有目的。

源：InputStream Reader
目的：OutputStream Writer.

2,明确是否是纯文本？一般键盘录入的都是文字，所以是纯文本的。

源：Reader
目的：Writer

3,明确设备：

源：键盘。
目的：硬盘。

具体对象
源是：System.in.
目的是：FileWriter

InputStream in = System.in;
FileWriter fw = new FileWriter("a.txt");
对这个读写，应该这样完成，通过键盘录入读取字节数据，先不做写入操作，
而是将字节数据临时存储，转成字符串，然后在交给fw写入。

发现代码操作的起来很麻烦。有没有已有的功能可以解决这个问题啊？
4,需要额外功能吗？

需要。必须的。
需要将键盘录入的字节转成字符。
使用转换流。而且是将字节-->字符的转换流对象。InputStreamReader

InputStreamReader isr = new InputStreamReader(System.in);
FileWriter fw = new FileWriter("a.txt");

还需要其他功能吗？
需要，高效。
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new FileWriter("a.txt"));

需求4：读取一个文本文件，显示到显示器上。
1,明确源和目的：既有源，又有目的。

源：InputStream Reader
目的：OutputStream Writer.

2,明确是否是纯文本？是。

源：Reader
目的：Writer

3,明确设备：

源：硬盘。File
目的：显示器。System.out

FileReader fr = new FileReader("a.txt");
OutputStream out = System.out;
这已经可以完成读写了。
通过fr读取文本到字符数组，将字符数组转成字符串，然后在将字符串转成字节数组。
交给out输出。

4,需要额外功能吗？

必须的。转换。需要将已有的字符数据转成字节。字符-->字节的桥梁 OutputStreamWriter

FileReader fr = new FileReader("a.txt");
OutputStreamWriter osw = new OutputStreamWriter(System.out);

需要高效。
BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWrier(System.out));

需求5：读取一个文本文件，将文件中文本按照指定的编码表UTF-8写入到另一个文件中。
1,明确源和目的：既有源，又有目的。

源：InputStream Reader
目的：OutputStream Writer.

2,明确是否是纯文本？是。

源：Reader
目的：Writer

3,明确设备：

源：硬盘。File
目的：硬盘。File

FileReader fr = new FileReader("a.txt");
FileWriter fw = new FileWriter("b.txt");

这样做不行，满足不了需求，为什么呢？
因为这个两个对象在操作文本数据，都是用了默认的编码表。在我的本机中默认码表是GBK.
而需求中希望写入到文件的数据是按照utf-8的码表。
其实这两个对象就是字节流+默认编码表。

源对象不变。
FileReader fr = new FileReader("a.txt");
需要目的为指定编码表。
这时就要用到转换流。因为转换流中可以指定具体的编码表。需要往里传递一个字节流，而且要操作文件，FileOutputStream
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("b.txt"),"UTF-8");

需要高效
BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("b.txt"),"UTF-8"));

c:\\1.txt 源是一个文件也是字节数据，是不是应该使用字节流呢？
FileInputStream fis = new FileInputStream("c:\\1.txt");
InputStreamReader isr = new InputStreamReader(fis,"gbk");
isr.read();//字符。

既然是明确操作是文件，而且使用默认编码表。
可以使用InputStreamReader的子类。FileReader

FileReader fr = new FileReader("c:\\1.txt");

秒客网

[置顶] 黑马程序员_IO流

相关文章