javaI/O

    一、文件处理

      1.File类概述

      在java中对文件处理的类是File类，它用于对文件和目录的检查和操作。例如创建、删除、改名、以及查看相关信息（文件大小、创建时间等）。java中的目录被当作是一种特殊的文件，所以也是用File类进行处理。

  在java中，File类的操作是与平台无关的，不论是对Linux还是Windows平台，都可以用一致的方式进行处理。

  2.File类的使用

  File类描述了文件对象的属性和提供了对文件对象的操作。下面是一些常见的File类方法

  File(String pathname)用一个给定路径名创建一个新的文件类实例

 boolean exists()测试文件或目录是否存在

 boolena isFile()测试文件是否是一个标准文件

 boolean isDirectory测试文件是否是一个目录

 long length()得到文件长度

 String getPath()获得文件路径

 boolean canRead()文件是否可读

 String[] list返回字符串数组，其值是文件中的文件和文件名

 File[] listFiles(FilenameFilter filter)返回file数组，其值是目录中满足指定过滤器的文件和目录

 3.File类的简单应用，列出目录下的各级文件名

package itcast.ioStu;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
public class FileStudy {
	public static void main(String[] args) {
	  File file=new File("F:/");
	     allDirs(file);
	}
	//列出目录下的所有目录,相互迭代出目录中的文件
	public static void allDirs(File file)
	{
		System.out.println(file.getName());//输出 文件名
		if(file.isDirectory()){//如果是目录
		File[] files=file.listFiles();
		System.out.println(file.getName());
		for (File file2 : files) {
			allDirs2(file2);
		}
		
	  }
	}
	//列出目录下的所有目录,相互迭代出目录中的文件
	public static void allDirs2(File file)
	{
		if(file.isDirectory()){
		File[] files=file.listFiles();
		System.out.println(file.getName());
		for (File file2 : files) {
			allDirs(file2);
		}
	  }
	}
}

4、RandomAccessFile类：随机读取文件类，此类的实例支持对随机访问文件的读取和写入

 1.特点：

     RandomAccessFile提供了众多的文件访问方法，支持随机访问方式

     RandomAccessFile类在随机读写等长记录格式的文件时有很大的优势。

二、java中流

（一）、1.流的概念：Java中流类分为两大类，节点流和过滤流（也叫处理流）。

    （1）、节点流：用于直接操作设备目标的流

    （2）、过滤流：间接处理节点流的流类

  2、java中主要使用的流

    （1）字节流类:适用于对二进制文件的操作，它分为字节输入流和字节输出流

    InputStream 字节输入流抽象类                                         OutputStream字节输出流抽象类

    FileInputSteam 字节文件输入流                                         FileOutputSteam 字节文件输出流        

    FilterInputStream 过滤文件输入流                                      FilterOutputStream 过滤文件输出流        

    BufferedInputStream 缓冲字节输入流                                 BufferedOutputStream 缓冲字节输出流

（2）字符流：适用于对文本文件进行操作，它分为字符输入流和字符输出流

   Reader字符输入流抽象类                                                    Writer字符输出流抽象类

   InputStreamReader 字符输入流                                             InputStreamWriter 字符输入流

   FilerReader字符文件输入流                                                     FilerWriter字符文件输出流

   BufferedReader缓冲字符输入流                                             BufferedWriter缓冲字符输出流

                 

  2、InputStream类：程序可以从中连续读取字节的对象叫输入流，在java中，用InputStream类来描述所有输入流的抽象概念。

   （1）、主要方法：

      int read() 从输入流中读取数据的下一个字节。流结束时返回-1，如果没有结束，又没有数据可读，则会阻塞。

      int read(byte[]b)   从输入流中读取一定数量的字节，并将其存储在缓冲区数组b 中。

     int read( byte[]b,int off,int len)将输入流中最多 len 个数据字节读入 byte 数组。

     long skip(long n) 跳过和丢弃此输入流中数据的 n 个字节,返回读取到的字节数。

     int available()   返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数。下一个调用可能是同一个线程，也可能是另一个线程。一次读取或跳过此估计数个字节不会受阻塞，但读取或跳过的字节数可能小于该数。 

   void mark(int readlimit)在此输入流中标记当前的位置。

   void reset()将此流重新定位到最后一次对此输入流调用 mark 方法时的位置。

  3.OutputStream类：程序可以向其中连续写入字节的对象叫输出流，在java中，用OutputStream类来描述所有输出流的抽象概念。

   常用方法:

    void write(int b);将指定的字节写入此输出流。

   void write (byte []b);将 b.length 个字节从指定的 byte 数组写入此输出流。

   write(byte[] b, int off, int len)将指定 byte 数组中从偏移量off 开始的len 个字节写入此输出流。write(b, off, len) 的常规协定是：将数组b 中的某些字节按顺序写入输出流；元素b[off] 是此操作写入的第一个字节，b[off+len-1] 是此操作写入的最后一个字节。

