2017 - 10 -26 IO流 斐波那契数列 字节流 缓冲字节

1 递归求阶乘
  public static int jieCheng(int n){
       if(n == 1){
             return 1;
      }else{
             return n*jieCheng(n-1);
        }
}
  public static void main(String[] args){
            System.out.println(jieCheng(5));
    }

2 斐波那契数列
有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子倡导第三个月后每个月又生一对兔子，假设兔子都不死，问第二十个月兔子的对数是多少？
1,1,2,3,5,8,13,21...
分析：可以看出从第三项开始，每一项是前两项之和。
   public static int fib(int n){
       if(n == 1 || n ==2){
             return 1;
        }else{
             return fib(n-1)+fib(n-2);
        }
   }

3 递归输出指定目录下文件绝对路径
需求：把E：\JavaEE目录下所有的java结尾的文件的绝对路径给输出在控制台。
   //创建目录
   File srcFolder = new File("E:\\javaEE");
   //递归功能实现
   getAllJavaFilePaths(srcFolder);
   pirvate static void getAllJavaFilePaths(File srcFolder){
     //获取该目录下所有的文件或者文件夹的File数组
     File[] fileArray = srcFolder.listFiles();
     //遍历File数组，得到每一个File对象
     for(File file : fileArray){
         //判断该File对象是否是文件夹
          if(file.isDirectiory()){
           getAllJavaFilePaths(file);
       }else{
           //继续判断是否以.java结尾
            if(file.getName().endsWith(".java")){
              //就输出该文件的绝对路径
              System.out.println(file.getAbsolutePath());
               }
        }
   }
}   

  //跟360扫描一个道理。。。。。。。感觉木马、

4 递归删除带内容的目录

  //封装目录
  File srcFolder = new File("demo");
  //递归实现
  deleteolder(srcFolder);
  private static void deleteFolder(File srcFolder){
     //获取该目录下的所有文件或者文件夹的File数组
     File[] fileArray = srcFolder.listFiles();
     //遍历该File数组，得到每一个File对象
     //删除一级目录下的文件夹
     for(File file : fileArray){
           //判断该File对象是否是文件夹
           if(file.isDirectory()){
                 deleteFolder(file);
           }else{
                 System.out.println(file.getName()+"---"+file.delete());
               }
           }
           //删除一级目录的文件夹
           System.out.println(srcFolder.getName()+"---"+srcFolder.delete());
}
5 IO流
(1)IO流概述
IO流用来处理设备之间的数据传输问题
   上传文件和下载文件
如果操作的数据是文本数据，就用字符流，把要操作的文件用windows自带的记事本打开，如果打开后数据是可以读懂的，就可以使用字符流，如果不能读懂，就用字节流。
如果什么都不知道，就用字节流。
IO流的分类：
      流向：
          输入流 读取数据
          输出流 写出数据
      数据类型：
           字节流
               字节输入流  读取数据 InputStream
               字节输出流  写出数据 OutputStream
           字符流 
               字符输入流  读取数据 Reder
               字符输出流  写入数据 Writer

注意：一般我们在探讨IO流的时候，如果没有明确按照哪种分类来说，默认情况下是按照数据类型来分的。
-------------------------------------------------- 
(2) 写入一句话
需求：往文件中写一句话。
通过分析，我们知道要使用OutputStream
所以，要找一个具体的子类。
文件是File，字节输出流是OutputStream，连起来就是FileOutputStream
注意：每种基类的子类都是以父类名作为后缀名。
      XxxOutputStream
      XxxInputStream
      XxxReader
      XxxWriter
查看FileOutputStream的构造方法：
      FileOutputStream(File file)
      FileOutputStream(String name)

字节输出流操作步骤： 
      A:创建字节输出流对象
      B:写数据 (write()方法)
      C:释放资源
--------------------------------------------------
      //创建字节输出流对象
      //FileOutputStream(File file)
      //File file = new File("fos.txt");
      //FileOutputStream fos = new FileOutputStream(file);
      //FileOutputStream(String name)
        FileOutputStream fos = new FileOutputStream("fos.txt");
      //创建字节输出流对象做了几件事情：
        A:调用系统功能区创建文件
        B:创建fos对象
        C:把fos对象指向这个文件
      
      //写数据
        fos.write("hello,IO".getBytes());  //转换成字节数组。。。
      //释放资源
      //关闭此文件输出流并释放与此流有关的所有系统资源。
        fos.close();
      //为什么一定要close()呢？
         A:让流对象编程垃圾，这样就可以被垃圾回收器回收了。
         B:通知系统去释放跟该文件相关的资源  
