第39节：Java当中的IO

Posted 2021-01-04 程序员哆啦A梦

Java当中的IO

IO的分类

第一种分：输入流和输出流
第二种分：字节流和字符流
第三种分：节点流和处理流

节点流处理数据，处理流是节点流基础上加工的。

IO中的重点：

InputStream
OutputStream
FileInputStream
FileOutputStream

InputStream

int read(byte[] b,int off,int len)

OutputStream

void write(byte[] b,int off,int len)

// 第一步，导入类
import java.io.*;
class Demo {
 public static void main(String[] args){
  // 声明输入流的引用
  FileInputStream fis = null;
 // 声明输出流的引用
 FileOutputStream fos = null;
  try{
   // 生成输入流的对象
   fis = new FileInputStream("e:/from.txt");
  // 生成代表输出流的对象
  fos = new FileOutputSteam("e:/to.txt");
  // 生成一个字节数组
   byte[] buffer = new byte[100];
 // 调用输入流对象的read方法
  int temp = fis.read(buffer,0,buffer.length);

  fos.write(buffer,0,temp);
   for(int i=0; i<buffer.length; i++){
    System.out.println(buffer[i]);
   }
  }catch(Exception e){
   System.out.println(e);
  }
 }
}

IO是为了对数据进行读写操作，数据的流向是以Java程序为参照物的，注意read方法和write方法。

流：在Java中输入和输出是通过流的类来实现的，Java提供了一套丰富的流类，可导入java.io，这样就可以完成输入和输出了，也同样可以实现网络操作等。

听到流，是不是很形象了呢？流好比一个走向，当程序中需要读取数据时，就会开启一个通向数据源的流，这个数据源可以是文件，内存，网络连接等，需要写入数据时，也会开启一个通向目的地的流。流好比连接起点到终点的路。

输入流：源到程序，即读，从数据源的地方输入到程序中，读即 一个文件里的内容读到程序中。

输出流：程序中输出到目的地，输出流，即写，一个文件写到另一个文件，从这边输出到另一边。

在Java中流：字节流，字符流都要掌握

InputStream
OutputStream
Reader
Writer

重点早期的Java内容：InputStream和OutputStream，这两个都是基于字节流。

字符流：Reader和Writer

Java语言中的流分：文本流（字符序列）和二进制流

输入流和输出流

InputStream类为基本的输入流类，是抽象的类，在InputStream类中定义了read方法，用于读取数据的，读的。

OutputStream类为基本的输出类，是抽象的类，在OutputStream类中定义了write方法，用于输出数据，写的。

OutputStream类
清除缓冲区：public void flush()
关闭输出流：public void close()

其他重点：

在Java中提供了DataInputStream类与DataOutputStream类，数据输入流和数据输出流。在JDK1.1版本提供了InputStreamReader类与OutputStreamWriter类，它们是Reader、Writer类的子类，提供了字节流到字符流的转换。

字符流

BufferedReader类与BufferedWriter类分别是Reader类和Writer类的子类，输入和输出的缓冲区得以提供。

文件类

FileInputStream类为输入操作，是文件输入流类

import java.io.*;
public class Demo{
 public static void main(String[] args){
  byte buffer[] = new byte[1024];
  try{
  // 创建FileInputStream类对象
   FileInputStream fis = new FileInputStream("from.txt");
 int temp = fis.read(buffer,0,buffer.length);
 String str=new String(buffer,0,temp);
 // 输出字符串内容
 System.out.println(str);
  }catch(Exception e){
   System.out.println(e);
  }
 }
}

FileOutputStream类为输出类，与FileInputStream同理即可。

FileInputStream类，FileOutputStream类
DataInputStream类，DataOutputStream类
InputStream类，OutputStream类
BufferedReader类，BufferedWriter类

说说IO

//第一种：输入流输出流
//第二种：字节流字符流
//第三种：节点流处理流
//FileInputStream
class Test{
 public static void main(String args[]){
  FileInputStream fis = null;
  try{
  fis = new FileInputStream("e:/read.txt");
  byte[] buffer = new byte[100];
  fis.read(buffer,0,buffer.length);
  for(int i = 0;i<buffer.length;i++){
   System.out.println(buffer[i]);
  }
}
 catch(Exception e){
 System.out.println(e);
  }
 }
}

