第39节:Java当中的IO

image

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内容:InputStreamOutputStream,这两个都是基于字节流。

字符流:ReaderWriter

Java语言中的流分:文本流(字符序列)和二进制流

输入流和输出流

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

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

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

其他重点:

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

字符流

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 FileOutputStreamFileInputStream类的使用。
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 点赞
posted @ 2018-09-08 19:19  达达前端  阅读(177)  评论(0编辑  收藏  举报