java笔记之File、递归、字节流、字符流、特殊操作流

File

File类概述和构造方法：

File是文件和目录路径名的抽象表示

1.文件和目录是可以通过File封装成对象的

2.对于File文件而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的也可以是不存在的。

将来是要通过具体的操作把这个路径的内容转换为具体存在的

方法名	说明
File (String pathname)	通过将给定的路径字符串转换为抽象路径名来创建新的File实例
File(String parent，String child)	从父路径名字符串和子路径名字符串创建新的File实例
File（File parent，String child）	从父抽象路径和子路径名字符串创建新的File实例

File类创建功能

方法名	说明
public boolean createNewFile()	当具有该名称的文件不存在时，创建一个该抽象路径名命名的新空文件
public boolean mkdir()	创建由此抽象路径名命名的目录
public boolean mkdirs()	创建由此抽象路径名命名的目录，包括任何必须但不存在的父目录

 

File类删除功能

方法名	说明
public boolean delete()	删除由此抽象路径名表示的文件或者目录

 

删除目录的注意事项：

如果一个目录中有内容（目录、文件），不能直接删除。应该先删除目录中的内容，最后才能删除目录。

File类判别和获取功能

方法名	说明
public boolean isDirectory()	测试此抽象路径名表示的File是否为目录
public boolean isFile()	测试此抽象路径名表示的File是否为文件
public boolean exists()	测试此抽象路径名表示的File是否存在
public String getAbsolutePath()	返回此抽象路径名的绝对路径名字符串
public String getPath()	将此抽象路径名转化为路径名字符串
public String getName()	返回此抽象路径名表示的文件或者目录名称
public String[] list()	返回此抽象路径名表示的目录中的文件和目录中的名称字符串数组
public File[] listFiles（）	返回此抽象路径名表示的目录中的文件和目录中的File对象数组

递归

递归概述

递归指的是方法定义中调用方法本身的现象

递归解决问题的思路：

把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解

递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算

递归解决问题要找两个内容：

1.递归出口：否则会出现内存溢出。(StackOverflowError：当堆栈溢出发生时抛出，一个应用程序递归太深)

2.递归规则：与原问题相似的规模较小的问题。

字节流

IO流概述和分类

1.IO：输入/输出

2.流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输

3.IO流就是用来处理设备间数据传输问题的

常见的应用：文件复制、文件上传、文件下载

IO流的分类：

1.按照数据的流向：

输入流：读数据

输出流：写数据

2.按照数据类型分：

字节流：字节输入流、字节输出流

字符流：字符输入流、字符输出流

一般来说，我们说IO流的分类是按照数据类型来分的。

如果用Windows自带的记事本打开，能读懂就用字符流，否则字节流。如果不清楚用哪个，就用字节流。

字节流写数据：

字节流抽象基类：

1.InputStream:这个抽象类是表示字节输入流的所有超类

2.OutputStream:这个抽象类是表示字节输出流的所有超类

3.子类名特点：子类名称都是以其父类名作为子类名的后缀

FileoutputStream: 文件输出流用于将数据写入File

FileoutputStream(String name): 创建文件输出流以指定的名称写入文件。

使用字节输出流写数据的步骤：

1.创建字节输出流对象（调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件）

2.调用字节输出流对象的写数据方法

3.释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源）

字节流写数据的三种方式

方法名	说明
void write(int b)	将指定的字节写入此文件输出流，一次写一个字节数据
void write(byte[] b)	将b.length字节从指定的字节数组写入此文件输出流，一次写一个字节数组数据
void write(byte[] b,int off,int len)	将len字节从中指定的字节数组开始，从偏移量off开始写入此文件输出流，一次写一个字节数组的部分数据

备注： byte[] getBytes():返回字符串对应的字节数组

字节流写入数据的两个小问题：

写入换行：

Windows "\r\n"

Linux "\n|

Mac "\r"

