Java当中的IO

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

//第一种：输入流输出流//第二种：字节流字符流//第三种：节点流处理流//FileInputStreamclass 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和BufferedReaderclass 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 点赞

这是一个有质量，有态度的公众号

喜欢本文的朋友们

欢迎长按下图关注订阅号

收看更多精彩内容