Live2D

IO流

IO流概述

IO流简介:

概述:

I(Input,输入)/o(Output,输出)流,是Java中用来传输数据的方式.

划分:

按照流向分:

输入流:读数据.

输出流:写数据.

按照操作分:

字节流:以字节为单位来操作数据.

InputStream :字节输入流的顶层抽象类..

FileInputStream :普通的字节输入流.

BufferedInputStream :高效的字节输入流(也叫:字节缓冲输入流)

 

OutputStream:字节输出流的顶层抽象类.

FileOutputStream :普通的字节输出流.

BufferedOutputStream:高效的字节输出流(也叫:字节缓冲输出流).

 

字符流:以字符为单位来操作数据.

Reader:字符输入流的顶层抽象类.

FileReader :普通的字符输入流.

BufferedReader:高效的字符输入流(也叫:字符缓冲输入流)

 

Writer:字符输出流的顶层抽象类.

FileWriter :普通的字符输出流.

BufferedWriter:高效的字符输出流(也叫:字符缓冲输出流

 

File类

概念 文件,文件夹,一个File对象代表磁盘上的某个文件或文件夹 解释:就是用来操作文件夹路径的

构造方法∶ File(String pathname) File(String parent, String child) File(File parent, String child)

成员方法: 创建功能:如果不存在就创建,返回true,存在就不创建,返回false createNewFile():创建文件 mkdir()和mkdirs()∶创建目录 判断功能: isDirectory():判断File对象是否为目录 isFile():判断File对象是否为文件 exists():判断File对象是否存在

import java.io.File;
import java.io.IOException;

/*       概念
      文件,文件夹,一个File对象代表磁盘上的某个文件或文件夹
      解释:就是用来操作文件夹路径的
      构造方法∶
      File(String pathname)
      File(String parent, String child)
      File(File parent, String child)
      成员方法:
      创建功能:如果不存在就创建,返回true,存在就不创建,返回false
      createNewFile():创建文件
      mkdir()和mkdirs()∶创建目录
      判断功能:
      isDirectory():判断File对象是否为目录
      isFile():判断File对象是否为文件
      exists():判断File对象是否存在
      */
public class Test {
  public static void main(String[] args) throws IOException {
      //需求:将F:\abc\1.txt封装成File对象
      //方式一根据字符串形式的路径获取File对象
      //File file1 = new File("F:\\abc\\1.txt");
      File file1 = new File("F:/abc/1.txt");
      System.out.println("file1:"+file1);
      //方式二根据字符串形式的父目录以及子目录创建File对象
      File file2 = new File("F:/abc/","1.txt");
      System.out.println("file2:"+file2);
      //方式三根据父目录对象,以及字符串形式的子目录来获取File对象
      File file3 = new File("F:/abc/");
      File file4 = new File(file3,"1.txt");
      System.out.println("file4:"+file4);
      System.out.println("----------------------");
      //在f盘下创建2.txt
      File file5 = new File("F:/2.txt");
      boolean flag1 = file5.createNewFile();
      System.out.println("flag:"+flag1);
      //在f盘下创建文件夹a
      File file6 = new File("f:/a");
      boolean m1 = file6.mkdir();//make directory创建单级目录
      System.out.println("m1:"+m1);
      //需求:在f盘下创建f:/a/b/c
      File file7 = new File("f:/a/b/c");
      boolean m2 = file7.mkdirs();//创建多级目录(也可以创建单级目录)
      System.out.println("m2:"+m2);
      System.out.println("-----------------");
      //判断功能
      File file8 = new File("f:/a/b");
      System.out.println("测试file8是否是文件夹:"+file8.isDirectory());
      System.out.println("测试file8是否是文件:"+file8.isFile());
      System.out.println("测试file8是否是存在:"+file8.exists());
  }
}

概念 文件,文件夹,一个File对象代表磁盘上的某个文件或文件夹

◆成员方法:

getAbsolutePath()∶获取绝对路径

绝对路径:以盘符开头的路径.例如:D:/1.txt

getPath()∶获取文件的相对路径

相对路径:一般是相对于当前项目路径来讲的.例如:1.txt

getName():获取文件名

list():获取指定目录下所有文件(夹)名称数组

listFiles()︰获取指定目录下所有文件(夹)File数组

import java.io.File;

/*概念
       文件,文件夹,一个File对象代表磁盘上的某个文件或文件夹
       成员方法:
       getAbsolutePath()∶获取绝对路径
       getPath()∶获取文件的相对路径
       getName():获取文件名
       list():获取指定目录下所有文件(夹)名称数组
       listFiles()︰获取指定目录下所有文件(夹)File数组
       java路径的划分:
       绝对路径:以盘符开头的路径,固定的路径例如:D:/1.txt
       相对路径:相对于某个路径而言,一般是相对于当前项目路径来讲的.例如:1.txt
       */
public class Test1 {
   public static void main(String[] args) {
       File file1 = new File("lib/1.txt");
       //获取绝对路径
       String path1 = file1.getAbsolutePath();
       System.out.println("绝对路径:"+path1);
       //获取相对路径
       String path2 = file1.getPath();
       System.out.println("相对路径:"+path2);
       //获取文件名
       String file1Name = file1.getName();
       System.out.println("文件名:"+file1Name);
       //获得lib文件下的所有文件夹:名称数组String[]
       System.out.println("----------------");
       File file2 = new File("F:/JavaSE/基础语法/lic");
       String[] list1 = file2.list();
       for (String s : list1) {
           System.out.println(s);
      }
           //获得lib文件下的所有文件夹:File对象数组File[]
           System.out.println("--------------");
           File[] list2 = file2.listFiles();
           for (File file : list2) {
               System.out.println(file);

          }
      }


  }

字符流读写文件

  1. 创建字符流读文件对象∶

Reader reader = new FileReader("readme.txt")

调用方法读取数据:

int data = reader. read() ;

读取一个字符,返回该字符代表的整数,若到达流的末尾,返回-1

异常处理;

throws IOException

关闭资源∶

reader.close();

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

/*     字符流读数据
      Reader类中的方法:
      int read() :
      读一个字符,返回该字符对应的ASCII码值,读不到返回-1.
      FileReader类的构造方法:
      public FileReader(String pathname);根据传入的字符串形式的路径,获取字符输入流对象*/
public class Test01 {
  public static void main(String[] args) throws IOException {
      //需求:通过字符流读取文件
      //1.创建字符流输入对象
      Reader reader = new FileReader("F:/JavaSE/基础语法/lib/1.txt");
      //2.读取数据
//       int ch1 = reader.read();
//       System.out.println(ch1);
//       int ch2 = reader.read();
//       System.out.println(ch2);
//       int ch3 = reader.read();
//       System.out.println(ch3);
//       int ch4 = reader.read();
//       System.out.println(ch4);
      //优化上述代码实际开发中,不知道循环次数用while循环
      /*(ch=reader.read())!=-1做了三件事
      1.执行reader.read(),去文件中读取一个字符
      2.执行ch=reader.read(),将读取到的字符赋值给变量ch
      3.(ch=reader.read())!=-1,用读取到的字符和-1作比较

      */
      int ch;//定义变量,用来接受读取到的数据
      while ((ch=reader.read())!=-1){
          //ch=reader.read();
          System.out.println(ch);
      }
      //3.释放资源
      reader.close();
  }
}

2.

字符流读数据-按字符数组读取

创建字符流读文件对象:

Reader reader = new FileReader("readme.txt") ;

调用方法读取数据:

char[] chs = new char[2048];int len = r.read(chs) ;

读取字符到数组中,返回读取的字符数,若到达流的末尾,返回-1

异常处理:

throws IOException

关闭资源∶

reader.close();

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

/*
       字符流读数据
       Reader类中的方法:
       int read(char[] chs) ;一次读一个字符数组,将读取到的内容存入到数组中,并返回读取到的有效字符数,读不到返回-1.
       FileReader类的构造方法:
       public FileReader(String pathname);根据传入的字符串形式的路径,获取字符输入流对象*/
public class Test02 {
   public static void main(String[] args) throws IOException {
       //需求:通过字符流读取数据,一次读取一个字符数组
       //1.创建字符输入流对象
       Reader reader = new FileReader("F:/JavaSE/基础语法/lib/2.txt");
       //2.读取数据
       /*char[] chs = new char[3];
       int len1 = reader.read(chs);
       System.out.println(chs);
       System.out.println(len1);
       int len2 = reader.read(chs);
       System.out.println(chs);
       System.out.println(len2);
       int len3 = reader.read(chs);
       System.out.println(chs);
       System.out.println(len3);*/
      //优化上述代码,用while循环
       //定义字符数组
       char[] chs = new char[3];
       //定义一个变量,记录读取到有效字符
       int len;
       while ((len= reader.read(chs))!=-1){
       //将读取到的数据转换成字符串,然后打印
           /*chs:表示要操作的数组
             0:表示起始索引
             len:表示要操作字符的个数
           */
           String s = new String(chs,0,len);
           System.out.println(s);
      }
       //3.关闭资源
       reader.close();
  }
}
  1. 字符流写数据―按单个字符写入

创建字符流写文件对象∶Writer writer = new FileWriter("dest.txt");

调用方法写入数据∶

int x =’中’;

writer.write(x) ;

写一个字符

异常处理:

throws IOException

关闭资源:

writer.close();

  1. 字符流写数据–按字符数组写入

创建字符流写文件对象∶Writer writer = new FileWriter ("dest.txt);

调用方法写入数据:

char[] chs = {橙’,’心',’橙’,’意’手};

writer.write(chs);

写一个字符数组

异常处理∶

throws IOException

关闭资源︰

writer.close();

  1. 字符流写数据–按字符串写入

创建字符流写文件对象∶Writer writer = new FileWriter ("dest.txt);

调用方法写入数据:

writer.write("小马爱学习");

写一个字符串

异常处理∶

throws IOException

关闭资源︰

writer.close();

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

/*字符流写数据
       Writer类中的方法:
       void write(int ch);                     一次写一个字符
       void write(char[] chs,int index,int len);一次写一个指定的字符数组
       void write(String str);                 一次写一个字符串
       FileWriter类的构造方法:
       public FileWriter(String pathname);     根据传入的字符串形式的路径,获取字符输出流对象
       */
public class Test01 {
   public static void main(String[] args) throws IOException {
       //需求:通过字符流写数据
       //创建字符输入流对象
       Writer writer = new FileWriter("F:/JavaSE/基础语法/lib/1.txt");
       //写数据
       //一次写一个字符
       //writer.write('好');
       //一次写一个指定的字符数组
//       char[] chs = {'你','是','一','个','大','帅','哥'};
//       writer.write(chs,4,3);
       //一次写一个字符串
       writer.write("好好学习,天天向上");
       //释放数据
       writer.close();
  }
}

字符流拷贝文件

  1. 字符流拷贝文件―按单个字符读写

创建字符流读文件对象∶

Reader reader = new FileReader("readme.txt);

创建字符流写文件对象∶

Writer writer = new FileWriter("dest.txt");

调用方法读取数据:

int data = reader.read() ;

调用方法写入数据:

writer.write(data) ;

异常处理:

throws IOException

关闭资源:

reader.close();

writer.close();

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

public class Test01 {
   public static void main(String[] args) throws IOException {
       //需求:通过字符流拷贝文件,一次读写一个字符
       //例如,把1.txt拷贝到2.txt中
       /*
       IO流拷贝文件核心6步:
       1.创建字符输入流对象,关联数据源文件.
       2.创建字狩输出流对象,关联目的地文件.
       3.定义变量,记录读取到的内容.
       4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量.
       5.将读取到的数据写入到目的地文件中.
       6.释放资源.
       */
       //1
       FileReader fr = new FileReader("F:/JavaSE/基础语法/lib/1.txt");
       //2
       FileWriter fw = new FileWriter("F:/JavaSE/基础语法/lib/3.txt");
       //如果目的地文件不存在,程序会自动创建
       //3
       int len;
       //4
       while ((len=fr.read())!=-1){
          //5
           fw.write(len);
      }
       //6
       fr.close();
       fw.close();
  }
}
  1. 字符流拷贝文件―按字符数组读写

创建字符流读文件对象∶

Reader reader = new FileReader("readme.txt");

创建字符流写文件对象∶

Writer writer = new FileWriter("dest.txt");

调用方法读取数据:

char[] chs = new char[2048];int len = reader. read(chs) ;

调用方法写入数据∶

writer. write(chs,o, len);

异常处理:

throws IOException

reader.close();

writer.close();

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

public class Test02 {
   public static void main(String[] args) throws IOException {
       //需求:通过字符流拷贝文件,一次读写一个字符数组
       //例如,把1.txt拷贝到2.txt中
       /*
       IO流拷贝文件核心6步:
       1.创建字符输入流对象,关联数据源文件.
       2.创建字狩输出流对象,关联目的地文件.
       3.定义变量,记录读取到的有效字符数.
       4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量.
       5.将读取到的数据写入到目的地文件中.
       6.释放资源.
       */
       //1
       FileReader fr = new FileReader("F:/JavaSE/基础语法/lib/1.txt");
       //2
       FileWriter fw = new FileWriter("F:/JavaSE/基础语法/lib/3.txt");
       //如果目的地文件不存在,程序会自动创建
       //3
       //定义一个字符数组
       char[] chs = new char[1024];
       int len;
       //4
       while ((len=fr.read(chs))!=-1){
           //5
           fw.write(chs,0,len);
      }

       //6.
       fr.close();
       fw.close();
  }
}

字符缓冲流拷贝文件

字节流的用法
FilefnputStream:普通的字节输入流,用来读取数据的.
构造方法:
public FileInputStream (String pathname) ;成员方法:
public int read();一次读取一个字节,并返回读取到的内容,读不到返回-1.
FileOutputStream:普通的字节输出流,用来写数据的.
构造方法:
public FileOutputStream (String pathname) ;成员方法:
public void write(int len);一次写入一个字节

字符缓冲流拷贝文件的标准代码

创建字符流读文件对象∶

BufferedReader br = new BufferedReader(

new FileReader("readme.txt")) ;

创建字符流写文件对象∶

BufferedWriter bw = new BufferedWriter(

new FileWriter("dest.txt")) ;

异常处理:

throws IOException

使用while循环读写数据∶

int len;

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

bw.write(len) ; }

关闭资源∶

br.close() ;

bw.close) ;

字节流读写文件

字节流的用法

FilefnputStream:普通的字节输入流,用来读取数据的.

构造方法:

public FileInputStream (String pathname) ;成员方法:

public int read();一次读取一个字节,并返回读取到的内容,读不到返回-1.

FileOutputStream:普通的字节输出流,用来写数据的.

构造方法:

public FileOutputStream (String pathname) ;成员方法:

public void write(int len);一次写入一个字节

字节流拷贝文件

  1. 字节流拷贝文件-按单个字节读

创建字节流读文件对象:

InputStream is = new FileInputStream("")

创建字节流写文件对象∶

OutputStream os = new FileOutputStream("");

异常处理:

throws IOException

使用while循环读写数据:

int b;

while((b = is.read()) != -1) {

os.write(b);

}

关闭资源:

is.close() ;

os.close( ;

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

/*
      字节流的用法
       FilefnputStream:普通的字节输入流,用来读取数据的.
       构造方法:
       public FileInputStream (String pathname) ;成员方法:
       public int read();一次读取一个字节,并返回读取到的内容,读不到返回-1.
       FileOutputStream:普通的字节输出流,用来写数据的.
       构造方法:
       public FileOutputStream (String pathname) ;
       成员方法:
       public void write(int len);一次写入一个字节
       */
public class Test {
   public static void main(String[] args) throws IOException {
//       1.创建字节输入流对象,关联数据源文件.
       FileInputStream fii = new FileInputStream("F:/JavaSE/基础语法/lib/1.jpg");
//       2.创建字节输出流对象,关联目的地文件.
       FileOutputStream fio = new FileOutputStream("F:/JavaSE/基础语法/lib/2.jpg");
//       3.定义变量,用来记录读取到的内容.
         int len;
//       4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量.
            while ((len=fii.read())!=-1){
                  fio.write(len);
            }
//       5.将读取到的数据写入到目的地文件中.

//       6.释放资源.
       fii.close();
       fio.close();
  }
}
  1. 字节流拷贝文件-按字节数组读写

创建字节流读文件对象∶

InputStream is = new FileInputStream("");

创建字节流写文件对象∶

OutputStream os = new FileOutputStream("");

异常处理:

throws IOException

定义字节数组,每次读取2048个字节:

byte[] b = new byte[2048];

使用while循环读写数据:

int len;

while((len = is.read(b)) != -1) {

os.write(b,0, len) ;

关闭资源:

is.close() ;

os.close() ;

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

/*
      字节流的用法
      FileInputStream:普通的字节输入流,用来读取数据的.
      成员方法:
       public int read(byte[] bys);一次读取一个字芮数组,将读取到的内容存入到数组中,
      并返回读取到的有效字节数,读不到返回-1.
      FileOutputStream:普通的字节输出流,用来写数据的.
      成员方法:
     public void write(bytel] bys,int index,int len);一次写入一个指定的字节数组
       */
public class Test1 {
   public static void main(String[] args) throws IOException {
//需求:通过普通字节流一次读写一个字节数组的方式,将4.jpg复制5.jpg
       //       1.创建字节输入流对象,关联数据源文件.
       FileInputStream fii = new FileInputStream("F:/JavaSE/基础语法/lib/4.jpg");
//       2.创建字节输出流对象,关联目的地文件.
       FileOutputStream fio = new FileOutputStream("F:/JavaSE/基础语法/lib/5.jpg");
//       3.定义变量,用来记录读取到的内容.
         byte[] b = new byte[2048];
       //用来记录读取到有效字节数
         int len;
//       4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量.
       while ((len=fii.read(b))!=-1){
           //       5.将读取到的数据写入到目的地文件中.
           fio.write(b,0,len);
            }
       
//       6.释放资源.
       fii.close();
       fio.close();
  }
}

字节缓冲流拷贝文件

字节缓冲流拷贝文件的标准代码

创建字节缓冲流读文件对象∶

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a. jpg"));

创建字节缓冲流写文件对象∶

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(

"b. jpg"));

异常处理∶

throws IOException

使用while循环读写数据∶

int len;

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

bos.write(len) ;

}

关闭资源︰

bis.close() ;

bos.close() ;

import java.io.*;

/*     字节缓冲流的用法:
       BufferTdInputStream:字节缓冲输入流(也叫:高效字节输入流),用来读取数据的.
       构造方法:
       public BufferedInputStream InputStream is);
       成员方法:
       public int read() ;一次读取一个字节,并返回读取到的内容,读不到返回-1
       BufferedOutputStream:字节缓冲输出流(也叫:高效字节输出流),用来写数据的.
       构造方法:
       public BufferedOutputStream(OutputStream os) ;
       成员方法:
       public void write(int len);一次写入一个字节.
       特点:
       字节缓冲流有自己的缓冲区,大小为8192个字节,也就是8KB.
       拷贝纯文本用字符流,拷贝其它(图片,音频,视频等)用字节流
       */
public class Test2 {
   public static void main(String[] args) throws IOException {
       //需求:通过字节缓冲流,将4.jpg复制到6.jpg
//       1.创建字节缓冲输入流对象,关联数据源文件.
       BufferedInputStream bi = new BufferedInputStream(new FileInputStream("F:/JavaSE/基础语法/lib/4.jpg"));
//       2.创建字节缓冲输出流对象,关联目的地文件.
       BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream("F:/JavaSE/基础语法/lib/6.jpg"));
//       3.定义变量,记录读取到的内容.
       int len;
//       4.循环读取,只要条件满足就一直读,并将读取到的内容赋值给变量.
       while ((len=bi.read())!=-1){
           //5.将读取到的数据写入到目的地文件中.
               bo.write(len);
      }


//       6.释放资源.
       bi.close();
       bo.close();
  }
}

 

posted @ 2021-02-06 22:31  MWTYING  阅读(52)  评论(0)    收藏  举报