Java基础-IO流

IO流本身是用来做文件输入输出的。

一、File类

1.File类简介

File类是java.io包下用来操作文件和目录的类。File类可以新建、删除文件和目录，但是不能访问文件内容本身，如果需要访问文件内容本身，则需要使用IO流。

 

2.File类常用的构造方法

        File没有无参的构造方法。操作每一个文件/文件夹都要对应一个对象。

1)File(String path) //输入路径及文件名。以pathname为路径创建File对象。反斜杠需要转义。

File file = new File(“C:\\worker” + File.separator + “log\\a.jpg”);

用File.separator来代替斜杠，会有更好的跨平台性。

2)File(String path, String name)   //父路径，子文件夹/文件名创建。

3)File(File file, String name)       //父对象，子文件夹/文件名创建。

 

3.File的常用方法

1)访问文件名、文件路径

String getName(); // 返回此File对象所表示的文件名或路径名

String getPath();   //返回此File对象所对应的路径名

Flie getAbsoluteFile();  //返回此对象所对应的绝对路径所对应的File对象

String getParent();  //返回此File对象所对应的目录的父目录名

boolean renameTo(File newName);  //重命名此File对象所对应的文件或目录，如果重命名成功，则返回true，否则返回false

 

2)文件检测

boolean exists();  //判断File对象所对应的文件或目录是否存在

boolean canWrite();  //判断File对象所对应的文件和目录是否可写

boolean canRead();  //判断File对象所对应的文件和目录是否可读

boolean isFile();  //判断File对象所对应的是否是文件，如果是文件则返回true，如果是目录则返回false

boolean isDirectory();  //判断File对象所对应的是否是目录，如果是目录则返回true，如果是文件则返回false

boolean isAbsolute();  //判断File对象所对应的文件或目录是否是绝对路径。

 

3)获取文件信息

long lastModified();  //返回文件的最后修改时间

long length(); 返回文件内容的长度   //即大小，以KB表示

 

4)操作文件

boolean createNewFile(); //创建文件：创造一个大小为0的文件，指定的文件夹路径必须存在。很少用，I/O流会自动创建文件。

boolean delete(); //删除File对象所对应的文件或路径，如果路径下有文件则无法删除

static File createTempFile(String prefix, String suffix);  //在默认的临时文件目录中创建一个临时的空文件，使用给定的前缀。系统生成的随机数和给定的后缀作为文件名。

static File createTempFile(String prefix, String suffix, File directory);  //在directory所指定的目录中创建一个临时的空文件。

void deleteOnExit();  //注册一个删除钩子，当Java虚拟机退出时，删除File对象所对应的文件和目录。(经常和临时文件一起用)

 

5)操作目录的方法

boolean mkdir();  //创建一个File对象所对应的目录，如果成功则返回true。调用该方法时，File对象必须是一个路径。

boolean mkdirs();  //效果等同于mkdir()方法，只是mkdir()只会创建一级路径，mkdirs()会创建多级。

String[] list();  //列出File对象的所有子文件名和路径名，返回String数组

File[] listFiles();  //列出File对象的所有子文件和路径所对应的File对象数组

static File[] listRoots();  //列出系统所有的根路径

 

4. 文件过滤器

File[] files = fileObj.listFiles(new FilenameFilter() {

@Override

public Boolean accept(File dir, String name) {

    return name.startsWith(“C”);

}

});

 

二、IO流

1.流的分类

1)按流向分

输入流：从其他地方到内存。

输出流：从内存到其他地方。

 

2)按传输单位分

字节流：基于8位字节为操作的数据单元。

字符流：基于16位字节为操作的数据单元。

字符流可看成特殊的字节流。

 

3)按功能分

节点流：直接从数据源读/写数据的流。

处理流：对一个已经存在的流进行连接封装，通过封装后的流来实现数据读/写功能。（常用用法：用处理流包装节点流）

 

2.流的父类

1)InputStream

 InputSteam是字节输入流的抽象基类，本身不能创建实例来进行输入。

常用方法：

a.int read();  //从输入流中读取单个字节，返回所读取的字节数据，转化成为int类型。

InputStream in = new FileInputStream(“C:\\demo\\haha\\test.txt”);

int a = in.read();

int b = in.read();

System.out.println(a + “, ” + b);