----------------------------------------------------
6  字节流 写出数据
(1)字节流中 write()的三个方法
 public void write(int b):写一个字节
 public void write(byte[] b):写一个字节数组
 public void write(byte[] b,int off,int len):写一个字节数组的一部分

  FileOutputStream fos = new FileOutputStream("fos.txt");
  //调用write()方法
   fos.write(97)://97 --底层二进制编码--通过记事本打卡--找到97对应的字符值--a
  //public void write(byte[] b)
  byte[] bys ={97,98,99,100,101};
  fos.write(bys); //abcde
  //public void write(byte[] b,int off,int len)
  fos.write(bys,1,3) // bcd

(2)写出数据 数据换行和追加写入
A:如何实现换行？
写入换行符号即可
fos.write("\n".getBytes);

刚才我们看到了有些文本文件打开是可以的，通过windows自带的那个不行，为什么呢？
因为不同的系统针对不同的换行符号识别是不一样的。
windows：\r\n
linux:\n
Max:\r
而一些常见的高级记事本，是可以识别任意换行符号的。

B:如何实现追加写入？
通过构造方法
FileOutputSream(File file,boolean append)
FileOutputStream fos = new FileOutputStream("fos.txt"，true);

(3)写出数据 字节流加入异常处理
/*
 * 加入异常处理的字节输出流操作
 */
//分开做异常处理
  FileOutputStream fos = null;
   try {
  fos = new FileOutputStream("fos4.txt");
         } catch (FileNotFoundException e) {
     e.printStackTrace();
         }

            try {
fos.write("java".getBytes());
} catch (IOException e) {
e.printStackTrace();
}

   try {
 fos.close();
} catch (IOException e) {
 e.printStackTrace();
       }

一起做异常处理
try {
FileOutputStream fos = new FileOutputStream("fos4.txt");
fos.write("java".getBytes());
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
         }

// 改进版
// 为了在finally里面能够看到该对象就必须定义到外面，为了访问不出问题，还必须给初始化值
FileOutputStream fos = null;
try {
    // fos = new FileOutputStream("z:\\fos4.txt");
fos = new FileOutputStream("fos4.txt");
fos.write("java".getBytes());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 如果fos不是null，才需要close()
if (fos != null) {
// 为了保证close()一定会执行，就放到这里了
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
             }
         }
     }
}

7 字节流 读取数据
(1) 读取数据
字节流输入操作步骤
A:创建字节输入流对象
B:调用read()方法读取数据，并把数据显示在控制台
C:释放数据

读取数据的方式：
A:int read():一次读取一个字节
B:int read(byte[] b):一次读取一个字节数组

如果一次读取一个字节的话，需要用循环改进，通过测试发现，如果读取的数据是-1，则说明已经读完了。
 FileInputStream fis = new FileInputStream("fis.txt");
//用循环改进
int by = fis.read();
while(by != -1){
     System.out.println((char)by);
     by=.fis.read();
}
//最终版代码
int by = 0;
//读取，赋值判断
while((by = fis.read())!=-1){
     System.out.println((char)by);
 }

(2)复制文本文件
数据源：从哪里来
a.txt -- 读取数据 -- FileInputStream
目的地：到哪里去
b.txt -- 写数据 --FileOutputStream

------------------------------------------------------
这一次复制中文没有出现任何问题，为什么呢?
上一次我们出现问题的原因在于我们每次获取到一个字节数据，就把该字节数据转换为了字符数据，然后输出到控制台。
而这一次呢?确实通过IO流读取数据，写到文本文件，你读取一个字节，我就写入一个字节，你没有做任何的转换。
它会自己做转换。

读取必须要有文件，输入可以没有
--------------------------------------------------------
//封装数据源
 FileInputStream fis = new FileInputStream("fis.txt");
//封装目的地
 FileOutputStream fos = new FileOutputStream("fos4.txt");
int by = 0;
while((by=fis.read())!=-1){
     fos.write(by);
}
//释放资源(先关谁都行)
fos.close();
fis.close();

(3)中文存储在计算机中

计算机是如何识别什么时候该把两个字节转换为一个中文呢?
在计算机中中文的存储分两个字节：
        第一个字节肯定是负数。
        第二个字节常见的是负数，可能有正数。但是没影响。
            // String s = "abcde";
            //输出：[97, 98, 99, 100, 101]
               String s = "我爱你中国";
            //输出：[-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]
               byte[] bys = s.getBytes();
               System.out.println(Arrays.toString(bys));

(4) 字节流 复制图片
//封装数据源
FileInputStream fis = new FileInputStream("e:\\林青霞.jpg");
//封装目的地
FileOutputStream fos = new FileOutputStream("mn.jpg");
//复制数据
int by = 0;
while((by=fis.read())!=-1){
     fos.write(by);
}
//释放资源(先关谁都行)
fos.close();
fis.close();

(5) 字节流 复制视频
//封装数据源
FileInputStream fis = new FileInputStream("e:\\视屏.mp4");
//封装目的地
FileOutputStream fos = new FileOutputStream("mn.mp4");
//复制数据
int by = 0;
while((by=fis.read())!=-1){
     fos.write(by);
}
//释放资源(先关谁都行)
fos.close();
fis.close();

