黑马程序员_java_05_IO

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1.javaIO类的关系图

2.字节流与字符流的区别

   1.读写对象不同

      字节流读取mp3、图片、视频等格式的文件。读取字节文件。

      字符流读取文本文件。读取字符文件。

   2.处理的单位不同

字节流处理的单位是字节，程序读取的时候一次只可以读取一个字节。

字符流处理的单位是字符,字符流里面融合了编码表。在读取的时候程序可以一次读取一个字符。

3. 输入流、和输出流

输入输出是相对与程序来说的，操作的对象向程序里面去的流叫做输入流，程序向操作对象去的流叫做输出流。

4.输入流

1.字节输入流InputStream

  子类字符流命名规则都是以父类名作为类名的后缀，以类的功能开始。

该类中的public abstract int read()throwsIOException方法。该方法为抽象方法，子类必须实现该方法。返回下一个字节，如果已经到达文件结尾返回-1.

public int read(byte[] b) throws IOException方法，该方法为抽象方法，子类必须实现该方法，把读取到的0----255之间的数据存储到字节数组中去，返回下一个字节数，如果已经到达文件结尾返回-1.

1. BufferedInputStream

字节流流输入缓冲区，当程序使用输入流读取到数据以后，存放在该类的对象中。等程序读取完成以后在把BufferedInputStream对象中的数据存储到需要操作的输出流中去从而实现高效读取。实现了InputStream类的read()方法。

2. FileInputStream

   文件输入流对象，该对象只要用于操作文件（mp3、图片等），使用该对象的构造方法传入一个文件对象既可以对该文件经行流操作。

2.字符输入流 Reader

  子类字符流命名规则都是以父类名作为类名的后缀，以类的功能开始。

  使用该类和其子类的时候必须使用close()方法，关闭流对象释放资源。

该类中的public int read()throws IOException该方法读取单个字符，返回读取字符个数，当读取到文件结尾返回-1。

该类中的public int read(char[] cbuf) throwsIOException

该方法读取单个字符，并把读取的字符存储到数组中，返回读取字符的个数，当读取到文件结尾返回-1.

  Reader是一个抽象类，想要使用该类必须实现该类中的read(char[], int, int) 和 close()方法。该类的子类有：

1. BufferedReader

   该类为缓冲类。当程序使用输入流读取到数据以后，存放在该类的对象中。等程序读取完成以后在把BufferedReader对象中的数据存储到需要操作的输出流中去从而实现高效读取。

BufferedReader类中增加public String readLine()方法，该方法可以实现读取一行数据，读取到“\n”、“\r”视为一行结束。该方法返回读取到的字符串，不包涵任何终止符，如果已到达流结尾，则返回null。

2. InputStreamReader

 该类为转换流，把一个字节输入流转换成一个字符输入流，使用该类转换时可以使用字符集解码器，默认为用户电脑系统使用的字节编码。

BufferedReader in

   = new BufferedReader(newInputStreamReader(System.in));

上述代码描述了一个标准输入流（字节输入流）转换成字符缓冲区的输入流对象的过程。

3.PipedReader

实现了 pipe 的概念，主要在线程中使用 . 管道输入流是指一个通讯管道的接收端。

一个线程通过管道输出流发送数据，而另一个线程通过管道输入流读取数据，这样可实现两个线程间的通讯。

3.标准输入流System.in

标准输入流主要是用来操作键盘输入的的对象，该对象输入字节流，调用System.in返回inputStrem对象。

5. 输出流

1.outputStream字节输出流

 该类中的public abstract void write(int b) throws IOException方法，该方法是向输出流写入一个字节。该方法为抽象方法，子类必须实现。

该类中的public abstract void write(byte[] b) throws IOException方法，该方法是向输出流写入一个字节数组，定义字节数组相当于缓存区，提高写入速度。

该类中的void flush()  方法，该方法是刷新输出流，流对象执行write方法以后必须执行次方法才可以把数据写入对象。执行该方法以后流对象并不关闭。

该类中的void close();方法，该方法是关闭流对象的方法。执行该方法以后释放流资源。并在释放流资源之前，先执行刷新流对象的方法。

   1.FileOutputStream 文件字节输出流。

      文件输出流用于把流写入到文件的操作，用于写入诸如图像数据之类的原始字节的流。

2.   PipedOutputStream管道输出流

 实现在多个线程共同操作一个流对象的时候，提高流对象的安全性。

3. BufferedOutputStream字节输出缓冲去对象。

    该对象可以实现输出流读取数据的时候把读取的数据读到该对象中，读取完毕以后在存储到操作的输出对象。提高了输出效率。

2.writer 字符输出流

  该对象是字符输出流，一次可以输出一个字符。主要操作文本类型的对象。

该类中的public void write(int c)方法，该方法为写入字符的方法。向输出对象中写入一个字符。

该类中的public void writer(char[] char)方法，该方法是向输出对象中写入一个字符数组。

Bufferwriter字符流输出

该对象是字符流输出缓存区。

