Java 输入输出流及文件读写详解
I/O类体系
在JDK API中，基础的IO类都位于java.io包，而新实现的IO类则位于一系列以java.nio开头的包名中，这里首先介绍java.io包中类的体系结构。
按照前面的说明，流是有方向的，则整个流的结构按照流的方向可以划分为两类：
1、输入流：
该类流将外部数据源的数据转换为流，程序通过读取该类流中的数据，完成对于外部数据源中数据的读入。
2、输出流：
该类流完成将流中的数据转换到对应的数据源中，程序通过向该类流中写入数据，完成将数据写入到对应的外部数据源中。
而在实际实现时，由于JDK API历史的原因，在java.io包中又实现了两类流：字节流(byte stream)和字符流(char stream)。这两种流实现的是流中数据序列的单位，在字节流中，数据序列以byte为单位，也就是流中的数据按照一个byte一个byte的顺序实现成流，对于该类流操作的基本单位是一个byte，而对于字节流，数据序列以char为单位，也就是流中的数据按照一个char一个插入的顺序实现成流，对于该类流操作的基本单位是一个char。
另外字节流是从JDK1.0开始加入到API中的，而字符流则是从JDK1.1开始才加入到API中的，对于现在使用的JDK版本来说，这两类流都包含在API的内部。在实际使用时，字符流的效率要比字节流高一些。
在实际使用时，字符流中的类基本上和字节流中的类对应，所以在开始学习IO类时，可以从最基础的字节流开始学习。
在SUN设计JDK的IO类时，按照以上的分类，为每个系列的类设计了一个父类，而实现具体操作的类都作为该系列类的子类，则IO类设计时的四个体系中每个体系中对应的父类分别是：
字节输入流InputStream
该类是IO编程中所有字节输入流的父类，熟悉该类的使用将对使用字节输入流产生很大的帮助，下面做一下详细的介绍。
按照前面介绍的流的概念，字节输入流完成的是按照字节形式构造读取数据的输入流的结构，每个该类的对象就是一个实际的输入流，在构造时由API完成将外部数据源转换为流对象的操作，这种转换对程序员来说是透明的。在程序使用时，程序员只需要读取该流对象，就可以完成对于外部数据的读取了。
InputStream是所有字节输入流的父类，所以在InputStream类中包含的每个方法都会被所有字节输入流类继承，通过将读取以及操作数据的基本方法都声明在InputStream类内部，使每个子类根据需要覆盖对应的方法，这样的设计可以保证每个字节输入流子类在进行实际使用时，开放给程序员使用的功能方法是一致的。这样将简化IO类学习的难度，方便程序员进行实际的编程。
默认情况下，对于输入流内部数据的读取都是单向的，也就是只能从输入流从前向后读，已经读取的数据将从输入流内部删除掉。如果需要重复读取流中同一段内容，则需要使用流类中的mark方法进行标记，然后才能重复读取。这种设计在使用流类时，需要深刻进行体会。
在InputStream类中，常见的方法有：
a、available方法
public int available() throws IOException
该方法的作用是返回当前流对象中还没有被读取的字节数量。
也就是获得流中数据的长度。
假设初始情况下流内部包含100个字节的数据，程序调用对应的方法读取了一个字节，则当前流中剩余的字节数量将变成99个。
另外，该方法不是在所有字节输入流内部都得到正确的实现，所以使用该方法获得流中数据的个数是不可靠的。
b、close方法
public void close() throws IOException
该方法的作用是关闭当前流对象，并释放该流对象占用的资源。
在IO操作结束以后，关闭流是进行IO操作时都需要实现的功能，这样既可以保证数据源的安全，也可以减少内存的占用。
c、markSupported方法
public boolean markSupported()
该方法的作用是判断流是否支持标记(mark)。标记类似于读书时的书签，可以很方便的回到原来读过的位置继续向下读取。
d、reset方法
public void reset() throws IOException
该方法的作用是使流读取的位置回到设定标记的位置。可以从该位置开始继续向后读取。
e、mark方法
public void mark(int readlimit)
为流中当前的位置设置标志，使得以后可以从该位置继续读取。
变量readlimit指设置该标志以后可以读取的流中最大数据的个数。
当设置标志以后，读取的字节数量超过该限制，则标志会失效。
f、read方法
read方法是输入流类使用时最核心的方法，能够熟练使用该方法就代表IO基本使用已经入门。所以在学习以及后期的使用中都
需要深刻理解该方法的使用。
在实际读取流中的数据时，只能按照流中的数据存储顺序依次进行读取，在使用字节输入流时，读取数据的最小单位是字节(byte)。
另外，需要注意的是，read方法是阻塞方法，也就是如果流对象中无数据可以读取时，则read方法会阻止程序继续向下运行，
一直到有数据可以读取为止。
read方法总计有三个，依次是：
public abstract int read() throws IOException
该方法的作用是读取当前流对象中的第一个字节。当该字节被读取出来以后，则该字节将被从流对象中删除，原来流对
象中的第二个字节将变成流中的第一个字节，而使用流对象的
available方法获得的数值也将减少1。如果需要读取流中的所
以数据，只要使用一个循环依次读取每个数据即可。当读取到
流的末尾时，该方法返回-1。该返回值的int中只有最后一个
字节是流中的有效数据，所以在获得流中的数值时需要进行强
制转换。返回值作成int的目的主要是处理好-1的问题。
由于该方法是抽象的，所以会在子类中被覆盖，从而实现最基础的读数据的功能。
public int read(byte[] b) throws IOException
该方法的作用是读取当前流对象中的数据，并将读取到的数据依次存储到数组b(b需要提前初始化完成)中，也就是把当
前流中的第一个字节的数据存储到b[0]，第二个字节的数据存
储到b[1]，依次类推。流中已经读取过的数据也会被删除，后
续的数据会变成流中的第一个字节。而实际读取的字节数量则
作为方法的返回值返回。
public int read(byte[] b, int off, int len) throws IOException 该方法的作用和上面的方法类似，也是将读取的数据存储到b中，只是将流中的第一个数据存储到b中下标为off的位
置，最多读取len个数据，而实际读取的字节数量则作为方法
的返回值返回。
g、skip方法
public long skip(long n) throws IOException
该方法的作用是跳过当前流对象中的n个字节，而实际跳过的字节数量则以返回值的方式返回。
跳过n个字节以后，如果需要读取则是从新的位置开始读取了。
使用该方法可以跳过流中指定的字节数，而不用依次进行读取了。
从流中读取出数据以后，获得的是一个byte数组，还需要根据以前的数据格式，实现对于该byte数组的解析。
由于InputStream类是字节输入流的父类，所以该体系中的每个子类都包含以上的方法，这些方法是实现IO流数据读取的基础。
字节输出流OutputStream
该类是所有的字节输出流的父类，在实际使用时，一般使用该类的子类进行编程，但是该类内部的方法是实现字节输出流的基础。
该体系中的类完成把对应的数据写入到数据源中，在写数据时，进行的操作分两步实现：第一步，将需要输出的数据写入流对象中，数据的格式由程序员进行设定，该步骤需要编写代码实现；第二步，将流中的数据输出到数据源中，该步骤由API实现，程序员不需要了解内部实现的细节，只需要构造对应的流对象即可。
在实际写入流时，流内部会保留一个缓冲区，会将程序员写入流对象的数据首先暂存起来，然后在缓冲区满时将数据输出到数据源。当然，当流关闭时，输出流内部的数据会被强制输出。
字节输出流中数据的单位是字节，在将数据写入流时，一般情况下需要将数据转换为字节数组进行写入。
在OutputStream中，常见的方法有：
a、close方法
public void close() throws IOException
该方法的作用是关闭流，释放流占用的资源。
b、flush方法
public void flush() throws IOException
该方法的作用是将当前流对象中的缓冲数据强制输出出去。使用该方法可以实现立即输出。
c、write方法
write方法是输出流中的核心方法，该方法实现将数据写入流中。在实际写入前，需要实现对应的格式，然后依次写入到流中。
写入流的顺序就是实际数据输出的顺序。
write方法总计有3个，依次是：
public abstract void write(int b) throws IOException
该方法的作用是向流的末尾写入一个字节的数据。写入的数据为参数b的最后一个字节。在实际向流中写数据时需要按
照逻辑的顺序进行写入。该方法在OutputStream的子类内部进
行实现。
public void write(byte[] b) throws IOException
该方法的作用是将数组b中的数据依次写入当前的流对象中。
public void write(byte[] b, int off, int len) throws
IOException
该方法的作用是将数组b中从下标为off(包含)开始，后续长度为len个的数据依次写入到流对象中。
在实际写入时，还需要根据逻辑的需要设定byte数值的格式，这个根据不同的需要实现不同的格式。
字符输入流Reader
字符输入流体系是对字节输入流体系的升级，在子类的功能上基本和字节输入流体系中的子类一一对应，但是由于字符输入流内部设计方式的不同，使得字符输入流的执行效率要比字节输入流体系高一些，在遇到类似功能的类时，可以优先选择使用字符输入流体系中的类，从而提高程序的执行效率。
Reader体系中的类和InputStream体系中的类，在功能上是一致的，最大的区别就是Reader体系中的类读取数据的单位是字符(char)，也就是每次最少读入一个字符(两个字节)的数据，在Reader体系中的读数据的方法都以字符作为最基本的单位。
Reader类和InputStream类中的很多方法，无论声明还是功能都是一样的，但是也增加了两个方法,依次介绍如下：
a、read方法
public int read(CharBuffer target) throws IOException
该方法的作用是将流内部的数据依次读入CharBuffer对象中，实际读入的char个数作为返回值返回。
b、ready方法
public boolean ready() throws IOException
该方法的作用是返回当前流对象是否准备完成，也就是流内部是否包含可以被读取的数据。
其它和InputStream类一样的方法可以参看上面的介绍。
字符输出流Writer
字符输出流体系是对字节输出流体系的升级，在子类的功能实现上基本上和字节输出流保持一一对应。但由于该体系中的类设计的比较晚，所以该体系中的类执行的效率要比字节输出流中对应的类效率高一些。在遇到类似功能的类时，可以优先选择使用该体系中的类进行使用，从而提高程序的执行效率。
Writer体系中的类和OutputStream体系中的类，在功能上是一致的，最大的区别就是Writer体系中的类写入数据的单位是字符(char)，也就是每次最少写入一个字符(两个字节)的数据，在Writer体系中的写数据的方法都以字符作为最基本的操作单位。
Writer类和OutputStream类中的很多方法，无论声明还是功能都是一样的，但是还是增加了一些方法，依次介绍如下：
a、append方法
将数据写入流的末尾。总计有3个方法，依次是：
public Writer append(char c) throws IOException
该方法的作用和write(int c)的作用完全一样，既将字符c写入流的末尾。
public Writer append(CharSequence csq) throws IOException
该方法的作用是将CharSequence对象csq写入流的末尾，在写入时会调用csq的toString方法将该对象转换为字符串，
然后再将该字符串写入流的末尾。
public Writer append(CharSequence csq, int start, int end)
throws IOException
该方法的作用和上面的方法类似，只是将转换后字符串从索引值为start(包含)到索引值为end(不包含)的部分写入流中。
b、write方法
除了基本的write方法以外，在Writer类中又新增了两个，依次是：
public void write(String str) throws IOException
该方法的作用是将字符串str写入流中。写入时首先将str 使用getChars方法转换成对应的char数组，然后实现依次写入
流的末尾。
public void write(String str, int off, int len)
throws IOException
该方法的作用是将字符串str中索引值为off(包含)开始，后续长度为len个字符写入到流的末尾。
使用这两个方法将更方便将字符串写入流的末尾。
其它和OutputStream类一样的方法可以参看上面的介绍。
小结
在实际使用IO类时，根据逻辑上的需要，挑选对应体系中的类进行实际的使用，从而实现程序中IO的相关功能。
熟悉了IO类的体系以后，就可以首先熟悉基本的IO类的使用，然后再按照IO类体系中相关类的使用方式逐步去了解相关的IO类的使用，从而逐步熟悉java.io包中类的使用，然后再掌握IO编程。
在实际使用时，一般都使用这4个类中对应的子类，每个子类完成相关的功能。对于这些子类，也可以根据这些类是否直接连接数据源，将这些IO类分类为：
1、实体流
指直接连接数据源的IO流类
2、装饰流
指不直接连接数据源，而是建立在其它实体流对象的基础之上。
下面IO类的使用中将分别介绍这些体系中的类。在实际使用时也应该根据流属于实体流还是装饰流进行不同的使用。
I/O类使用
由于在IO操作中，需要使用的数据源有很多，作为一个IO技术的初学者，从读写文件开始学习IO技术是一个比较好的选择。因为文件是一种常见的数据源，而且读写文件也是程序员进行IO编程的一个基本能力。本章IO类的使用就从读写文件开始。
文件操作
文件(File)是最常见的数据源之一，在程序中经常需要将数据存储到文件中，例如图片文件、声音文件等数据文件，也经常需要根据需要从指定的文件中进行数据的读取。当然，在实际使用时，文件都包含一个的格式，这个格式需要程序员根据需要进行设计，读取已有的文件时也需要熟悉对应的文件格式，才能把数据从文件中正确的读取出来。
文件的存储介质有很多，例如硬盘、光盘和U盘等，由于IO类设计时，从数据源转换为流对象的操作由API实现了，所以存储介质的不同对于程序员来说是透明的，和实际编写代码无关。
文件的概念
文件是计算机中一种基本的数据存储形式，在实际存储数据时，如果对于数据的读写速度要求不是很高，存储的数据量不是很大时，使用文件作为一种持久数据存储的方式是比较好的选择。
存储在文件内部的数据和内存中的数据不同，存储在文件中的数据是一种“持久存储”，也就是当程序退出或计算机关机以后，数据还是存在的，而内存内部的数据在程序退出或计算机关机以后，数据就丢失了。
在不同的存储介质中，文件中的数据都是以一定的顺序依次存储起来，在实际读取时由硬件以及操作系统完成对于数据的控制，保证程序读取到的数据和存储的顺序保持一致。
每个文件以一个文件路径和文件名称进行表示，在需要访问该文件的时，只需要知道该文件的路径以及文件的全名即可。在不同的操作系统环境下，文件路径的表示形式是不一样的，例如在Windows操作系统中一般的表示形式为C:/windows/system，而Unix上的表示形式为/user/my。所以如果需要让Java程序能够在不同的操作系统下运行，书写文件路径时还需要比较注意。
绝对路径和相对路径
绝对路径是指书写文件的完整路径，例如d:/java/Hello.java，该路径中包含文件的完整路径d:/java以及文件的全名Hello.java。使用该路径可以唯一的找到一个文件，不会产生歧义。但是使用绝对路径在表示文件时，受到的限制很大，且不能在不同的操作系统下运行，因为不同操作系统下绝对路径的表达形式存在不同。
相对路径是指书写文件的部分路径，例如/test/Hello.java，该路径中只包含文件的部分路径/test和文件的全名Hello.java，部分路径是指当前路径下的子路径，例如当前程序在d:/abc下运行，则该文件的完整路径就是d:/abc/test。使用这种形式，可以更加通用的代表文件的位置，使得文件路径产生一定的灵活性。
在Eclipse项目中运行程序时，当前路径是项目的根目录，例如工作空间存储在
d:/javaproject，当前项目名称是Test，则当前路径是：d:/javaproject/Test。在控制台下面运行程序时，当前路径是class文件所在的目录，如果class文件包含包名，则以该class文件最顶层的包名作为当前路径。
另外在Java语言的代码内部书写文件路径时，需要注意大小写，大小写需要保持一致，路径中的文件夹名称区分大小写。由于’/’是Java语言中的特殊字符，所以在代码内部书写文件路径时，例如代表“c:/test/java/Hello.java”时，需要书写成“c://test//java//Hello.java”或“c:/test/java/Hello.java”，这些都需要在代码中注意。
文件名称
文件名称一般采用“文件名.后缀名”的形式进行命名，其中“文件名”用来表示文件的作用，而使用后缀名来表示文件的类型，这是当前操作系统中常见的一种形式，例如“readme.txt”文件，其中readme代表该文件时说明文件，而txt后缀名代表文件时文本文件类型，在操作系统中，还会自动将特定格式的后缀名和对应的程序关联，在双击该文件时使用特定的程序打开。
其实在文件名称只是一个标示，和实际存储的文件内容没有必然的联系，只是使用这种方式方便文件的使用。在程序中需要存储数据时，如果自己设计了特定的文件格式，则可以自定义文件的后缀名，来标示自己的文件类型。
和文件路径一样，在Java代码内部书写文件名称时也区分大小写，文件名称的大小写必须和操作系统中的大小写保持一致。
另外，在书写文件名称时不要忘记书写文件的后缀名。
File类
为了很方便的代表文件的概念，以及存储一些对于文件的基本操作，在java.io包中设计了一个专门的类——File类。
在File类中包含了大部分和文件操作的功能方法，该类的对象可以代表一个具体的文件或文件夹，所以以前曾有人建议将该类的类名修改成FilePath，因为该类也可以代表一个文件夹，更准确的说是可以代表一个文件路径。
下面介绍一下File类的基本使用。
1、File对象代表文件路径
File类的对象可以代表一个具体的文件路径，在实际代表时，可以使用绝对路径也可以使用相对路径。
下面是创建的文件对象示例。
public File(String pathname)
该示例中使用一个文件路径表示一个File类的对象，例如：
File f1 = new File(“d://test//1.txt”);
File f2 = new File(“1.txt”);
File f3 = new File(“e://abc”);
这里的f1和f2对象分别代表一个文件，f1是绝对路径，而f2是相对路径，f3则代表一个文件夹，文件夹也是文件路径的一种。
public File(String parent, String child)
也可以使用父路径和子路径结合，实现代表文件路径，例如：
File f4 = new File(“d://test//”,”1.txt”);
这样代表的文件路径是：d:/test/1.txt。
2、File类常用方法
File类中包含了很多获得文件或文件夹属性的方法，使用起来比较方便，下面将常见的方法介绍如下：
a、createNewFile方法
public boolean createNewFile() throws IOException
该方法的作用是创建指定的文件。该方法只能用于创建文件，不能用于创建文件夹，且文件路径中包含的文件夹必须存在。
b、delect方法
public boolean delete()
该方法的作用是删除当前文件或文件夹。如果删除的是文件夹，则该文件夹必须为空。如果需要删除一个非空的文件夹，则需要首先删除该文件夹内部的每个文件和文件夹，然后在可以删除，这个需要书写一定的逻辑代码实现。
c、exists方法
public boolean exists()
该方法的作用是判断当前文件或文件夹是否存在。
d、getAbsolutePath方法
public String getAbsolutePath()
该方法的作用是获得当前文件或文件夹的绝对路径。例如c:/test/1.t则返回c:/test/1.t。
e、getName方法
public String getName()
该方法的作用是获得当前文件或文件夹的名称。例如c:/test/1.t，则返回1.t。
f、getParent方法
public String getParent()
该方法的作用是获得当前路径中的父路径。例如c:/test/1.t则返回c:/test。
g、isDirectory方法
public boolean isDirectory()
该方法的作用是判断当前File对象是否是目录。
h、isFile方法
public boolean isFile()
该方法的作用是判断当前File对象是否是文件。
i、length方法
public long length()
该方法的作用是返回文件存储时占用的字节数。该数值获得的是文件的实际大小，而不是文件在存储时占用的空间数。
j、list方法
public String[] list()
该方法的作用是返回当前文件夹下所有的文件名和文件夹名称。说明，该名称不是绝对路径。
k、listFiles方法
public File[] listFiles()
该方法的作用是返回当前文件夹下所有的文件对象。
l、mkdir方法
public boolean mkdir()
该方法的作用是创建当前文件文件夹，而不创建该路径中的其它文件夹。假设d盘下只有一个test文件夹，则创建d:/test/abc文件夹则成功，如果创建d:/a/b文件夹则创建失败，因为该路径中d:/a文件夹不存在。如果创建成功则返回true，否则返回false。
m、mkdirs方法
public boolean mkdirs()
该方法的作用是创建文件夹，如果当前路径中包含的父目录不存在时，也会自动根据需要创建。
n、renameTo方法
public boolean renameTo(File dest)
该方法的作用是修改文件名。在修改文件名时不能改变文件路径，如果该路径下已有该文件，则会修改失败。
o、setReadOnly方法
public boolean setReadOnly()
该方法的作用是设置当前文件或文件夹为只读。
3、File类基本示例
以上各方法实现的测试代码如下：
import java.io.File;
/**
* File类使用示例
*/
public class FileDemo {
public static void main(String[] args) {
//创建File对象
File f1 = new File("d://test");
File f2 = new File("1.txt");
File f3 = new File("e://file.txt");
File f4 = new File("d://","1.txt");
//创建文件
try{
boolean b = f3.createNewFile();
}catch(Exception e){
e.printStackTrace();
}
//判断文件是否存在
System.out.println(f4.exists());
//获得文件的绝对路径
System.out.println(f3.getAbsolutePath());
//获得文件名
System.out.println(f3.getName());
//获得父路径
System.out.println(f3.getParent());
//判断是否是目录
System.out.println(f1.isDirectory());
//判断是否是文件
System.out.println(f3.isFile());
//获得文件长度
System.out.println(f3.length());
//获得当前文件夹下所有文件和文件夹名称
String[] s = f1.list();
for(int i = 0;i < s.length;i++){
System.out.println(s[i]);
}
//获得文件对象
File[] f5 = f1.listFiles();
for(int i = 0;i < f5.length;i++){
System.out.println(f5[i]);
}
//创建文件夹
File f6 = new File("e://test//abc");
boolean b1 = f6.mkdir();
System.out.println(b1);
b1 = f6.mkdirs();
System.out.println(b1);
//修改文件名
File f7 = new File("e://a.txt");
boolean b2 = f3.renameTo(f7);
System.out.println(b2);
//设置文件为只读
f7.setReadOnly();
}
}
4、File类综合示例
下面以两个示例演示File类的综合使用。第一个示例是显示某个文件夹下的所有文件和文件夹，原理是输出当前名称，然后判断当前File对象是文件还是文件夹，如果则获得该文件夹下的所有子文件和子文件夹，并递归调用该方法实现。第二个示例是删除某个文件夹下的所有文件和文件夹，原理是判断是否是文件，如果是文件则直接删除，如果是文件夹，则获得该文件夹下所有的子文件和子文件夹，然后递归调用该方法处理所有子文件和子文件夹，然后将空文件夹删除。则测试时谨慎使用第二个方法，以免删除自己有用的数据文件。示例代码如下：
import java.io.File;
/**
* 文件综合使用示例
*/
public class AdvanceFileDemo {
public static void main(String[] args) {
File f = new File("e://Book");
printAllFile(f);
File f1 = new File("e://test");
deleteAll(f1);
}
/**
* 打印f路径下所有的文件和文件夹
* @param f 文件对象
*/
public static void printAllFile(File f){
//打印当前文件名
System.out.println(f.getName());
//是否是文件夹
if(f.isDirectory()){
//获得该文件夹下所有子文件和子文件夹
File[] f1 = f.listFiles();
//循环处理每个对象
int len = f1.length;
for(int i = 0;i < len;i++){
//递归调用，处理每个文件对象
printAllFile(f1[i]);
}
}
}
/**
* 删除对象f下的所有文件和文件夹
* @param f 文件路径
*/
public static void deleteAll(File f){
//文件
if(f.isFile()){
f.delete();
}else{ //文件夹
//获得当前文件夹下的所有子文件和子文件夹
File f1[] = f.listFiles();
//循环处理每个对象
int len = f1.length;
for(int i = 0;i < len;i++){
//递归调用，处理每个文件对象
deleteAll(f1[i]);
}
//删除当前文件夹
f.delete();
}
}
}
关于File类的使用就介绍这么多，其它的方法和使用时需要注意的问题还需要多进行练习和实际使用。
读取文件
虽然前面介绍了流的概念，但是这个概念对于初学者来说，还是比较抽象的，下面以实际的读取文件为例子，介绍流的概念，以及输入流的基本使用。
按照前面介绍的知识，将文件中的数据读入程序，是将程序外部的数据传入程序中，应该使用输入流——InputStream或Reader。而由于读取的是特定的数据源——文件，则可以使用输入对应的子类FileInputStream或FileReader实现。
在实际书写代码时，需要首先熟悉读取文件在程序中实现的过程。在Java语言的IO编程中，读取文件是分两个步骤：1、将文件中的数据转换为流，2、读取流内部的数据。其中第一个步骤由系统完成，只需要创建对应的流对象即可，对象创建完成以后步骤1就完成了，第二个步骤使用输入流对象中的read方法即可实现了。
使用输入流进行编程时，代码一般分为3个部分：1、创建流对象，2、读取流对象内部的数据，3、关闭流对象。下面以读取文件的代码示例：
import java.io.*;
/**
* 使用FileInputStream读取文件
*/
public class ReadFile1 {
public static void main(String[] args) {
//声明流对象
FileInputStream fis = null;
try{
//创建流对象
fis = new FileInputStream("e://a.txt");
//读取数据，并将读取到的数据存储到数组中
byte[] data = new byte[1024]; //数据存储的数组
int i = 0; //当前下标
//读取流中的第一个字节数据
int n = fis.read();
//依次读取后续的数据
while(n != -1){ //未到达流的末尾
//将有效数据存储到数组中
data[i] = (byte)n;
//下标增加
i++;
//读取下一个字节的数据
n = fis.read();
}
//解析数据
String s = new String(data,0,i);
//输出字符串
System.out.println(s);
}catch(Exception e){
e.printStackTrace();
}finally{
try{
//关闭流，释放资源
fis.close();
}catch(Exception e){}
}
}
}
在该示例代码中，首先创建一个FileInputStream类型的对象fis：
fis = new FileInputStream("e://a.txt");
这样建立了一个连接到数据源e:/a.txt的流，并将该数据源中的数据转换为流对象fis，以后程序读取数据源中的数据，只需要从流对象fis中读取即可。
读取流fis中的数据，需要使用read方法，该方法是从InputStream类中继承过来的方法，该方法的作用是每次读取流中的一个字节，如果需要读取流中的所有数据，需要使用循环读取，当到达流的末尾时，read方法的返回值是-1。
在该示例中，首先读取流中的第一个字节：
int n = fis.read();
并将读取的值赋值给int值n，如果流fis为空，则n的值是-1，否则n中的最后一个字节包含的时流fis中的第一个字节，该字节被读取以后，将被从流fis中删除。
然后循环读取流中的其它数据，如果读取到的数据不是-1，则将已经读取到的数据n强制转换为byte，即取n中的有效数据——最后一个字节，并存储到数组data中，然后调用流对象fis中的read方法继续读取流中的下一个字节的数据。一直这样循环下去，直到读取到的数据是-1，也就是读取到流的末尾则循环结束。
这里的数组长度是1024，所以要求流中的数据长度不能超过1024，所以该示例代码在这里具有一定的局限性。如果流的数据个数比较多，则可以将1024扩大到合适的个数即可。
经过上面的循环以后，就可以将流中的数据依次存储到data数组中，存储到data数组中有效数据的个数是i个，即循环次数。
其实截至到这里，IO操作中的读取数据已经完成，然后再按照数据源中的数据格式，这里是文件的格式，解析读取出的byte数组即可。
该示例代码中的解析，只是将从流对象中读取到的有效的数据，也就是data数组中的前n个数据，转换为字符串，然后进行输出。
在该示例代码中，只是在catch语句中输出异常的信息，便于代码的调试，在实际的程序中，需要根据情况进行一定的逻辑处理，例如给出提示信息等。
最后在finally语句块中，关闭流对象fis，释放流对象占用的资源，关闭数据源，实现流操作的结束工作。
上面详细介绍了读取文件的过程，其实在实际读取流数据时，还可以使用其它的read 方法，下面的示例代码是使用另外一个read方法实现读取的代码：
import java.io.FileInputStream;
/**
* 使用FileInputStream读取文件
*/
public class ReadFile2 {
public static void main(String[] args) {
//声明流对象
FileInputStream fis = null;
try{
//创建流对象
fis = new FileInputStream("e://a.txt");
//读取数据，并将读取到的数据存储到数组中
byte[] data = new byte[1024]; //数据存储的数组
int i = fis.read(data);
//解析数据
String s = new String(data,0,i);
//输出字符串
System.out.println(s);
}catch(Exception e){
e.printStackTrace();
}finally{
try{
//关闭流，释放资源
fis.close();
}catch(Exception e){}
}
}
}
该示例代码中，只使用一行代码：
int i = fis.read(data);
就实现了将流对象fis中的数据读取到字节数组data中。该行代码的作用是将fis流中的数据读取出来，并依次存储到数组data中，返回值为实际读取的有效数据的个数。
使用该中方式在进行读取时，可以简化读取的代码。
当然，在读取文件时，也可以使用Reader类的子类FileReader进行实现，在编写代码时，只需要将上面示例代码中的byte数组替换成char数组即可。
使用FileReader读取文件时，是按照char为单位进行读取的，所以更适合于文本文件的读取，而对于二进制文件或自定义格式的文件来说，还是使用FileInputStream进行读取，方便对于读取到的数据进行解析和操作。
读取其它数据源的操作和读取文件类似，最大的区别在于建立流对象时选择的类不同，而流对象一旦建立，则基本的读取方法是一样，如果只使用最基本的read方法进行读取，
则使用基本上是一致的。这也是IO类设计的初衷，使得对于流对象的操作保持一致，简化IO类使用的难度。
写文件
如前所述，将程序内部的数据输出到程序外部的数据源，应该使用IO类体系中的输出流。在实际的编程中，将程序中的数据，例如用户设定或程序运行时生成的内容，存储到外部的文件中，应该使用输出流进行编程。
基本的输出流包含OutputStream和Writer两个，区别是OutputStream体系中的类(也就是OutputStream的子类)是按照字节写入的，而Writer体系中的类(也就是Writer的子类)是按照字符写入的。
使用输出流进行编程的步骤是：
1、建立输出流
建立对应的输出流对象，也就是完成由流对象到外部数据源之间的转换。
2、向流中写入数据
将需要输出的数据，调用对应的write方法写入到流对象中。
3、关闭输出流
在写入完毕以后，调用流对象的close方法关闭输出流，释放资源。
在使用输出流向外部输出数据时，程序员只需要将数据写入流对象即可，底层的API 实现将流对象中的内容写入外部数据源，这个写入的过程对于程序员来说是透明的，不需要专门书写代码实现。
在向文件中输出数据，也就是写文件时，使用对应的文件输出流，包括FileOutputStream 和FileWriter两个类，下面以FileOutputStream为例子说明输出流的使用。示例代码如下：import java.io.*;
/**
* 使用FileOutputStream写文件示例
*/
public class WriteFile1 {
public static void main(String[] args) {
String s = "Java语言";
int n = 100;
//声明流对象
FileOutputStream fos = null;
try{
//创建流对象
fos = new FileOutputStream("e://out.txt");
//转换为byte数组
byte[] b1 = s.getBytes();
//换行符
byte[] b2 = "/r/n".getBytes();
byte[] b3 = String.valueOf(n).getBytes();
//依次写入文件
fos.write(b1);
fos.write(b2);
fos.write(b3);
} catch (Exception e) {
e.printStackTrace();
}finally{
try{
fos.close();
}catch(Exception e){}
}
}
}
该示例代码写入的文件使用记事本打开以后，内容为：
Java语言
100
在该示例代码中，演示了将一个字符串和一个int类型的值依次写入到同一个文件中。在写入文件时，首先创建了一个文件输出流对象fos：
fos = new FileOutputStream("e://out.txt");
该对象创建以后，就实现了从流到外部数据源e:/out.txt的连接。说明：当外部文件不存在时，系统会自动创建该文件，但是如果文件路径中包含未创建的目录时将出现异常。这里书写的文件路径可以是绝对路径也可以是相对路径。
在实际写入文件时，有两种写入文件的方式：覆盖和追加。其中“覆盖”是指清除原文件的内容，写入新的内容，默认采用该种形式写文件，“追加”是指在已有文件的末尾写入内容，保留原来的文件内容，例如写日志文件时，一般采用追加。在实际使用时可以根据需要采用适合的形式，可以使用：
public FileOutputStream(String name, boolean append) throws FileNotFoundException 只需要使用该构造方法在构造FileOutputStream对象时，将第二个参数append的值设
Java 输入输出流及文件读写详解
I/O类体系 在JDK API中，基础的IO类都位于java.io包，而新实现的IO类则位于一系列以java.nio开头的包名中，这里首先介绍java.io包中类的体系结构。 按照前面的说明，流是有方向的，则整个流的结构按照流的方向可以划分为两类： 1、输入流： 该类流将外部数据源的数据转换为流，程序通过读取该类流中的数据，完成对于外部数据源中数据的读入。 2、输出流： 该类流完成将流中的数据转换到对应的数据源中，程序通过向该类流中写入数据，完成将数据写入到对应的外部数据源中。 而在实际实现时，由于JDK API历史的原因，在java.io包中又实现了两类流：字节流(byte stream)和字符流(char stream)。这两种流实现的是流中数据序列的单位，在字节流中，数据序列以byte为单位，也就是流中的数据按照一个byte一个byte的顺序实现成流，对于该类流操作的基本单位是一个byte，而对于字节流，数据序列以char为单位，也就是流中的数据按照一个char一个插入的顺序实现成流，对于该类流操作的基本单位是一个char。 另外字节流是从JDK1.0开始加入到API中的，而字符流则是从JDK1.1开始才加入到API中的，对于现在使用的JDK版本来说，这两类流都包含在API的内部。在实际使用时，字符流的效率要比字节流高一些。 在实际使用时，字符流中的类基本上和字节流中的类对应，所以在开始学习IO类时，可以从最基础的字节流开始学习。 在SUN设计JDK的IO类时，按照以上的分类，为每个系列的类设计了一个父类，而实现具体操作的类都作为该系列类的子类，则IO类设计时的四个体系中每个体系中对应的父类分别是： 字节输入流InputStream 该类是IO编程中所有字节输入流的父类，熟悉该类的使用将对使用字节输入流产生很大的帮助，下面做一下详细的介绍。 按照前面介绍的流的概念，字节输入流完成的是按照字节形式构造读取数据的输入流的结构，每个该类的对象就是一个实际的输入流，在构造时由API完成将外部数据源转换为流对象的操作，这种转换对程序员来说是透明的。在程序使用时，程序员只需要读取该流对象，就可以完成对于外部数据的读取了。
实验9 Java输入输出流
山西大学计算机与信息技术学院 实验报告 姓名学号专业班级 课程名称 Java实验实验日期2013-12-4 成绩指导教师批改日期实验名称实验9 Java的输入输出流 ●实验目的 1. 理解I/O流的概念，掌握其分类 2. 掌握文本文件读写、二进制文件读写 ●实验内容 1. 分别使用FileWriter 和BufferedWriter 往文件中写入1万个随机数，比较用时的多少？(用时采用方法System.currentTimeMillis()）求时间差; 使用：FileWriter 程序源代码 package a; import java.io.*; public class Filewriter { public Filewriter(String string){ } public static void main(String[] args)throws IOException { long time =System.currentTimeMillis(); Filewriter filewriter=new Filewriter("text"); int num; for(int i=0;i<=10000;i++){ num=(int)Math.random()*10000; filewriter.write(num+" "); } filewriter.close(); time=System.currentTimeMillis()-time; System.out.println("使用Filewriter所用时间："+time+"um"); } private void write(String string){ } private void close(){ } }
JAVA输入输出流--字节流篇(什么时候用哪个)
1流的概念 stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收源。流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样，如下图： 在Java的IO中，所有的stream（包括Inputstream和Out stream）都包括两种类型： (1)字节流 表示以字节为单位从stream中读取或往stream中写入信息，即io包中的inputstream类和outputstream类的派生类。通常用来读取二进制数据，如图象和声音。 (2)字符流 以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream中写入信息。 区别： Reader和Writer要解决的，最主要的问题就是国际化。原先的I/O类库只支持8位的字节流，因此不可能很好地处理16位的Unicode字符流。Unicode是国际化的字符集(更何况Java内置的char就是16位的Unicode 字符)，这样加了Reader和Writer之后，所有的I/O就都支持Unicode了。此外新类库的性能也比旧的好。 但是，Read和Write并不是取代InputStream和OutputStream，有时，你还必须同时使用"基于byte的类"和"基于字符的类"。为此，它还提供了两个"适配器(adapter)"类。InputStreamReader负责将InputStream转化成Reader，而OutputStreamWriter则将OutputStream转化成Writer。实际上是通过byte[]和String来关联。在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的。 以字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类实现的功能相同，只是在操作时的导向不同。
第9章输入输出流与文件操作
什么是流？流有什么用？面向对象语言为什么需要流？哪些场合需要流？ 答：流是指一组有顺序、有起点和终点地字节集合，是对数据传输地总称或抽象（也就是数据在两个对象之间地传输称为流）.个人收集整理勿做商业用途 流地作用就是使数据传输操作独立于相关设备. 在面向对象地程序设计中，数据地传输和流动具有广泛性，可以在内存与外部设备之间传输，还可以从内存到内存，甚至可以从一台计算机通过网络流向另一台计算机等，故面向对象语言采用流机制.个人收集整理勿做商业用途 在标准输入输出、在文件地读写等操作中都需要流. 提供了哪些流类？各种流类之间地关系是怎样地？什么场合需要使用什么流类？ 答：中按照流地方向性，流分为输入流和输出流两大类.按照流中元素地基本类型，流分为字节流和字符流两大类.字节流类按照流地方向分为字节输入流类和字节输出流类，字符流类方向性分为字符输入流类和字符输出流类.以及文件操作类，随机存取文件类.个人收集整理勿做商业用途 其中类是所有字节输入流地根类，类是所有字节输出流地根类；类是所有字符输入流地根类，类是所有字符输出流地根类.个人收集整理勿做商业用途 操作系统中文件和目录概念是怎么样地？提供了哪些对文件和目录操作地类？程序中对文件和目录能够进行哪些操作？如何操作？个人收集整理勿做商业用途 答：文件是信息地一种组织形式，是存储在外部存储介质上地具有标识名地一组相关地信息集合.目录是文件系统组织和管理文件地基本单位，保存它所管理地每个文件地基本属性信息（称为文件目录项或文件控制块）.个人收集整理勿做商业用途 直接对文件地顺序存取和随机存取操作，提供了类记载文件属性信息，对文件读写操作时以流地形式.类以随机存取方式进行文件读写操作.但在对文件操作过程中还需要使用文件过滤器接口和文件对话框类.在操作系统中，目录也是以文件地形式保存地，称为目录文件.故一个对象也可以表示一个目录.个人收集整理勿做商业用途 可以对文件进行读、写、删除、创建等操作，对目录可以读取、创建、删除等操作.应用程序通过调用操作系统提供地系统调用能够对文件及目录进行各种操作.个人收集整理勿做商业用途 再打开、保存、复制文件时，需要读写文件中地数据内容，这些操作由流实现，不同类型地文件需要使用不同地流泪.个人收集整理勿做商业用途 流与文件操作有什么关系？实际应用中将流类与文件操作结合起来能够实现哪些复杂问题？如何实现？个人收集整理勿做商业用途 答：对文件地操作时通过流这个工具进行地.再打开、保存、复制文件时，需要读写文件中地数据内容，这些操作由流实现，不同类型地文件需要使用不同地流泪.个人收集整理勿做商业用途 什么是输入输出?什么是标准输入输出？怎样实现标准输入输出功能？ 答：数据由外部设备流向内存，这个过程称为输入；数据有内存流向外部设备，这个过程称为输出. 在计算机系统中，标准输入是从键盘等外部输入设备中获得数据，标准输出是向显示器或打印机等外部输出设备发送数据.个人收集整理勿做商业用途 在类中声明了个常量、和用于实现标准输入输出功能.个人收集整理勿做商业用途除了标准输入输出及文件操作之外，还有那些应用中需要使用流？ 答：在面向对象地程序设计中，数据地传输和流动具有广泛性，不仅可以在内存与外部设备之间传输，还可以从内存流向内存，甚至可以从一台计算机通过网络流向另一台计算机，因此各种不同地数据源地传输都需要采取不同地流机制来实现.个人收集整理勿做商业用途
文件流是以外存文件为输入输出对象的数据流
文件流是以外存文件为输入输出对象的数据流，字符串流不是以外存文件为输入输出的对象，而以内存中用户定义的字符数组(字符串)为输入输出的对象，即将数据输出到内存中的字符数组，或者从字符数组(字符串)将数据读入。字符串流也称为内存流。 字符串流也有相应的缓冲区，开始时流缓冲区是空的。如果向字符数组存入数据，随着向流插入数据，流缓冲区中的数据不断增加，待缓冲区满了(或遇换行符)，一起存入字符数组。如果是从字符数组读数据，先将字符数组中的数据送到流缓冲区，然后从缓冲区中提取数据赋给有关变量。 在字符数组中可以存放字符，也可以存放整数、浮点数以及其他类型的数据。在向字符数组存入数据之前，要先将数据从二进制形式转换为ASCII代码，然后存放在缓冲区，再从缓冲区送到字符数组。从字符数组读数据时，先将字符数组中的数据送到缓冲区，在赋给变量前要先将ASCII代码转换为二进制形式。总之，流缓冲区中的数据格式与字符数组相同。这种情况与以标准设备（键盘和显示器）为对象的输入输出是类似的，键盘和显示器都是按字符形式输入输出的设备，内存中的数据在输出到显示器之前，先要转换为ASCII码形式，并送到输出缓冲区中。从键盘输入的数据以ASCII码形式输入到输入缓冲区，在赋给变量前转换为相应变量类型的二进制形式，然后赋给变量。对于字符串流的输入输出的情况，如不清楚，可以从对标准设备的输入输出中得到启发。 文件流类有ifstream,ofstream和fstream,而字符串流类有istrstream,ostrstream和strstream。文件流类和字符串流类都是ostream,istream和iostream类的派生类,因此对它们的操作方法是基本相同的。向内存中的一个字符数组写数据就如同向文件写数据一样,但有3点不同： 1. 输出时数据不是流向外存文件，而是流向内存中的一个存储空间。输入时从内存中的存储空间读取数据。在严格的意义上 说，这不属于输入输出，称为读写比较合适。因为输入输出一般指的是在计算机内存与计算机外的文件（外部设备也视为文件）之间的数据传送。但由于C++的字符串流采用了C++的流输入输出机制，因此往往也用输入和输出来表述读写操作。 2. 字符串流对象关联的不是文件,而是内存中的一个字符数组,因此不需要打开和关闭文件。 3. 每个文件的最后都有一个文件结束符,表示文件的结束。而字符串流所关联的字符数组中没有相应的结束标志,用户要指定 一个特殊字符作为结束符,在向字符数组写入全部数据后要写入此字符。 字符串流类没有open成员函数，因此要在建立字符串流对象时通过给定参数来确立字符串流与字符数组的关联。即通过调用构造函数来解决此问题。建立字符串流对象的方法与含义如下。 建立输出字符串流对象 ostrstream类提供的构造函数的原型为： ostrstream::ostrstream(char *buffer,int n,int mode=ios::out); buffer是指向字符数组首元素的指针，n为指定的流缓冲区的大小（一般选与字符数组的大小相同，也可以不同），第3个参数是可选的，默认为ios::out方式。可以用以下语句建立输出字符串流对象并与字符数组建立关联： ostrstream strout(ch1,20); 作用是建立输出字符串流对象strout，并使strout与字符数组ch1关联（通过字符串流将数据输出到字符数组ch1），流缓冲区大小为20。 建立输入字符串流对象 istrstream类提供了两个带参的构造函数，原型为： istrstream::istrstream(char *buffer); istrstream::istrstream(char *buffer,int n); buffer是指向字符数组首元素的指针，用它来初始化流对象（使流对象与字符数组建立关联）。可以用以下语句建立输入字符串流对象： istrstream strin(ch2); 作用是建立输入字符串流对象strin，将字符数组ch2中的全部数据作为输入字符串流的内容。 istrstream strin(ch2,20); 流缓冲区大小为20，因此只将字符数组ch2中的,20个字符作为输入字符串流的内容。 建立输入输出字符串流对象 strstream类提供的构造函数的原型为： strstream::strstream(char *buffer,int n,int mode); 可以用以下语句建立输入输出字符串流对象：
java输入输出流和文件操作
Java IO流和文件操作Java流操作有关的类或接口： Java流类图结构：
1、File类 File类是对文件系统中文件以及文件夹进行封装的对象，可以通过对象的思想来操作文件和文件夹。 File类保存文件或目录的各种元数据信息，包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名，判断指定文件是否存在、获得当前目录中的文件列表，创建、删除文件和目录等方法。 构造方法摘要 File(File parent, String child) File(String pathname) File(String parent, String child) 构造函数 创建方法 1.boolean createNewFile() 不存在返回true 存在返回false 2.boolean mkdir() 创建目录 3.boolean mkdirs() 创建多级目录 删除方法 1.boolean delete() 2.boolean deleteOnExit() 文件使用完成后删除 例子1：列出指定文件夹的文件或文件夹 public class FileDemo1 { public static void main(String[] args){ File[] files =File.listRoots(); for(File file:files){
System.out.println(file); if(file.length()>0){ String[] filenames =file.list(); for(String filename:filenames){ System.out.println(filename); } } } } } 例子2：文件过滤 import java.io.File; public class FileTest2 { public static void main(String[] args) { File file = new File("file"); String[] names = file.list(); for(String name : names) { if(name.endsWith(".java")) { System.out.println(name); }
实验04 Java输入输出流报告
实验四 Java 输入输出流 1．实验目的 (1) 掌握输入输出流的总体结构； (2) 掌握流的概念； (3) 了解各种流（包括文件流、过滤流、对象的序列化、随机访问）的使用。2．实验内容 实验题1 编写一个Java Application程序，打印命令行输入的所有参数。 [基本要求] 编写完整程序。 运行结果： 代码如下： import java.util.Scanner; public class CommandOutPut { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub System.out.println("Please input ："); Scanner in = new Scanner(System.in);
String str = in.nextLine(); System.out.println("The output results ："); System.out.println(str); in.close(); } } 实验题2 通过键盘输入路径，搜索指定路径下的全部内容。 运行结果： 代码如下： package https://www.360docs.net/doc/0218440493.html,.output; import java.io.File; import java.io.FileInputStream; import java.io.IOException; public class Output { /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub String fileName = "d:\\xxx.txt"; File file = new File(fileName); byte[] b=new byte[(int)file.length()]; FileInputStream out=new FileInputStream(file);
实验五 输入输出流
实验五输入输出流 一、实验目的 1.掌握文件的使用 2.掌握字节I/O流、字符类I/O流、缓冲流、数据流等常用流的使用。 3.熟悉对象流、RandomAccessFile类的使用。 二、实验内容 1.利用各种常用IO流的处理方法，编写Java应用程序。 三、实验步骤与要求 第1题文件加密 编写一个Java应用程序，将已存在的扩展名为.txt的文本文件加密后存入另一个文本文件中。 package four; import java.io.*; public class file { public static void main(String args[]) { File readFile =new File("Student.txt"), writeFile =new File("Hello.txt"); String s="欢迎来到北京 welcome"; char b[]=s.toCharArray(); try{ FileWriter out=new FileWriter(readFile,true); out.write(b); out.close(); FileWriter tofile=new FileWriter ("hello.txt"); for(int i=0;i tofile.write(secret); tofile.close(); FileReader inOne=new FileReader("Hello.txt"); int t=0; System.out.println("存入后："); while((t=inOne.read(b,0,2))!=-1) { String str=new String(b,0,2); System.out.println(str); } inOne.close(); } catch (IOException e){ System.out.println(e); } } } 第2题读写基本类型数据 编写一个Java应用程序，将若干基本数据写入到一个文件，然后再按顺序读出。 班级：13科技2班学号：201324131225 姓名：许耿宁 Java多线程和输入输出流 一、实验目的： 1.熟悉利用Thread类建立多线程方法。 2.熟悉利用Thread接口建立多线程方法。 3.熟悉Java的文件读写机制，练习输入输出流的使用。 二、实验内容： 1.阅读下列程序，分析并上机检验其功能。 public class DelayRunnable implements Runnable{ private static int count=0; private int no; private int delay; public DelayRunnable(){ count++; no=count; } public void run(){ try{ for (int i=0;i<10;i++){ delay=(int)(Math.random()*5000); Thread.sleep(delay); System.out.println("Thread "+no+" with a delay "+delay); } }catch(InterruptedException e){} } } class MyRunnable{ public static void main(String args[]){ DelayRunnable r1 = new DelayRunnable(); DelayRunnable r2 = new DelayRunnable(); Thread thread1=new Thread(r1); Thread thread2=new Thread(r2); thread1.start(); thread2.start(); try{ Thread.sleep(1000); }catch(InterruptedException e){ System.out.println("Thread wrong"); } } } 2.将上列程序利用Runnable接口改写，并上机检验。 3.创建简单的程序ThreeThread.java，该程序将创建三个线程，每个线程应当显示它所运行的时间（可以考虑使用Date类或Calendar类）。 4.键盘输入10个整数，从小到大进行排序。 5.接收键盘输入的字符串，用FileInputStream类将字符串写入文件，用 FileOutputStream类读出文件内容显示在屏幕上。 6.将一个文本文件的内容按行读出，每读出一行就顺序加上行号，并写入到另一个文件中。 三、实验要求： 1.通过实验掌握Thread 、Runnable使用方法； 2.程序必须能够实现多线程； 3.程序必须能够完成题目要求； 4.通过实验掌握文件输入输出流的使用方法； 5.程序必须能够从键盘接收字符串并保存在文件中； 6.程序必须能够读出文件内容显示在屏幕上； 7.写出实验报告。 四、实验代码及截图： 第一题： 在编译器上运行程序得到截图所示结果： ▇▆大学计算机与信息技术学院 实验报告 姓名□□□学号▅▅▅▅专业班级▅▅ 课程名称 Java实验实验日期???? 成绩指导教师▇▇██批改日期实验名称实验9 Java的输入输出流 ●实验目的 1. 理解I/O流的概念，掌握其分类 2. 掌握文本文件读写、二进制文件读写 ●实验内容 1. 分别使用FileWriter 和BufferedWriter 往文件中写入1万个随机数，比较用时的多少？(用时采用方法System.currentTimeMillis()）求时间差; 使用：FileWriter 程序源代码 import java.io.*; public class TestFileWriter { public static void main(String []args) throws IOException{ File f = new File("C:/java/tem.txt"); if (f.exists()){ System.out.printf("文件\"C:/java/tem.txt\"已存在"); System.exit(0); } FileWriter fileWriter = new FileWriter(f); long time = System.currentTimeMillis(); for(int i=0;i<10000;i++) fileWriter.write((int)(Math.random()*101)); fileWriter.close(); time = System.currentTimeMillis() - time; System.out.printf("使用FileWriter耗时："+time+"毫秒"); } } 程序运行结果贴图 使用：BufferedWriter 程序源代码 import java.io.*; public class TestBufferedWriter { public static void main(String []args) throws IOException{ File f = new File("C:/java/tem2.txt"); 实验6 输入输出流操作 一、实验目的 1. 理解数据流的概念 2. 理解Java流的层次结构 3. 理解文件的概念 二、实验要求 1. 掌握字节流的基本使用方法 2. 掌握字符流的基本使用方法 3. 能够创建、读写、更新文件 三、实验练习内容 1. Java的标准输入输出流System.in/System.out 知识点解析: 标准数据流指在字符方式下（如DOS 提示符）程序与系统进行输入输出的方式，键盘和显示器屏幕是标准输入输出设备，数据输入的起点为键盘，数据输出的终点是屏幕，输出的数据可以在屏幕上显示出来。 示例：课本例10.1 2. 文件字节输入输出流类FileInputStream/ FileOutputStream 知识点解析: 文件字节输入输出流主要负责完成对本地磁盘文件的顺序输入与输出操作。示例：课本例10.2 3. 数据字节输入输出流DataOutputStream/DataInputStream 知识点解析: 使用数据输入流DataOutputStream 和数据输出流DataInputStream 可以读取或写入8种基本数据类型的数据，不用关心它们的实际长度是多少字节。一般与文件输入流FileInputStream 和输出流类FileOutputStream 一起使用。 示例：课本例10.3 4. 对象字节输入输出流ObjectInputStream/ ObjectOutputStream 知识点解析: 使用对象流可以直接写入或读取一个对象。由于一个类的对象包含多种信 息，为了保证从对象流中能够读取到正确的对象，因此要求所有写入对象流的对象都必须是序列化的对象。一个类如果实现了Serializable 接口，那么这个类的对象就是序列化的对象。Serializable 接口没有方法，实现该接口的类不需要实现额外的方法。 示例：课本例10.4 5. 文件字符输入输出流FileReader/FileWriter和字符缓冲输入输出流 BufferedReader/BufferedWriter 知识点解析:文件字符输入输出流类与文件字节输入输出流类功能类似，但处理的基本单位是字符。字符缓冲输入输出流类用来对字符流进行成批的处理。 示例：课本例10.5 6. 文件类File 知识点解析: 文件类主要用来保存文件或目录的各种属性, 包括文件名、文件长度、最后修改时间、是否可读等；文件类还有以下功能：提供获得当前文件的路径名, 判断指定文件是否存在, 获得当前目录中所有文件列表, 创建文件、删除文件、创建目录、删除目录等操作的方法。 示例：课本例10.6 7. 文件过滤器接口FileFilter和FilenameFilter 知识点解析: 文件过滤器接口FileFilter和FilenameFilter用来实现对文件名字符串的过滤。两个接口中都声明accept()方法来实现过滤操作。 示例：课本例10.7 8. 随机文件类RandomAccessFile 知识点解析:随机文件类用于进行随意位置、任意类型的文件访问，并且在文件的读取方式中支持文件的任意读取而不只是顺序读取。 示例：课本例10.8 四、设计题（以下题目1、2题必做，第3题选做） 1. 利用文件字节输入输出流和数据字节输入输出流，将"九九乘法表"写入整数类型文件，并输出显示。 2. 将Java的关键字保存在一个文本文件中，判断一个字符串是否为Java的关键字。 3. 使用文件字节输入/输出流，合并两个指定文件；当文件中的数据已排序时，合并后的数据也要求是已排序的。 第9章输入/输出流与文件操作 9.1 什么是流？流有什么用？面向对象语言为什么需要流？哪些场合需要流？ 答：流是指一组有顺序、有起点和终点的字节集合，是对数据传输的总称或抽象（也就是数据在两个对象之间的传输称为流）。 流的作用就是使数据传输操作独立于相关设备。 在面向对象的程序设计中，数据的传输和流动具有广泛性，可以在内存与外部设备之间传输，还可以从内存到内存，甚至可以从一台计算机通过网络流向另一台计算机等，故面向对象语言采用流机制。 在标准输入/输出、在文件的读/写等操作中都需要流。 9.2 Java提供了哪些流类？各种流类之间的关系是怎样的？什么场合需要使用什么流类？ 答：Java中按照流的方向性，流分为输入流和输出流两大类。按照流中元素的基本类型，流分为字节流和字符流两大类。字节流类按照流的方向分为字节输入流类和字节输出流类，字符流类方向性分为字符输入流类和字符输出流类。以及文件操作类File，随机存取文件类RandomAccessFile. 其中InputStream类是所有字节输入流的根类，OutputStream类是所有字节输出流的根类；Reader类是所有字符输入流的根类，Writer类是所有字符输出流的根类。 9.3 操作系统中文件和目录概念是怎么样的？Java提供了哪些对文件和目录操作的类？程序中对文件和目录能够进行哪些操作？如何操作？ 答：文件是信息的一种组织形式，是存储在外部存储介质上的具有标识名的一组相关的信息集合。目录是文件系统组织和管理文件的基本单位，保存它所管理的每个文件的基本属性信息（称为文件目录项或文件控制块）。 Java直接对文件的顺序存取和随机存取操作，提供了File类记载文件属性信息，对文件读/写操作时以流的形式。RandomAccessFile类以随机存取方式进行文件读/写操作。但在对文件操作过程中还需要使用文件过滤器接口和文件对话框类。在操作系统中，目录也是以文件的形式保存的，称为目录文件。故一个File对象也可以表示一个目录。可以对文件进行读、写、删除、创建等操作，对目录可以读取、创建、删除等操作。应用程序通过调用操作系统提供的系统调用能够对文件及目录进行各种操作。 再打开、保存、复制文件时，需要读/写文件中的数据内容，这些操作由流实现，不同类型的文件需要使用不同的流泪。 9.4 流与文件操作有什么关系？实际应用中将流类与文件操作结合起来能够实现哪些复杂问题？如何实现？ 答：对文件的操作时通过流这个工具进行的。再打开、保存、复制文件时，需要读/写文件中的数据内容，这些操作由流实现，不同类型的文件需要使用不同的流泪。 9.5 什么是输入/输出?什么是标准输入/输出？Java怎样实现标准输入/输出功能？答：数据由外部设备流向内存，这个过程称为输入；数据有内存流向外部设备，这个过程称为输出。 在计算机系统中，标准输入是从键盘等外部输入设备中获得数据，标准输出是向显示器或打印机等外部输出设备发送数据。 Java在https://www.360docs.net/doc/0218440493.html,ng.System类中声明了3个常量in、out和err用于实现标准输入/输出功能。 9.6 除了标准输入/输出及文件操作之外，还有那些应用中需要使用流？ 软件091班java程序机试题 编程题： 0. 求两点之间的距离。 要求： 1)设计点类，属性为点的坐标；利用点类设计距离类。 2)两点的坐标通过键盘输入，键盘输入要运用流，输入数据时要有合理的提示信息， 输出信息表达明确。 1．实现如下界面功能的图形界面应用程序（字体设置）。 2．编写程序，通过键盘输入多行信息，直接输入一个文本文件中。 要求：键盘输入的信息要使用流。 3．求5个以上学生的Java平均成绩。 要求： 1)要利用对象数组生成对象 2)信息通过键盘输入（利用流）。 3)Java成绩的范围在0-分100分，若输错，则需要重新输入。 4．设计一个包含两个命令按钮（显示文字和显示图片）的界面。 要求： 1)当单击“显示文字”命令按钮后，命令按钮变为“文字消失”，同时显示一行“单 击了命令按钮！”的文字。单击“文字消失”命令按钮后，命令按钮又变为“显 示文字”命令按钮，同时文字“单击了命令按钮！”消失。如此可以反复。 2)当单击“显示图片”命令按钮后，命令按钮变为“图片消失”，同时显示任意一 幅图片。单击“图片消失”命令按钮后，命令按钮又变为“显示图片”命令按钮， 同时图片消失。如此可以反复。 5．求5个以上人的平均年龄。 要求： 1)要利用对象数组生成对象 2)信息通过键盘输入（利用流）。 3)人年龄的范围在0岁-120岁，若输错，则需要重新输入。 6．打开Login1.Java源程序，题目要求见源程序的注释部分。 7．分别利用接口和抽象类，求给定三个以上三角形和给定三个以上矩形的平均周长。 提示：应该产生两个源程序。 要求： 1)要利用对象数组生成对象。 2)信息通过键盘输入（利用流）。 3)输入的三角形的三条边要能构成三角形，否则需要重新输入。 一. 创建文件 （1）最常用的（获得一个固定路径下的文件对象） File parentFile = new File(“D:\\My Documents\\.....”);//参数是一个路径的字符串。 （2）在父目录创建一个名为child的文件对象，child 为文件对象的名字 File chileFile= new File(“D:\\My Documents\\.....”,String child); 或File chileFile= new File(parentFile,String child); 二,常见文件夹属性和方法 （1）createNewFile（）； 该方法的作用是创建指定的文件。该方法只能用于创建文件，不能用于创建文 件夹，且文件路径中包含的文件夹必须存在 File file=new ("D:\\My Document\\text.txt"); file.createNewFile(); 这样就会在D盘下的My Document 创建text.txt的记事本（注意：首先得保 证D盘下有My Documen这个文件夹） （2）mkdir(); 根据File对象的名字(路径)创建一个目录(文件夹)，如果是相对目录，则新建的目 录在当前目录下 （3）mkdirs(); 如果File对象名字有多级目录，则可以调用该方法一次性创建多级目录。 （4）exists(); 判断File对象指向的文件是否存在，返回一个boolean类型（5）isDirectory（）； 判断File对象指向的文件是否为目录，返回一个boolean类型的值，true或者false。 （6）getName();获得文件名称（不带路径） （7）length（）； 得到File对象指向文件的长度，以字节计算，返回一个长整形的值(long);注意：在 系统中，文件夹(目录)的大小为零，也就是不占用空间，使用length()时返回的是0 （8）delete（）; 删除File对象所指定的文件 （9）isFile（）； 判断File对象指向的文件是不是标准文件（就像图片，音乐文件等） 三,文件的属性和方法 1.File.separator 当前操作系统的名称分隔符，等于字符串“\”. 实验八输入输出流类及文件的读写 一、实验目的： 1、掌握标准输入输出（iostream库中标准对象cin、cout）的使用 2、熟悉IO流类成员函数输入输出（cin.get, cin.getline, cin.read; cout.put, cout.write）的使用 3、掌握输出格式（标准控制符、IO流类成员函数、iomanip 头文件中的控制符）控制方法 4、掌握磁盘文件的输入输出方法 二、实验环境： 1、PC计算机一台； 2、Dev-C＋＋开发环境。 三、实验内容: 1、创建一个文件xx.txt，编写程序，统计文件中字符的个数。 2、定义描述职工工资的类Laborage，数据成员为职工号(No)、姓名(Name[8])、应发工资(Ssalary)、社保金(Security)、实发工资(Fsalary)。定义公有成员函数Input()，在Input()函数内输入职工号、姓名、应发工资、社保金，实发工资由公式： Fsalary=Ssalary-Security计算。定义输出职工工资的成员函数Show()。在显示函数Show()中，职工号、姓名的输出域宽为8、 左对齐，其余数据的输出域宽为10、右对齐、保留小数点后两位，输出格式均用预定义格式控制函数设置。在主函数中用Laborage 类定义职工对象数组a[3]。用Input()输入职工工资，用Show()显示每个职工的工资。 五、实验代码及结果（程序运行结果请以截屏图给出）：（1） #include 一、数据流的基本概念 流一般分为输入流（Input Stream）和输出流（Output Stream）两类，但这种划分并不是绝对的。比如一个文件，当向其中写数据时，它就是一个输出流；当从其中读取数据时，它就是一个输入流。当然，键盘只是一个数人流，而屏幕则只是一个输出流。 java的标准数据流：标准输入输出指在字符方式下（如DOS），程序与系统进行交互的方式，分为三种： 标准输入studin,对象是键盘。 标准输出stdout,对象是屏幕。 标准错误输出stderr,对象也是屏幕。 二、java.io包中的数据流和文件类 字节流：从InputStream和OutputStream派生出来的一系列类。这类流以字节(byte)为基本处理单位。 InputStream、OutputStream FileInputStream、FileOutputStream PipedInputStream、PipedOutputStream ByteArrayInputStream、ByteArrayOutputStream FilterInputStream、FilterOutputStream DataInputStream、DataOutputStream BufferedInputStream、BufferedOutputStream 字符流：从Reader和Writer派生出的一系列类，这类流以16位的Unicode码表示的字符为基本处理单位。 Reader、Writer InputStreamReader、OutputStreamWriter FileReader、FileWriter CharArrayReader、CharArrayWriter PipedReader、PipedWriter FilterReader、FilterWriter BufferedReader、BufferedWriter StringReader、StringWriter 三、字节流方法 InputStream 和OutputStream read()：从流中读入数据 skip()：跳过流中若干字节数 available()：返回流中可用字节数 mark()：在流中标记一个位置 reset()：返回标记过得位置 markSupport()：是否支持标记和复位操作 close()：关闭流 int read() :从输入流中读一个字节，形成一个0～255之间的整数返回（是一个抽象方法）。 int read(byte b[]) :读多个字节到数组中。 int read(byte b[], int off, int len)：从输入流中读取长度为len的数据，写入数组b中从索引of f开始的位置，并返回读取得字节数。 write(int b) :将一个整数输出到流中（只输出低位字节，抽象） write(byte b[]) :将字节数组中的数据输出到流中 write(byte b[], int off, int len) :将数组b中从off指定的位置开始，长度为len的数据输出到流 第十章 输入／输出流Java多线程和输入输出流
实验9 Java输入输出流
实验6 输入输出流操作
第9章 输入输出流与文件操作
Java输入输出流经典编程题
javaFile文件操作和文件流的详解(福哥出品)
实验八+输入输出流类及文件的读写
java输入输出流总结
输入输出流
程序在运行时通常要和外部进行交互， 即从外部读取数据或向外部设备发送数据， 这就 是所谓的输入／输出(Input/Output)。 数据可以来自或者发往文件、 内存、 另一个程序或网络。 数据也可有不同的格式，例如可以是各种编码（ASCII 码或 Unicode 码等）的字符串、图像、 声音或对象等等。 Java 语言使用抽象概念——流来描述程序与数据发送或接收者之间的数据 通道。使用输入／输出流，程序员可以方便灵活和安全地实现输入输出功能。
§10.1 输入／输出基本概念
10.1.1 外部设备与文件
我们可以从不同角度对外部设备进行分类。 按照外部设备的工作特性， 我们可将外部设 备分为两类：存储设备和输入／输出设备。 存储设备用于存储信息，包括硬盘、软盘、磁带、光盘等。程序可将数据写入到这些设 备上，也可从这些设备读出数据，数据通常组织为文件形式。这类设备上存储的数据在物理 上往往是按字符块组织的，因而又将它们称为块设备。 输入／输出设备又可分为输入设备和输出设备。 输入设备是计算机用于接受外界信息的 设备，诸如键盘、鼠标、扫描仪等均为输入设备；输出设备是将计算机处理完毕的数据送往 外界的设备，诸如显示器、打印机、绘图仪等均为输出设备。由于这两类设备上的数据往往 是以字符为单位组织的，所以又称它们为字符设备。 计算机程序要与外界进行交互就必须使用相应的机制与输入／输出设备打交道。 程序的 输入是指从输入设备接收数据，程序的输出是指将数据传递给外部设备。 早期的高级程序设计语言对特定的外部设备提供特定的输入／输出操作， 这导致设计出 来的程序代码可移植性很差。后来引入了文件（file）的概念，在程序中不仅可以声明文件 并将文件作为输入／输出的对象， 而且还可以在文件与某个外部设备之间建立关联， 将文件 作为输入设备与输出设备的抽象描述。 目前文件已成为高级程序设计语言输入／输出机制的 基本概念。 一个文件必须有一个由用户命名的唯一名字。 文件可用于存储程序和数据， 还可用于提 高程序的设备无关性， 所谓设备无关性不仅指程序要独立于同类设备的具体台号， 而且还要 独立于设备的类型。 当我们的程序向屏幕或打印机输出时， 不必考虑使用的是哪一种型号的 显示器或打印机。 在操作系统中， 输入／输出设备被视作一种特殊的文件， 这类文件的名字是由操作系统 预先规定好的。例如在 MS-DOS 中显示器被命名为 CON 的文件（控制台终端 console 的缩 写） 、打印机被命名为 PRN 的文件（printer 的缩写） 。这样，程序的输入／输出操作采用了 与文件统一的方式，而不用理会实际的物理设备是什么。
10.1.2 文件的基本概念
Java 语言将文件看作是字节的序列， 即由一个个字节的数据顺序组成。 例如我们要将一 个班全体学生的基本资料存放在一个文件中， 文件中的数据并不是由学生记录组成的， 而是 由一个个字节组成的。 如何将文件中的这些字节组织为记录是由程序完成的， 文件本身并没 有划定任何边界。因而这种文件又称为流式文件（stream file） 。 (1)文本文件与二进制文件 根据文件中数据的组织形式， 可将文件分为文本文件和二进制文件两类。 文本文件存放 的是 ASCII 码（或其他编码的）字符，使用 Windows 操作系统的记事本打开可正确查看其
-1-