第十天IO流

File类
(1)因为我们硬盘上的数据最常见的方式就是以文件的方式存在。
 为了方便对这些文件进行操作，java就提供了一个类File供我们使用。(了解)
(2)File类的构造方法(理解)
A:File file = new File("d:\\a.txt");
B:File file = new File("d:\\","a.txt");
C:File file = new File("d:\\");
 File file2 = new File(file,"a.txt");
以上三种等价。
(3)File类的功能方法
A:创建方法
创建文件 createNewFile()
创建文件夹:mkdir()/创建多级文件夹:mkdirs()
B:删除方法
删除文件或者文件夹 delete()
C:判断方法
文件对象是否存在  exists()
文件对象是否是文件isFile()
文件对象是否是文件夹 isDrectory()
文件对象是否可读  canRead();
文件对象是否可写   canWrite();
文件对象是否隐藏    isHidden();
D:获取方法(掌握)
获取文件对象的绝对路径  getAbsoluteFilePath()
获取文件对象的相对路径   getPath()
获取文件对象的名称  getName()
获取文件对象的大写   length();
获取文件对象的最后一次修改时间 lastmodified
E:重要获取方法(掌握)
根据目录获取该目录下所有文件或者文件夹的名称数组  list()
根据目录获取该目录下所有文件或者文件夹的对象数组  listFiles()
               加入文件名称过滤器的使用： list(FilenameFilter  filter)
F:重命名方法  
重命名文件   renameTo();
(4)案例：(掌握)
需求：把d盘目录下指定后缀的文件名称输出。
比如：我要获取d盘目录下所有的java文件名称。


方式1：先获取所有的文件对象数组，然后遍历的时候进行判断。

File file = new File("d:\\")


File[] fileArray = file.listFiles();


for(File f : fileArray)
{
if(f.isFile())
{
if(f.getName().endsWith(".java"))
{
System.out.println(f.getName());
}
}
}




方式2：直接获取满足条件的文件名称数组，然后遍历即可
    File file=new File("d:\\");
    String[] fileArray=file.list(new FilenameFilter(){

public boonlean accept(File dir,String name){
   return new File(dir,name).isFile()&&name.endWith(".java");
}
    })


            


2:递归
(1)递归：方法定义内部调用方法本身的现象叫递归。
举例：
老和尚给小和尚讲故事
我们学编程
(2)注意事项：(掌握)
A:明确出口，否则就是死递归。  
B:次数不能过多，过多就会有内存溢出。  
(3)案例：
A:递归求阶乘
规律：n! = n*(n-1)!
出口：1! = 1;


public static int jc(int n)
{
if(n==1)
{
return 1;
}
else
{
return n*jc(n-1);
}
}
B:递归求斐波纳契数列第二十项的值
 规律：从第三项，每一项是前两项之和
                  出口：第一项，第二项的和都为1
  public  static int fun(int n){
   if(n==1|| n==2){
  return 1
}else{
return fun(n-1)+fun(n-2);
}


 }
  ******************************************************************************************************88
IO流:
    
  1：IO流的分类:
A:流向不同
输入流
输出流
B:操作数据不同
字节流
字符流(就是文件数据用记事本打开并能够读懂的数据就用字符流)
  2：IO流的体系结构

      |--字节流
|--输入流(读取数据)
|--InputStream
|--FileInputStream(基本流)
|--BufferedInputStream(高效流) 就是高效的作用，没有特殊方法
|--输出流(写入数据)
|--OutputStream
|--FileOutputStream(基本流)
|--BufferedOutputStream(高效流) 就是高效的作用，没有特殊方法
|--字符流
|--输入流(读取数据)
|--Reader
|--FileReader(基本流)
|--BufferedReader(高效流)
|--输出流(写入数据)
|--Writer
|--FileWriter(基本流)
|--BufferedWriter(高效流)
  3：基本字符流写入数据
FileWriter：
步骤：
创建字符输出流对象
写入数据
write(String str)
write(int ch)
write(char[] chs,int index,int len)
释放资源


代码体现：
FileWriter fw = new FileWriter("fw.txt");


fw.write("hello,io,我来了");
fw.flush();


fw.close();


需注意的问题：
   A：创建字符输出流对象做了几件事情？
                                1.创输出流对象
                       2.调用系统功能，创建一个文件。
                       3.把对象引用指向创建的文件。


   B：为什么需要刷新缓冲区？
                       因为数据的最本单位为字节,而一个字符最小为2个字节，在读取的时候会被存入到缓冲区中
然后通过，刷新缓冲区，将字符刷到目标文件中。 
   C：既然close()和flush()都可以刷新缓冲区，那么，他们的区别是什么？
                       close：将缓冲中的数据刷新到目的地后，直接关闭流资源，流无法继续使用。只能使用一次。
close方法当中其实在关闭流之前都会调用一次flush方法。
                       flush: 仅将缓冲中的数据刷新到目的地，流对象还可以继续使用。可以使用多次。 
   D：如果实现数据的换行？
java中识别\r,\n,\r\n.
windows中,只识别\r\n
mac中，只识别\r.
如何实现数据的追加？
                       使用构造FileWriter(String filename,boolean append)
4:基本字符流读取数据(掌握)
FileReader:
步骤：
创建字符输入流对象
读取数据
int read()
int read(char[] chs)
释放资源


代码体现：
FileReader fr = new FileReader("fw.txt");


//方式1
int ch = 0;
while((ch=fr.read())!=-1)
{
System.out.print((char)ch);
}


//方式2
char[] chs = new char[1024];
int len = 0;
while((len=fr.read(chs))!=-1)
{
System.out.print(String.valueOf(chs,0,len));
}