该类中的newLine（）方法。该方法实现写入一个换行符操作。

3.System.out标准输出流

该对象是一个字节流，当调用System.out方法时返回outputStream对象。该标准输出主要针对为控制台操作。

6.操作演示

练习一：

使用字节流复制图片文件：

importjava.io.*;
public classCopyPic{
      public static void main(String[] args) {
           copy_2();
      }
      public static void copy_2(){
      FileInputStream fis=null;
      FileOutputStream fos=null;
      try{
           fis=newFileInputStream("1.png");
           fos=newFileOutputStream("1_copy.png");
           int len=0;
           while((len=fis.read())!=-1){
                 fos.write((char)len);
           }
      }catch(Exception e){
           throw newRuntimeException("wenjzhaobud");
      }finally{
           try{
                 if(fis!=null)
                      fis.close();
           }catch(Exception e){
                 throw new  RuntimeException("fis");
           }finally{
                 try{
                      if(fos!=null)
                            fos.close();
                 }catch(Exception e){
                      throw newRuntimeException("fos");
                 }
                
           }
      }
      }
public staticvoid copy_1(){
      FileInputStream fis=null;
      FileOutputStream fos=null;
      try{
      fis=newFileInputStream("1.png");   
      fos=new FileOutputStream("1_copy.png");
      byte[] by=new byte[1024];
      int len=0;
      //把输入流对象中的文件读取到by数组中去并返回读取字节的个数，当返回的字节个数不等于-1时表示文件没有读取完毕。
      while((len=fis.read(by))!=-1){
           fos.write(by,0,len);
      }
      }catch(Exception e){
           throw newRuntimeException("meiy");
      }finally{
           try{
                 if(fis!=null)
                      fis.close();
           }catch(Exception e){
                 throw newRuntimeException("in");
           }finally{
                 try{
                 if(fos!=null)
                      fos.close();
           }catch(Exception e ){
                 throw newRuntimeException("out");
           }
           }
      }
}
 
 
}

练习二：

 

需求：把键盘录入的数字存储到文件中

 源：

    键盘录入，字符流，使用字节输入流的到键盘录入流，因为需要存储的是字符穿，把字节流转换成字符流。

 目的：

    文件

importjava.io.*;
class ReadInput{
public staticvoid main(String[] args) throws Exception {
      BufferedReader bufr=new BufferedReader(newInputStreamReader(System.in));
      BufferedWriter bufw=new BufferedWriter(newOutputStreamWriter(new FileOutputStream("aa.txt")));
      FileWriter fw=newFileWriter("aa1.txt");
     
      while(true){
           String s=bufr.readLine();
           fw.write(s);
          
           fw.flush();
      }
}
}

该示例主要展示把字节流转换成字符流的操作。

练习三：

使用字符流读取问本文件并打印

importjava.io.FileReader;
 
class ReadText{
      public static void main(String[] args){
           fileRead2();
      }
      public static void readFile1(){
           FileReader readfile=null;
           try{
                 readfile=newFileReader("aa.java");
           char[] buf=new char[1024];
           int num=0;
           //使用数组的方式读取文件
           while((num=readfile.read(buf))!=-1){
                 System.out.print(newString(buf,0,num));
           }
           }catch(Exception e){
                 e.toString();
           }finally{
                 try{
                      if (readfile!=null){
                            readfile.close();
                      }
                     
                 }catch(Exceptione){e.toString();}
                
                
           }
          
          
          
      }
      public static void fileRead2(){
           FileReader fileRead=null;
           try{
                 fileRead=newFileReader("aa.java");
                 int chars=0;
                 //使用不用数组的方式读取文件
                 while((chars=fileRead.read())!=-1){
                      System.out.print((char)chars);
                 }
           }catch(Exception e){
                 e.toString();
           }finally{
                 try{
                 if(fileRead!=null)
                      fileRead.close();
                
           }catch(Exception e){
                 e.toString();
           }
           }
      }
           }

File类的使用

File类就是对件的各个属性进行描述。

Separator属性，跨平台的目录分割符

2. File对象的操作方法

   1.创建

     boolean createNewFile （）；在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象已建立则创建文件，如果存在则覆盖文件。

File createTempFile :创建临时文件。

Boolean mkdir();创建文件夹

Boolean mkdirs();创建多级目录

   2.删除

Boolean delete:删除失败返回false

VoiddeleteOnExt;在程序退出时删除指定文件。

  3. 判断

BooleancanExecute（）：文件可以操作

Booleanextsts():文件是否存在

在判断文件对象是否是文件或着目录时，必须要判断该文件对象是否存在通过exists判断。

IsFile()；是否是文件。

isDirectory；是否是目录

isHidden();是否是隐藏文件。

isAbsolute();是否是决定路径

  4.获取信息

getName（）：获取文件名字。

getPath（）获取文件目录：返回形式“d:\\java\\aa.java”

getparent（）该方法返回的是绝对路径中的父目录，如果获取的是相对路径的父目录返回为空。如果相对路径中有上一级目录，那么该目录就是返回结果。