//注意：一次一个字节，效率太低了。。。

(6) 字节流一次一个字节数组
   FileInputStream fis = new FileInputStream("fis.txt");
   byte[] bys = new byte[115];
   int len = 0;
   while((len = fis.read(bys))!=-1){
         System.out.println(new String(bys,0,len));
       //System.out.println(new String(bys));//千万要带上len的使用
   }
  
   //最终版代码
   //数组的长度一般是1024或者1024的整数倍
   byte[] bys = new byte[1024];
   int len = 0;
   while((len = fis.read(bys))!=-1){
         System.out.println(new String(bys,0,len));
   }

(7) 两种方式的图解

(8) 复制文本 字节数组
         //封装数据源
           FileInputStream fis = new FileInputStream("c:\\a.txt");
           FileOutputStream fos = new FileOutputStream("d:\\b.txt");
         //复制数据
           byte[] bys = new byte[1024];
           int len = 0;
           while ((len = fis.read(bys)) != -1) {
                 fos.write(bys, 0, len);
            }
         //释放资源
  fos.close();
           fis.close();

(9) 复制视频 字节数组
         //封装数据源
           FileInputStream fis = new FileInputStream("e:\\视屏.mp4");
           FileOutputStream fos = new FileOutputStream("mn.mp4");
         //复制数据
           byte[] bys = new byte[1024];
           int len = 0;
           while ((len = fis.read(bys)) != -1) {
                 fos.write(bys, 0, len);
            }
         //释放资源
  fos.close();
           fis.close();

8 字节缓冲区流
通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。
既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。
这种类被称为：缓冲区类(高效类)
字节缓冲输出流：BufferedOutputStream
字节缓冲输入流：BufferedInputStream

构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream的对象呢？
原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的，但是呢，真正的读写操作还是得靠基本的流兑现实现。
--------------------------------------
//BufferedOutputStream(OutputStream out)
//FileOutputStream fos = new FileOutputStream("bos.txt");
//BufferedOutputStream bos = new BufferedOutputStream(fos);
//简单写法
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
//写数据
bos.write("hello,IO".getBytes()); 
//释放资源
bos.close();
---------------------------------------
       BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bos.txt"));
     //读取数据
     //int by = 0;
     //while ((by = bis.read()) != -1) {
     //   System.out.print((char) by);
 //  }

       byte[] bys = new byte[1024];
       int len = 0;
       while ((len = bis.read(bys)) != -1) {
       System.out.print(new String(bys, 0, len));
   }
       // 释放资源
       bis.close();

注意：虽然有两种方式可以读取，但是，注意，这两种方式针对同一个对象在一个代码中只能使用一个。

9 四种复制方式的比较

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 需求：把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中
 * 
 * 字节流四种方式复制文件：
 * 基本字节流一次读写一个字节： 共耗时：117235毫秒
 * 基本字节流一次读写一个字节数组： 共耗时：156毫秒
 * 高效字节流一次读写一个字节： 共耗时：1141毫秒
 * 高效字节流一次读写一个字节数组： 共耗时：47毫秒
 */
public class CopyMp4Demo {
public static void main(String[] args) throws IOException {
long start = System.currentTimeMillis();
// method1("e:\\哥有老婆.mp4", "copy1.mp4");
// method2("e:\\哥有老婆.mp4", "copy2.mp4");
// method3("e:\\哥有老婆.mp4", "copy3.mp4");
method4("e:\\哥有老婆.mp4", "copy4.mp4");
long end = System.currentTimeMillis();
System.out.println("共耗时：" + (end - start) + "毫秒");
}

// 高效字节流一次读写一个字节数组：
public static void method4(String srcString, String destString)
throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
srcString));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destString));
byte[] bys = new byte[1024];
int len = 0;
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
bos.close();
bis.close();
}

// 高效字节流一次读写一个字节：
public static void method3(String srcString, String destString)
throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
srcString));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destString));
int by = 0;
while ((by = bis.read()) != -1) {
bos.write(by);
}
bos.close();
bis.close();
}

// 基本字节流一次读写一个字节数组
public static void method2(String srcString, String destString)
throws IOException {
FileInputStream fis = new FileInputStream(srcString);
FileOutputStream fos = new FileOutputStream(destString);
byte[] bys = new byte[1024];
int len = 0;
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
fos.close();
fis.close();
}

// 基本字节流一次读写一个字节
public static void method1(String srcString, String destString)
throws IOException {
FileInputStream fis = new FileInputStream(srcString);
FileOutputStream fos = new FileOutputStream(destString);
int by = 0;
while ((by = fis.read()) != -1) {
fos.write(by);
}
fos.close();
fis.close();
}
}