class Test{
 public static void main(String args[]){
  FileInputStream fis = null;
  FileOutputStream fos = null;
 try{
  fis = new FileInputStream("e:/read.txt");
  fos = new FileOutputStream("e:/write.txt");
  byte[] buffer = new byte[100];
  int temp = fis.read(buffer,0,buffer.length);
  fos.write(buffer,0,temp);
  }
   catch(Exception e){
    System.out.println(e);
   }
  }
}

class Test{
 public static void main(String args[]){
  FileInputStream fis = null;
  FileOutputStream fos = null;
  try{
   fis = new FileInputStream("e:/read.txt");
   fos = new FileOutputStream("e:/write.txt");
  byte[] buffer = new byte[1024];
  while(true){
   int temp = fis.read(buffer,o,buffer.length);
   if(temp = -1){
    break;
   }
   fos.write(buffer,0,temp);
  }
  }catch(Exception e){
   System.out.println(e);
 }finally{
  try{
  fis.close();
  fos.close();
 }catch(Excepiton e){
 System.out.println(e);
  }
 }
}
}  

//字符流
public class TextChar
 public static void main(String args[]){
  FileReader fr = null;
  FileWriter fw = null;
  try{
  fr = new FileReader("e:/read.txt");
  fw = new FileWriter("e:/write.txt");
   
   char[] buffer = new char[100];
   int temp = fr.read(buffer,0,buffer.length);
   fw.write(buffer,0,temp); 
   }
   catch(Exception e){
    System.out.println(e);
   }finally{
     try{
       fr.close();
       fw.close();
       }
   catch(Excepiton e){
    System.out.println(e); 
   }
  }
}

//FileReader和BufferedReader
class Test{
 public static void main(String args[]){
  FileReader fileReader = null;
  BufferedReader bufferedReader = null;
try{
  fileReader = new FileReader("e:/read.txt");
  bufferedReader = new BufferedReader(fileReader);
  String line = null;
   while(true){
   line = bufferedReader.readLine();
   if(line == null){ 
     break;
   }
   System.out.println(line);
  }
  }catch(Exception e){
  System.out.println(e); 
 }
  finally{
   try{
     bufferedReader.close(); 
     fileReader.close();
    }
    catch(Exception e){
     System.out.println(e);
    }
   }
  }
}

