2.java基础之io

#1、File类

File类是对文件操作的类，是文件和目录路径名的抽象表示形式，能够创建文件（目录），删除文件（目录），重命名文件（目录）
注意： 
删除目录的时候，如果目录有文件，不能完成删除，必须先把文件删除了，才能删除该目录。
删除是直接删除，不进回收站
特点：
File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身    
只有IO流才能访问文件的内容    
File对象可以作为参数传递给IO流的构造函数
File类的常见构造方法：  
public File(String pathname)
  以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
绝对路径：window下据对路径带盘符，linux下带根目录/
相对路径：相对当前位置的路径          
public File(String parent,String child)
  以parent为父路径，child为子路径创建File对象
文件操作相关
createNewFile() 创建新文件
delete() 删除文件
访问文件名：
getName() //能够得到文件名
getPath() //得到文件的路径+文件名
getAbsoluteFile() //得到绝对路径,返回File对象，可以继续操作文件
getAbsolutePath() //得到绝对路径，返回字符串
getParent() //得到文件的路径
renameTo(File newName) //文件重命名
文件检测
exists() //判断文件是否存在
canWrite() //判断文件是否可写
canRead() //判断文件是否可读
isFile() //判断是否一个文件
isDirectory() //判断是否一个目录
获取常规文件信息
lastModified()  //最后一次修改时间
length() //文件的长度
目录操作相关
mkDir()  //创建目录
mkDirs() //创建多级目录
list() //列出目录下的文件
listFiles() //列出目录下的文件对象

#2、递归

方法递归：
1、方法调用本身
2、递归调用要有出口，否则就是死循环
/**
* 求出10的阶乘
*  10*9*8*7*6*5*4*3*2*1
* 
* 注意递归得有出口：
* 出口条件是：a==1
* 
* @author Administrator
*
*/
public class DiGui02 {
public static void main(String[] args) {
System.out.println(mul(10));
}
public static int mul(int a){

if(a==1){
return 1;
}
else{
return a*mul(a-1);
}
}
}
案例：递归删除某个目录下所有的txt文件，包含子目录
/**
*  需求：
* 删除桌面目录abc下所有目录的txt文件
* 
* 
* @author Administrator
*
*/
public class FileTest02 {


public static void main(String[] args) {

File file=new File("C:\\Users\\Administrator\\Desktop\\abc\\");
FileTest02.delFileTxt(file);
}

public static void delFileTxt(File f){
File[] files=f.listFiles();
for (File file2 : files) {
if(file2.isDirectory()){
delFileTxt(file2);
}else{
if(file2.getPath().endsWith(".txt")){
file2.delete();
}
}
}
}
}

#3、IO

IO:输入输出流
四大基类：Reader，Writer，InputStream，OutputStream
分类：
流向不同：
输入流
InputStream
Reader

输出流
OutputStream
Writer
按类型不同
字节流
InputStream
OutputStream
字符流
Reader
Writer
JAVA中流操作基本上都是派生自以上四个基类，命名规则基本上如下
XXXXReader
XXXXWriter
XXXXInputStream
XXXXOutputStream
备注：
对于文本文件，应使用字符Reader、Writer流
对于二进制文件，应使用字节InputStream、OutputStream流

##3.1 FileInputStream

 字节输入流InputStream常用方法：
int read() //读取一个字节
int read(byte[] b) //一次性读多个字节到缓冲区数组
int read(byte[] b, int off, int len)
 代码示例：
/*
* 读入数据步骤：
* 1、使用文件输入流打开指定文件
* 对于文本文件，应使用字符输入流FileReader流
* 对于二进制文件，应使用字节输入流FileInputStream流
* 2、读取文件数据
* 3、关闭输入流
* 
*/
InputStream inputStream = new FileInputStream("C:\\Users\\Administrator\\Desktop\\abc.txt");
//一次读一个字节
int read=0;
while((read = inputStream.read()) !=-1){
System.out.print((char)(read));
}
inputStream.close();
System.out.println();
inputStream = new FileInputStream("C:\\Users\\Administrator\\Desktop\\abc.txt");
//解决一次读一个字节中文乱码的方法
byte[] byte1 = new byte[inputStream.available()];
for (int i = 0; (read = inputStream.read()) !=-1;i++ ) {
byte1[i]=(byte)read;
}
System.out.println(new String(byte1));
System.out.println();
inputStream = new FileInputStream("C:\\Users\\Administrator\\Desktop\\abc.txt");
//一次读一个缓冲区
byte[] b=new byte[4096];
while((read=inputStream.read(b)) != -1){
System.out.println(new String(b, 0, read));
}

##3.2 FileOutputStream

 字节输出流OutputStream常用方法：
void write(int b);// 向流中写一个字节
void write(byte[] b);//向流中写一个数组
void write(byte[] b, int offset, int length);
void flush(); //把数据从OS缓冲区刷入硬盘
void close(); 需要先刷新，再关闭此流
 常用实现类：FileOutputStream
