Java——输入与输出

1. File类

Ⅰ 创建一个File对象的常用构造方法有3种:

（1）File(String pathname)     通过指定的文件路径字符串来创建一个新File实例对象。

（2）File(String path,String filename)  根据指定的父路径字符串和子路径字符串（包括文件名称）创建File类的实例对象。

（3）File(File file,String filename)   根据指定的File类的父路径和字符串类型的子路径（包括文件名称）创建File类的实例对象。

注意： 创建一个File对象时，如果它代表的文件不存在，系统不会自动创建，必须要调用createNewFile()方法创建。

Ⅱ File类常用的方法如下表所示：

import java.io.File;

public class Example1 {
	public static void main(String[] args) {
	
		// 创建文件对象
		File file = new File("F:\\flora大学\\example.txt");
		 
		// 输出文件属性
		System.out.println("文件名称：" + file.getName());
		System.out.println("文件是否存在：" + file.exists());
		System.out.println("文件的相对路径：" + file.getPath());
		System.out.println("文件的绝对路径：" + file.getAbsolutePath());
		System.out.println("文件可以读取：" + file.canRead());
		System.out.println("文件可以写入：" + file.canWrite());
		System.out.println("文件大小：" + file.length() + "B");
	}
}

 运行效果：

2.  输入输出流

输入输出流一般分为4种：

• 字节输入流:InputStream类是字节输入流的抽象类，它是所有字节输入流的父类，其各种子类实现了不同的数据输入流。
• 字节输出流:OutputStream类是字节输出流的抽象类，它是所有字节输出流的父类，其子类实现了不同数据的输出流。
• 字符输入流:Reader类是字符输入流的抽象类，所有字符输入流的实现都是它的子类。
• 字符输出流:Writer类是字符输出流的抽象类，所有字符输出流的实现都是它的子类。

(1) FileInputStream类:实现了文件的读取，是文件字节输入流。该类适用于比较简单的文件读取.

创建文件字节输入流常用的构造方法有两种：

