Io流之File概述(递归/字节流/字符流)

File：1.文件 2.目录(文件夹)3.路径名

IO流用来处理设备之间的数据传输

流按操作数据分为两种：字节流与字符流。

package com.oracle.demo01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo01 {
	  public static void main(String[] args) throws IOException {
	       //创建字节输出流对象
		   //当这个构造方法指定地址的时候，如果存在则覆盖，如果不存则自动创建！(必须指定文件，不能是文件夹)
		   FileOutputStream fos=new FileOutputStream("D:\java\d.txt");
		   //向文件中写入一个字节write(int b) ASCII码
		   //0 -48
		   //a -49
		   //A -65
/*		   fos.write(49);
		   fos.write(48);
		   fos.write(48);*/
		   //向文件中写入一个字节数组 write(byte[] b)
		   //BCDE
		   byte[] bytes={-66,-67,-68,-69,-70};
		   /*fos.write(bytes);*/
		   //从哪开始 传几个
		   fos.write(bytes,2,2);
		   //释放资源
		   fos.close();
	}
}

　　

package com.oracle.demo01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo02 {
	   public static void main(String[] args) throws IOException {
		//创建字节输出流(开启续写功能)
		  FileOutputStream  fos=new FileOutputStream("D:\java\d.txt",true);
		//字符串--->字节数组 getBytes();
		  fos.write("abc".getBytes());
		//换行

		  fos.write("
换行了".getBytes());
		//释放资源
		  fos.close();
	}
}

如果不开启续写模式，则不用加任何属性，默认就是false

递归：在当前方法里面调用自身就称为递归

public void method(){
	System.out.println(“递归调用自身”);
	//在当前方法内调用自己
	method();
}

递归也可以分两种形式，一种是直接递归，另一种是间接递归

直接递归就是方法自身调用自身，间接递归是A可以调用B，B在调用C，C在调用A这种形式

字节流：什么文件都可以复制

字节输出流:：OutputStream

以后要是看到Stream结尾就要肯定为是字节流，如果不是Stream结尾则是字符流

close()：释放资源进行关闭之前，自动刷新一下

flush()：写一次刷新一次！

明确数据源：FileOutputStream fis=new FileOutputStream("写入的路径");

package com.oracle.demo01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo04 {
	   public static void main(String[] args) throws IOException {
	   //创建字节输入流(明确从哪个文件中读取数据)
		 FileInputStream fis=new FileInputStream("D:\java\d.txt");
		 //读取一个字节
/*		 int len=fis.read();
		 System.out.println((char)len);
		 len=fis.read();
		 System.out.println((char)len);
		 len=fis.read();
		 System.out.println((char)len);
		 len=fis.read();
		 System.out.println((char)len);
		 len=fis.read();
		 System.out.println((char)len);
		 len=fis.read();
		 System.out.println(len);*/
		 
		 //一个字节一个字节读取文件所有数据
		 int len=0;
		 while((len=fis.read())!=-1){
			 System.out.println((char)len);
		 }
		 //释放资源
		 fis.close();
	   }
}

　字节输入流：InputStream

   FileInputStream 读取文件数据的输入字节流

   1.找到目标文件 2. 建立数据的输入通道 3. 读取文件中的数据 4.关闭资源

package com.oracle.demo01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo05 {
	  public static void main(String[] args) throws IOException {
		  //明确数据源
	    FileInputStream fis=new FileInputStream("D:\java\d.txt");
	      //创建字节数组
	    byte[] bytes=new byte[2];
/*	    //读取一个字节数组
	    int len=fis.read(bytes);
	    //实际读取的有效字节数 
	    System.out.println(len);
	    //字节数组---->字节字符串
	    System.out.println(new String(bytes));*/
	    
	    //读取一个字节数组
	    int len=0;
	    while((len=fis.read(bytes))!=-1){
	    	System.out.println(new String(bytes,0,len));
	    }
	    //释放资源
	    fis.close();
	}
}

　字符流：只可以复制文本文件，什么是文本文件，记事本打开能看的懂的就是文本文件！

    字符输入流基类：Reader

    字节流转字符流：InputStreamReader                //读取字节输入流中的字符

  

package com.oracle.demo02;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Demo01 {
	 public static void main(String[] args) throws IOException {
	 //创建字符输入流
	   FileReader fr=new FileReader("D:\java\d.txt");  
	   int len=0;
	   //一个字符一个字符读
	   while((len=fr.read())!=-1){
		    System.out.println((char)len);
	   }
	  //释放资源
	   fr.close();
	}
}

　　

package com.oracle.demo02;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Demo02 {
    public static void main(String[] args) throws IOException {
		//创建字符输入流
    	FileReader fr=new FileReader("D:\java\d.txt");
    	//创建字符数组
    	char[] ch=new char[1024];
    	//一个字符数组一个字符数组的读
    	int len=0;
    	while((len=fr.read(ch))!=-1){
    		System.out.println(new String(ch,0,len));
    	}
    	//释放资源
    	fr.close();
    }
}

   字符输出流：writer

Writer是所有字符输出流的顶层父类， 并且这个类是一个抽象类。一般使用子类，最常用的子类是FileWriter。

public class Demo01Writer {
    public static void main(String[] args) throws IOException {
        //1创建
        FileWriter fw = new FileWriter("fiel05.txt");
        //2写入
        fw.write("起于凡而非凡");
//         3刷新
        fw.flush();
//         4释放
        fw.close();

    }
}

　　

import java.io.FileWriter;
import java.io.IOException;

public class Demo03 {
	   public static void main(String[] args) throws IOException {
	   //创建字符输出流
		 FileWriter fw=new FileWriter("D:\java\d.txt");
	    //写入一个字符
		fw.write(100);
		fw.flush();
		//写入一个字符
		fw.write("起于凡而非凡");
		//写入字符数组
		char[] ch={'a','1','r'};
		fw.write(ch);
		fw.flush();
		//释放资源
		fw.close();
	}
}