import java.io.File;
import java.io.FileFilter;
import java.io.FileOutputStream;
import java.io.IOException;
/*
- 递归遍历指定路径下指定后缀名的文件，输出文件名 d盘下找txt文件
- 分析：
- 1，封装路径
- 2，获取该路径下所有内容的File数组
- 3，遍历，获取每一个File
- 4，判断File是否是文件夹
- 是：回到2继续
- 不是：判断是否是.txt结尾
- 是：输出
- 不是：不用管
- 因为不知道将来会有多少层文件夹，所以使用递归
- */
public class Main {
public static void main(String[] args) throws IOException {
// 获取指定目录下所有指定格式的文件
test1(new File("D:\新建文件夹"), ".txt");
}
public static void test1(File src, String regex) throws IOException {
File[] files = src.listFiles();
for (File file : files) {
if(file.isDirectory()){
System.out.println(file.getAbsolutePath());
test1(file,regex);
}else{
if(file.getName().endsWith(regex)){
//System.out.println(file.getAbsolutePath());
System.out.println("\t"+file.getName());
/* FileOutputStream fos = new FileOutputStream("log.txt",true);
fos.write(file.getAbsolutePath().getBytes());
fos.write("\r\n".getBytes());
fos.close();*/
}
}
}
}
}
package com.momo.demo;
import java.io.File;
/*
- 递归删除带内容的文件夹
- 分析：
- 1 封装路径
- 2 获取该路径下所哟内容File数组
- 3 遍历数组获取每一个file
- 4 判断是否是文件夹
- 是：继续 回到2
- 不是：删除
- */
public class Demo2 {
public static void main(String[] args) {
File f = new File("D:\新建文件夹");
deleteDir(f);
}
public static void deleteDir(File src){
File[] files = src.listFiles();
if(files!=null){
for (File file : files) {
if(file.isDirectory()){
deleteDir(file);
}else{
System.out.println(file.getName()+"--"+file.delete());
}
}
System.out.println(src.getAbsolutePath()+"---"+src.delete());
}
}
}
package com.momo.demo;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
- 我们通过这个案例，很明显能感觉到一次一个字节数组要快很多，因为加入了字节数组一次可以
- 读写多个，我们用字节数组作为缓冲区一次缓冲多个进行读写
- java本身在设计的时候也考虑到了这样的设计思想(装饰设计模式)
- 所以java还提供了 字节缓冲流(自带缓冲区) 提高效率
- */
public class Demo3 {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("C:\Users\67823540\Desktop\11.mp3");
FileOutputStream fos = new FileOutputStream("111.mp3");
//一次一个字节
/* int i=0;
while ((i=fis.read())!=-1){
fos.write(i);
}*/
//一次一个字节数组 int i=0; byte[] bys = new byte[1024]; while ((i=fis.read(bys))!=-1){ fos.write(bys,0,i); } fos.close(); fis.close();
}
}
一，字节缓冲流
1，概述
-为了提高效率，提供的自带缓冲区的字节流
2，分类
-字节缓冲输入流 BufferedInputStream
-字节缓冲输出流 BufferedOutputStream
3，BufferedOutputStream
-该类实现缓冲输出流。 通过设置这样的输出流，
应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用。
-成员变量
protected byte[] buf
存储数据的内部缓冲区。
protected int count
缓冲区中有效字节的数量。
-构造方法
BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
BufferedOutputStream(OutputStream out, int size)
创建一个新的缓冲输出流，以便以指定的缓冲区大小将数据写入指定的底层输出流。
构造方法之所以传递的是基本字节流，而不是文件路径名，
是因为缓冲流只是提供缓冲效果，读写方法还是在基本的字节流中
所以参数要的是基本字节流
-成员方法
void close()
关闭此输出流并释放与流相关联的任何系统资源。
void flush()
刷新此输出流，并强制将任何缓冲的输出字节写入流。
void write(byte[] b)
将 b.length个字节写入此输出流。
void write(byte[] b, int off, int len)
将 len字节从位于偏移量 off的指定 byte阵列写入此输出流。
void write(int b)
写入指定 byte此输出流。
package com.momo.demo;
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;
/*
- 字节缓冲流写数据
- flush和close的区别？
- flush：刷新缓冲区，把缓冲区中的内容写出入，flush之后对象还可以继续使用，继续写数据
- close：关闭对象，关闭之前会把缓冲区的数据写出入，然后在关闭，close之后就不能写数据了
- 注意： 缓冲流写数据，数据会先存入缓冲区中，最后必须调用flush或者close方法，才能把数据写出去
- /
public class Demo4 {public static void main(String[] args) throws IOException {BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt"));/
//bos.flush();
//bos.close();
bos.write(99);
bos.close();*/
//System.out.println(bos);
// bos.write(100);
// bos.write("hello".getBytes());
bos.write("hello".getBytes(),1,2);
bos.close();
}
}
4，BufferedInputStream
-A BufferedInputStream为另一个输入流添加了功能，
即缓冲输入和支持mark和reset方法的功能。
-构造方法
BufferedInputStream(InputStream in)
创建一个 BufferedInputStream并保存其参数，输入流 in ，供以后使用。
BufferedInputStream(InputStream in, int size)
创建 BufferedInputStream具有指定缓冲区大小，并保存其参数，输入流 in ，供以后使用。
-成员方法
void close()
关闭此输入流并释放与流相关联的任何系统资源。
int read()
从该输入流读取下一个数据字节。
int read(byte[] b)
从该输入流读取最多 byte.length个字节的数据到字节数组。
int read(byte[] b, int off, int len)
从该输入流读取最多 len字节的数据到字节数组。
package com.momo.demo;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
- 字节缓冲流读取数据
- /
public class Demo5 {public static void main(String[] args) throws IOException {BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));/
while ((i=bis.read())!=-1){
System.out.println((char)i);
}*/
int i = 0; byte[] bys = new byte[5]; while ((i=bis.read(bys))!=-1){ System.out.println(new String(bys,0,i)); } bis.close();
}
}
package com.momo.demo;
import java.io.*;
/*
*
- 字节流4种方式复制文件对比
- 基本字节流
- 一次一个字节 27906
- 一次一个字节数组 46
- 字节缓冲流
- 一次一个字节 147
- 一次一个字节数组 16
- */
public class Demo6 {
public static void main(String[] args) throws IOException {
long start = System.currentTimeMillis();
// fun1();
// fun2();
// fun3();
fun4();
long end = System.currentTimeMillis();
System.out.println(end-start);
}
public static void fun4() throws IOException {
BufferedInputStream fis = new BufferedInputStream(new FileInputStream("11.mp3"));
BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("4.mp3"));
int i=0; byte[] bys = new byte[1024]; while ((i=fis.read(bys))!=-1){ fos.write(bys,0,i); } fos.close(); fis.close();
}
public static void fun3() throws IOException {
BufferedInputStream fis = new BufferedInputStream(new FileInputStream("11.mp3"));
BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("3.mp3"));
int i=0; while ((i=fis.read())!=-1){ fos.write(i); } fos.close(); fis.close();
}
public static void fun2() throws IOException {
FileInputStream fis = new FileInputStream("11.mp3");
FileOutputStream fos = new FileOutputStream("2.mp3");
int i=0; byte[] bys = new byte[1024]; while ((i=fis.read(bys))!=-1){ fos.write(bys,0,i); } fos.close(); fis.close();
}
public static void fun1() throws IOException {
FileInputStream fis = new FileInputStream("11.mp3");
FileOutputStream fos = new FileOutputStream("1.mp3");
int i=0; while ((i=fis.read())!=-1){ fos.write(i); } fos.close(); fis.close();
}
}
一，编码表(常见)
1，编码表
-由现实世界的字符和对应的数值组成的一张表
2，常见的编码表
-ascii 表
-iso8859-1 拉丁码表，欧洲码表
-gb2312 中国码表
-gbk 升级版，融合了更多的符号
-utf-8 定义了区间规则
能用一个字节表示就用一个
一个不够用2个
2个不够最多用3个来表示
3，字符串的编码和解码问题
-编码：把我们能看懂的变成计算机能看懂的
byte[] getBytes()
使用平台的默认字符集将此 String编码为字节序列，将结果存储到新的字节数组中。
byte[] getBytes(String charsetName)
使用命名的字符集将此 String编码为字节序列，将结果存储到新的字节数组中。
-解码：把计算机能看懂的变成我们能看懂的
String(byte[] bytes, String charsetName)
构造一个新的String由指定用指定的字节的数组解码charset 。
String(byte[] bytes)
通过使用平台的默认字符集解码指定的字节数组来构造新的 String 。
package com.momo.demo;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
/*
- 字符串
- 编码： String---byte[]
- 解码：byte[]---String
- 注意：编码表要一致
- */
public class Demo8 {
public static void main(String[] args) throws UnsupportedEncodingException {
String s = "今天晚上发起总攻";
//byte[] bytes = s.getBytes();
//[-28, -69, -118, -27, -92, -87, -26, -103, -102, -28, -72, -118, -27, -113, -111, -24, -75, -73, -26, -128, -69, -26, -108, -69]
// byte[] bytes = s.getBytes("utf-8"); //[-28, -69, -118, -27, -92, -87, -26, -103, -102, -28, -72, -118, -27, -113, -111, -24, -75, -73, -26, -128, -69, -26, -108, -69] // byte[] bytes = s.getBytes("gbk"); //[-67, -15, -52, -20, -51, -19, -55, -49, -73, -94, -58, -16, -41, -36, -71, -91] //System.out.println(Arrays.toString(bytes)); byte[] bys = {-67, -15, -52, -20, -51, -19, -55, -49, -73, -94, -58, -16, -41, -36, -71, -91}; // String ss = new String(bys);//?????????????? // String ss = new String(bys,"utf-8");//?????????????? String ss = new String(bys,"gbk");//今天晚上发起总攻 System.out.println(ss);
}
}
二，字符流
-字符流是通过字节流转换而来的，所以我们在这里先给大家讲解一下转换流
-字符流 = 字节流 + 编码表
1，Reader
-InputStreamReader
FileReader
...
2，Writer
-OutputStreamWriter
FileWriter
...
3, 因为字节流操作中文不方便，所以java提供了转换流，转换流也是字符流
-InputStreamReader
-OutputStreamWriter
4，OutputStreamWriter
-把字节流输出流转成了字符输出流
-可以使用默认的编码，或者指定编码来转换
-构造方法
OutputStreamWriter(OutputStream out)
创建一个使用默认字符编码的OutputStreamWriter。
OutputStreamWriter(OutputStream out, Charset cs)
创建一个使用给定字符集的OutputStreamWriter。
OutputStreamWriter(OutputStream out, CharsetEncoder enc)
创建一个使用给定字符集编码器的OutputStreamWriter。
OutputStreamWriter(OutputStream out, String charsetName)
创建一个使用命名字符集的OutputStreamWriter。
-成员方法
void close()
关闭流，先刷新。
void flush()
刷新流。
String getEncoding()
返回此流使用的字符编码的名称。
void write(char[] cbuf)
写入一个字符数组。
void write(char[] cbuf, int off, int len)
写入字符数组的一部分。
void write(int c)
写一个字符
void write(String str)
写一个字符串
void write(String str, int off, int len)
写一个字符串的一部分。
package com.momo.demo;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
/*
- 字符流
- 转换输出流写数据
- */
public class Demo7 {
public static void main(String[] args) throws IOException {
//默认编码表 utf8
// OutputStreamWriter oow = new OutputStreamWriter(new FileOutputStream("c.txt"));
//指定 utf8
// OutputStreamWriter oow = new OutputStreamWriter(new FileOutputStream("c.txt"),"utf-8");
//指定 gbk OutputStreamWriter oow = new OutputStreamWriter(new FileOutputStream("c.txt"),"gbk"); //oow.append("abc"); // oow.write(101); // oow.write('f'); /* char[] chs = {97,98,99,100,101,102}; oow.write(chs); oow.flush(); oow.write(chs,2,2); // oow.flush();*/ oow.write("默默是帅哥"); // oow.write("momoshishuaige",7,7); oow.close(); // oow.write(chs,2,2);IOException: Stream closed
}
}
5，InputStreamReader
-把字节流输入流转成了字符输入流
-可以使用默认的编码，或者指定编码来转换
-构造方法
InputStreamReader(InputStream in)
创建一个使用默认字符集的InputStreamReader。
InputStreamReader(InputStream in, Charset cs)
创建一个使用给定字符集的InputStreamReader。
InputStreamReader(InputStream in, CharsetDecoder dec)
创建一个使用给定字符集解码器的InputStreamReader。
InputStreamReader(InputStream in, String charsetName)
创建一个使用命名字符集的InputStreamReader。
-成员方法
void close()
关闭流并释放与之相关联的任何系统资源。
String getEncoding()
返回此流使用的字符编码的名称。
int read()
读一个字符
int read(char[] cbuf)
将字符读入数组。
int read(char[] cbuf, int off, int len)
将字符读入数组的一部分。
package com.momo.demo;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
/*
- 转换输入流读取数据
- /
public class Demo9 {public static void main(String[] args) throws IOException {//InputStreamReader isr = new InputStreamReader(new FileInputStream("c.txt"));InputStreamReader isr = new InputStreamReader(new FileInputStream("c.txt"),"utf-8");// InputStreamReader isr = new InputStreamReader(new FileInputStream("c.txt"),"gbk");/
while ((i=isr.read())!=-1){
System.out.println((char)i);
}*/
int i=0; char[] chs = new char[1024]; while ((i=isr.read(chs))!=-1){ System.out.println(new String(chs,0,i)); } isr.close();
}
}
package com.momo.demo;
import java.io.*;
/*
- 转换流复制文件
- 注意：转换流已经是字符流了，不能读写(图片，音频，视频等文件了)
- /
public class Demo10 {public static void main(String[] args) throws IOException {//这个是错误演示，不能操作图片，音频，视频等文件了/
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.webp"));
int i = 0; while ((i=isr.read())!=-1){ osw.write(i); osw.flush(); } osw.close(); isr.close();*/ InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt")); OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("c.txt")); /* int i = 0; while ((i=isr.read())!=-1){ osw.write(i); osw.flush(); }*/ int i = 0; char[] chs = new char[1024]; while ((i=isr.read(chs))!=-1){ osw.write(chs,0,i); osw.flush(); } osw.close(); isr.close();
}
}
6，转换流名字太长，还要传递字节流和编码表，麻烦，
而且我们常见的操作都是按照本地默认编码实现的，所以
为了简化使用和书写，转换流提供了对应的子类
-FileReader
-FileWriter
7,FileWriter
-简化字符的写入，有默认字符编码和默认字节缓冲区大小
-构造方法：
FileWriter(File file)
给一个File对象构造一个FileWriter对象。
FileWriter(File file, boolean append)
给一个File对象构造一个FileWriter对象。
FileWriter(String fileName)
构造一个给定文件名的FileWriter对象。
FileWriter(String fileName, boolean append)
构造一个FileWriter对象，给出一个带有布尔值的文件名，表示是否附加写入的数据。
-成员方法：
都是父类中讲过的
package com.momo.demo;
import java.io.FileWriter;
import java.io.IOException;
public class Demo11 {
public static void main(String[] args) throws IOException {
FileWriter fw = new FileWriter("a.txt",true);
fw.write("默默是大帅逼");
fw.write("\r\n");
fw.close();
}
}
8,FileReader
-简化字符的读取，有默认字符编码和默认字节缓冲区大小
-构造方法：
FileReader(File file)
创建一个新的 FileReader ，给出 File读取。
FileReader(String fileName)
创建一个新的 FileReader ，给定要读取的文件的名称。
-成员方法：
都是父类中讲过的
package com.momo.demo;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class Demo12 {
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader("a.txt");
/* int i = 0; while ((i=fr.read())!=-1){ System.out.println((char)i); }*/ int i = 0; char[] chs = new char[1024]; while ((i=fr.read(chs))!=-1){ System.out.println(new String(chs,0,i)); } fr.close(); }
}
package com.momo.demo;
import java.io.*;
public class Demo13 {
public static void main(String[] args) throws IOException {
FileReader isr = new FileReader("a.txt");
FileWriter osw = new FileWriter("c.txt");
/* int i = 0; while ((i=isr.read())!=-1){ osw.write(i); osw.flush(); }*/ int i = 0; char[] chs = new char[1024]; while ((i=isr.read(chs))!=-1){ osw.write(chs,0,i); osw.flush(); } osw.close(); isr.close(); }
}
三 ，字符缓冲流
1, BufferedWriter
-将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入。
-可以指定缓冲区大小，或者可以接受默认大小。 默认值足够大，可用于大多数用途。
-构造方法：
BufferedWriter(Writer out)
创建使用默认大小的输出缓冲区的缓冲字符输出流。
BufferedWriter(Writer out, int sz)
创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。
-成员方法：
写数据的方法都是讲过的
特有：void newLine()
会根据当前系统自动决定换行符
package com.momo.demo;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
/*
- 字符缓冲流写数据
- */
public class Demo14 {
public static void main(String[] args) throws IOException {
BufferedWriter bw =new BufferedWriter(new FileWriter("a.txt"));
for (int i = 0; i < 5; i++) {
bw.write("默默是帅哥");
bw.newLine();
bw.flush();
}
bw.close();
}
}
2，BufferedReader
-从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。
-可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途。
-构造方法：
BufferedReader(Reader in)
创建使用默认大小的输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int sz)
创建使用指定大小的输入缓冲区的缓冲字符输入流。
-成员方法：
特点：String readLine() 读取到文件末尾返回null
读一行文字。
package com.momo.demo;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/*
- 字符缓冲流读取数据
- /
public class Demo15 {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new FileReader("a.txt"));/
System.out.println(s);
s = br.readLine();
System.out.println(s);
s = br.readLine();
System.out.println(s);
s = br.readLine();
System.out.println(s);
s = br.readLine();
System.out.println(s);
s = br.readLine();
System.out.println(s);*/
String s = null; while ((s=br.readLine())!=null){ System.out.println(s); } br.close();
}
}
package com.momo.demo;
import java.io.;/
字符缓冲流复制文件
- */
public class Demo16 {
public static void main(String[] args) throws IOException {
BufferedReader isr = new BufferedReader(new FileReader("a.txt"));
BufferedWriter osw = new BufferedWriter(new FileWriter("c.txt"));
/* int i = 0; while ((i=isr.read())!=-1){ osw.write(i); osw.flush(); }*/ /* int i = 0; char[] chs = new char[1024]; while ((i=isr.read(chs))!=-1){ osw.write(chs,0,i); osw.flush(); }*/ String s; while ((s=isr.readLine())!=null){ osw.write(s); osw.newLine(); osw.flush(); } osw.close(); isr.close();
}
}
3，io流的练习
-复制文本文件
-复制图片
-把ArrayList集合中的字符串存储到文本文件中
-从文本文件中每读取一行数据就存储集合中，遍历集合
-复制单级文件夹
-复制多级文件夹
-键盘输入几个学生信息(按照成绩总分从高到底排序) 存储到文本文件中
-a.txt中有一个字符串dslsdljfldjgsdeewrqwe
要求读取数据排序，然后存入b.txt中
-模拟用户注册登录，实现增删改查(io版)
