io知识点总结和一些看法!

                                                       黑马程序员  io知识点总结(2)

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

(一)知识框架

1:字符流(掌握)
Reader
|--InputStreamReader
|--FileReader
|--BufferedReader
Writer
|--OutputStreamWriter
|--FileWriter
|--BufferedWriter


针对文本文件这样的数据操作。
基本的读取和基本的写入，单独使用也是要求掌握的。

掌握：(5种方式)
把c:\\a.txt复制到d:\\b.txt中。


(1)FileWriter写入数据
操作步骤：
A:创建字符输出流对象
B:调用对象的write()方法
C:释放资源


代码体现：
FileWriter fw = new FileWriter("fw.txt");


fw.write("hello,IO");
//fw.flush();


fw.close();


几个小问题?
A:创建字符输出流对象做了那几件事情?
B:为什么要flush()?
C:为什么要close()?
D:flush()和close()的区别?
E:怎么实现换行?
F:怎么实现追加写入?
G:文件不存在，会创建一个。文件如果存在，到底是重新创建，还是把内容给清空?
(2)FileReader读取数据
操作步骤：
A:创建字符输入流对象
B:调用对象的read()方法
C:释放资源


代码体现：
FileReader fr = new FileReader("fw.txt");


//方式1
//一次读取一个字符
int ch = 0;
while((ch=fr.read())!=-1) {
System.out.print((char)ch);
}




//方式2
//一次读取一个字符数组
char[] chs = new char[1024];
int len = 0;
while((len=fr.read(chs))!=-1) {
System.out.print(String.valueOf(chs,0,len));
}


fr.close();
(3)复制文本文件
数据源：
看用那种类型的流，读取数据。
目的地：
看用那种类型的流，写出数据。


案例：
把当前项目路径下的Demo.txt复制到d盘目录下的Copy.txt中。


代码体现：
方式1:
FileReader fr = new FileReader("Demo.txt");
FileWriter fw = new FileWriter("d:\\Copy.txt");


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


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




方式2:
FileReader fr = new FileReader("Demo.txt");
FileWriter fw = new FileWriter("d:\\Copy.txt");


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


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




2:转换流(理解)
InputStreamReader isr = new InputStreamReader(System.in);
InputStreamReader isr = new InputStreamReader(new FileInputStream(...));


OutputStreamWriter osw = new OutputStreamWriter(System.out);
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(...));


3:字符编码(理解)
(1)编码表
字符及其对应的数值组成的一张表。
(2)常见的码表：
ASCII,ISO-8859-1,GB2312,GBK,GB18030,BIG5,UTF-8
(3)编码应用：
A:IO流中(转换流)
B:字符串

(二)代码实现部分:

1.  字符流四中复制方式
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;


/*
 * 四种方式复制比较
 */
public class Test {


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


long before = System.currentTimeMillis();
// method();   68641
// method2();  127
// method3();  //415  62416(如果高效流在写出一个字节后就直接刷新，就失去了高效的意义。)
// method4();  36
long after = System.currentTimeMillis();
System.out.println(after-before);
}


//普通流一次一个字节
private static void method() throws IOException {

//创建流对象
FileInputStream fis = new FileInputStream("czbk.mp3");
FileOutputStream fos = new FileOutputStream("czbk_今天我们要走了.mp3");
//复制

//定义变量，存储本次读取到的字节
int b;
while((b=fis.read())!=-1) {
fos.write(b);
}

//关闭流
fos.close();
fis.close();
}

//普通流一次一个字节数组
private static void method2() throws IOException  {
//创建流对象
FileInputStream fis = new FileInputStream("czbk.mp3");
FileOutputStream fos = new FileOutputStream("czbk_今天我们要走了.mp3");
//复制

//定义变量，存储每次读取到的数据
byte[] bytes = new byte[1024];
//定义变量，记录每次读取到的字节个数
int len;

while((len=fis.read(bytes))!=-1) {
fos.write(bytes,0,len);
}

//关闭流
fos.close();
fis.close();
}