换行
windown \r\n
linux \n
通常情况下只需要\n即可换行
 
内容追加
new FileOutputStream(String path, boolean append)
append true表示向文件追加内容
不写或者false,覆盖源文件的内容
 代码实例：
OutputStream out = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\abc.txt");
//一次写一个字节
out.write(97);
out.write(98);
out.write(99);
out.write(100);
out.close();
out = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\abc.txt");
//按缓冲区来写
//换行
// windown \r\n
//  linux \n
//  通常情况下只需要\n即可换行
out.write("中国足球队真没就了\r\n".getBytes());
out.write("就是穆里尼奥来了都不行\r\n".getBytes());
out.close();

##3.3 FileReader

 字符输入流：Reader
int read() // 读取一个字符
int read(char [] c) //一次性读多个字符到缓冲区数组
int read(char [] c, int off, int len)
 常用实现类：FileReader
 代码示例：
Reader reader = new FileReader("C:\\Users\\Administrator\\Desktop\\abc.txt");
//一次对一个字符
int r=0;
while((r=reader.read()) != -1){
System.out.print((char)r);
}
System.out.println();
reader = new FileReader("C:\\Users\\Administrator\\Desktop\\abc.txt");
//按缓冲区来读
char[] c=new char[4096];
while((r=reader.read(c)) != -1){
System.out.print(new String(c,0,r));
}

##3.4 FileWriter

 字符输出流：Writer
void write(int c);// 向流中写一个字节/字符
void write(char[] cbuf);//向流中写一个数组
void write(char[] buff, int offset, int length);
void flush(); //把数据从OS缓冲区刷入硬盘
void close(); 需要先刷新，再关闭此流
 常用实现类：FileWriter
因为字符流直接以字符作为操作单位，所以 Writer 可以用字符串来替换字符数组，即以 String 对象作为参数
void write(String str);
void write(String str, int off, int len);
 换行
  windown \r\n
  linux \n
  通常情况下只需要\n即可换行
 内容追加
  new FileWriter(String path, boolean append)
  append true表示向文件追加内容
  不写或者false,覆盖源文件的内容 
 代码示例：
  FileWriter writer = new FileWriter("C:\\Users\\Administrator\\Desktop\\abc.txt");
//一次写一个字符
writer.write(97);
writer.write(98);
writer.write(99);
writer.write(100);
writer.flush();
writer.close();
//一次写一个缓冲区
writer = new FileWriter("C:\\Users\\Administrator\\Desktop\\abc.txt",true);
char[] c= {'我','爱','你','中','国'};
writer.write(c);
writer.flush();
writer.close();
//一次写一个字符串
writer = new FileWriter("C:\\Users\\Administrator\\Desktop\\abc.txt",true);
writer.write("我们都是中国人....\r\n");
writer.write("我们都是中国人....\r\n");
writer.write("我们都是中国人....\r\n");
writer.flush();

writer.close();

#4、缓冲流

 缓冲流：就是套在文件流之上的缓冲流  
 特点：能够提高程序读写的效率
 字节缓冲流：BufferedInputStream,BufferedOutputStream  
 字符缓冲流：BufferedReader,BufferedWriter
 注意：输出的时候，需要调用flush()方法，将缓冲区的数据刷新到磁盘

##4.1. 字节缓冲流

1、字节缓冲流：输入流BufferedInputStream
BufferedInputStream(InputStream in) 
         创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。 
BufferedInputStream(InputStream in, int size) 
          创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。 
案例：

BufferedInputStream in = new BufferedInputStream(new FileInputStream

("C:\\Users\\Administrator\\Desktop\\IO05.java"));

int r =0;
byte[] b = new byte[4096];
while((r=in.read(b)) != -1){
System.out.println(new String(b,0,r));
}
2.字节缓冲流：输出流BufferedOutputStream
BufferedOutputStream(OutputStream out) 
         创建一个新的缓冲输出流，以将数据写入指定的底层输出流。 
BufferedOutputStream(OutputStream out, int size) 
         创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。 
案例：

BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream

("C:\\Users\\Administrator\\Desktop\\新建文本文档.txt"));

out.write("战狼2最近很火，但是我没有时间看！".getBytes());
//注意flush操作，才能把数据写到磁盘
out.flush();
out.close();

##2.1. 字符缓冲流

1.字符缓冲输入流：BufferedReader
BufferedReader(Reader in) 
   创建一个使用默认大小输入缓冲区的缓冲字符输入流。 
BufferedReader(Reader in, int sz) 
  创建一个使用指定大小输入缓冲区的缓冲字符输入流。 
  这是字符缓冲流特有的方法
  String readLine() 
   读取一个文本行。
  案例：