如何实现追加写入：第二次参数设置为true,即append值置为true，如FileInputStream fis = new FileInputStream("这里是文件的路径",true);

字节流写数据加异常处理

finally：在异常处理时提供finally块来执行所有清除操作。比如说IO流中的释放资源

特点：被finally控制的语句一定会被执行，除非JVM退出。

try{

    可能出现异常的代码;

}catch{

    异常处理的代码;

}finally{

    执行所有清除操作;

}

字节流读数据（一次读一个字节数组数据）

使用字节输入流读数据的步骤：

1.创建字节输入流对象

2.创建字节输入流对象的读取数据方法

3.释放资源

范例：

FileInputStream fis = new FileInputStream("这里是文件的路径");

//读取的标准代码,这里是一次读取一个字节
int by;
while((by=fis.read())!=-1){
    System.out.print(by);
}

fis.close();//一定要释放资源

复制文本步骤：

1.根据数据源创建字节输入流对象

2.根据数据源创建字节输出流对象

3.读写数据，复制文本文件（假如一次读取一个字节，那么一次读一个字节，一次写一个字节这两步循环完成）

4.释放资源

以复制图片举例巩固上面所学：

//根据数据源创建字节输入流对象
FileInputStream fis = new FileInputStream("E:\\1D\\zayn.jpg");

//根据数据源创建字节输出流对象
FileOutputStream fos = new FileOutputStream("E:\\1Dcopy\\zayn.jpg");


//读写数据，复制文本文件（一次读取一个字节数组，一次写入一个字节数组）
byte[] bys = new byte[1024];
int len;
while((len=fis.read())!=-1_{
    fos.write(bys,0,len);
}

//释放资源
fos.close();
fis.close();

字节缓冲流：

BufferOutputStream：该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用。

BufferInputStream：创建BufferInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节。

构造方法：

字节缓冲输出流：BufferedOutputStream(OutputStream out)

字节缓冲输入流：BufferedInputStream(InputStream in)

字符流

字符串中的编码解码问题

编码：

1.byte[] getBytes()：使用平台默认的字符集将String编码为一系列字节，将结果存储到新的字节数组中

2.byte[] getBytes(String charsetName)：使用指定的字符集将String编码为一系列字节，将结果存储到新的字节数组中

解码：

1.String(byte[] bytes): 通过使用平台默认的字符集解码指定的字节数组来构造新的String

2.String(byte[] bytes, String charsetName): 通过指定的字符集解码指定的字节数组来构造新的String

charsetName有"UTF-8":三个字节表示一个汉字，"GBK"：两个字节表示一个汉字

字符流中的编码解码问题

字符流抽象基类：

1.Reader：字符输入流的抽象类

2.Writer：字符输出流的抽象类

字符流中和编码解码问题相关的两个类

1.InputStreamReader:是从字节流到字符流的桥梁

    读取字节，并使用指定的编码将其解码为字符

    使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

2.OutputStreamWriter：是从字符流到字节流的桥梁

    使用指定的编码将写入的字符编码为字节

    使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

//向1D.txt中写入“中国”
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("1D.txt"));
osw.write("中国");
osw.close();

字符流中写入数据的5种方式：

方法名	说明
void write(int c)	写入一个字符
void write(char[] cbuf)	写入一个字符数组
void write(char[] cbuf,int offf,int len)	写入字符数组的一部分
void write(String str)	写入一个字符串
void write(String str,int off,int len)	写入字符串的一部分

两种刷新

方法名	说明
flush()	刷新流，还可以继续写入数据。
close()	关闭流，释放资源，但是在关闭之前会先刷新流，一旦关闭，就不能再写数据。

字符流读入数据的两种方式：

方法名	说明
int read()	一次读一个字符数据
int read(char[] cbuf)	一次读一个字符组数据

字符缓冲流

字符缓冲流

1.BufferedWriter :将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区的大小，或者可以接受默认的大小。默认足够大，可用于大多数用途。