• FileInputStream（String filePath）
• FileInputStream(File file)

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class Example2 {
	public static void main(String args[]) {
		File f = new File("F:\\flora大学\\example.txt");
		try {
			byte bytes[] = new byte[512];
			FileInputStream fis = new FileInputStream(f); // 创建文件字节输入流
			int rs = 0;
			System.out.println("The content of Example2 is:");
			while ((rs = fis.read(bytes, 0, 512)) > 0) {// 在循环中读取输入流的数据
				String s = new String(bytes, 0, rs);
				System.out.println(s);
			}
			fis.close(); // 关闭输入流
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

显示效果：

（2)FileOutputStream类:实现了文件的写入，能够以字节形式写入文件中

创建文件字节输出流常用的构造方法有两种：

• FileOutputStream(String filePath)
• FileOutputStream(File file)        注意：file：File文件类型的实例对象。在file后面，加true会对原有内容进行追加，不加true会将原有内容覆盖。

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class Example3 {
	public static void main(String args[]) {
		int b;
		File file = new File("F:\\flora大学\\example.txt");
		byte bytes[] = new byte[512];
		System.out.println("请输入你想存入文本的内容:");
		try {
			if (!file.exists()) // 判断文件是否存在
				file.createNewFile();
			b = System.in.read(bytes);// 把从键盘输入的字符存入bytes里
			FileOutputStream fos = new FileOutputStream(file,true); // 创建文件输出流
			fos.write(bytes, 0, b); // 把bytes写入到指定文件中
			fos.close(); // 关闭输出流
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

显示效果：

                

注意：如果把FileOutputStream fos = new FileOutputStream(file,true);语句中的true去掉，则新写入的内容会覆盖掉原来文件的内容。

3.字符流

• 字符流（charactercstreams）用于处理字符数据的读取和写入，它以字符为单位。
• Reader类和Writer类是字符流的抽象类，它们定义了字符流读取和写入的基本方法，各个子类会依其特点实现或覆盖这些方法。

ⅠReader类和Write类 

（1）Reader类：是所有字符输入流的父类，它定义了操作字符输入流的各种方法。常用方法如下表所示。

（2)Writer类是所有字符输出流的父类，它定义了操作输出流的各种方法。常用方法如下表所示。

 Ⅱ InputStreamReader类与OutputStream Writer类

（1)InputStreamReader 是字节流通向字符流的桥梁。它可以根据指定的编码方式，将字节输入流转换为字符输入流。

创建字符输入流常用的构造方法有两种：

• InputStreamReader(InputStream in)      in：字节流类的实例对象。
• InputStreamReader(InputStream in, String cname)      cname：使用的编码方式名。

InputStreamReader类常用的方法如下表所示。 

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Example4 {
	public static void main(String args[]) {
		try {
			int rs;
			File file = new File("F:\\\\flora大学\\\\example.txt");
			FileInputStream fis = new FileInputStream(file);
			InputStreamReader isr = new InputStreamReader(fis);
			System.out.println("The content of Example4 is:");
			while ((rs = isr.read()) != -1) { // 顺序读取文件里的内容并赋值给整型变量b,直到文件结束为止。
				System.out.print((char) rs);
			}
			isr.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

（2）OutputStreamWriter类

OutputStreamWriter 是字节流通向字符流的桥梁。写出字节，并根据指定的编码方式，将之转换为字符流。

创建字符输出流常用的构造方法有两种。

• OutputStreamWriter(OutputStream out)
• OutputStreamWriter(OutputStream out,String cname)

OutputStreamWriter类常用的方法如下表所示： 

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Example5 {
	public static void main(String[] args){
		File filein=new File("F:\\flora大学\\example.txt");
		File fileout=new File("F:\\\\flora大学\\\\example1.txt");		
		try {
			if (!filein.exists()   // 如果文件不存在
				filein.createNewFile();	// 创建新文件
			if (!fileout.exists())							
				fileout.createNewFile();						
			FileInputStream fis = new FileInputStream(filein);
			FileOutputStream fos=new FileOutputStream(fileout,true);
			InputStreamReader in = new InputStreamReader (fis); 
			OutputStreamWriter out = new OutputStreamWriter (fos);
			int is;
			while((is=in.read()) != -1){  //读取example文件的数据
				out.write(is);            //写入example1文件中
			}
			in.close();
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

ⅲ FileReader类与FileWriter类

（1）FileReader类：实现了从文件中读出字符数据，是文件字符输入流

FileReader类的常用构造方法有两种:

• FileReader(String filePath)
• FileReader(File file)

读取example1中的内容输出到控制台——核心代码
try {
     File f=new File("F:\\\\flora大学\\\\example1.txt");
     FileReader fr=new FileReader(f);		// 创建文件字符输入流
     char[] data=new char[512];
     int rs=0;
     while((rs=fr.read(data))>0){			// 在循环中读取数据，将读取的数据存在数组里
          String str=new String(data,0,rs);
          System.out.println(str);
     }
     fr.close();
} catch (Exception e) {
     e.printStackTrace();
}

（2）FileWriter类：实现了将字符数据写入文件中，是文件字符输出流。

FileWriter类的常用构造方法有两种：

• FileWriter(String filePath)
• FileWriter(File file)

将“Example5-1.txt”的内容复制到文件“Example6.txt”中——核心代码
try {
     File f=new File("C:\\","Example6.txt");
     if (!f.exists())				
          f.createNewFile();				
     FileReader fr=new FileReader("C:\\Example5-1.txt");	// 创建文件字符输入流
     FileWriter fWriter=new FileWriter(f);		// 创建文件字符输出流
     int is;
     while((is=fr.read()) != -1){
          fWriter.write(is);				// 将数据写入输出流
     }
     fr.close();
     fWriter.close();
} catch (Exception e) {
     e.printStackTrace();
}

 Ⅳ BufferedReader类与BufferedWriter类

（1）BufferedReader类：使用该类可以以行为单位读取数据。

①BufferedReader类的主要构造方法为：BufferedReader(Reader in)   即该构造方法使用Reader类的对象，创建一个BufferReader对象。

②BufferedReader 类中提供了一个ReaderLine()方法，Reader类中没有此方法，该方法能够读取文本行。

try {
			FileReader fr = new FileReader("F:\\flora大学\\example1.txt"); // 创建文件字符输入流
			BufferedReader br = new BufferedReader(fr);
			String aline;
			while ((aline = br.readLine()) != null) { // 按行读取文本
				String str = new String(aline);
				System.out.println(str);
			}
			fr.close();
			br.close();
		} catch (Exception e) {
			e.printStackTrace();
		}

 (2)BufferedWriter类:以行为单位写入数据

①BufferedWriter类常用的构造方法为：BufferedWriter(Writer out)

②BufferedWriter类提供了一个newLine()方法，Writer类中没有此方法。该方法是换行标记。

	File file=new File("F:\\\\flora大学\\\\example.txt");
		try {
	             FileWriter fos = new FileWriter(file,true);
		     BufferedWriter bw=new BufferedWriter(fos);
		     bw.write("Example");
		     bw.newLine();
		     bw.write("Example");
		     bw.close();
		} catch (IOException e) {
		     e.printStackTrace();
		}

（3）综合用法： 

用BufferedReader和BufferedWriter将Example5中的内容复制到Example5-1中
try {
			FileReader fr = new FileReader("C:\\Example5.txt");	// 创建BufferedReader对象
			File file = new File("C:\\Example5-1.txt");
			FileWriter fos = new FileWriter(file);		// 创建文件输出流
			BufferedReader br=new BufferedReader(fr);
			BufferedWriter bw=new BufferedWriter(fos);	// 创建BufferedWriter对象
			String str =null;
			while ((str = br.readLine()) != null) {
				bw.write(str + "\n"); 					// 为读取的文本行添加回车
			}
			br.close();									// 关闭输入流
			bw.close();									// 关闭输出流
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

ⅴPrintStream类与PrintWriter类

（1）PrintStream：打印输出流，它可以直接输出各种类型的数据。

创建打印输出流常用的构造方法为：PrintStream(OutputStream out)

PrintStream类常用的方法如下表所示：

try {
			File file=new File("F:\\flora大学\\example2.txt");
			if (!file.exists())								
				file.createNewFile();					
			PrintStream ps = new PrintStream(new FileOutputStream(file));
			Random r=new Random();
			int rs;
			for(int i=0;i<5;i++){
			rs=r.nextInt(100);  //随机生成0——100间的5个数（不包括100）——※
			ps.println(rs+"\t");
			}
			ps.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

显示效果：

（2）PrintWriter类

①PrintWriter是打印输出流，该流把Java语言的内构类型以字符表示形式送到相应的输出流中，可以以文本的形式浏览。

②创建该打印输出流常用的构造方法有两种。

③PrintWriter类常用的方法如下表所示：

• PrintWriter(Writer out)
• PrintWriter(OutputStream out)

使用PrintWriter实现文件的复制执行过程为：
File filein=new File("C:\\","Example6.txt");
File fileout=new File("C:\\","Example7.txt");
try {
     //创建一个BufferedReader对象
     BufferedReader br=new BufferedReader(new FileReader(filein));
     //创建一个PrintWiter对象
     PrintWriter pw=new PrintWriter(new FileWriter(fileout));     
     int b;
     //读出文件“Example6.txt”中的数据
     while((b=br.read())!=-1){
          pw.println(b);				//写入文件中
     }
     br.close();					//关闭流
     pw.close();					//关闭流
} catch (Exception e) {
     e.printStackTrace();
}

4.System.in获取用户输入

①in：是静态变量，类型是InputStream。

②Java实现键盘输入的一般过程为：

实现键盘输入，把输入的内容存到example2中
核心代码：
File file=new File("F:\\\\flora大学\\\\example2.txt");
		try {
			if (!file.exists())								
				file.createNewFile();							
			InputStreamReader isr=new InputStreamReader(System.in);
			BufferedReader br=new BufferedReader(isr);
			System.out.println("请输入：");
			String str=br.readLine();
			System.out.println("您输入的内容是："+str);

			FileWriter fos=new FileWriter(file,true);    //创建文件输出流
			BufferedWriter bw=new BufferedWriter(fos);
			bw.write(str);
			br.close();
			bw.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

5.  RandomAccessFile类

①使用RandomAccessFile类可以读取任意位置数据的文件。RandomAccessFile类既不是输入流类的子类，也不是输出流类的子类。

②RandomAccessFile类常用的构造方法有两种。

• RandomAccessFile(String name,String mode)

     name：和系统相关的文件名。mode：用来决定创建的流对文件的访问权利，它可以是r、rw、rws或rwd。r代表只读， rw代表可读写，rws代表同步写入，rwd代表将更新同步写入。

• RandomAccessFile(File file,String mode)

③RandomAccessFile类常用的方法如下表所示：

利用RandomAccessFile类显示文件本身 
   try {
			File f = new File("F:\\flora大学\\example1.txt");
			RandomAccessFile raf = new RandomAccessFile(f, "rw"); // 创建随机访问文件为读写
			long filepoint = 0;     // 定义文件总长度变量
			long filel = raf.length();   // 获取文件的长度
			while (filepoint < filel) {
				String str = raf.readLine();   // 从文件中读取数据
				System.out.println(str);
				filepoint = raf.getFilePointer();
			}
			raf.close();
		} catch (Exception e) {
			e.printStackTrace();
		}

创建int型数组，把int型数组写入到文件example2中，然后按倒序读出这些数据
核心代码：
                int bytes[] = { 1, 2, 3, 4, 5 };
		try {
			RandomAccessFile raf = new RandomAccessFile("F:\\flora大学\\example2.txt", "rw"); //创建RandomAccessFile类的对象
			for (int i = 0; i < bytes.length; i++) {
				raf.writeInt(bytes[i]);
			}
			for (int i = 0; i < bytes.length; i++) {
				raf.seek(i * 4); // int型数据占4个字节
				System.out.println(raf.readInt());
			}
			raf.close();
		} catch (Exception e) {
			e.printStackTrace();
		}

6. 过 滤 器 流

①过滤器流（FilterStream）是为某种目的过滤字节或字符的数据流。基本输入流提供的读取方法，只能用来读取字节或字符。而过滤器流能够读取整数值、双精度值或字符串。但需要一个过滤器类来包装输入流。

②DataInputStream 和DataOutputStream类分别是FilterInputStream和FilterOutputStream类的子类。它们分别实现了DataInput和DataOutput接口，该接口中定义了独立于具体机器的带格式的读写操作，从而可以实现对Java中的不同基本类型数据的读写。

例如，从文件中读取数据。可以先创建一个FileInputStream类的对象，然后把该类传递给一个DataInputStream的构造方法。

FileInputStream fis = new FileInputStream("Example.txt");

DataInputStream dis=new DataInputStream(fis);

int i=dis.readInt();

dis.close();

再例如，把数据写入文件。可以先创建一个FileOutputStream类的对象，然后把该类传递给一个DataOutputStream的构造方法。

7.对象序列化

①使用对象输入输出流实现对象序列化可以直接存取对象。

②将对象存入一个流称为序列化。而从一个流将对象读出称为反序列化。

③ObjectInput接口与ObjectOutput接口中定义的对象反序列化和序列化方法如下：

ⅰ.ObjectInput与ObjectOutput

（1）readObject()

所谓反序列化就是从输入流中获取序列化的对象数据，用这些数据生成新的Java对象。该方法定义在ObjectInput接口中，由ObjectInputStream类实现。

语法：Object object=readObject()   object：Java对象。

注意：使用readObject()方法获取的序列化对象是Object类型的，必须通过强行类型转换才能使用。

（2）writeObject ()

序列化就是将对象写入到输出流，这个输出流可以是文件输出流、网络输出流以及其他数据输出流。该方法定义在ObjectOutput接口中，由ObjectOutputStream类实现。

语法：writeObject(object);    object：将要序列化的对象。

注意：被序列化的对象必须实现java.io.Serializable接口，否则不能实现序列化。

ii.ObjectInputStream与ObjectOutputStream

①Java提供了ObjectInputStream和ObjectOutputStream类读取和保存对象，它们分别是对象输入流和对象输出流。②ObjectInputStream类和ObjectOutputStream类是InputStream类和OutputStream类的子类，继承了它们所有的方法。

③创建ObjectInputStream 类的构造方法为：ObjectInputStream(InputStream in)

例1：使用对象输入流读取一个对象到程序中。

FileInputStream fis=new FileInputStream("Example.txt");

ObjectInputStream ois=new ObjectInputStream(fis);

ois.readObject();  //读取基本数据类型

ois.close();

例2.使用对象输出流将对象写入到文件中。

FileOutputStream fos=new FileOutputStream("Example.txt");

ObjectOutputStream obs=new ObjectOutputStream(fos);

obs.writeObject("Example");   //写入基本数据类型方法

obs.close();

实现用户密码的修改
（1）创建user类，构造方法中存在姓名、密码、年龄3个参数，并实现Serializable接口。
public class user implements Serializable {
	String name;
	String password;
	int age;

	user(String name, String password, int age) {
		this.name = name;
		this.password = password;
		this.age = age;
	}

	public void setpassword(String pass) {
		this.password = pass;
	}
}

（2）创建Example10类，将user类的对象写入文件中，修改用户密码之后再将其读出
public class Example10 {
	public static void main(String args[]){
		user use=new user("Tom","111",21); //创建user类的对象
		try {
			
			FileOutputStream fos=new FileOutputStream("F:\\\\flora大学\\\\example2.txt");
			ObjectOutputStream obs=new ObjectOutputStream(fos);//创建输出流的对象，使之可以将对象写入文件中
			obs.writeObject(use);	//将对象写入文件中
			
			System.out.println("未修改写入文件的用户信息");
            //打印文件中的信息
			System.out.println("用户名："+use.name);			
			System.out.println("原密码："+use.password);
			System.out.println("年龄："+use.age);
			
			FileInputStream fis=new FileInputStream("F:\\flora大学\\example2.txt");		
			ObjectInputStream ois=new ObjectInputStream(fis);//创建输入流的对象，使之可以从文件中读取数据
			use=(user)ois.readObject();	//读取文件中的信息
			use.setpassword("1111");	//修改密码
			
			System.out.println("修改之后文件中的信息");
	  //打印修改后的文件信息
			System.out.println("用户名："+use.name);
			System.out.println("修改后的密码："+use.password);
			System.out.println("年龄："+use.age);
			obs.close();
			ois.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

实现效果：