黑马程序员-Java基础-IO总结

----------------------
ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------
 * IO:就是输入（input）和输出（output），IO流用来处理设备之间的数据传输。Java中对数据的操作是通过流的方式进行的。

      * 1、操作的数据分为：字节流和字符流

      * 2、根据输入输出分为：输入流和输出流

      * 字节流的抽象基类：

      * InputStream 

      * OutputSream

      * 字符流的抽象基类：

      * Reader

      * Writer
IO中的派生类都是以其父类名作为子类名的后缀。
字符串缓冲区：提供一个临时的存储区域，方便字符数据的读取，提高读写效率
      BufferedWriter
      BufferedReader
      BufferedInputStream
      BufferedOutputStream
缓冲区的出现是为了提高流的操作效率而出现的，
* 所以在创建缓冲区之前，必须要先有流对象。

 * BufferedWiter提供了一个跨平台的换行符newLine()方便换行。

 * readLine()方法返回的时候只返回回车符之前的数据内存，并不返回回车符。

 * BufferedReader提供了一个一次读取一行的方法readLine(),方便于对文本数据的获取，

当返回null时，读到文件末尾。

注意：在文本文件读取时，必须明确源文件和目的文件，明确设备（内存或硬盘），明确具体的操作对象。
文本文件读取有三种方式；
1、单个字节读取
2、字符数组读取
3、带缓冲区读取
 InputStream中的重要方法 
int available():读取的字节长度 
void close（）：关闭输入流 
int read():读取字节，虽然是int类型，但实际上读取的是byte

OutputStream 常用方法 
void write（int b）：像流中写入一个byte值
void close（）：关闭输出流 
void flush（）：强制输出数据 
操作的基本规律：
 * 通过三个明确来完成：
 * 1、明确源和目的、
 *     源：输入流  InputStream Reader
 *     目的：输出流 OutputStream Writer
 * 2、操作的数据是否是纯文本
 *     是：字符流
 *     不是：字节流
 * 3、当体系明确后，再明确要使用哪个具体的对象，
 *     通过设备来进行区分
 *     源设备：内存，硬盘，键盘
 *     目的设备：内存，硬盘，键盘
 *     
 * 下面以文本文件复制举例说明
 * 源：读取流，InputStream Reader
 *   使操作文本文件：Reader，体系明确了。
 *   明确对象：
 *   设备：硬盘，上一个文件，Reader体系中可以操作文件的对象是FileReader
 *   FileReader fr = new FileReader("a.txt");
 *   BufferedReader bufr = new BufferedReader(fr);
 *   是否需要提高效率，加入Reader体系中的BufferedReader
 * 目的：OutputStream Writer
 *   是文本文件：Writer
 *   设备：硬盘  一个文件
 *   Writer体系中可以操作文件 的对象FileWriter
 *   FileWriter fw = new FileWriter("b.txt");
 *   BufferedWriter bufw = new BufferedWriter(fw);
 *   是否需要提高效率，加入Writer体系中的BufferedWriter
示例1，文本文件的复制，代码如下：

package blog.Javase.IO;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
* 举例：
* 文本文件的复制
*
*复制原理：
*就是将D盘下的文件数据存储到E盘的一个文件中
*
*步骤：
*1、在F盘创建一个文件，用于存储D盘文件中的数据
*2、定义读取流和D盘文件关联
*3、通过不断的读写完成数据存储。
*4、关闭资源
* @author kevin
*
*/
public class IODemo {

/**
* @param args
*/
public static void main(String[] args) throws IOException
{
//copy_02	();
copy_3();
}
//第二种方式，带缓冲区的写法
public static void copy_02()
{
FileWriter fw = null;
FileReader fr = null;

try {
fw = new FileWriter("E:\\Copy_IODemo.java");
fr = new FileReader("D:\\IODemo.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) {
throw new RuntimeException("IO关闭异常");
}
if(fr!=null)
try {
fw.close();

} catch (IOException e) {
throw new RuntimeException("IO关闭异常");
}
}
}
//读一个字符，就往F盘写一个字符.方式一，写入单个字符
public static void copy_1() throws IOException
{
//创建目的文件
FileWriter fw = new FileWriter("E:\\Copy_IODemo.java");

//与已有文件关联
FileReader fr = new FileReader("D:\\IODemo.java");
int ch = 0;
while((ch = fr.read())!=-1)
{
fw.write(ch);
}
fw.close();
fr.close();

}
//方式三，带缓冲区的文本文件复制
public static void copy_3() throws IOException
{
BufferedReader bufr = null;
BufferedWriter bufw = null;
try
{
bufr = new BufferedReader(new FileReader("FileCopy.java"));
bufw = new BufferedWriter(new FileWriter("Buf_Copy.java"));
String line = null;
while((line = bufr.readLine())!=null)
{
System.out.println(line);
bufw.write(line);
bufw.newLine();
bufw.flush();
}
}
catch(IOException e)
{
throw new RuntimeException("读写错误！");
}
finally
{
if (bufr != null)
try {
bufr.close();
}
catch (IOException e)
{
throw new RuntimeException("读取关闭失败！");
}
if (bufw != null)
try
{
bufw.close();
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败!");
}
}
}
}

