JavaFile、递归、字节流、字符流整理

File

1.1                File类的构造函数

当需要把内存中的数据存储到持久化设备上这个动作称为输出（写）Output操作。

当把持久设备上的数据读取到内存中的这个动作称为输入（读）Input操作。

 

 

package com.oracle.demo01;

import java.io.File;

public class FileDemo01 {

public static void main(String[] args) {

//File ： 文件

//directory ： 目录（文件夹）

//path ：路径

//flie类的构造方法没有检查该路径指定的文件是否存在的功能

File file=new File("E:\\test\\a.txt");

//File类的构造方法没有检测该路径指定的文件是否存在的功能

System.out.println(file.exists());

m1("E:\\test\\", "ee.txt");

m1("E:\\test\\", "ee.txt");

}                       //父路径         //子路径

public static void m1(String parent,String child){

//缺点：没法调用对象.exists方法

File file=new File(parent,child);

System.out.println(file);

}                       //传一个对象

public static void m2(File parent,String child){

//判断路径是否存在

parent.exists();

File file=new File(parent,child);

}

}

运行结果：

1.2                File类的获取

package com.oracle.demo01;

import java.io.File;

import java.io.IOException;

public class FileDemo02 {

public static void main(String[] args) throws IOException {

m1();

m2();

m3();

m4();

m5();

m6();

m7();

}

public static void m1() {

// 相对路径：相对本工程的路径

File file = new File("src");

// 获取绝对路径

System.out.println(file.getAbsolutePath());

// 获取文件（夹）名

System.out.println(file.getName());

// 获取该路径的字符串路径

System.out.println(file.getPath());

// 获取该文件（夹）的长度

System.out.println(file.length());

}

// 创建文件

public static void m2() throws IOException {

// 只能 创建文件 不能创 建文件夹

// 不能创建同名文件

File file = new File("E:\\test\\c.txt");

boolean flag = file.createNewFile();

System.out.println("创建文件" + flag);

}

// 创建文件夹

public static void m3() throws IOException {

// 不区分大小写（包括文件和文件夹）

File file = new File("E:\\test\\c\\a\\a");

boolean flag = file.mkdirs();

System.out.println("创建文件夹" + flag);

}

// 删除创建文件或者文件夹

public static void m4() throws IOException {

// 不区分大小写（包括文件和文件夹）

File file = new File("E:\\test\\a.txt");

// 判断该file指定的文件（夹）是否存在

System.out.println("文件（夹）是否存在" + file.exists());

// 判断该file指定的文件（夹）是否是目录

System.out.println("文件（夹）是否是目录" + file.isDirectory());

// 判断该file指定的文件（夹）是否是文件

System.out.println("文件（夹）是否是文件" + file.isFile());

}

// 删除创建文件或者文件夹

public static void m5() throws IOException {

// 不区分大小写（包括文件和文件夹）

File file = new File("E:\\test\\c\\a\\a");

boolean flag = file.delete();

System.out.println("创建文件或者文件夹" + flag);

}

// 获取的是目录下的当前的文件以及文件夹的名称。

public static void m6() throws IOException {

File file = new File("E:\\test");

String [] files=file.list();

for(String f: files ){

System.out.println("获取所有文件和文件夹"+f);

}

}

// 获取目录下当前文件以及文件对象，只要拿到了文件对象，那么就可以获取其中想要的信息

public static void m7() throws IOException {

File file = new File("E:\\test");

File [] files=file.listFiles();

for(File f: files ){

System.out.println(f);

}

}

}

运行结果

1.3                listFiles()方法介绍

// 获取目录下当前文件以及文件对象，只要拿到了文件对象，那么就可以获取其中想要的信息

public static void m7() throws IOException {

File file = new File("E:\\test");

File [] files=file.listFiles();

for(File f: files ){

System.out.println(f);

}

}

运行结果：

注意：在获取指定目录下的文件或者文件夹时必须满足下面两个条件

1，指定的目录必须是存在的，

2，指定的必须是目录。否则容易引发返回数组为null，出现NullPointerException

1.4                文件过滤器

package com.oracle.demo01;

import java.io.File;

import java.io.FileFilter;