b.int read(byte[] b);  //从输入流中最多读取字节数组b的长度个字节数据，并且保存在b中，返回值表示本次读取实际读取的字节数。

c.int read(byte[] b, int off, int len); //从输入流中最多读取len个字节的数据，并存储在字节数组b中，并不是从数组的开头放入的，而是从off位置开始，返回实际读取的字节数。

byte[] bs = new byte[10];

int r = in.read(bs, 1, 2);

System.out.println(r);

d.long skip(long n); //跳过和丢弃此输入流中数据的 n 个字节，返回实际跳过的字节数

e.void close(); //关闭此输入流并释放与此流关联的所有系统资源。常用：

if (in != null){in.close}

相应的，输出流也要关闭才能将缓冲的内容写入文件。或者flush()：out.flush();out.close();

public static void main(String[] args) {

InputStream in = new FileInputStream(“C:\\test.txt”);



byte[] buffer = new byte[1024];

// 将数据读入buffer字节数组中

int len;



while ((len = in.read(buffer)) != -1) {

    System.out.println(new String(buffer, 0. len));

}

// 关闭释放资源

in.close();

}

 

2)OutputStream

OutputStram是左右字节输出流的抽象父类。

常用方法：

a. void write(int c); //写一个字节

 

b. void write(byte[] b); // 将字节数组中的数据输出到指定的输出流中

byte[] buffer = string.getBytes(); //字符串转字节数组。

String str = new String(Bytes, 0, len);//将数组中从0到len字节转换

 

若没有指定的路径，不会自动生成。若指定的路径下没有文件，文件可以自动生成。

输出是覆盖输出，每次都会清空原文件里的内容。除了随机访问类是在指定的原文件中相应的位置写，其他类都是直接替换源文件。

 

c. void write(byte[] b, int off, int len);  //将字节数组中的off位置开始，长度为len的字节输出到输出流中

      public static void outputStream() throws IOException {

           // 文件的copy

           InputStream in = new FileInputStream("C:\\source.txt");

           OutputStream out = new FileOutputStream("C:\\target.txt");

          

           byte[] bs = new byte[1024];

           int length = -1;

          

           while ((length = in.read(bs)) != -1) {

                 out.write(bs, 0, length);

           }

          

           in.close();

           out.close();

      }

 

3）Reader与Writer

字符输入/输出流。文本文件才能用字符流。

与InputSteam的差别仅仅是将用byte运输改为用char运输而已。

它们的常用方法和InputStream()、OutputStream()类似，就不多说了。

 

3.常用的流的实现类

1）文件流

FileInputStream、FileOutputStream、FileReader、FileReader。

 

2）内存流

InputStream inputStream = new FileInputStram(fileObj);

OutputStream outputStream = new ByteArrayOutputStream();

InputStream inputStream = new FileInputStram(fileObj);

OutputStream outputStream = new ByteArrayOutputStream();

byte[] spoonIn = new byte[1024]

inputStream.read(spoonIn);

outputStream.write(spoonIn, 0, length);


outputStream.flush();


String txt = outputStream.toString();

 

3)缓冲流/打印流

a.bufferedReader/bufferedWriter/printWriter/printStream

前者是输入流，后三个是输出流。.bufferedReader和printWriter常配合在一起使用。

前三个用于对字符节点流进行处理。所以输入和输出都是用FileReader和FileWriter接收。

对于bufferedWriter，写出的数据会先缓存在内存缓冲区中，关闭此流前要用flush()方法将缓存区的数据立刻写出。

关闭过滤流时，会自动关闭过滤流所包装的所有底层流。即关闭处理流会自动关闭底层的节点流。

 

4)转换流（处理流）

InputStreamReader：将字节输入流转换成字符输入流，本质是Reader，继承于Reader。

OutputStreamWriter：将字符流转换为字节流输出。

 

5)对象流（处理流）

对象流的作用就是序列化

 

序列化：

ObjectOutput out = new ObjectOutputStream(new FileOutputStream(“D:\\xxxxxxx.whatever”))；

out.writeObject(new Object())

out.close();

 

反序列化：

ObjectInput in = new ObjectInputStream(new FileInputStram(“C:\\SSSS.relin”));

Person p = (Person)in.readObject();

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

in.close();