示例2，使用字节流复制MP3音频文件，代码如下：

package com.itheima.day19;

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 Mp3Copy
{

/**
* 演示MP3复制，通过缓冲区
* BufferedOutputStream
* BufferedInputStream
*
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException
{
long start = System.currentTimeMillis();
copyFile();
long end = System.currentTimeMillis();
System.out.print(end-start+"毫秒");
}
//通过字节流缓冲区实现拷贝
public static void copyFile()
{
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
bis = new BufferedInputStream(new FileInputStream("01.黎明时分.MP3"));
bos = new BufferedOutputStream(new FileOutputStream("Copy_黎明时分.MP3.mp3"));
int ch = 0;
try {
while((ch = bis.read())!=-1)
{
bos.write(ch);
}
} catch (IOException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
finally
{
if(bos!=null)
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
if(bis!=null)
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

示例3，图片文件的复制，代码如下：

package com.itheima.day19;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class PictureCopy
{
/**
*复制一个图片
*思路：
*1、用字符读取流对象和图片关联
*2、用字节写入流对象创建一个图片文件，用于存储获取到的图片数据
*3、通过循环读写，完成数据的存储
*4、关闭资源
*/
public static void main(String[] args)
{
FileRead();
}
public  static void FileRead()
{
FileOutputStream fos = null;
FileInputStream fis = null;
try
{
fos = new FileOutputStream("2.jpg");
fis = new FileInputStream("1.jpg");
byte[] buf = new byte[1024];
int len = 0;
while((len = fis.read(buf))!=-1)
{
fos.write(buf);
}
}
catch(IOException e)
{
throw new RuntimeException("图片复制失败！");
}
finally
{
try
{
if(fis !=null)
fis.close();
}
catch(IOException e)
{
throw new RuntimeException("读取关闭失败");
}
try
{
if(fos !=null)
fos.close();
}
catch(IOException e)
{
throw new RuntimeException("写入关闭失败");
}
}
}

}

示例4，字节流和字符流之间的转化用法，代码如下：

package com.itheima.day19;

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
{

/**
* newLine()方法只有在BufferedWriter中才有，所以如果字节流想要使用它，
* 就必须要转换为字符流，这时就会用到InputStreamReader进行转换。
*
* 将字节流对象转换为字符流对象，使用转换流，InputStreamReader
* 将字符流转换为字节流，使用转换流     outputStreamWriter
*
*
* output-----writer
* input------reader
*
* 键盘录入改写
*
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException
{
//获取键盘录入对象
//InputStream in = System.in;

//将字节流对象转换为字符流对象，使用转换流，InputStreamReader
//InputStreamReader isr = new InputStreamReader(in);

//为了提高效率，将字符串进行缓冲区技术高效操作，使用BufferedReader
//BufferedReader bufr = new BufferedReader(isr);

//读取键盘输入流，以下为最常见写法
BufferedReader bufr = new BufferedReader(
new InputStreamReader(System.in));

//OutputStream out = System.out;
//将字符流转换为字节流，使用转换流     outputStreamWriter
//OutputStreamWriter  osw = new OutputStreamWriter(out);
//BufferedWriter bufw = new BufferedWriter(osw);

//输出键盘语句常见写法
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();
}

}

示例5，异常信息通过IO流技术保存为日志文件。代码如下：

package com.itheima.day19;

import java.io.IOException;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionLog
{

/**
* 保存异常信息日志
* @param args
* @throws IOException
*/
public static void main(String[] args)
{
try
{

char[] arr = new char[2];
System.out.println(arr[3]);
}
catch(Exception e)
{
try {
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 E HH:mm:ss");
String time = sdf.format(d);
PrintStream ps = new PrintStream("ExceptionLog.log");
ps.println(time);
System.setOut(ps);
} catch (IOException e1) {
throw new RuntimeException("日志文件创建失败");
}
e.printStackTrace(System.out);
}
}

}

----------------------
ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------