BufferedReader br = new BufferedReader(new FileReader("C:\\Users\\Administrator\\Desktop\\IO05.java"));
//按一个字符读
int len=0;
while((len=br.read()) != -1){
System.out.print((char)len);
}

br = new BufferedReader(new FileReader("C:\\Users\\Administrator\\Desktop\\IO05.java"));
System.out.println("=================================");
//按缓冲区读
len=0;
char[] c = new char[1024];
while((len=br.read(c)) != -1){
System.out.print(new String(c,0,len));
}

//按行读
br = new BufferedReader(new FileReader("C:\\Users\\Administrator\\Desktop\\IO05.java"));
System.out.println("=================================");
//按缓冲区读
String line=null;
while((line=br.readLine()) != null){
System.out.println(line);
}
2.字符缓冲输出流：BufferedWriter
BufferedWriter(Writer out) 
         创建一个使用默认大小输出缓冲区的缓冲字符输出流。 
BufferedWriter(Writer out, int sz) 
         创建一个使用给定大小输出缓冲区的新缓冲字符输出流。 
BufferedWriter特有的方法，不过可以使用\r\n替换
newLine() 
         写入一个行分隔符。
案例：
BufferedWriter bw = new BufferedWriter(new FileWriter("C:\\Users\\Administrator\\Desktop\\新建文本文档.txt"));
bw.write("创建一个使用默认大小输出缓冲区的缓冲字符输出流。  ");
bw.newLine();
bw.write("创建一个使用给定大小输出缓冲区的新缓冲字符输出流。 ");
bw.flush();
bw.close();

#5、转换流

 转换流：就是把字节流转化成字符流
 java提供两个转换流：
  字节流转字符流（输入） InputStreamReader
  字节流转字符流（输出） OutputStreamWriter
 为什么提供这样的转换流：  
  字节流中的数据都是字符时，转成字符流操作更高效。
1.转换输入流：InputStreamReader
InputStreamReader(InputStream in) 
          创建一个使用默认字符集的 InputStreamReader。       
InputStreamReader(InputStream in, String charsetName) 
          创建使用指定字符集的 InputStreamReader。        
案例：

InputStreamReader isr = new InputStreamReader(new FileInputStream

("C:\\Users\\Administrator\\Desktop\\IO05.java"));

int len=0;
char[] c = new char[1024];
while((len=isr.read(c)) != -1){
System.out.println(new String(c,0,len));
}
System.out.println("=============");
//指定字符集
isr = new InputStreamReader(new FileInputStream("C:\\Users\\Administrator\\Desktop\\IO05.java"),"GBK");
len = 0;
while ((len = isr.read(c)) != -1) {
System.out.println(new String(c, 0, len));
}
2.转换输出流：OutputStreamWriter
OutputStreamWriter(OutputStream out) 
          创建使用默认字符编码的 OutputStreamWriter。
       
OutputStreamWriter(OutputStream out, String charsetName) 
          创建使用指定字符集的 OutputStreamWriter。    
案例：

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream

("C:\\Users\\Administrator\\Desktop\\新建文本文档.txt"));

osw.write("hello io...hello OutputStreamWriter...");
osw.flush();
3.可以使用缓冲流在包装转换流

BufferedReader rs = new BufferedReader(new InputStreamReader(new FileInputStream

("C:\\Users\\Administrator\\Desktop\\IO05.java")));

//缓冲流有个特殊的方法readLine,能够按行读取
String line = null;
//不等于null就表示没有到结尾
while ((line = rs.readLine()) != null) {
System.out.println(line);
}
rs.close;//可以把包装的流也关闭

#6、标准输入输出流

System.in和System.out分别代表了系统标准的输入和输出

#7、打印流

打印流（了解）：
字节打印 PrintStream
字符打印 PrintWriter
特点：
PrintStream和PrintWriter的输出不会抛出异常
PrintStream和PrintWriter有自动flush功能
System.out返回的是PrintStream的实例

#8、数据流

主要是操作Java语言的基本数据类型的数据

#9、对象流

对象流：
主要用于：对象的序列化和反序列化（通俗的说就是用户对象写入IO流或从IO流读取对象）  
ObjectInputStream  
ObjectOutputStream 
注意：要序列化到磁盘上的对象，必须实现Serializable

#10、随机访问流（了解）

随机访问流：RandomAccessFile
构造器
public RandomAccessFile(File file, String mode) 
public RandomAccessFile(String name, String mode)
mode：
r: 以只读方式打开
rw：打开以便读取和写入
rwd:打开以便读取和写入；同步文件内容的更新
rws:打开以便读取和写入；同步文件内容和元数据的更新
案例：
RandomAccessFile rf = new  RandomAccessFile("C:\\Users\\Administrator\\Desktop\\IO05.java", "r");
rf.seek(100);
byte [] b = new byte[1024];
int off = 0;
int len = 100;
rf.read(b, off, len);
String str = new String(b, 0, len);
System.out.println(str);