//高效流一次一个字节
private static void method3() throws IOException  {
//创建流对象
FileInputStream fis = new FileInputStream("czbk.mp3");
FileOutputStream fos = new FileOutputStream("czbk_今天我们要走了.mp3");

BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
//复制
//定义变量，存储本次读取到的字节
int b;
while((b=bis.read())!=-1) {
bos.write(b);
bos.flush();
}

//关闭流
bos.close();
bis.close();
}

//高效流一次一个字节数组
private static void method4() throws IOException  {
//创建流对象
FileInputStream fis = new FileInputStream("czbk.mp3");
FileOutputStream fos = new FileOutputStream("czbk_今天我们要走了.mp3");

BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
//定义变量，存储每次读取到的数据
byte[] bytes = new byte[1024];
//定义变量，记录每次读取到的字节个数
int len;

while((len=bis.read(bytes))!=-1) {
bos.write(bytes,0,len);
}

//关闭流
bos.close();
bis.close();
}
}

2.   高效字符流一次复制一行

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


/*
 * 高效字符流一次复制一行
 */
public class Test2 {


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

//创建流对象
BufferedReader br = new BufferedReader(new FileReader("c.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("d.txt"));
//先读
String line;

while((line=br.readLine())!=null) {
//后写
bw.write(line);
bw.newLine();
}
//关闭流
bw.close();
br.close();
}


}

3. 复制单级文件夹

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;


/*
 * 复制单级文件夹：
 * 将 src/cn/itcast2 文件夹下的所有内容，复制到  a文件夹中
 */
public class Test2 {


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

File srcDIR = new File("src/cn/itcast2");
File destDIR = new File("a");

copyDIR(srcDIR, destDIR);
}


public static void copyDIR(File srcDIR, File destDIR)
throws FileNotFoundException, IOException {
//如果目标文件夹不存在，则创建目标文件夹
if(!destDIR.exists()) {
destDIR.mkdirs();
}
//依次拿到源文件夹下的所有文件对象
File[] listFiles = srcDIR.listFiles();
//迭代数组，依次拿到每一个文件
for (File file : listFiles) {
//将每次拿到的这个文件复制到新的文件夹中

//找到源文件对象
File oldFile = file;
//找到目标文件对象
File newFile = new File("a",oldFile.getName());
//文件复制
//创建流对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(oldFile));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile));
//先读
byte[] bytes = new byte[1024];
int len;
while((len=bis.read(bytes))!=-1) {
//后写
bos.write(bytes, 0, len);
}
//关闭流
bos.close();
bis.close();
}
}
}

4.集合与io知识点的结合点

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;


/*
 * 将集合中数据存储到文件中。再完成相反的动作。
 * 随机获取文本文件中的姓名
 * 
 * ArrayList:  {"成成","涔涔","安安","念念","青青","乐乐","斌斌","立立"}   >>  放到文件中
 */
public class Test {


public static void main(String[] args) throws IOException {
//将文件中的人名写到集合中
//创建输入流对象
BufferedReader br = new BufferedReader(new FileReader("g.txt"));
//创建集合对象
ArrayList<String> list = new ArrayList<String>();

//读取人名
String name;
while((name = br.readLine())!=null) {
//获取一个人名，向集合中添加一个人名
list.add(name);
}

System.out.println(list);
//随机从集合中取一个人名

//获取索引上限
int maxIndex = list.size();
//随机获取一个索引
int randomIndex = new Random().nextInt(maxIndex);
int randomIndex2 = new Random().nextInt(maxIndex);
//通过索引获取元素
System.out.println(list.get(randomIndex)+"和"+list.get(randomIndex2));
}


//将集合内容写到文件中
public static void method() throws IOException{
/*
* 使用集合准备数据
* 迭代集合，依次获取每一个元素
* 每获取一个元素，就写出一个元素并换行
*/

ArrayList<String> list = new ArrayList<String>();
//创建一个字符输出流，用来输出人名
BufferedWriter bw = new BufferedWriter(new FileWriter("h.txt"));

Collections.addAll(list, "成成","涔涔","安安","念念","青青","乐乐","斌斌","立立");

for (String name : list) {
bw.write(name);
bw.newLine();
}

bw.close();
}
}