----------------------------------------------day21 总结-------------------------------------------
1:字符流(掌握)
(1)字节流操作中文数据不是特别的方便，所以就出现了转换流。
转换流的作用就是把字节流转换字符流来使用。
(2)转换流其实是一个字符流
字符流 = 字节流 + 编码表
(3)编码表
A:就是由字符和对应的数值组成的一张表
B:常见的编码表
ASCII
ISO-8859-1
GB2312
GBK
GB18030
UTF-8
C:字符串中的编码问题
编码
String – byte[]
解码
byte[] – String
(4)IO流中的编码问题
A:OutputStreamWriter
OutputStreamWriter(OutputStream os):默认编码，GBK
OutputStreamWriter(OutputStream os,String charsetName):指定编码。
B:InputStreamReader
InputStreamReader(InputStream is):默认编码，GBK
InputStreamReader(InputStream is,String charsetName):指定编码
C:编码问题其实很简单
编码只要一致即可
(5)字符流
Reader
|–InputStreamReader
|–FileReader
|–BufferedReader
Writer
|–OutputStreamWriter
|–FileWriter
|–BufferedWriter
(6)复制文本文件(5种方式)
2:IO流小结(掌握)
IO流
|–字节流
|–字节输入流
InputStream
int read():一次读取一个字节
int read(byte[] bys):一次读取一个字节数组
|--FileInputStream
|--BufferedInputStream
|--字节输出流
OutputStream
void write(int by):一次写一个字节
void write(byte[] bys,int index,int len):一次写一个字节数组的一部分
|--FileOutputStream
|--BufferedOutputStream
|--字符流
|--字符输入流
Reader
int read():一次读取一个字符
int read(char[] chs):一次读取一个字符数组
|--InputStreamReader
|--FileReader
|--BufferedReader
String readLine():一次读取一个字符串
|--字符输出流
Writer
void write(int ch):一次写一个字符
void write(char[] chs,int index,int len):一次写一个字符数组的一部分
|--OutputStreamWriter
|--FileWriter
|--BufferedWriter
void newLine():写一个换行符
void write(String line):一次写一个字符串
3:案例(理解 练习一遍)
A:复制文本文件 5种方式(掌握)
B:复制图片(二进制流数据) 4种方式(掌握)
C:把集合中的数据存储到文本文件
D:把文本文件中的数据读取到集合并遍历集合
E:复制单级文件夹
F:复制单级文件夹中指定的文件并修改名称
回顾一下批量修改名称
G:复制多级文件夹
H:键盘录入学生信息按照总分从高到低存储到文本文件
I:把某个文件中的字符串排序后输出到另一个文本文件中
J:用Reader模拟BufferedReader的特有功能
K:模拟LineNumberReader的特有功能
-----------------------------------知识点1-------------------------------------
package cn.itcast_01;
import java.io.FileInputStream;
import java.io.IOException;
/*
-
字节流读取可能出现的小问题：
-
*/
public class FileInputStreamDemo {
public static void main(String[] args) throws IOException {
// 创建字节输入流对象
FileInputStream fis = new FileInputStream(“a.txt”);// 读取数据 int by =0; while((by =fis.read()) !=-1){ System.out.print((char) by); } // 释放资源 fis.close();}
}
package cn.itcast_01;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
/*
-
public String(byte[] bytes,String charsetName):通过指定的字符集解码字节数
-
public byte[] getBytes(Charset charset)：使用指定的字符集和把字符串编码为字节数组
-
编码问题，只要编码的格式一致，就不会出现问题。
-
*/
public class StringDemo {
public static void main(String[] args) throws UnsupportedEncodingException {
String s = “你好”;
//byte [] bys = s.getBytes();
//byte [] bys = s.getBytes(“GBK”);//[-60, -29, -70, -61]
byte [] bys = s.getBytes(“UTF-8”); //[-28, -67, -96, -27, -91, -67]
System.out.println(Arrays.toString(bys)); // [-60, -29, -70, -61]String ss = new String(bys); //String ss = new String(bys,"GBK"); //String ss = new String(bys,"UTF-8"); // ??? System.out.println(ss);}
}
-----------------------------------知识点2-------------------------------------
package cn.itcast_02;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
/*
-
InputStreamReader(InputStream in) :用于默认的编码读取数据
-
InputStreamReader(InputStream in, String charsetName)：用指定的编码读取数据
-
*/
public class InputStreamReaderDemo {
public static void main(String[] args) throws IOException {
// 创建对象
InputStreamReader isr = new InputStreamReader(new FileInputStream(“osw.txt”));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream(“osw.txt”));
// 读取数据 方式1 一次读一个字节
int ch =0;
while((ch=isr.read()) !=-1){
System.out.print((char)ch);
}// 读取数据 方式2 一次读取一个字节数组 int len =0; char [] cha = new char [1024]; while((len=isr2.read(cha)) !=-1){ System.out.print(new String(cha,0,len)); } // 释放资源 isr.close();}
}
-----------------------------------知识点3-------------------------------------
package cn.itcast_02;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
/*
-
public OutputStreamWriter(OutputStream out):根据默认编码把字节流转换为字符流
-
public OutputStreamWriter(OutputStream out,Charset cs)：根据指定的编码格式把字节流转化为字符流
-
*/
public class OutputStreamWriterDemo {
public static void main(String[] args) throws IOException {
// 创建对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(“osw.txt”));// 写数据 osw.write("中国"); // 释放资源 osw.close();}
}
-----------------------------------知识点4-------------------------------------
package cn.itcast_03;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
/*
-
InputStreamReader的方法：
-
int read():一次读取一个字符
-
int read(char[] cbuf)：一次读取一个字符数组
-
int read(char[] cbuf,int offset,int length)： 读取字符数组的一部分
-
*/
public class InputStreamReaderDemo {
public static void main(String[] args) throws IOException {
// 创建对象
InputStreamReader isr = new InputStreamReader(new FileInputStream(“StringDemo.java”));// 读取数据方式1 一次读取一个字节
// int ch = 0;
// while((ch= isr.read()) !=-1){
// System.out.print((char)ch);
// }
// 读取数据方式2 一次读取一个字符数组
int len = 0;
char [] chs = new char [1024];
while((len=isr.read(chs))!=-1){
System.out.print(new String(chs,0,len));
}
// 释放资源
isr.close();
}
}
-----------------------------------知识点5-------------------------------------
package cn.itcast_03;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
/* OutputStreamWriter写数据方法:
- public void write(int c):字一个字符
- public void write(char[] cbuf)：写一个字符数组
- public void write(char[] cbuf,int off,int len)：写字符数组的一部分
- public void write(String str)：写一个字符串
- public void write(String str,int off,int len)：写字符串的一部分
*面试题：close()和flush()的区别
-
1.close()关闭流对象，但是刷新一次缓冲区。关闭之后，流对象不可以继续在使用了。
-
2.flush()仅仅刷新缓冲区，流对象可以继续使用。
-
*/
public class OutputStreamWriterDemo {
public static void main(String[] args) throws IOException{
// 创建对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(“osw2.txt”));// 写入数据 osw.write('a'); osw.write(97); osw.write("中国"); // 释放资源 // 没有释放资源或者刷新，数据没法写入 // 原因是：1字符=2字节 // 文件中数据存储的基本单位是字节 // void flush() // osw.flush(); // public void write(char[] cbuf)：写一个字符数组 // 创建字符数组 char [] ch = {'a','b','c','d'}; osw.write(ch); // public void write(char[] cbuf,int off,int len):写字符数组的一部分 osw.write(ch,0,3); // public void write(String str)：写一个字符串 osw.write("java"); // public void write(String str,int off,int len)：写字符串的一部分 osw.write("java",0,2); osw.flush(); // 释放资源 osw.close();}
}
-----------------------------------知识点6-------------------------------------
package cn.itcast_04;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
/*
-
需求：把当前项目录下的a.txt内容复制到当前目录下的b.txt中
-
*/
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
// 封装数据源
InputStreamReader isr = new InputStreamReader(new FileInputStream(“a.txt”));
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(“b.txt”));// 复制数据 // 读数据 // 方式1 // int ch = 0; // while((ch=isr.read()) !=-1){ // // 输出读取的数据 // System.out.print((char)ch); // 复制操作 // //osw.write(ch); //} // 方式2 int len =0; char [] chs = new char[1024]; while((len=isr.read(chs)) != -1){ System.out.print(new String(chs,0,len)); osw.write(chs,0,len); } // 释放资源 isr.close(); osw.close();}
}
-----------------------------------知识点7-------------------------------------
package cn.itcast_04;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
-
由于我们常见的操作都是使用本地默认编码，所以，不用指定编码
-
而转换流的名称有点长，所以java提供了其子类供我们使用。
-
OutputStreamWriter = FileOutputStream +编码表 (GBK)
-
FileWriter = FileOutputStream +编码表(GBK)
-
InputStreamReader = FileOutputStream + 编码表(GBK)
-
FileReader = FileInputStream + 编码表(GBK)
-
需求：把当前目录下的a.txtz复制到b.txt中
-
数据源：
-
a.txt – 读取数据 --字符转换流–InputStreamReader – FileReader
-
b.txt – 写入数据–字符转化流–OutputStreamWriter-- FileWriter
-
*/
public class CopyFileDemo2 {
public static void main(String[] args) throws IOException{
// 封装数据源
FileReader fr = new FileReader(“a.txt”);
// 封装目的地
FileWriter fw = new FileWriter(“b.txt”);// 复制操作 // 读取数据方式1
// int ch=0;
// while((ch=fr.read()) !=-1){
// System.out.print((char)ch);
// }
// 读取数据 方式2
int len =0;
char [] chs = new char[1024];
while((len=fr.read(chs)) != -1){
fw.write(chs,0,len);
}
// 释放资源
fr.close();
fw.close();
}
}
-----------------------------------知识点8-------------------------------------
package cn.itcast_05;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
-
字符缓冲流的特殊方法：
-
BufferedWriter
public void newLine()：根据系统来决定换行符BufferedReader
public String readLine()：一次读取一行数据 -
*/
public class BufferedDemo {
public static void main(String[] args) throws IOException {
//write();
read();
}private static void read() throws IOException {
// 创建字符输入流对象
BufferedReader br = new BufferedReader(new FileReader(“bw.txt”));// public String readLine()：一次读取一行数据
// System.out.println(br.readLine());
// System.out.println(br.readLine());
// 最终代码
String line = null;
while((line=br.readLine()) !=null){
System.out.println(line);
}
// 释放资源
br.close();
}
private static void write() throws IOException {
// 创建字符缓冲流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
// 写入数据
for (int x=0;x<10;x++){
bw.write("hello"+x);
//bw.write("\r\n");
bw.newLine();
bw.flush();
}
// 释放资源
bw.close();
}
}
-----------------------------------知识点9-------------------------------------
package cn.itcast_05;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/*
-
读数据方案
-
BufferedReader：字符缓冲输入流
-
字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 -
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。 -
*/
public class BufferedReaderDemo {
public static void main(String[] args) throws IOException {
// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader(“a.txt”));// 读取数据 int len =0; char [] chs = new char [1024]; while((len=br.read(chs)) != -1){ System.out.print(new String(chs,0,len)); } // 释放资源 br.close();}
}
-----------------------------------知识点10-------------------------------------
package cn.itcast_05;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/*
-
字符流为了高效的读写，也提供了对应的字符缓冲流
-
BufferedWriter：字符缓冲输出流
-
BufferedReader：字符缓冲输入流
-
BufferedWriter：字符缓冲输出流
-
文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
-
可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。
-
*/
public class BufferedWriterDemo {
public static void main(String[] args) throws IOException {
// BufferedWriter(Writer out)
// BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(“bw.txt”)));
// 改进
BufferedWriter bw = new BufferedWriter(new FileWriter(“bw.txt”));// 写数据 bw.write("hello"); bw.write("world"); bw.write("java"); // 释放资源 bw.close();}
}
-----------------------------------知识点11-------------------------------------
package cn.itcast_06;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
-
需求：把当前目录下的a.txtz复制到b.txt中
-
数据源：
-
a.txt – 读取数据 --字符转换流–InputStreamReader – FileReader–BufferedReader
-
目的地：
-
b.txt – 写入数据–字符转化流–OutputStreamWriter-- FileWriter–BufferedWriter
-
*/
public class CopeFileDemo {
public static void main(String[] args) throws IOException{
// 封装数据源
BufferedReader br = new BufferedReader(new FileReader(“a.txt”));// 封装目的地 BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt")); // 复制数据 int len =0; char [] chs = new char[1024]; while((len=br.read(chs)) !=-1){ System.out.print(new String(chs,0,len)); bw.write(chs,0,len); bw.flush(); } // 释放资源 br.close(); bw.close();}
}
-----------------------------------知识点12-------------------------------------
package cn.itcast_06;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
-
需求：把当前目录下的a.txtz复制到b.txt中
-
数据源：
-
a.txt – 读取数据 --字符转换流–InputStreamReader – FileReader–BufferedReader
-
目的地：
-
b.txt – 写入数据–字符转化流–OutputStreamWriter-- FileWriter–BufferedWriter
-
*/
public class CopyFileDemo2 {
public static void main(String[] args) throws IOException{
// 封装数据源
BufferedReader br = new BufferedReader(new FileReader(“a.txt”));// 封装目的地 BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt")); // 复制数据 String len =null; while((len=br.readLine()) !=null){ bw.write(len); bw.newLine(); bw.flush(); } // 释放资源 br.close(); bw.close();}
}
-----------------------------------知识点13-------------------------------------
package cn.itcast_01;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
/*
-
需求：使用字符流五种读写方法实现，文件的复制
-
数据源：
-
E：\a.txt
-
目的地：
-
F：\b.txt
-
*/
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
String scrString = “E:\a.txt”;
String destString = “F:\b.txt”;
method5(scrString,destString);
}// 方法1 字符流一次读写一个字符
private static void method1(String scrString,String destString) throws IOException {
// 封装数据源
InputStreamReader isr = new InputStreamReader(new FileInputStream(scrString));
// 封装目的地
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(destString));// 复制数据 int ch =0; while((ch=isr.read()) !=-1){ osw.write(ch); } // 释放资源 isr.close(); osw.close();}
// 方法2 字符流一次读写一个字符数组
private static void method2(String scrString,String destString) throws IOException {
// 封装数据源
InputStreamReader isr = new InputStreamReader(new FileInputStream(scrString));
// 封装目的地
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(destString));// 复制数据 int len =0; char [] chs = new char [1024]; while((len=isr.read(chs)) !=-1){ osw.write(chs,0,len); } // 释放资源 isr.close(); osw.close();}
// 方法3 高效字符流(字符缓冲流)一次读写一个字符
private static void method3(String scrString,String destString) throws IOException {
// 封装数据源
BufferedReader br= new BufferedReader(new FileReader(scrString));
// 封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter(destString));// 复制数据 int ch =0; while((ch=br.read()) !=-1){ bw.write(ch); } // 释放资源 br.close(); bw.close();}
// 方法4 高效字符流(字符缓冲流)一次读写一个字符数组
private static void method4(String scrString,String destString) throws IOException {
// 封装数据源
BufferedReader br= new BufferedReader(new FileReader(scrString));
// 封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter(destString));// 复制数据 int len =0; char [] chs = new char [1024]; while((len=br.read(chs)) !=-1){ bw.write(chs,0,len); } // 释放资源 br.close(); bw.close();}
// 方法5 高效字符流(字符缓冲流)特有方法
private static void method5(String scrString,String destString) throws IOException {
// 封装数据源
BufferedReader br= new BufferedReader(new FileReader(scrString));
// 封装目的地
BufferedWriter bw = new BufferedWriter(new FileWriter(destString));// 复制数据 String line =null; while((line=br.readLine()) !=null){ bw.write(line); bw.newLine(); bw.flush(); } // 释放资源 br.close(); bw.close(); }
}
-----------------------------------知识点14-------------------------------------
package cn.itcast_02;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
-
需求:复制图片
-
分析：
-
复制数据，如果我们知道用笔记本打开能读懂，就用字符流，否则就用字节流 -
从题可知，我们采用字节流 -
含有4中方式，推荐使用第四种方式 -
*/
public class CopyImageDemo {
public static void main(String[] args) throws IOException {
String scrString = “E:\111.jpg”;
String destString =“F:\美女.jpg”;
method4(scrString,destString);
}// 方式1 字节流一次读取一个字节
private static void method1(String scrString,String destString) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream(scrString);
// 封装目的地
FileOutputStream fos = new FileOutputStream(destString);// 复制数据 int ch =0; while((ch=fis.read())!=-1){ fos.write(ch); fos.flush(); } // 释放资源 fis.close(); fos.close();}
// 方式2 字节流一次读取一个字节数组
private static void method2(String scrString,String destString) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream(scrString);
// 封装目的地
FileOutputStream fos = new FileOutputStream(destString);// 复制数据 int len =0; byte [] bys = new byte[1024]; while((len=fis.read(bys)) !=-1){ fos.write(bys,0,len); fos.flush(); } // 释放资源 fis.close(); fos.close(); }// 方式3 高效字节流(缓冲字节流)一次读取一个字节
private static void method3(String scrString,String destString) throws IOException {
// 封装数据源
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(scrString));
// 封装目的地
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destString));// 复制数据 int ch =0; while((ch=bis.read())!=-1){ bos.write(ch); bos.flush(); } // 释放资源 bis.close(); bos.close(); }// 方式4 高效字节流(缓冲字节流)一次读取一个字节数组
private static void method4(String scrString,String destString) throws IOException {
// 封装数据源
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(scrString));
// 封装目的地
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destString));// 复制数据 int len =0; byte [] bys = new byte[1024]; while((len=bis.read(bys)) !=-1){ bos.write(bys,0,len); bos.flush(); } // 释放资源 bis.close(); bos.close(); }
}
-----------------------------------知识点15-------------------------------------
package cn.itcast_03;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
/*
-
需求:把ArrayList集合中的字符串数据存储到文本文件中
-
分析：
-
1.创建集合对象 -
2.遍历集合对象 -
3.将每个元素写入文本文件中 -
数据源： ArrayList array
-
目的地:a.txt–OutputStreamWriter–FileWriter–BufferedWriter
-
*/
public class ArrayToFileDemo {
public static void main(String[] args) throws IOException {
// 创建集合对象
ArrayList array = new ArrayList();// 添加元素 array.add("林青霞"); array.add("周星驰"); array.add("刘德华"); array.add("关羽"); array.add("张飞");
// // 封装目的地
// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(“a.txt”));
//
// // 遍历数组
// for(int x=0;x<array.size();x++){
// osw.write(array.get(x));
// osw.write("\r\n");
// osw.flush();
// }
//
// // 释放资源
// osw.close();
//
// 由于上述方法，不能调用换行方法，故因采用高效字符缓冲流
BufferedWriter bw = new BufferedWriter(new FileWriter(“a.txt”));
// 遍历数组，将数组元素写入文件
for(int x=0;x<array.size();x++){
bw.write(array.get(x));
bw.newLine();
bw.flush();
}
// 释放资源
bw.close();
}
}
-----------------------------------知识点16-------------------------------------
package cn.itcast_03;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
-
需求：复制单级文件夹
-
将e:\demo 复制到e:\test下
-
数据源：e:\demo
-
目的地：e:\test
-
分析：
-
1.封装目录 -
2.获取该目录下所有文本的File数组 -
3.遍历该File数组，得到每一个File对象 -
4.把该File进行复制 -
*/
public class CopyFolderDemo {
public static void main(String[] args) throws IOException {
// 数据源：封装目录
File srcFolder = new File(“e:\demo”);// 目的地 File destFolder = new File("e:\\test"); // 如果文件夹不存在，则创建文件夹 if(!destFolder.exists()){ destFolder.mkdir(); } // 获取该文件夹下所有File对象 File [] array = srcFolder.listFiles(); // 遍历File数组 for(File file:array){ //System.out.println(file.getName()); String name = file.getName(); File newfile = new File(destFolder,name); CopyFile(file,newfile); } }private static void CopyFile(File file,File newFile) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile));// 复制文件 int len =0; byte [] bys = new byte [1024]; while((len=bis.read(bys)) !=-1){ bos.write(bys,0,len); } // 释放资源 bis.close(); bos.close();}
}
-----------------------------------知识点17-------------------------------------
package cn.itcast_03;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
/*
-
需求：从文件中读取数据(每一行为一个字符串数据)到集合，并遍历集合
-
分析：
-
1.创建字符流输入对象，采用高效缓冲字节流 -
2.创建集合 ArrayList<String> -
3.读取文件数据，添加到集合中 -
4.遍历集合 -
*/
public class FileToArrayDemo {
public static void main(String[] args) throws IOException{
// 创建字符流对象
BufferedReader br =new BufferedReader(new FileReader(“b.txt”));// 创建集合对象 ArrayList<String> array = new ArrayList<String>(); // 读取数据 String line = null; while((line=br.readLine()) !=null){ array.add(line); } // 释放资源 br.close(); // 遍历集合 for(int x=0;x<array.size();x++){ System.out.println(array.get(x)); }}
}
package cn.itcast_03;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;
/*
-
需求：有一个文本中存储了几个名称，请随机获取一个人的名字。
-
1.将文本中的名称存储到集合中 -
2.随机产生一个索引 -
3.输出索引对应的元素 -
*/
public class GetName {
public static void main(String[] args) throws IOException{
// 创建字符流对象
FileReader fr = new FileReader(“name.txt”);// 创建字符集合 ArrayList<String> array = new ArrayList<String>(); // 读取文本文件内容 int len =0; char [] chs = new char[1024]; while((len=fr.read(chs)) !=-1){ /* new String(chs,0,len) 是一个字符串，所以集合中只有一个对象 *read（）相当于往后移的指针，从数据开头，一直往后 */ array.add(new String(chs,0,len)); } // 释放资源 fr.close(); // 遍历集合 for(int x=0;x<array.size();x++){ System.out.println(array.get(x)); } System.out.println("------------------"); // 产生一个随机索引 Random rd = new Random(); int index = rd.nextInt(array.size()); System.out.println(array.size()); System.out.println(array.get(index));}
}
-----------------------------------知识点18-------------------------------------
package cn.itcast_03;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;
/*
-
需求：有一个文本中存储了几个名称，请随机获取一个人的名字。
-
1.将文本中的名称存储到集合中 -
2.随机产生一个索引 -
3.输出索引对应的元素 -
*/
public class GetName2 {
public static void main(String[] args) throws IOException {
// 创建字符流对象
BufferedReader br =new BufferedReader(new FileReader(“name.txt”));// 创建字符集合 ArrayList<String> array = new ArrayList<String>(); // 读取文本文件内容 String line = null; while((line=br.readLine())!=null){ array.add(line); } // 释放资源 br.close(); // 遍历集合 for(int x=0;x<array.size();x++){ System.out.println(array.get(x)); } System.out.println("------------------"); // 产生一个随机索引 for(int x=0;x<12;x++){ Random rd = new Random(); int index = rd.nextInt(array.size()); System.out.println(index); System.out.println(array.get(index)); }}
}
-----------------------------------知识点19-------------------------------------
package cn.itcast_04;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
/*
-
需求：复制指定目录下的指定文件，并修改后缀名
-
指定的文件是：.java文件
-
指定的后缀名：.jad
-
指定的目录:jad
-
数据源：e:\demo\java\A.java
-
目的地：e:\jad\A.jad
-
分析：
-
1.封装目录 -
2.获取该目录下所有文本的File数组 -
3.遍历该File数组，得到每一个File对象 -
4.把该File进行复制 -
5.在文件夹下修改文件名 -
*/
public class CopyFolderDemo {
public static void main(String[] args) throws IOException {
// 封装数据源
File scrFolder = new File(“e:\demo\hello.java”);// 封装目的地 File destFolder = new File("e:\\jad"); if(!destFolder.exists()){ destFolder.mkdir(); } // 获取该目录下的java文件的File数组 // File [] arrayFile = scrFolder.listFiles(); File [] fileArray = scrFolder.listFiles(new FilenameFilter() { @Override public boolean accept(File dir, String name) { return new File(dir,name).isFile()&&name.endsWith(".java"); } }); // 遍历File数组 ,复制文件 for(File file:fileArray){ System.out.println(file); File newFile = new File(destFolder,file.getName()); CopyFile(file,newFile); } // 在目的地下修改目录 File [] destFileArray = destFolder.listFiles(); for(File file:destFileArray){ String name = file.getName(); String newName = name.replace(".java", ".jad"); File newFile = new File(destFolder,newName); file.renameTo(newFile); }}
private static void CopyFile(File file,File newFile) throws IOException {
// 封装数据源
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));// 封装目的地 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile)); // 复制操作 int len = 0; byte [] bys = new byte[1024]; while((len=bis.read(bys)) !=-1){ bos.write(bys,0,len); } // 释放资源 bis.close(); bos.close();}
}
-----------------------------------知识点20-------------------------------------
package cn.itcast_05;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
-
需求：复制多级目录
-
数据源:E:\demo\hello.java
-
目的地：E:\
-
分析：
-
1.封装数据源File -
2.封装目的地File -
3.判断该File是文件夹还是文件 -
a.是文件夹 -
就在目的地目录下创建该文件夹 -
获取该File对象下所有的文件或者文件夹File对象 -
遍历得到每个File对象 -
返回3 -
b.是文件 -
就复制(字节流) -
*/
public class CopyFolderDemo {
public static void main(String[] args) throws IOException {
// 封装数据源
File scrFile = new File(“E:\demo\hello.java”);
// 封装目的地
File destFile = new File(“E:\”);CopyFolder(scrFile,destFile);}
private static void CopyFolder(File scrFile, File destFile) throws IOException {
// 判断是文件夹还是文件
if(scrFile.isDirectory()){
// 封装数据源
File newFolder = new File(destFile,scrFile.getName());
newFolder.mkdir();// 遍历文件夹获取文件对象 File [] FileArray =scrFile.listFiles(); for(File file:FileArray){ CopyFolder(file,newFolder); } }else{ File newFile = new File(destFile,scrFile.getName()); CopyFile(scrFile,newFile); }}
private static void CopyFile(File scrFile, File newFile) throws IOException {
// 封装数据源
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(scrFile));// 封装目的地 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile)); // 复制操作 int len = 0; byte [] bys = new byte[1024]; while((len=bis.read(bys)) !=-1){ bos.write(bys,0,len); } // 释放资源 bis.close(); bos.close();}
}
-----------------------------------知识点21-------------------------------------
package cn.itcast_06;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
/*
-
键盘录入5个学生信息(姓名，语文成绩，数学成绩，英语成绩)，按照总分从高到低存入文本文件
-
分析：
-
1.创建学生对象 -
2.创建集合对象 -
TreeSet<Student> -
3.键盘录入学生信息存储到集合 -
4.遍历集合，把数据写到文本文件 -
*/
public class StudentDemo {
public static void main(String[] args) throws IOException {
GetInformation();}
private static void GetInformation() throws IOException {
// 创建集合对象
TreeSet ts = new TreeSet(new Comparator(){
@Override
public int compare(Student s1, Student s2) {
int num1 = s2.getSum()-s1.getSum();
int num2 = (num10?(s2.getChinese()-s1.getChinese()):num1);
int num3 = (num20?(s2.getMath()-s1.getMath()):num2);
int num4 = (num3==0?(s2.getName().compareTo(s1.getName())):num3);
return num4;
}
});// 创建键盘录入对象 for(int x=0;x<5;x++){ Student s = new Student(); Scanner sc = new Scanner(System.in); System.out.println("请输入第"+(x+1)+"个学生的信息"); System.out.println("姓名："); s.setName(sc.nextLine()); System.out.println("语文成绩："); s.setChinese(sc.nextInt()); System.out.println("数学成绩："); s.setMath(sc.nextInt()); System.out.println("英语成绩："); s.setEnglish(sc.nextInt()); // 将对象添加到集合 ts.add(s);
// if(x==4){
// sc.close();
// }
}
System.out.println(“输入信息完毕”);
// 遍历集合，将信息写入文本文件
BufferedWriter bw = new BufferedWriter(new FileWriter("成绩单.txt"));
bw.write(" 学生成绩单 ");
bw.newLine();
bw.write("姓名,语文成绩,数学成绩,英语成绩,总分");
bw.newLine();
bw.flush();
for(Student s:ts){
StringBuilder sb = new StringBuilder();
sb.append(s.getName()).append(",").append(s.getChinese()).append(",")
.append(s.getMath()).append(",").append(s.getEnglish()).append(",").append(s.getSum());
bw.write(sb.toString());
bw.newLine();
bw.flush();
}
// 释放资源
bw.close();
}
}
-----------------------------------知识点22-------------------------------------
package cn.itcast_07;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
/*
-
已知s.txt文件中有这样的一个字符串：“hcexfgijkamdnoqrzstuvwybpl”
-
请编写程序读取数据内容，把数据排序后写入ss.txt中。
-
分析：
-
1.读取数据，将数据转化为字符串 -
2.将字符串转化为字符数组 -
3.将数组排序 -
4.将数组转化字符串 -
5.把字符串写入文件中 -
*/
public class StringDemo {
public static void main(String[] args) throws IOException {
// 读取数据
BufferedReader br = new BufferedReader(new FileReader(“s.txt”));
String line = br.readLine();// 将字符串转化字节数组 char [] arr = line.toCharArray(); // 升序 Arrays.sort(arr); // 把排序后的字符数组转换成字符串 String s = new String(arr); // 把字符串再次写入ss.txt中 BufferedWriter bw = new BufferedWriter(new FileWriter("ss.txt")); bw.write(s); bw.newLine(); bw.flush(); bw.close();}
}
-----------------------------------知识点23-------------------------------------
package cn.itcast_08;
import java.io.IOException;
import java.io.Reader;
/*
-
需求： 用Reader模拟BufferedReader的readLine()功能
-
readLine():一次读取一行，根据换行符判断是否结束，只返回内容，不返回换行符。
-
*/
public class MyBufferedReader {
private Reader r;public MyBufferedReader(Reader r) {
this.r = r;
}/*
-
思考：写一个方法，返回值是一个字符串。
/
public String readLine() throws IOException {
/- 我要返回一个字符串，我该怎么办呢? 我们必须去看看r对象能够读取什么东西呢? 两个读取方法，一次读取一个字符或者一次读取一个字符数组
- 那么，我们要返回一个字符串，用哪个方法比较好呢? 我们很容易想到字符数组比较好，但是问题来了，就是这个数组的长度是多长呢?
- 根本就没有办法定义数组的长度，你定义多长都不合适。 所以，只能选择一次读取一个字符。
- 但是呢，这种方式的时候，我们再读取下一个字符的时候，上一个字符就丢失了 所以，我们又应该定义一个临时存储空间把读取过的字符给存储起来。
- 这个用谁比较和是呢?数组，集合，字符串缓冲区三个可供选择。
- 经过简单的分析，最终选择使用字符串缓冲区对象。并且使用的是StringBuilder
*/
StringBuilder sb = new StringBuilder();
// 做这个读取最麻烦的是判断结束，但是在结束之前应该是一直读取，直到-1
/*
hello
world
java104101108108111
119111114108100
1069711897
*/int ch = 0;
while ((ch = r.read()) != -1) { //104,101,108,108,111
if (ch == ‘\r’) {
continue;
}if (ch == '\n') { return sb.toString(); //hello } else { sb.append((char)ch); //hello }}
// 为了防止数据丢失，判断sb的长度不能大于0
if (sb.length() > 0) {
return sb.toString();
}return null;
}
/*
- 先写一个关闭方法
*/
public void close() throws IOException {
this.r.close();
}
}
-----------------------------------知识点24-------------------------------------
package cn.itcast_08;
-
import java.io.FileReader;
import java.io.IOException;
/*
-
测试MyBufferedReader的时候，你就把它当作BufferedReader一样的使用
*/
public class MyBufferedReaderDemo {
public static void main(String[] args) throws IOException {
MyBufferedReader mbr = new MyBufferedReader(new FileReader(“my.txt”));String line = null; while ((line = mbr.readLine()) != null) { System.out.println(line); } mbr.close(); // System.out.println('\r' + 0); // 13 // System.out.println('\n' + 0);// 10}
}
package cn.itcast_09;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;
/* BufferedReader
-
----LineNumberReaderDemo:跟踪行号的缓冲字符输入流 -
public void setLineNumber(int lineNumber) 设置当前行号。
-
public int getLineNumber() 获得当前行号。
-
*/
public class LineNumberReaderDemo {
public static void main(String[] args) throws IOException {
LineNumberReader lnr = new LineNumberReader(new FileReader(“My.txt”));// 读取数据 String line = null; // 设置行号，从10开始 lnr.setLineNumber(10); while((line=lnr.readLine()) !=null){ System.out.println(lnr.getLineNumber()+":"+line); } // 释放资源 lnr.close();}
}
-----------------------------------知识点25-------------------------------------
package cn.itcast_09;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
/*
-
自定义类模拟LineNumberReader的特有功能
获取每次读取数据的行号 -
*/
public class MyLineNumberReader {
// 成员变量
private Reader r;
private int lineNumber =0;// 构造方法
public MyLineNumberReader(FileReader r){
this.r =r;
}// 成员方法
// setLineNumber(int lineNumber) 设置当前行号
public void setLineNumber(int lineNumber){
this.lineNumber=lineNumber;
}// getLineNumber() 获得当前行号。
public int getLineNumber() throws IOException{
// 遍历输入流对象
// int len =0;
// char [] chs = new char [1024];
// while((len=r.read(chs)) !=-1){
// //System.out.print(new String(chs,0,len));
// String s = new String(chs,0,len);
// if(s.equals(’\r’)){
// continue;
// }
// if(s.equals(’\n’)){
// lineNumber++;
// }
// return lineNumber;
// }
return lineNumber;
}// readLine() 读取文本行。
public String readLine() throws IOException{
lineNumber++;
StringBuilder sb = new StringBuilder();
int ch =0;
while((ch=r.read()) !=-1){
//System.out.print(new String(chs,0,len));
//String s = new String(chs,0,len);
if(ch==’\r’){
continue;
}
if(ch!=’\n’){
sb.append((char)ch);
}else{
return sb.toString();
}
}
if (sb.length() > 0) {
return sb.toString();
}return null;}
// 释放资源
public void close() throws IOException{
r.close();
}
}
package cn.itcast_09;
import java.io.FileReader;
import java.io.IOException;
public class MyLineNumberReaderDemo {
public static void main(String[] args) throws IOException {
MyLineNumberReader mlnr = new MyLineNumberReader(new FileReader(“My.txt”) );
// 读取数据
String line = null;
while((line=mlnr.readLine()) !=null){
System.out.println(mlnr.getLineNumber()+":"+line);
}
// 释放资源
mlnr.close();
}
}
282
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
