1:字符流(掌握)
基本的读取和基本的写入,单独使用也是要求掌握的。
掌握:(5种方式)
3:转换流(理解)
InputStreamReader isr = new InputStreamReader(System.in);
InputStreamReader isr = new InputStreamReader(new FileInputStream(...));
OutputStreamWriter osw = new OutputStreamWriter(System.out);
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(...));
4:字符编码(理解)
(1)编码表
字符及其对应的数值组成的一张表。
(2)常见的码表:
ASCII,ISO-8859-1,GB2312,GBK,GB18030,BIG5,UTF-8
(3)编码应用:
A:IO流中(转换流)
B:字符串
最好编码一致。
5:练习题目(掌握)
Reader
|--InputStreamReader
|--FileReader
|--BufferedReader
Writer
|--OutputStreamWriter
|--FileWriter
|--BufferedWriter
针对文本文件这样的数据操作。
基本的读取和基本的写入,单独使用也是要求掌握的。
掌握:(5种方式)
把c:\\a.txt复制到d:\\b.txt中。
字符流
一次一个字符
FileReader fr=new FileReader("c:\\a.txt");
FileWriter fw=new FileWriter("d:\\b.txt");
in ch=0;
while((ch=fr.read())!=-1){
fw.write();
}
fr.close();
fw.close();
一此一个字符数组
FileReader fr=new FileReader("c:\\a.txt");
FileWriter fw=new FileWriter("d:\\b.txt");
char[] chs=new char[1024];
in len=0;
while((len=fr.read(chs))!=-1){
fw.write(chs,0,len);
}
fr.close();
fw.close();
缓冲区流对象(一次一个字节、一次一个数组、、省略)
BufferedReader br=new BufferedReader(new FileReader("c:\\a.txt"));
BufferedWriter bw=new BufferedWriter(new FileWriter("d:\\b.txt"));
String line=null;
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
br.close();
bw.close();
2:字节流(掌握)
InputStream
|--FileInputStream
|--BufferedInputStream
OutputStream
|--FileOutputStream
|--BufferedOutputSteam
掌握:(4种方式)
把c:\\a.jpg复制到d:\\b.jpg中。
字节流
一次一个字节
FileInputStream fis=new FileInputStream("c:\\a.jpg");
FileOutputStream fos=new FileOutputStream("d:\\b.jpg");
in by=0;
while((by=fis.read())!=-1){
fos.write();
}
fis.close();
fos.close();
一次一个字节数组
FileInputStream fis=new FileInputStream("c:\\a.jpg");
FileOutputStream fos=new FileOutputStream("d:\\b.jpg");
byte[] bys=new byte[1024];
in len=0;
while((len=fis.read(bys))!=-1){
fos.write(bys,0.len);
}
fis.close();
fos.close();
缓冲区流对象(一次一个字节省略)
BufferedInputStream bis=new BufferedInputStream(new FileInputStream("c:\\a.jpg"));
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("d:\\b.jpg"));
byte[] bys=new byte[1024];
in len=0;
while((len=bis.read(bys))!=-1){
bos.write(bys,0.len);
}
bis.close();
bos.close();
3:转换流(理解)
InputStreamReader isr = new InputStreamReader(System.in);
InputStreamReader isr = new InputStreamReader(new FileInputStream(...));
OutputStreamWriter osw = new OutputStreamWriter(System.out);
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(...));
4:字符编码(理解)
(1)编码表
字符及其对应的数值组成的一张表。
(2)常见的码表:
ASCII,ISO-8859-1,GB2312,GBK,GB18030,BIG5,UTF-8
(3)编码应用:
A:IO流中(转换流)
B:字符串
最好编码一致。
5:练习题目(掌握)
A:单级目录的复制
public static void copy(File srcFile) throws IOException{
File[] arrayFile=srcFile.listFile();
File toFile=new File("d:\\copy");
toFile.mkdir();
BufferedInputStream bis=null;
BufferedOutputStream bos=null;
byte[] bys=new byte[1024];
int len=0;
for(File file:arrayFile){
bis=new BufferedInputStream(new FileInputStream(file));
bos=new BufferedOutputStream(new FileOutputStream(toFile,file.getName()));
while((len=bis.read(bys))!=-1){
bos.write(bys,0,len);
bos.flush();
}
}
bis.close();
bos.close();
}
package cn.itcast_07;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
/*
* System.in 标准的输入流。
* public static final InputStream in
*
* 需求:通过标准的输入流实现键盘录入数据写入文本文件。
*
* 数据源:
* 键盘录入 -- 标准输入流 -- System.in -- InputStream
* 目的地:
* 目的地 -- 文本文件 -- FileWriter -- BufferedWriter
*
* 注意:如果数据是键盘录入的,请自己给出结束标记。
*/
public class SystemInDemo {
public static void main(String[] args) throws IOException {
// 封装数据源
InputStream is = System.in; // 右边是子类对象
// System.out.println(is); // java.io.BufferedInputStream@60e128
// 封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter("is.txt"));
// 读写
// 我们现在需要通过is对象读取数据。
// 由于他是标准的输入流对象,所以,他的读取方式有两种:
// 一次读取一个字节,一次读取一个字节数组。
// 那么,我们现在选择哪种方案呢?
// 而一行到底有多少数据是不明确的,所以,我们选择了一次读取一个字节。
// 这个时候,又有了一个新的问题,我要的是一行数据,而你只能读取一个字节。
// 怎么办?通过循环读取即可。
// 如果通过循环读取,那么,每一次读取到下一个字节的时候,前面的字节数据又丢失了。
// 为了不让数据丢失,我们要把曾经读取过的数据给临时存储起来。
// 通过简单的分析,我们最终选择StringBuilder这个容器。
// 这样的话,我们就只剩下了一个难点,就是什么时候结束呢?
// 我们又知道遇到"\r\n"才结束。所以我们就可以判断了。
StringBuilder sb = new StringBuilder();
int by = 0;
while (true) {
by = is.read();
if (by == '\r') {
continue;
}
if (by == '\n') {
String s = sb.toString();
sb.delete(0, sb.length()); // 清空数据
if ("over".equals(s)) {
break;
}
// System.out.println(s);
bw.write(s);
bw.newLine();
bw.flush();
} else {
sb.append((char) by);
}
}
// 释放
bw.close();
is.close();
}
}
package cn.itcast_07;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
/*
* 如果按照刚才的标准输入流做法,我们也可以实现数据的录入。
* 但是,这样还要自己写判断,太麻烦。
* 我们就想能不能有一种方式能够一次读取一行数据呢?
* 有了。readLine()方法。
* 而这个方法确实BufferedReader类才有的。
*/
public class SystemInDemo2 {
public static void main(String[] args) throws IOException {
// 封装键盘录入
// InputStream is = System.in;
// // 注意:这个时候,我们发现一个问题。
// // 问题是字符缓冲区流对象只能对字符流进行高效的包装
// // 也就是说,他的功能是针对字符流有效。
// // 而你现在拥有的是字节流。
// // 偏偏又想使用这个方法,请问你们说怎么办?
// // 如果有一个东西可以实现把字节流转换成字符流就好了。
// // 针对这种情况,java就提供了转换流
// // InputStreamReader 是字节流通向字符流的桥梁
// // InputStreamReader(InputStream in)
// InputStreamReader isr = new InputStreamReader(is);
// BufferedReader br = new BufferedReader(isr);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new FileWriter("is2.txt"));
String line = null;
while ((line = br.readLine()) != null) {
if ("886".equals(line)) {
break;
}
bw.write(line);
bw.newLine();
bw.flush();
}
bw.close();
br.close();
}
}
package cn.itcast_07;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
/*
* 需求:我要把一个文本文件的数据显示在控制台。
* public static final PrintStream out:标准输出流
* 通过上面这句话,我可以写出这样的代码:
* OutputStream
* |--FilterOutputStream
* |--PrintStream
* OutputStream os = System.out;
*/
public class SystemOutDemo {
public static void main(String[] args) throws IOException {
// 封装数据源
// BufferedReader br = new BufferedReader(new FileReader("is2.txt"));
// OutputStream os = System.out;
//
// String line = null;
// while ((line = br.readLine()) != null) {
// os.write(line.getBytes());
// os.write("\r\n".getBytes());
// }
//
// os.close();
// br.close();
// 上面的代码中,"\r\n".getBytes()将来可能有问题。所以,我们需要改进
// 用一个newLine()方法搞定。
// 而这个方法是BufferedWriter。
// 你现在有的输出流是OutputStream
// 这是一个字节流,最终要用字符高效流
// 就必须转换。
// OutputStreamWriter 是字节流通向字符流的桥梁(使用上) 是字符流通向字节流的桥梁(理解上)
BufferedReader br = new BufferedReader(new FileReader("is2.txt"));
// OutputStream os = System.out;
// OutputStreamWriter osw = new OutputStreamWriter(os);
// BufferedWriter bw = new BufferedWriter(osw);
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
System.out));
String line = null;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
}
bw.close();
br.close();
}
}
B:集合和IO的数据转换(字符流)
package cn.itcast.test;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
/*
* 把集合中的字符串数据用IO流写到文本文件。
*
* 数据源:
* 集合 -- 存储数据并遍历
* 目的地:
* 文本文件 -- BufferedWriter
*/
public class ArrayListToFile {
public static void main(String[] args) throws IOException {
// 封装数据源
// 创建集合对象
ArrayList<String> array = new ArrayList<String>();
// 添加元素
array.add("hello");
array.add("world");
array.add("java");
// 封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter("array.txt"));
// 遍历集合
for (String str : array) {
bw.write(str);
bw.newLine();
bw.flush();
}
bw.close();
}
}
package cn.itcast.test;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
/*
* 把文本文件中的数据通过IO流写到集合中。
*
* 数据源:
* 文本文件 -- BufferedReader
* 目的地:
* 集合 -- String
*/
public class FileToArrayList {
public static void main(String[] args) throws IOException {
// 封装数据源
BufferedReader br = new BufferedReader(new FileReader(
"FileOutputStreamDemo.java"));
// 封装目的地
ArrayList<String> array = new ArrayList<String>();
String line = null;
while ((line = br.readLine()) != null) {
array.add(line);
}
br.close();
// 遍历集合
for (String str : array) {
System.out.println(str);
}
}
}
package cn.itcast.test;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 复制单级文件夹。
* 需求:把d:\\datasource这个文件夹的内容复制到当前项目路径下的copy这个文件夹中。
*
* 分析:
* A:封装数据源目录
* B:获取数据源目录下的所有File数组
* C:遍历File数组,获取得到每一个File
* D:复制File
* 新的File的路径问题。
* a:创建一个新的文件夹
* b:获取以前的文件名称,和新的文件夹组合成新的路径。
*/
public class CopyDirectory {
public static void main(String[] args) throws IOException {
// 封装数据源目录
File srcFile = new File("d:\\datasource");
// 给一个判断
if (!srcFile.exists()) {
throw new RuntimeException("数据源文件夹不存在");
}
// 获取数据源目录下的所有File数组
File[] fileArray = srcFile.listFiles();
// 造一个新的文件夹
File destFile = new File("copy");
destFile.mkdir();
// 遍历File数组,获取得到每一个File
for (File file : fileArray) {
// file -- d:\\datasource\\cxy.bmp
// 目的地:-- copy\\cxy.bmp
String name = file.getName(); // cxy.bmp
File newFile = new File(destFile, name); // copy\\cxy.bmp
copy(file, newFile);
}
}
public static void copy(File file, File newFile) throws IOException {
// 封装数据源
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
file));
// 封装目的地
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(newFile));
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
bos.close();
bis.close();
}
}
package cn.itcast.test;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
/*
* 编写一个程序,将d:\java目录下的所有.java文件复制到d:\jad目录下,
* 并将原来文件的扩展名从.java改为.jad。
*
* 分析:
* A:封装数据源目录
* B:获取数据源目录下的所有File数组(加过滤器)
* C:遍历File数组,获取得到每一个File
* D:复制File
* 改名:
* a:先改再复制
* b:先复制再改(思考留作作业)
*/
public class CopyDirectory2 {
public static void main(String[] args) throws IOException {
// 封装数据源目录
File srcFile = new File("d:\\java");
// 获取数据源目录下的所有File数组(加过滤器)
File[] fileArray = srcFile.listFiles(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return new File(dir, name).isFile() && name.endsWith(".java");
}
});
// 造新目录
File destFile = new File("d:\\jad");
if (!destFile.exists()) {
destFile.mkdir();
}
// 遍历File数组,获取得到每一个File
for (File file : fileArray) {
// file -- d:\\java\\ConstDemo.java
// 目的地:-- d:\\jad\\ConstDemo.jad
String oldName = file.getName(); // ConstDemo.java
String newName = oldName.replace(".java", ".jad"); // ConstDemo.jad
File newFile = new File(destFile, newName);
CopyDirectory.copy(file, newFile);
}
}
}
package cn.itcast.test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/*
* 复制多级目录:把d盘目录下的source目录(还有目录和文件)内容拷贝到e盘目录下。
* 分析:
* A:封装目录为File对象
* B:判断File对象是目录还是文件
* 如果是目录,在目的地创建同名目录。
* 如果是文件,就复制。
*/
public class IOTest {
public static void main(String[] args) throws IOException {
File source = new File("d:\\source");
File target = new File("e:\\");
copyDir(source, target);
}
// 拷贝目录
private static void copyDir(File source, File target) throws IOException {
// 判断source
if (source.isDirectory()) {
// 是目录
// 在target下创建同名目录
File dir = new File(target, source.getName());
dir.mkdirs();
// 遍历source下所有的子文件,将每个子文件作为source,将新创建的目录作为target进行递归。
File[] files = source.listFiles();
for (File file : files) {
copyDir(file, dir);
}
} else {
// 是文件
// 在target目录下创建同名文件,然后用流实现文件拷贝。
File file = new File(target, source.getName());
file.createNewFile();
copyFile(source, file);
}
}
// 拷贝文件
private static void copyFile(File source, File file) throws IOException {
// 创建流对象
InputStream is = null;
OutputStream os = null;
try {
is = new FileInputStream(source);
os = new FileOutputStream(file);
// 基本读写操作
byte[] bys = new byte[1024];
int len = 0;
while ((len = is.read(bys)) != -1) {
os.write(bys, 0, len);
}
} finally {
if (os != null) {
os.close();
}
if (is != null) {
is.close();
}
}
}
}