public class MyFileFilter implements FileFilter {

/*      public boolean accept(File pathname){

//               把对象转换称文件名      将文件名转换称小写字母格式      但后在判断是否是.java后缀的文件

return pathname.getName().toLowerCase().endsWith(".java");

}*/

public boolean accept(File pathname){

return pathname.getName().toLowerCase().endsWith(".txt");

}

}

package com.oracle.demo01;

import java.io.File;

public class File03 {

public static void main(String[] args) {

//获取的是目录下的当前的文件以及文件夹的名称。

File file=new File("E:\\test");

File[] files=file.listFiles(new MyFileFilter());

for(File f : files){

System.out.println(f);

}

}

}

运行结果：

递归

递归分为两种，直接递归和间接递归。

直接递归称为方法自身调用自己。间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。

 

 

package com.oracle.demo01;

import java.util.Scanner;

public class File04 {

/*  斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34,

55, 89, 144, 233，377，610，987，1597，

2584，4181，6765，10946，17711，28657，46368。*/

public static void main(String[] args) {

System.out.println(sum(5));

//System.out.println(fib(20));

}

public static long fib(long num){

if(num==0||num==1){

return 1;

}

return fib(num-1)+fib(num-2);

}

public static int sum(int n){

if(n==1){

return 1;

}

return n+sum(n-1);

}

}

运行结果：

字节流

3.1                字节输出流OutputStream

OutputStream此抽象类，是表示输出字节流的所有类的超类。操作的数据都是字节，定义了输出字节流的基本共性功能方法。

输出流中定义都是写write方法

3.1.1            FileOutputStream类

构造方法：

FileOutputStream类写入数据到文件中

package com.oracle.output;

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("E:\\test\\a.txt");

//像文件中写入一个字节

//fos.write(100);

//想文件中写字节数组

byte[] bytes={-97,-98,-99,-100,-101};

//fos.write(bytes);

//指定位置

fos.write(bytes,0,4);

//释放资源

fos.close();

}

}

给文件中续写和换行：

public class FileOutputStreamDemo2 {

public static void main(String[] args) throws Exception {

File file = new File("c:\\file.txt");

FileOutputStream fos = new FileOutputStream(file, true);

String str = "\r\n" +"aaa";

fos.write(str.getBytes());

fos.close();

}

}

IO异常的处理：

package com.oracle.output;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

public class Demo02 {

public static void main(String[] args){

FileOutputStream fos=null;

try{

fos=new FileOutputStream("E:\\test\\a.txt",true);

fos.write("嘤嘤嘤".getBytes());

fos.write("\r\n换行".getBytes());

}catch(IOException ex){

ex.printStackTrace();

throw new RuntimeException("文件写入失败");

}finally{

//文件释放

try {

if(fos!=null)

fos.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

throw new RuntimeException("关闭流错误！");

}

}

}

}

3.2                字节输入流InputStream

通过InputStream可以实现。InputStream此抽象类，是表示字节输入流的所有类的超类。，定义了字节输入流的基本共性功能方法。

l  int read():读取一个字节并返回，没有字节返回-1.

l  int read(byte[]): 读取一定量的字节数，并存储到字节数组中，返回读取到的字节数。

InputStream有很多子类，其中子类FileInputStream可用来读取文件内容。

FileInputStream 从文件系统中的某个文件中获得输入字节。

构造方法：

3.2.1            FileInputStream类读取数据read方法

在读取文件中的数据时，调用read方法，实现从文件中读取数据

package com.oracle.output;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

public class Demo03 {

public static void main(String[] args) throws IOException {

//创建一个字节流对象

FileInputStream fis=new FileInputStream("E:\\test\\a.txt");

//一次读一个字节

int len=0;

while ((len=fis.read())!=-1) {

System.out.print((char)len+" ");

}

//释放资源

fis.close();

}

}

读取数据read(byte[])方法：

在读取文件中的数据时，调用read方法，每次只能读取一个，太麻烦了，于是我们可以定义数组作为临时的存储容器，这时可以调用重载的read方法，一次可以读取多个字符。

package com.oracle.output;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.MissingFormatArgumentException;