fr.close();
5.复制文本文件(掌握)
不管是用哪种方式实现，请大家记住分析出数据源和目的地：
数据源：
a.txt -- Reader -- FileReader
目的地：
b.txt -- Writer -- FileWriter


代码体现：
FileReader fr = new FileReader("a.txt");
FileWriter fw = new FileWriter("b.txt");


//方式1
int ch = 0;
//int count = 0;
while((ch=fr.read())!=-1)
{
fw.write(ch);


//if(count++%1024==0)
//{
//fw.flush();
//}

}


//方式2
char[] chs = new char[1024];
int len = 0;
while((len=fr.read(chs))!=-1)
{
fw.write(chs,0,len);
fw.flush();
}


fw.close();
fr.close();
6.高效的流(掌握)
高效流，处理流，高级流：都是建立在基本流基础之上的流。


只起到高效的作用，基本的读写还得依靠基本的流对象。
BufferedReader:
包装了Reader
特殊方法：
String readLine()
BufferedWriter:
包装了Writer
特殊方法：
void newLine()
7.使用高效流复制文本文件
          方式1：一次读取一个字符
public static void main(String[] args){
BufferedReader br=new BufferedReader(new FileReader("TXT.txt"));
BufferedWriter bw=new BufferedWtiter(new FileWriter("TXT1.txt"));
int ch=0;
while((ch=br.read())!=-1){
bw.write(ch);
}

}
bw.close();
br.close();
}
         


 方式2：一次读取一个字符数组
BufferedReader br=new BufferedReader(new FileReader("TXT.txt"));
BufferedWriter bw=new BufferedWtiter(new FileWriter("TXT1.txt"));
char[] chs=char[1024];
int len=0;
while((len=br.read(chs))!=-1){
bw.write(chs);
bw.flush();
}
bw.close();
br.close();


 方式3：一次读取一个字符串
BufferedReader br=new BufferedReader(new FileReader("TXT.txt"));
BufferedWriter bw=new BufferedWtiter(new FileWriter("TXT1.txt"));
String line=null;
while((line=br.readLine())!=null){
bw.writer(line);
bw.newLine();
bw.flush();
}
br.close();
bw.close();
8.IO流的使用规律
(1)数据源和目的地
数据源:
读取数据
InputStream
Reader
目的地:
写入数据
OutputStream
Writer
(2)判断数据源和目的地的数据是否是文本文件：
数据源：
是：Reader
不是：InputStream
目的地：
是：Writer
不是：OutputStream
(3)考虑设备
数据源：
文件(File)
FileReader
键盘录入(System.in)
InputStream -- System.in
目的地：
文件(File)
FileWriter
控制台输出(System.out)
OutputStream -- System.out


可能需要使用转换流。
(4)使用高效：
使用：就用带Buffered的流
不使用：不用带Buffered的流
9.IO规律使用的代码体现
    
    复制数据的规律
A:文本文件--文本文件
数据源：
文本文件 -- Reader -- FileReader -- BufferedReader
目的地：
文本文件 -- Writer -- FileWriter -- BufferedWriter


代码：
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));


String line = null;
while((line=br.readLine())!=null)
{
bw.write(line);
bw.newLine();
bw.flush();
}

bw.close();
br.close();


B:文本文件--控制台输出(System.out)
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
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();
C:键盘录入(System.in)--文本文件
数据源：
键盘录入 -- System.in -- InputStream -- InputStreamReader -- BufferedReader
目的地：
文本文件 -- Writer -- FileWriter -- BufferedWriter


代码：
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));


String line = null;
while((line=br.readLine())!=null)
{
if("over".equals(line))
{
break;
}
bw.write(line);
bw.newLine();
bw.flush();
}


bw.close();
br.close();



D:键盘录入(System.in)--控制台输出(System.out)
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

String line = null;
while((line=br.readLine())!=null)
{
if("over".equals(line))
{
break;
}


bw.write(line);
bw.newLine();
bw.flush();
}


bw.close();
br.close();


****************************************************************************************************************
其它流：


1:转换流(理解)
只有你在使用字节流中需要使用字符流的特殊方法时，才需要使用转换流。
在编码的使用，需要使用转换流。


2.打印流
   A：打印流的种类：
   PrintWriter:字符打印流。
   PrintStream:字节打印流。
      注间事项：
         打印流的特点：打印流只有输出流，没有输入流。
   B：打印流的好处：
a: 可以对任意数据类型的数据进行写入。
b：如果启用了自动刷新，在使用Println，Printf,format等方法的时候会自动刷新。
c: 可以直接操作文件。

3:Properties(理解)
(1)是Map的体系，但是，它可以和IO结合使用。
(2)特殊方法：(理解)
list:把集合中的数据保存到文件中。使用打印流。
load:把文件中的数据加载到集合中，使用任意流。
store:把集合中的数据保存到文件中。使用任意流。
(3)案例：(理解)
查找prop.txt中有没有键为lisi的，如果有，则修改其实为35


4:序列化流(理解)
(1)序列化:把对象按照流的方式操作
  反序列化：把流数据还原成对象。
(2)案例：存储的对象必须实现序列化接口。(理解)
存储一个对象
存储多个对象。
(3)使用(掌握)
A:以后看到对象实现了序列化接口，就要知道，该对象可以按照流一样的方式被操作。
B:看到对象实现了序列化接口，有黄色警告时，知道怎么解决，并知道这是什么意思。


5:字符编码
编码表：字符和数字的对应关系表。
解码：把看的懂变成看不懂的。
解码：把看不懂的变成看的懂的。