2.BufferedReader:从字符输出入流读文本，缓冲字符，以提供单个字符，数组和行的高效读取，可以指定缓冲区的大小，或者可以接受默认的大小。默认足够大，可用于大多数用途。

构造方法：

1.BufferedWriter(Writer out)

2.BufferedReader(Reader in)

字符缓冲流的特有功能：

BufferedWriter:

void newLine(): 写一行行分隔符，行分隔符字符串由系统属性定义

BufferedReader:

public String readLine(): 读一行文字。结果包含行的内容字符串，不包括任何 行终止字符，如果流的结尾已经到达，则null。

IO流小结：

案例：使用字符流复制单级文件夹

package com.it;

import java.io.*;

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

        //创建数据源项目File对象，路径是E:\\it
        File srcFolder = new File("E:\\it");

        //获取数据源项目File对象名称
        String srcFolderName = srcFolder.getName();

        //创建目的地目录File对象的名称(1D)
        File destFolder = new File("1D",srcFolderName);

        //判断目的地目录File文件是否存在，如果不存在就创建
        if(!destFolder.exists()){
            destFolder.mkdirs();
        }

        //获取数据源目录下所有文件的File数组
        File[] listFiles = srcFolder.listFiles();

        //遍历File数组，得到每一个File对象，该File对象其实就是数据源文件
        for(File file : listFiles){
            String name = file.getName();
            File destFile = new File(destFolder,name);
            copyFile(file,destFile);
        }
    }

    private static void copyFile (File file, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));

        byte[] bys = new byte[1024];
        int len;
        while((len= bis.read(bys))!=-1){
            bos.write(bys,0,len);
        }

        bos.close();
        bis.close();
    }
}

案例：复制多级文件夹

package com.it;

import java.io.*;


//复制多级文件夹
public class CopyFolderDemo2 {

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

        //创建数据源项目File对象，路径是E:\\it
        File srcFolder = new File("E:\\it");

        //创建目的地目录File对象,路径是F：\\
        File destFolder = new File("F:\\");

        copyFolder(srcFolder,destFolder);
    }

    private static void copyFolder(File srcFolder, File destFolder) throws IOException{
        //判断数据源File是否为目录
        if(srcFolder.isDirectory()){
            //在目的地下创建和数据源File名称一样的目录
            String srcName = srcFolder.getName();
            File newFolder  = new File(destFolder,srcName);
            if(!newFolder.exists()){
                newFolder.mkdir();
            }
            //获取数据源下的所有文件或者目录的File数组
            File[] fileArray = srcFolder.listFiles();
            for(File file : fileArray) {
                copyFolder(file, newFolder);
            }
        }
        else{
            //说明是文件，直接复制，用字节流
            String name  = srcFolder.getName();
            File newFile = new File(destFolder,srcFolder.getName());
            copyFile(srcFolder,newFile);
        }
    }

    private static void copyFile (File file, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));

        byte[] bys = new byte[1024];
        int len;
        while((len= bis.read(bys))!=-1){
            bos.write(bys,0,len);
        }

        bos.close();
        bis.close();
    }
}

复制文件的异常处理：

特殊操作流

标准输入输出流

System类中有两个静态的成员变量：

public static final InputStream in ：标准输入流。通常该流对应键盘输入或由主机环境或由用户指定的另一个输入源

public static final OutputStream out ：标准输出流。通常该流对应显示输出或由主机环境或由用户指定的另一个输出目标

自己实现键盘录入数据：

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

写起来太麻烦，java就提供了一个类似实现键盘录入

Scanner sc = new Scanner(System.in);

输出语句的本质：是一个标准的输出流

1.PrintStream ps = System.out;

2.PrintStream类有的方法，Syetem.out都可以有

打印流

打印流分类：

1.字节打印流：PrintStream

2.字符打印流：PrintWriter

打印流的特点：