public class Demo05 {

public static void main(String[] args) throws IOException {

//明确数据源

FileInputStream fis=new FileInputStream("E:\\test\\a.txt");

//明确目的地

FileOutputStream fos=new FileOutputStream("E:\\test\\e\\eee.txt");

//开始复制

byte[] bytes=new byte[1024]; //长度可以定义成1024的整数倍

int len=0;

while ((len=fis.read(bytes))!=-1) {

fos.write(bytes,0,len);

}

fos.close();

fis.close();

}

}

字符流

4.1                字符输入流Reader

Reader，读取字符流的抽象超类。

l  read():读取单个字符并返回

l  read(char[]):将数据读取到数组中，并返回读取的个数。

4.1.1            FileReader类

FileReader的API介绍。用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的

l  构造方法

FileReader读取包含中文的文件：

public class CharStreamDemo {

public static void main(String[] args) throws IOException {

//给文件中写中文

writeCNText();

//读取文件中的中文

readCNText();

}

//读取中文

public static void readCNText() throws IOException {

FileReader fr = new FileReader("D:\\test\\cn.txt");

int ch = 0;

while((ch = fr.read())!=-1){

//输出的字符对应的编码值

System.out.println(ch);

//输出字符本身

System.out.println((char)ch);

}

}

//写中文

public static void writeCNText() throws IOException {

FileOutputStream fos = new FileOutputStream("D:\\test\\cn.txt");

fos.write("欢迎你".getBytes());

fos.close();

}

}

package com.oracle.reader;

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("E:\\test\\c.txt");

//一个字符一个字符读

int len=0;

/*while ((len=fr.read())!=-1) {

System.out.println((char)len);

}

fr.close();

*/

//一个字符数组一个字符数组的读

char[] ch=new char[1024];

while ((len=fr.read(ch))!=-1) {

System.out.print(new String(ch,0,len));

}

fr.close();

}

}

4.2                字符输出流Writer

package com.oracle.reader;

import java.io.FileWriter;

import java.io.IOException;

public class Demo02 {

public static void main(String[] args) throws IOException {

//明确目的地

FileWriter fw=new FileWriter("E:\\test\\b.txt");

fw.write("好吗");

//fw.close();

fw.flush();

//字符数组

char[] ch={'小','猪','佩','奇'};

fw.write(ch);

fw.flush();

fw.close();

}

}

4.2.1            FileWriter类

4.3                flush()和close()的区别？

flush():将流中的缓冲区缓冲的数据刷新到目的地中，刷新后，流还可以继续使用。

close():关闭资源，但在关闭前会将缓冲区中的数据先刷新到目的地，否则丢失数据，然后在关闭流。流不可以使用。如果写入数据多，一定要一边写一边刷新，最后一次可以不刷新，由close完成刷新并关闭。

4.3.1            FileWriter写入中文到文件中

package com.oracle.reader;

import java.io.FileWriter;

import java.io.IOException;

public class Demo02 {

public static void main(String[] args) throws IOException {

//明确目的地

FileWriter fw=new FileWriter("E:\\test\\b.txt");

fw.write("好吗");

//fw.close();

fw.flush();

//字符数组

char[] ch={'小','猪','佩','奇'};

fw.write(ch);

fw.flush();

fw.close();

}

}

运行结果：

v\:* {behavior:url(#default#VML);}
o\:* {behavior:url(#default#VML);}
w\:* {behavior:url(#default#VML);}
.shape {behavior:url(#default#VML);}

Normal
0
false

7.8 磅
0
2

false
false
false

EN-US
ZH-CN
X-NONE

/* Style Definitions */
table.MsoNormalTable
{mso-style-name:普通表格;
mso-tstyle-rowband-size:0;
mso-tstyle-colband-size:0;
mso-style-noshow:yes;
mso-style-priority:99;
mso-style-parent:"";
mso-padding-alt:0cm 5.4pt 0cm 5.4pt;
mso-para-margin:0cm;
mso-para-margin-bottom:.0001pt;
mso-pagination:widow-orphan;
font-size:10.5pt;
mso-bidi-font-size:11.0pt;
font-family:"Calibri","sans-serif";
mso-ascii-font-family:Calibri;
mso-ascii-theme-font:minor-latin;
mso-hansi-font-family:Calibri;
mso-hansi-theme-font:minor-latin;
mso-bidi-font-family:"Times New Roman";
mso-bidi-theme-font:minor-bidi;
mso-font-kerning:1.0pt;}