本文共 13875 字，大约阅读时间需要 46 分钟。
本人是个新手，写下博客用于自我复习、自我总结。 如有错误之处，请各位大佬指出。 参考教材：零基础学Java
输入和输出是向某个方向流动的数据流。
流就是数据流向某个对象，并且到达这个对象的过程。 输入流就是从目标程序中，将数据以流的形式复制到前面说的流对象中，然后，再从流对象中将数据读取出来。输出流就是将数据以流的形式复制到流对象中，再从这些流对象中取出流，写入到目标中。 程序读取数据称为打开输入流，程序向其他源写入数据称为打开输出流。有关输入和输出，在Java类库中有一个与之相对应的类库java.io包。
也就是说，如果要使用输入输出类的方法和属性值，就需要引入java.io类。 经常使用的输入输出类： 1）file类 2）OutputStream类 3）InputStream类 4）FilterStream类 5）Writer类 6）Reader类public File(String pathname)
使用指定的路径，创建一个File对象 public File(String parent,String child) 使用指定的路径和字符串，创建一个File类 public File(File parent,String child) 使用一个File类的对象parent与字符串创建一个新的File对象通过以上的构造函数来构造File对象。然后使用这个类提供的方法函数和属性值，来进行文件和目录信息的操作。
public boolean canread() 测试这个文件是否可读
public boolean canwrite() 测试这个文件是否可写
public boolean createNewFile() 看这个文件或目录是否存在
public static File create TempFile(String prefix,String suffix,File directory) 在目录directory中创建以prefix为文件名，suffix为拓展名的临时文件
public boolean delete() 删除当前对象所指文件。删除成功返回true，否则返回false
例：
import java.io.*; //导入包public class InputAndOutput { public void print(File f){ //实现判断文件类对象性质的方法 if(f.isDirectory()){ //当为目录时 System.out.println("这是一个目录！"); } else{ System.out.println("这不是一个目录！"); } if(f.exists()){ //当文件存在时 System.out.println("这个文件存在！"); }else{ System.out.println("这个文件不存在！"); try{ f.createNewFile(); //创建文件 }catch(Exception e){ } } } public void print1(File f){ //实现获取文件对象信息的方法 //输出文件的名字 System.out.println(f.getName()); //输出文件的父目录 System.out.println(f.getParent()); //输出文件的路径 System.out.println(f.getPath()); } public void print2(File f){ //实现获取文件对象信息的方法 if(f.isFile()){ //输出文件的最后修改日期，以long型来表示 System.out.println(f.lastModified()); //输出文件的大小 System.out.println(f.length()); } } public static void main(String args[]){ //主方法 InputAndOutput f1=new InputAndOutput();//创建对象f1 File f=new File("d:\\filetest","file.txt"); //创建对象f // try{ //创建相应文件 f.createNewFile(); }catch(Exception(e)){ } // /** 也就是说，如果不用代码方式创建相应文件，直接用以上的方法声明， 则什么都没有，即不会主动创建。也可以使用手动方式创建相应文件， 即去D磁盘，创建文件夹，放入相应文件。 */ //获取f2指示的目录下的所有文件，并用数组方式存储 File f2=new File("d:\\filetest"); File[] ff=f2.listFiles(); 通过循环语句输出 for(int i=0;i 数据流对象分为两大类：一类是负责输入的输入流对象；另一类是负责输出的输出流对象。这两大类的父类是InputStream类和OutputStream类，这两个类都是抽象类。
int read() 自输入流读取并返回0~255之间的一个int整数。若文件读完或者再无可读数据，则返回-1
int read(byte[] b) 从输入流中读取数据并存入字节数组b中。它的返回值是所读取的byte数。若无可读数据，则返回-1
int read(byte[] b,int off,int len)从输入流中读取len个字节的数据，并存入字节数组b中，并且从字节数组的第off位开始存储。它的返回值是所读取的字节数。若无可读数据，则返回-1
void close() 关闭输入流，并且释放与输入流相关的系统资源
int write(int b) 将b转换成字节，然后写到输出流中，每次写一个字节
int write(byte[] b) 将字节数组中的数据写到输出流中
int write(byte[] b,int off,int len)将字节数组中从第off位置开始长度为len个字节的数据写入到输出流中
void close() 关闭输出流，并且释放与输出流相关的系统资源
FileInputStream类是InputStream类的子类，并且其不是一个抽象类。这样，程序员就可以利FileInputStream类的对象来使用前面的方法。同理FileOutputStream类也是一样。
public FileInputStream(String name)：创建一个FileInputStream对象，从以name为名称的文件中读取数据
public FileInputStream(File file)：创建一个FileInputStream对象，从指定的对象file中读取数据
例：
import java.io.*; //导入包public class InputAndOutput { public static void main(String args[])throws Exception{ File f=new File("d:\\filetest\\file.txt"); //创建文件对象f //获取文件对象f的输入流对象fis FileInputStream fis=new FileInputStream(f); char ch; for(int i=0;i ##④FileOutputStream类的构造函数
public FileOutputStream(String name)
按照指定字符串创建的目标，创建一个输出流对象。若文件不存在则创建它。若文件存在则覆盖它public FileOutputStream(File file)
使用指定的文件对象创建输出流对象public FileOutputStream(String name,boolean append)
按照指定字符串创建的目标，创建一个输出流对象。若文件存在且append为真，新写入的数据将追加在原数据之后。若append为假，新数据将覆盖原来的数据public FileOutputStream(File file,boolean append)
使用指定的文件对象创建输出流对象。若文件存在且append为真，新写入的数据将追加在原数据之后例：
import java.io.*; //导入包public class InputAndOutput { public static void main(String args[])throws Exception{ File f=new File("d:\\filetest\\file.txt"); //创建文件对象f //创建一个文件输出流对象fos FileOutputStream fos=new FileOutputStream(f); for(int i='a';i<='z';i++){ //通过循环语句向f中写数据 fos.write(i); } fos.close(); //关闭输出流 } } 综合例：
import java.io.*; //导入包public class InputAndOutput { public static void main(String args[])throws Exception{ //创建文件类对象f和f1 File f=new File("d:\\filetest\\file.txt"); File f1=new File("d:\\filetest\\file2.txt"); //创建文件输出流对象fos和文件输入流对象fis FileInputStream fis=new FileInputStream(f); FileOutputStream fos=new FileOutputStream(f1); //创建字节数组对象b byte[]b=new byte[(int)f.length()]; fis.read(b);//使用字节数组将f中的数据读出 for(int i=0;i 在JAVA中，有时候需要一行一行地读取数据，有时候需读取特定格式的数据。
因此JAVA提供了一种机制，能够用数据流做连接，让原本没有特殊访问方法的流，经过接到特殊的流后，变得可以用特定方法来访问数据。这就是所谓的Filter机制，这是一个非常有用的类，它能够进行多字节数据的读取。Filter流对象被分为FilterInputStream和FilterOutputStream两个流类。数据的数据类型可以是字节、字符、整型、浮点型等。先通过FilterInputStream类读取数据，然后通过FilterInputStream类对数据进行组合，最后再输出数据。
例：
import java.io.*; //导入包public class InputAndOutput { public static void main(String args[])throws Exception{ //创建文件类对象f File f=new File("d:\\filetest\\file.txt"); //创建文件输入流对象fis FileInputStream fis=new FileInputStream(f); //创建一个过滤输入流对象filter FilterInputStream filter=new FilterInputStream(fis); for(int i=0;i 数据的数据类型可以是字节、字符、整型、浮点型等。先通过FilterOutputStream类，将所有这些类型的数据分解成字节类型的数据，再将字节类型的数据通过FileOutputStream类，向目标对象输出数据。
例：
import java.io.*; //导入包public class InputAndOutput { public static void main(String args[])throws Exception{ //创建文件类对象f File f=new File("d:\\filetest\\file.txt"); //创建文件输出流对象fos FileOutputStream fos=new FileOutputStream(f); //创建一个过滤输出流对象filter FilterOutputStream filter=new FilterOutputStream(fos); for(int i='a';i<='z';i++){ //通过循环语句向f中写数据 filter.write(i); } fos.close(); //关闭输出流 } } //FilterOutputStream类不像使用FileOutputStream类那样，必须用字节数组来存储数据。FilterOutputStream类可以直接处理除字节以外的数据。
其实FilterInputStream和FilterOutputStream类同样很难处理整型，字符串型等数据，因为它们都继承InputStream和OutputStream，并且这两个子类中，没有新的方法函数，只有一些简单的write()和read()方法。这些方法不能处理整型、字符串型等数据。为了解决这个问题，出现了DataInput和DataOutput接口，同时DataInputStream类和DataOutputStream类分别实现了以上两个接口，并继承了FilterInputStream和FilterOutputStream类。
boolean writeBoolean(boolean v); byte writeByte(byte v); char writeChar(char v); short writeShort(short v); int writeInt(int v); long writeLong(long v); float writeFloat(float v); double writeDouble(double v); String writeUTF(String str);
例：
import java.io.*; //导入包public class InputAndOutput { public static void main(String args[])throws Exception{ String st; //关于字符串对象st //创建文件类对象f File f=new File("d:\\filetest\\1.dat"); //创建文件输出流对象fos FileOutputStream fos=new FileOutputStream(f); //创建一个多字节输出流对象dos DataOutputStream dos=new DataOutputStream(fos); //使用dos对象将数据写入到f中 try{ dos.writeUTF("明天要下雨了。"); dos.writeUTF("明天要下雨了。"); dos.writeUTF("明天要下雨了。"); dos.writeUTF("明天要下雨了。"); }catch(Exception e){ } dos.close(); //关闭输入流 } } boolean readBoolean();
byte readByte(); char readChar(); short readShort(); int readInt(); long readLong(); float readFloat(); double readDouble(); String readUTF();例：
import java.io.*; //导入包public class InputAndOutput { public static void main(String args[])throws Exception{ //创建文件类对象f File f=new File("d:\\filetest\\1.dat"); //创建文件输入流对象fis FileInputStream fis=new FileInputStream(f); //创建一个多字节输入流对象dis DataInputStream dis=new DataInputStream(fis); //使用dis对象将数据从f中读取 try{ System.out.println(dis.readUTF()); }catch(Exception e){ } dis.close(); //关闭输入流 } } 综合例：
import java.io.*; //导入包public class InputAndOutput { public void read(DataInputStream dis){ //在类中创建以下参数 String name=" "; int age=0; float maths=0; try{ //在read方法中，以多字节输入流对象作为参数，并且利用 //此对象读取数据 name=dis.readUTF(); age=dis.readInt(); maths=dis.readFloat(); }catch(Exception e){ } //输出相应的值 System.out.println("姓名："+name); System.out.println("年龄："+age); System.out.println("数学成绩："+maths); } //在write方法中，以多字节输出流对象作为参数，并且利用此对象写入数据 public void write(String name,int age,float maths,DataOutputStream dos){ try{ dos.writeUTF(name); dos.writeInt(age); dos.writeFloat(maths); }catch(Exception e){ } } public static void main(String args[])throws Exception{ InputAndOutput f2=new InputAndOutput(); //创建文件类对象f File f=new File("d:\\filetest\\1.dat"); //创建文件输入流对象fis FileInputStream fis=new FileInputStream(f); //创建数据输入流对象dis DataInputStream dis=new DataInputStream(fis); //创建文件输出流对象fos FileOutputStream fos=new FileOutputStream(f); //创建数据输出流对象dos DataOutputStream dos=new DataOutputStream(fos); //在文件类对象中写入内容并将其内容读出来 f2.write("王鹏",18,87,dos); f2.read(dis); f2.write("松江",17,90,dos); f2.read(dis); dos.close(); //关闭输出流 dis.close(); //关闭输入流 }} 前面的处理数据的方式，都以字节为单位，只不过通过不同的流组合成其他类型数据而已。真正要处理的还得是字符流。也就是说，以字节为单位处理数据的流，称为字节流。可以一次性处理两个字节的流，称为字符流。字符流分为两个类：Reader类和Writer类。Reader类负责字符输入工作，Writer类负责字符输出工作。
这个类是抽象类，其中的方法没有被实现，所以无法使用，且无法创建对象。可以使用其子类来覆盖其抽象方法，从而创建对象。
常用方法： public int read()：自输入流读取一个字符，并以int类型返回。 如无数据可读，返回-1.public int read(char cbuf[])：自输入流读取cbuf这个数组长度的字符，并且存储在这个数组中。如无数据可读，返回-1.
这个类是抽象类，其中的方法没有被实现，所以无法使用，且无法创建对象。可以使用其子类来覆盖其抽象方法，从而创建对象。
常用方法： public int write(int c)：将字符c写入输出流。public int read(char cbuf[])：将字符数组中的字符写到输入流
public void write(String str)：将字符串str写入输出流。
正因为Reader是抽象类，所以出现了非抽象类：InputStreamReader和BufferedReader
例：
import java.io.*; //导入包public class InputAndOutput { public static void main(String args[])throws Exception{ //创建文件类对象f File f=new File("d:\\filetest","2.txt"); //创建输入流对象fis FileInputStream fis=new FileInputStream(f); //创建字符输入流对象isr InputStreamReader isr=new InputStreamReader(fis); //创建带缓冲的输入流对象，利用此对象读取一行数据 BufferedReader br=new BufferedReader(isr); //输出读取到的内容 System.out.println(br.readLine()); System.out.println(br.readLine()); /* 这是读取2.txt中的内容，需要自己建立。 * BufferedReader类是继承Reader类的子类，其在内部带有缓冲机制，所以可以以行为单位进行输入。 * 常用方法：public String readLine(); * 它每一次读取一行数据。 */ } } 正因为Writer是抽象类，所以出现了非抽象类：OutputStreamWriter和BufferedWriter
例：
import java.io.*; //导入包public class InputAndOutput { public static void main(String args[])throws Exception{ //创建文件类对象f File f=new File("d:\\filetest","2.txt"); //创建输出流对象fos FileOutputStream fos=new FileOutputStream(f); //创建字符输出流对象osw OutputStreamWriter osw=new OutputStreamWriter(fos); //创建带缓冲的输出流对象，利用此对象读取一行数据 BufferedWriter bw=new BufferedWriter(osw); //输出相应内容和空格 bw.write("小王是一个好学生"); bw.newLine(); bw.write("他也是一个好学生。"); bw.newLine(); bw.close(); //关闭输出流对象 /* 这是向2.txt中书写内容，需要自己建立txt。 * BufferedWriter类是继承Writer类的子类，其在内部带有 * 缓冲机制，所以它可以以行为单位进行输入。 * 常用方法：public void newLine()：向输出流中写入一个行结束 * 标记。 * public void flush()：将缓冲区内的数据强制写入 * 输出流。 * public void write(String str)： * 将字符串写入到输出流中。 */ }} 例：
import java.io.*; //导入包public class InputAndOutput { public static void main(String args[])throws Exception{ //创建一个多字节输入流对象isr InputStreamReader isr=new InputStreamReader(System.in); //创建带缓冲的输入流对象br BufferedReader br=new BufferedReader(isr); System.out.println(br.readLine()); br.close(); //关闭对象br }} 所谓的随机文件访问，就是指可以读写任意位置数据的文件。通过移动文件指针，来达到随机访问的目的。这个类实现了DataInput和DataOutput接口，所以可以读取基本数据类型的数据。为了能够随机访问，必须先创建对象。
它的构造函数：
public RandomAccessFile(String name,String mode) public RandomAccessFile(File file,String mode) //使用给定的字符串或文件对象和存取模式创建一个RandomAccessFile类对象对于RamdomAccessFile类的存取模式，总共有4种：分别是"r",“rw”,“rws”,“rwd”。"r"代表以只读方式打开文件，若此时进行写操作会出错。“rw”,“rws”,"rwd"是以读写模式打开文件，若文件不存在，则创建它。创建完对象后，就要使用它的方法来操作数据：
public native void seek(long pos):将文件位置指针移动到pos处
public native long length():获取文件大小，以字节为单位 public native long getFilePointer():取到文件位置指针 readBoolean(),readByte(),readChar(),readShort()…: 读取不同类型的数据 write(int b),writeBoolean(boolean v),writeByte(byte v)…: 将不同类型的数据输出到文件例：
import java.io.*; //导入包public class InputAndOutput { public static void main(String args[])throws Exception{ //创建一个文件类对象 f File f=new File("d://raf.txt"); //创建一个随机访问类对象raf RandomAccessFile raf=new RandomAccessFile(f,"rw"); RandomAccessFile raf1=new RandomAccessFile(f,"rw"); //创建各种变量 int x=4; char c='a'; String str="这些都是基本数据类型的数据"; //利用raf写入不同数据类型的数据到f中 raf.writeInt(x); raf.writeChar(c); raf.writeUTF(str); //利用raf读取不同的数据类型的数据 System.out.println(raf1.readInt()); System.out.println(raf1.readChar()); System.out.println(raf1.readUTF()); //关闭对象raf raf.close(); raf1.close(); }} 例：
import java.io.*; //导入包public class InputAndOutput { public static void main(String args[])throws Exception{ //创建一个文件类对象 f File f=new File("d://raf.txt"); //创建一个随机访问类对象raf RandomAccessFile raf=new RandomAccessFile(f,"rw"); //创建字符串对象 String s="这个就是学校最好的学生"; System.out.println("现在要添加数据了！"); //让raf的指针指向内部数据的末端 try{ long l=raf.length(); raf.seek(l); raf.writeUTF(s); System.out.println("刚刚加到后面的字符串是："); raf.seek(l); System.out.println(raf.readUTF()); raf.seek(0); System.out.println(raf.readUTF()); raf.close(); }catch(Exception e){ } }} 注：
1、字节流与字符流的主要区别： 字节流是最基本的，所有的InputStream和OutputStream的子类都是字节流，其主要用于处理二进制数据，并按字节来处理。实际开发中很多的数据都是文本，这就提出了字符流的概念，它按虚拟机的encode来处理，也就是要进行字符集的转化。这两者之间通过InputStreamReader和OutputStreamWriter来关联。实际上，通过byte[]和String来关联 在实际开发中出现的汉字问题，这都是在字符流和字节流之间转化不统一 而造成的。在从字节流转化为字符流时，实际上就是byte[]转化为String转载地址：http://wxyki.baihongyu.com/