![IO 流](https://img-blog.csdn.net/20180131211800030?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvaHV6b25nbmFu/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
字符流
字符流
一个字符一个字符的读
注意:只能用来操作文本(不能写图片、音频、视频)
Writer(所有字符输出流的父类,是抽象类)
FileWirter
构造方法(绑定写入的路径):
文件
字符串
mac 系统下,一个中文字符占3个字节
默认使用 UTF-8的编码表(通用的编码表)
Windows 系统下,一个中文字符占2个字节
默认使用 GBK 编码表(简体中文)
FileWriter fw = new FileWriter("/Users/Desktop/Test/test.txt");
fw.write(100);
// 注意:字符输出流,在写入文件的时候
// 需要调用刷新方法
// 建议:每次写入,最好都刷新一次
fw.flush();
char[] c = {'l', 'o', 'n', 'g'};
fw.write(c);
fw.flush();
// 获取 char 类型中的字节
fw.write(c, 1, 3);
fw.flush();
// 使用字符串直接写入
fw.write("hello");
fw.flush();
fw.write("\n床前明月光\n");
fw.write("疑是地上霜\n");
fw.write("举头望明月\n");
fw.write("低头思故乡\n");
fw.flush();
// 输入字符串,获取其中的字符
fw.write("白日依山尽", 1, 2);
fw.flush();
// 关闭资源前,先刷新
fw.close();
字符输入流
字符输入流
Reader(所有字符输入流的父类,抽象类)
写的时候可以直接写入字符串
读的时候不能,字符串很难界定到哪里结束,不太容易判断一个字符串
单字节读取
FileReader fr = new FileReader("/Users/Desktop/Test/test.txt");
int len;
while ((len = fr.read()) != -1) {
System.out.println((char)len);
}
fr.close();
字符数组读取
FileReader fr = new FileReader("/Users/Desktop/Test/test.txt");
int len;
char[] c = new char[1024];
while ((len = fr.read(c)) != -1) {
System.out.println(new String(c, 0, len));
}
fr.close();
/*
* 利用字符流,复制文件(带异常处理)
*/
public class Demo {
public static void main(String[] args) {
copyDir();
}
public static void copyDir() {
FileReader fr = null;
FileWriter fw = null;
try {
fr = new FileReader("/Users/Desktop/Test/test.txt");
fw = new FileWriter("/Users/Desktop/XTest/test.txt");
char[] c = new char[1024];
int len = 0;
while ((len = fr.read(c)) != -1) {
fw.write(c, 0, len);
fw.flush();
}
} catch (FileNotFoundException e) {
throw new RuntimeException("文件路径有误,无法找到该文件!");
} catch (IOException e) {
throw new RuntimeException("文件读取失败!");
} finally {
try {
if (fr != null) {
fr.close();
}
} catch (IOException e) {
throw new RuntimeException("资源关闭失败!");
} finally {
try {
fw.close();
} catch (Exception e2) {
throw new RuntimeException("资源关闭失败!");
}
}
}
}
}
转换流
转换流
OutputStreamWriter(字符流转向字节流)
作用:可以根据不同编码格式写入
需要使用到 FileOutputStream 类
InputStreamWriter(字节流转向字符流)
作用:可以读取不同编码格式的文件
需要使用到 FileInputStream 类
![这里写图片描述](https://img-blog.csdn.net/20180131211900168?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvaHV6b25nbmFu/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
// 利用转换流写文件 OutputStreamWriter 默认UTF-8写的
public static void getUTF8() throws IOException{
FileOutputStream fos = new FileOutputStream("/Users/Desktop/Test/utf8.txt");
// 创建转换流,字符流转向字节流
OutputStreamWriter osw = new OutputStreamWriter(fos);
// 写文件
osw.write("张三");
// 关闭资源(之关闭外层流即可,内层流在外层流关闭时,外层流会帮你内部实现关闭)
osw.close();
}
// 利用转换流,使用 GBK 的编码写入文件
public static void getGBK() throws IOException{
FileOutputStream fos = new FileOutputStream("/Users/Desktop/Test/gbk.txt");
// 构建转换流,传入编码格式(编码格式的字符串,忽略大小写)
OutputStreamWriter osw = new OutputStreamWriter(fos, "GBK");
osw.write("李四");
osw.close();
}
// 利用转换流 InputStreamWriter 读文件,默认 UTF-8
public static void readUTF8() throws IOException {
FileInputStream fis = new FileInputStream("/Users/Desktop/Test/utf8.txt");
InputStreamReader isr = new InputStreamReader(fis);
char[] c = new char[1024];
int len = 0;
while ((len = isr.read(c)) != -1) {
System.out.println(new String(c, 0, len));
}
isr.close();
}
// 利用转换流,读取 GBK 编码的文件
public static void readGBK() throws IOException {
FileInputStream fis = new FileInputStream("/Users/Desktop/Test/gbk.txt");
InputStreamReader isr = new InputStreamReader(fis, "GBK");
char[] c = new char[1024];
int len = 0;
while ((len = isr.read(c)) != -1) {
System.out.println(new String(c, 0, len));
}
isr.close();
}
/*
* "Success is the constant experience of failure and always keeping the initial enthusiasm"
* 把上列字符串以下列形式写入文件
* Success=1
* is=1
* the=2
* .....
*/
public class Demo {
public static void main(String[] args) throws IOException {
mapPutIntoTxt();
readGBK();
}
/*
* 定义一个 String string = "Success is the constant experience of failure and always keeping the initial enthusiasm";
* 用空格分割成一个一个字符串
* 将获取到的字符串存入 map 中为key 值,比对有无字符串,有value + 1,没有 value = 1;
*/
public static HashMap<String, Integer> stringPutIntoMap() {
HashMap<String, Integer> map = new HashMap<>();
String string = "Success is the constant experience of failure and always keeping the initial enthusiasm";
String[] split = string.split(" ");
for (String key : split) {
if(map.containsKey(key)) {
Integer value = map.get(key);
map.put(key, value + 1);
} else {
map.put(key, 1);
}
}
return map;
}
/*
* 获取 key - value 键值对
* 将键值对输入文件中
*/
public static void mapPutIntoTxt() throws IOException {
FileOutputStream fos = new FileOutputStream("/Users/Desktop/Test/utf8.txt");
HashMap<String, Integer> map = stringPutIntoMap();
OutputStreamWriter osw = null;
for (Entry<String, Integer> entry : map.entrySet()) {
String string = entry.toString();
string = string +"\n";
osw = new OutputStreamWriter(fos);
osw.write(string);
osw.flush();
}
osw.close();
}
// 利用转换流,读取 GBK 编码的文件
public static void readGBK() throws IOException {
FileInputStream fis = new FileInputStream("/Users/Desktop/Test/utf8.txt");
InputStreamReader isr = new InputStreamReader(fis);
char[] c = new char[1024];
int len = 0;
while ((len = isr.read(c)) != -1) {
System.out.println(new String(c, 0, len));
}
isr.close();
}
}
/*
* 将一个文件夹下的所有txt文件 复制 到另一个文件夹下 并且把txt改成java
*/
public class Demo {
public static void main(String[] args) throws IOException {
test();
}
public static void test() throws IOException {
File src = new File("/Users/Desktop/Test");
File dest = new File("/Users/Desktop/XTest");
copyDirTXTFIle(src, dest);
}
public static void copyDirTXTFIle(File src, File dest) throws IOException {
File[] listFiles = src.listFiles(new MyFilterByTxt());
InputStreamReader isr = null;
OutputStreamWriter osw = null;
for (File subFile : listFiles) {
// 判断是否是文件
if (subFile.isFile()) {
// 是文件,通过过滤器,得到的一定是 TXT 文件,进行读写
FileInputStream fis = new FileInputStream(subFile);
// 拼接
String[] split = subFile.getName().split("\\.");
File tempFile = new File(dest,split[0] + ".java");
isr = new InputStreamReader(fis);
FileOutputStream fos = new FileOutputStream(tempFile);
osw = new OutputStreamWriter(fos);
char[] c = new char[1024];
int len = 0;
while((len = isr.read(c)) != -1) {
osw.write(new String(c, 0, len));
}
osw.flush();
} else {
copyDirTXTFIle(subFile, dest);
}
}
isr.close();
osw.close();
}
}
class MyFilterByTxt implements FileFilter{
@Override
public boolean accept(File pathname) {
// 判断是否是文件夹,是直接返回 true, 确保文件不被过滤
if (pathname.isDirectory()) {
return true;
}
// 直接返回 TXT 文件
return pathname.getName().endsWith("txt");
}
}
/*
* 计算
* 字节流的两种读取文件方式(单个字节读/字符数组读)
* 字符流的两种读取文件方式(单个字节读/字符数组读)
* 复制文件的时间(使用模板设计模式)
*/
public class Demo {
public static void main(String[] args) throws IOException {
Test();
}
public static void Test() throws IOException {
System.out.println("字节流单字节读取文件:");
ByteStreamRead byteStreamReadSingleByte = new ByteStreamReadSingleByte();
byteStreamReadSingleByte.countSpeedTimes();
System.out.println("字节流字符数组读取文件:");
ByteStreamRead byteStreamReadCharacterArray = new ByteStreamReadCharacterArray();
byteStreamReadCharacterArray.countSpeedTimes();
System.out.println("字符流单字节读取文件:");
CharacterStream characterStreamSingleByte = new CharacterStreamSingleByte();
characterStreamSingleByte.countSpeedTimes();
System.out.println("字符流字符数字读取文件:");
CharacterStream characterStreamCharacterArray = new CharacterStreamCharacterArray();
characterStreamCharacterArray.countSpeedTimes();
}
}
// 模板设计模式
abstract class Count{
// 统计程序所用时间
public void countSpeedTimes() throws IOException {
// 获取开始时间
long start = System.currentTimeMillis();
// 调用抽象方法
readFile();
// 获取结束时间
long end = System.currentTimeMillis();
// 打印所用时间
System.out.println("花费:" + (end - start) + " ms");
}
// 声明一个抽象方法
public abstract void readFile() throws IOException;
}
// 字节流的读取方法
abstract class ByteStreamRead extends Count{
// 重新抽象方法
@Override
public void readFile() throws IOException {
FileInputStream fis = null;
try {
fis = new FileInputStream("/Users/Desktop/Test/utf8.txt");
int len = 0;
run(len, fis);
} catch (FileNotFoundException e) {
throw new RuntimeException("文件路径有误,无法找到该文件!");
} catch (IOException e) {
throw new RuntimeException("文件读取失败!");
} finally {
try {
if (fis != null) {
fis.close();
}
} catch (IOException e) {
throw new RuntimeException("资源关闭失败!");
}
}
}
public abstract void run(int len, FileInputStream fis) throws IOException;
}
class ByteStreamReadSingleByte extends ByteStreamRead{
@Override
public void run(int len, FileInputStream fis) throws IOException {
while ((len = fis.read()) !=-1) {
System.out.println((char)len);
}
}
}
class ByteStreamReadCharacterArray extends ByteStreamRead{
@Override
public void run(int len, FileInputStream fis) throws IOException {
byte[] b = new byte[1024];
while((len = fis.read(b)) != -1) {
System.out.println(new String(b, 0, len));
}
}
}
abstract class CharacterStream extends Count{
@Override
public void readFile() throws IOException {
FileReader fr = new FileReader("/Users/Desktop/Test/utf8.txt");
run(fr);
fr.close();
}
public abstract void run(FileReader fr) throws IOException;
}
class CharacterStreamSingleByte extends CharacterStream{
@Override
public void run(FileReader fr) throws IOException {
int len;
while ((len = fr.read()) != -1) {
System.out.println((char)len);
}
}
}
class CharacterStreamCharacterArray extends CharacterStream{
@Override
public void run(FileReader fr) throws IOException {
int len;
char[] c = new char[1024];
while ((len = fr.read(c)) != -1) {
System.out.println(new String(c, 0, len));
}
}
}
http://blog.csdn.net/huzongnan/article/list