public class Test{
 public static void main(String[] args) throws Exception{
  //字节流
 FileInputStream in = new FileInputStream("c:/read.txt");
 FileOutStream out = new FileOutputStream("c:/write.txt");
 byte[] buffer = new byte[1024];
  int len;
  while( (len = in.read(buffer)) != -1){
  out.write(buffer,0,len);
  }
  in.close();
  out.close();
  //字符流
  BufferedReader bf = new BufferedReader(new FileReader("c:/read.txt");
  BufferedWriter bw = new BufferedWriter(new FileWriter("c:/write.txt");
 String str;
 while( (str=bf.readLine()) != null ){
  bw.write(str);
  bw.newLine();
 }
 bf.close();
 bw.close();
  }
}

字节流: InputStream字节输入流,OutputStream字节输出流
字符流 : Reader字符输入流 ,Writer字符输出流
数据流: DataInputStream 数据输入流 ,DataOutputStream 数据输出流

文件读写

目的
1 掌握文件读写的几种方法
2 FileOutputStream和FileInputStream类的使用。
3 基本数据类型之间的转换

实现文件读取后转换为大写后写入到目标文件中，其中src是指源文件，des是目标文件目录。

public class FileDemo {

    //创建一个文件夹
    public static void createFolder(String path){
        File folder=new File(path);
        if(folder.exists()){
            System.out.println("文件夹已存在！");
        }else{
            //不存在时去创建
            folder.mkdir();
        }
    }
    //创建一个文件
    public static void createFile(String path,String filename){
        File file=new File(path,filename);
        //文件判断是否已存在
        if(file.exists()){
            System.out.println("文件已存在！");
            System.out.println(file.length());
        }else{
            try{
                file.createNewFile();
            }catch(IOException e){
                System.out.println("文件创建失败！");
            }
        }
    }
    //写文件
    public static void write(String path,String filename){
        try{
            String str="0123456789/nac";
            String Upstr = str.toUpperCase();//
            byte b[]=Upstr.getBytes();//
            FileOutputStream fos=new FileOutputStream(new File(path,filename));
            fos.write(b);
            fos.close();
        }catch(FileNotFoundException e){
            System.out.println("文件不存在");
        }catch(IOException e){
            System.out.println("写文件失败");
        }
    }
    //读文件
    public static void read(String path,String filename){
        try{
            int length=0;
            String str="";
        
            byte buffer[]=new byte[10];
            FileInputStream fis=new FileInputStream(new File(path,filename));
            
            while((length=fis.read(buffer, 0, buffer.length)) !=-1){
                str+=new String (buffer, 0, length);
            }
            System.out.println(str);//
            fis.close();
        }catch(FileNotFoundException e){
            System.out.println("文件不存在");
        }catch(IOException e){
            e.printStackTrace();
        }
    }
//
    public static void FileReaderCopy(String src,String des){
        try{
        FileReader fr=new FileReader(src);
        FileWriter fw=new FileWriter(des);
        char c[]=new char[1024];
        int len=0;
        
        while((len=fr.read(c, 0, c.length)) != -1){
            fw.write(c, 0, c.length);
        }
        fw.close();
        fr.close();
    } catch(FileNotFoundException e){
        System.out.println("文件不存在");
    }catch(IOException e){
        System.out.println("读写失败");
    }
    }
    //
    public static void BufferedReaderCopy(String src,String des){
        try{
            BufferedReader br=new BufferedReader(new FileReader(src));
            BufferedWriter bw=new BufferedWriter(new FileWriter(des));
            String str="";
            while((str=br.readLine()) != null){
                String Upstr = str.toUpperCase();//加入大写的变换
                bw.write(Upstr);//
                bw.newLine();
            }
            bw.close();
            br.close();
        } catch(FileNotFoundException e){
            System.out.println("文件存在");
        }catch(IOException e){
            System.out.println("读写失败");
        }
        }
    //复制
    public static void copy(String src,String des){
        try{
            FileInputStream fis=new FileInputStream(src);
            FileOutputStream fos=new FileOutputStream(des);
            int c;
            while((c=fis.read()) != -1){
                fos.write(c);
            }
            fos.close();
            fis.close();
        }catch(FileNotFoundException e){
            System.out.println("文件不存在");
        }catch(IOException e){
            System.out.println("读写失败");
        }
    }
    //复制文件
    public static void copy1(String src,String des){
        try{
            FileInputStream fis=new FileInputStream(src);
            FileOutputStream fos=new FileOutputStream(des);
            int c;
            byte buff[]=new byte[1024];
            while((c=fis.read(buff,0,buff.length)) != -1){
                fos.write(buff,0,c);
            }
            fos.close();
            fis.close();
        }catch(FileNotFoundException e){
            System.out.println("文件不存在");
        }catch(IOException e){
            System.out.println("读写失败");
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        FileDemo.createFolder("c:/test");
        FileDemo.createFile("c:/test", "1.txt");
        FileDemo.write("c:/test", "1.txt");
        FileDemo.read("c:/test", "1.txt");
        FileDemo.read("c:/test", "FileDemo.java");
        FileDemo.BufferedReaderCopy("c:/test/FileDemo.java", "c:/test/FileDemo2.java");
        FileDemo.copy1("c:/test/1.mp3", "c:/test/2.mp3");
    }

}

读文件

//读文件
public static void read(String path,String filename){
 try{
  int length = 0;
  String str = "";
  byte buffer[]=new byte[10];
  FileInputStream fis=new FileInputStream(new File(path,filename));
  
  while((length=fis.read(buffer,0,buffer.length))!=-1){
     str+=new String(buffer,0,length);
  }
  System.out.println(str);
  fis.close();
 }catch(FileNotFoundException e){
   System.out.println("文件不存在");
 }catch(IOException e){
  e.printStackTrace();
 }
}

文件的创建

public class FileDemo{
 public static void createFolder(String path){
  File folder = new File(path);
  if(folder.exists()){
   System.out.println("文件已存在!");
  }else{
    folder.mkdir();
 }
}

 public static void createFile(String path,String filename){
  File file = new File(path,filename);
  if(file.exists()){
   System.out.println("文件已存在!");
   System.out.println(file.length());
  }else{
   try{
    file.createNewFile();
  }catch(IOException e){
   System.out.println("文件创建失败");
  }
  }
}

public static void main(String[] args){
  FileDemo.createFolder("c:/test");
  FileDemo.createFile("c:/test","1.txt");
}
}

写文件

public static void write(String path,String filename){
 try{
  String str = "234455";
   byte b[] = str.getBytes();
   FileOutputStream fos =  new FileOutputStream(new File(path,filename));
  fos.write(b);
 }catch(FileNotFoundException e){
   System.out.println("文件不存在");
  }catch(IOException e){
   System.out.println("写文件失败");
  }
}

文件的读写

重点：

文件类主要功能：创建，读属性，写属性，删除等

文件读写操作

File类
File类的对象

用来获取文件本身的信息，如文件所在目录、文件长度、文件读写权限等，不涉及文件的读写操作。

构造函数

File(String filename)
File(String directoryPath,String filename)
File(File f,String filename)

获取文件的属性

String getName()
boolean canRead()
boolean canWrite()
long length()
boolean isFile()等

目录操作

boolean mkdir()：创建目录。
String[] list()：以字符串的形式返回目录下所有文件。
File[] listFiles()：以File对象形式返回目录下所有文件。

文件操作

boolean createNewFile()：创建一个新的文件。
boolean delete()：删除一个文件

流的概念

Java输入输出功能是借助输入输出流类来实现的。

java.io包中包含大量用来完成输入输出流的类。

Java中流的分类：

流的运动方向，可分为输入流和输出流两种。

流的数据类型，可以分为字节流和字符流。

输入流类都是抽象类InputStream（字节输入流）或抽象类Reader类（字符输入流）的子类。

输出流类都是抽象类OutputStream（字节输出流）或抽象类Writer类（字符输出流）的子类。

输入流

输入流用于读取数据，用户可以从输入流中读取数据，但不能写入数据。

输入流读取数据过程如下：

（1）打开一个流。
如：FileInputStream inputFile=new FileInputStream("数据源");
（2）从信息源读取信息。
如：inputFile.read();
（3）关闭流。
如：inputFile.close();

输出流

输出流用于写入数据。只能写，不能读。

写数据到输出流过程如下：

（1）打开一个流。
如：FileOutputStream outFile=new FileOutputStream("数据源");
（2）写入信息到目的地。
如：outFile.write(inputFile.read()):
（3）关闭流。如：
如：outFile.close();

IO

1. I/O操作的目标
2. IO的分类方法
3. 读取文件和写入文件的方法

I/O操作的目标

目标是从数据源中读取数据，将数据写入到数据目的地中。

从一个地方输入到java程序中输出到另外一个地方。

文件与数据流

写入和读出数据文件，在Java的输入/输出操作采用数据流的形式，数据流的两种形式为16位字符或8位字节

数据流的操作对象：

数据文件的读写
线程间的数据传输
网络间的数据传播

读/写步骤：
导入输入/输出包，导入java.io.*包
创建文件对象

FileReader/FileWriter类用于文本文件的读写操作
DataInputStream（用于文件读出）和DataOutputStream（用于文件写入）类文件的读写
FileInputStream（用于文件读出）和FileOutputStream对象（用于文件写入）

关闭文件

close函数关闭文件

File对象的特性

创建文件

boolean createNewFile();

创建子目录

boolean mkdir();
boolean mkdirs();

重命名/移动文件

boolean renameTo(File dest);

删除文件

boolean delete();

检查文件是否存在

boolean exists();

检查是否为文件

boolean isFile();

检查是否为文件夹

boolean isDirectory();

查询文件长度

long length();

往后余生，唯独有你
简书作者：达叔小生
90后帅气小伙，良好的开发习惯；独立思考的能力；主动并且善于沟通
简书博客： https://www.jianshu.com/u/c785ece603d1

结语

• 下面我将继续对 其他知识 深入讲解 ，有兴趣可以继续关注
• 小礼物走一走 or 点赞