void flush();刷新此输出流并强制写出所有缓冲的输出字节。

  4.FileInputStream 与FileOutputStream 文件输入与输出 流

   （1）、构造方法

    FileInputStream fs=new FileInputStream(String filename);

   FileInputStream fs=new FileInputStream(File file);//传入File对象

    FileOutputStream fos=new FileOutputStream(filename);//传入文件名

    FileOutputStream fos=new FileOutputStream(file)//传入一个File对象

   注意：创建FileOutputStream实例对象时，可以指定还在存在的文件，不能指定一个已被其它程序打开了的文件

 5、Reader与Writer类

   Reader与Writer类是所有字符流类的抽象基类，用于简化对字符串的输入输出编程。即用于读写文本数据

  6、PipedInputStream 和PipedOutputStream管道流类

       这两个类主要用于线程间的通信。

 7、StringReader和StringWriter类 可以直接操作字符串

  

（二）、  过滤流

     用于对流中的数据进行处理，这样的流称为处理流。过渡流就是一种处理流，它像管道中的过渡器，从上游接收数据，经过过滤处理，然后送往下游。过滤流提供了很多增强功能，实现了多样化的数据加密和解密、压缩数据和解压数据。

  1、BufferedInputStream和BufferedOutputStream 缓冲输入流和缓冲输出流，它采用一个内部缓冲区数组来缓存数据，从而提高磁盘的读写速度。

      缓冲流进入输入

     FileInputStream fis=new FileInputStream("filename");//定义一个文件输入流

     BufferedInputStream bis=new BufferedInputStream(fis);//将文件流转换为缓冲流

 

   2、BufferedReader 和BufferedWriter

    BufferedReader :从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

   readLine()   可以一次读取一行文本

    BufferedWriter:  将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

    newLine()    写入一个行分隔符。

     write(String s, int off, int len) 写入字符串的某一部分。

  3、PrintStream 提供了一系列的print和println方法可以将基本数据类型的数据格式化成字符串输出

 （三）、java中的对象序列化

     1、序列化概述：对象的寿命通常随着生成该对象的程序的终止而终止。有时候，可能需要将对象的状态保存起来，需要时再将对象恢复，对象的这种能记录自己状态以便将来再生的能力，称为对象的持久化（Persistence）,而对象通过写出描述自己状态的属性值来记录自己，这个过程称为对象的序列化。就是把对象的属性值保存到硬盘文件上。需要时再从硬盘文件中读取出来 （反序列化）。

    2、在java中， 一个对象要想能够被序列化，那么该对象的类必须实现Serializable接口。

   3、Serializable：通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。

  4 、对象序列化的实现

    ObjectInputStream 和ObjectOutputStream 流用于支持对象序列化的实现。

 5 、下面是一个对象序列化和反序列化的例子

  

package itcast.ioStu;

import java.io.Serializable;
//定义一个学生类，让它实现序列化接口
public class Student implements Serializable {

 private int id;
 private String name;
 private int age ;
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public Student(int id,String name,int age){
  this.id=id;
  this.name=name;
  this.age=age;
 }
}

 

package itcast.ioStu;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

//序列化学生类
public class SerializeStudent {

	public static void main(String[] args) {
		Student stu=new Student(1, "Serialize", 12);
		File file=new File("stu.txt");
		Student result=null;
		Serialize(stu, file);
		try {
			result=deserialize(stu, file);
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(result.getName());
		

	}
	//将一个Student对象保存到文件中去
	public static void Serialize(Student stu,File file)
	{
		ObjectOutputStream out=null;
		try {
			out=new ObjectOutputStream(new FileOutputStream(file));
			out.writeObject(stu);//将对象保存到文件中
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally
		{
			try {
				out.close();//关闭对象输出流
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	public static Student deserialize(Student stu,File file) throws ClassNotFoundException
	{
		ObjectInputStream in=null;
		Student result=null;
		try {
			in=new ObjectInputStream(new FileInputStream(file));
			result=(Student)in.readObject();//将对象从文件中读取出来
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally
		{
			try {
				in.close();//关闭对象输入流
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return result;
		
	}

}

6、对象序列化注意事项

   （1）、要序列化的类必须是public 类型的

   （2）、序列化不能保存类变量、也不能保存成员方法各构造方法

    （3）、序列化保存的是对象的状态，即非静态属性的值。

7、transient关键字

    被transient修饰的属性将不被序列化。所以对于不需要或不应该保存的属性应加上transient修饰符。