1.只负责输出数据，不负责读取数据

2.有自己的特有方法

字节打印流

1.PrintStream（String fileName)：使用指定的文件名创建新的打印流

2.使用继承父类的方法写数据，查看的时候会转码；使用自己的特有方法写数据，查看的数据原样输出。

字符打印流的构造方法

方法名	说明
PrintWriter(String fileName)	使用指定的文件名创建一个新的PrintWriter，而不需要自动执行刷新
PrintWriter(String fileName,boolean autoFlush)	创建一个新的PrintWriter out：字符输出流 autoFlush：一个布尔值，如果为真，则println,printf，或format方法将刷新缓冲区

 

使用字符打印流实现文件的复制：

package com.it;

import java.io.*;

public class CopyFileDemoPw {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("E:\\it\\论文的进度记录.docx"));
        PrintWriter pw  = new PrintWriter(new FileWriter("F:\\a.docx"),true);
        String  line;

        while((line=br.readLine())!=null){
            pw.println(line);
        }

        pw.close();
        br.close();


    }
}

对象序列化流：

对象序列化：就是将对象保存到磁盘上，或者在网络中传输对象

这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型，对象的数据和对象中存储的属性等信息

字节序列写到文件之后，相当于文件中持久保存了一个对象的信息

反之，该字节序列还可以从文件中读取回来，重构对象，对他进行反序列化

 

要实现序列化和反序列化，就要实现对象序列化和对象反序列化流：

对象序列化流：ObjectOutputStream

对象反序列化流：ObjectInputStream

 

对象序列化流：ObjectOutputStream

将Java对象的原始数据类型和图形写入OutputStream。可以使用ObjectInputStream读取（重构）对象。可以通过使用流的文件来实现对象的持久存储。如果流是网络套接字流，则可以在另一个主机上或者另一个进程中重构对象。

构造方法：

ObjectOutputStream（OutputStream out):创建一个写入指定的OutputStream的ObjectOutputStream

序列化对象的方法：

void writeObject(object obj): 将指定的对象写入ObjectOutputStream

注意：

1.一个对象要想被序列化，该对象所属的类就必须实现Serializable接口

2.Serializable是一个标记接口，实现该接口不需要重写任何方法。

package com.it;

import javax.imageio.IIOException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //ObjectOutputStream（OutputStream out):创建一个写入指定的OutputStream的ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("F:\\a.txt"));
        //创建对象
        Student s = new Student("Zayn",20);
        //oid writeObject(object obj): 将指定的对象写入ObjectOutputStream
        oos.writeObject(s);
        //释放资源
        oos.close();
    }
}

对象反序列化流：ObjectInputStream

ObjectInputStream反序列化先使用ObjectOutputStream编写的原始数据和对象

构造方法：

ObjectInputStream(InputStream in):创建从指定的InputStream读取ObjectInputStream

反序列化对象的方法：

Object   readObject()：从ObjectInputStream读取一个对象

package com.it;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectinputStreamDemo1 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //ObjectInputStream(InputStream in):创建从指定的InputStream读取ObjectInputStream
        ObjectInputStream ois  = new ObjectInputStream(new FileInputStream("F:\\a.txt"));
        //Object readObject()：从ObjectInputStream读取一个对象
        Object obj = ois.readObject();
        Student s = (Student)(obj);
        System.out.println(s.getName()+","+s.getAge());
        ois.close();

    }
}

问题及解决方案：

1.用对象序列化流对象序列化了一个对象后，加入我们修改了对象所属的类文件，读数据会不会出错？

会出问题，抛出InvalidClassException

2.如果出了问题，如何解决呢？

给对象所属的类加一个serialVersionUID 

    private static final long serialVersionUID = 42L;

3.如果成员变量中的某个值不想被序列化，那么该怎么实现呢？

给该成员变量加transient关键字修饰，该关键字标记成员变量不参与序列化过程。