getAbsolutePath()此抽象路径名的绝对路径名字符串。

lastModified()最后修改的时间。

ListRowts()列出可用的文件系统根;返回“C盘D盘E盘“

List();调用list方法的file对象必须是封装了一个目录，该目录必须存在

public String[]list(FilenameFilter filter)；返回字符串数组，这些字符串是文件目录中的文件名字，返回的名字必须是满足 filter过滤条件的字符串。

listFiles（）；返回File[]数组，就是文件目录中的文件对象。

public File[]listFiles(FilenameFilter filter)：返回File[]数组，就是文件目录中的文件对象。返回的对象必须满足fileter 过滤器中的过滤条件。

练习一：

复制一个目录下面的所有.java 文件

importjava.io.*;
classcopyJavaFile{
 
public staticvoid main(String[] args){
     
      isJava();
     
}
 
public staticvoid isJava(){
     
      File file=newFile("D:\\java\\andrord\\eclipse\\workspace\\aa\\bb");
      File[] files=file.listFiles(newFileFilter(){
          
           public boolean accept(File fil){
                
                 returnfil.getName().endsWith(".java");
           }
          
      });
      for(File f:files){
           try {
                 copyJava(f);
           } catch (Exception e) {
                 // TODO Auto-generated catchblock
                 e.printStackTrace();
           }
      }
     
}
 
public staticboolean copyJava(File file) throws Exception{
      BufferedReader bfr=new BufferedReader(newFileReader(file));
     
      File bfwFile=newFile(file.getParent()+"\\"+"copy"+"\\"+file.getName());
     
      BufferedWriter bfw=new BufferedWriter(newFileWriter(bfwFile));
     
      while(true){
           String str=bfr.readLine();
           if(str==null){
                 System.out.println(file.getName()+"finsh");
                 break;
           }
           bfw.write(str);
           bfw.newLine();
           bfw.flush();
          
      }
      return true;
     
}
}
 

练习二

拷贝c下面的一个文件夹及文件夹下面的子文件夹和文件，到d盘下面

思路：

1.把源文件夹文件，创建一个文件对象。使用ListFiles得到文件下面的每一个文件对象。判断是文件还是文件夹

2.是文件：判断文件名是否重复，拷贝文件

3.是文件夹：返回第一步执行。

源代码如下所示：

import java.io.*;
public class CopyFile {
	/**
	 * @param args
	 */
	public static void main(String[] args)throws Exception {
		// TODO Auto-generated method stub
		 Filename(new File("c:\\text"));
	
	}

	public static void Filename(File file)throws Exception{
		File[] filearrays=file.listFiles();//得到需要复制的文件对象列表
		for(File f:filearrays){//遍历文件列表返回文件对象
			if(f.isFile()){//判断是文件还是文件夹
				String copyPath=f.getPath();//得到文件的父目录
				copyPath="d"+copyPath.substring(1,copyPath.length());//把文件的目录变成d盘下的
				File filecopy=null;//得到复制的目的文件对象
			
				filecopy=isFileCz(filecopy,copyPath);//把源文件对象和目的文件对象的文件路径传入到判断文件是否重复的方法中，最后返回没有重复的目的文件对象。
				fileCopy(f,filecopy);//是文件的时候复制文件并把源文件对象和目的文件对象传到复制方法中去。
				}else{
					Filename( f);//假如该文件对象是文件夹则继续遍历该文件夹下的所有文件，并把当前文件路径传进去。
				}
		}
	}
	/*复制文件方法*/
	public static void fileCopy(File file,File filecopy) throws Exception{
		InputStream ips=new FileInputStream(file);
		OutputStream ops=new FileOutputStream(filecopy);
		
		byte[] buf=new byte[1024];
		int leng=0;
		while((leng=ips.read(buf))!=-1){
			ops.write(buf,0,leng);
		}
		//System.out.println(filecopy.getName()+"复制完成");
		ips.close();
		ops.close();
		
	}
	/*判断文件是否重复
	 * 使用递归的方式返回文件重复以后修改的文件名以后的文件对象，知道文件不存在的情况下跳出递归方法。
	 * 
	 * */
	public static File isFileCz(File filecopy ,String copyPath){
		filecopy=new File(copyPath);
		if(!filecopy.exists()){//判断文件是否存在
			filecopy.getParentFile().mkdirs();//文件目录不存在则创建该目录。
			//filecopy.createNewFile();
			
		}else{
			 copyPath=filecopy.getParent()+"\\"+filecopy.getName().substring(0,filecopy.getName().lastIndexOf('.'))+"-副本"+
		                                                                                                                             filecopy.getName().substring(filecopy.getName().lastIndexOf('.'));
			filecopy=isFileCz(filecopy,copyPath);//在文件存在的情况下继续执行此方法，返回的文件对象替换以前的文件对象。
			
			
		}
		return filecopy;
	}
	
	
}

运行结果如下图所示：

源文件如下所示：

目的文件如下图所示：