09:15 提问
java中读取文件提示找不到指定路径？？？
import java.io.F
import java.io.FileR
import java.io.FileW
public class FileCombine {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
FileManager afilemg = new FileManager("a.txt",new char[]{'\n'});
FileManager bfilemg = new FileManager("b.txt",new char[]{'\n',' '});
FileWriter cfile = new FileWriter("c.txt");
String aword =
String bword =
while((aword = afilemg.nextWord())!=null){
cfile.write(aword+"\n");
bword = bfilemg.nextWord();
if(bword != null)
cfile.write(bword+"\n");
while((bword = bfilemg.nextWord()) != null)
cfile.write(bword);
cfile.close();
class FileManager{
String[] words =
int pos = 0;
public FileManager(String filename, char[]separators)throws Exception{
File f = new File(filename);
FileReader reader = new FileReader(f);
char[] buf = new char[(int)f.length()];
int len = reader.read(buf);
reader.close();
String result = new String(buf,0,len);
String regex =
if(separators.length&1)
regex = ""+separators[0]+"|"+separators[1];
else regex = ""+separators[0];
words = result.split(regex);
public String nextWord(){
if(pos==words.length)
else return words[pos++];
Exception in thread "main" java.io.FileNotFoundException: a.txt (系统找不到指定的文件。)
at java.io.FileInputStream.open(Native Method)
at java.io.FileInputStream.(Unknown Source)
at java.io.FileReader.(Unknown Source)
at excises.FileManager.(FileCombine.java:35)
at excises.FileCombine.main(FileCombine.java:11)
请问这是什么问题？？？
按赞数排序
----------------------biu~biu~biu~~~在下问答机器人小D，这是我依靠自己的聪明才智给出的答案，如果不正确，你来咬我啊！
把你文件的具体路径打印出来，看看是否正确，是否有特殊符号在里面等等
找不到a.txt，你看看你把a.txt放哪了？是不是程序目录下？
找不到a.txt，并且肯定也找不到b.txt，建议将a.txt和b.txt放在程序的bin目录下。
文件地址要用全局的绝对路径，你测试一下你的路径，看看对不
跟class文件放在一起
很有可能就是路径问题，检查下你a、b 文件的路径
其实吧你 在 工程目录下 放一个 代码目录下放一下 成功了再删就是了
实在 不行 用绝对路径好了
打印一下当前路径的位置，然后对比一下，对应的确定a、b的位置
a.txt要放在工程的根目录:
工程路径/a.txt, 检查一下a.txt路径是否正确
准确详细的回答，更有利于被提问者采纳，从而获得C币。复制、灌水、广告等回答会被删除，是时候展现真正的技术了！
其他相关推荐【图文】JAVA练习题(第9章)_百度文库
赠送免券下载特权
10W篇文档免费专享
部分付费文档8折起
每天抽奖多种福利
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
JAVA练习题(第9章)
阅读已结束，下载本文到电脑
想免费下载本文？
登录百度文库，专享文档复制特权，积分每天免费拿！
你可能喜欢扫一扫体验手机阅读
Java相对路径读取文件
不管你是新手还是老鸟，在程序中读取资源文件总会遇到一些找不到文件的问题，这与Java底层的实现有关，不能算bug，只要方法得当，问题还是可以解决的。
项目的文件夹结构：
repathtest ├─src │&&&&└─com │&&&&&&&&&&&&└─lavasoft │&&&&&&&&&&&&&&&&&&&&├─test │&&&&&&&&&&&&&&&&&&&&└─res ├─doc
1、在Java开发工具的project中使用相对路径
在project中，相对路径的根目录是project的根文件夹，在此就是repathtest文件夹了。
创建文件的写法是：
File f = new File("src/com/lavasoft/res/a.txt");
File f = new File("doc/b.txt");
路径不以“/”开头；
脱离了IDE环境，这个写法就是错误的，也并非每个IDE都如此，但我见到的都是这样的。
2、通过CLASSPATH读取包内文件
读取包内文件，使用的路径一定是相对的classpath路径，比如a，位于包内，此时可以创建读取a的字节流：
InputStream in = ReadFile.class.getResourceAsStream("/com/lavasoft/res/a.txt");
有了字节流，就能读取到文件内容了。
这里必须以“/”开头；
3、看看完整的测试代码
package com.lavasoft. import java.io.*; /** * Java读取相对路径的文件 * * @author leizhimin
10:59:43 */ public class ReadFile { &&&&&&&&public static void main(String[] args) { &&&&&&&&&&&&&&&&readTextA_ByClassPath(); &&&&&&&&&&&&&&&&readTextA_ByProjectRelativePath(); &&&&&&&&&&&&&&&&readTextB_ByProjectRelativePath(); &&&&&&&&} &&&&&&&&/** &&&&&&&& * 通过工程相对路径读取（包内）文件，注意不以“/”开头 &&&&&&&& */ &&&&&&&&public static void readTextA_ByProjectRelativePath() { &&&&&&&&&&&&&&&&System.out.println("-----------------readTextA_ByProjectRelativePath---------------------"); &&&&&&&&&&&&&&&&File f = new File("src/com/lavasoft/res/a.txt"); &&&&&&&&&&&&&&&&String a = file2String(f, "GBK"); &&&&&&&&&&&&&&&&System.out.println(a); &&&&&&&&} &&&&&&&&/** &&&&&&&& * 通过工程相对路径读取（包外）文件，注意不以“/”开头 &&&&&&&& */ &&&&&&&&public static void readTextB_ByProjectRelativePath() { &&&&&&&&&&&&&&&&System.out.println("-----------------readTextB_ByProjectRelativePath---------------------"); &&&&&&&&&&&&&&&&File f = new File("doc/b.txt"); &&&&&&&&&&&&&&&&String b = file2String(f, "GBK"); &&&&&&&&&&&&&&&&System.out.println(b); &&&&&&&&} &&&&&&&&/** &&&&&&&& * 通过CLASSPATH读取包内文件，注意以“/”开头 &&&&&&&& */ &&&&&&&&public static void readTextA_ByClassPath() { &&&&&&&&&&&&&&&&System.out.println("-----------------readTextA_ByClassPath---------------------"); &&&&&&&&&&&&&&&&InputStream in = ReadFile.class.getResourceAsStream("/com/lavasoft/res/a.txt"); &&&&&&&&&&&&&&&&String a = stream2String(in, "GBK"); &&&&&&&&&&&&&&&&System.out.println(a); &&&&&&&&} &&&&&&&&/** &&&&&&&& * 文件转换为字符串 &&&&&&&& * &&&&&&&& * @param f&&&&&&&&&&&& 文件 &&&&&&&& * @param charset 文件的字符集 &&&&&&&& * @return 文件内容 &&&&&&&& */ &&&&&&&&public static String file2String(File f, String charset) { &&&&&&&&&&&&&&&&String result = null; &&&&&&&&&&&&&&&&try { &&&&&&&&&&&&&&&&&&&&&&&&result = stream2String(new FileInputStream(f), charset); &&&&&&&&&&&&&&&&} catch (FileNotFoundException e) { &&&&&&&&&&&&&&&&&&&&&&&&e.printStackTrace(); &&&&&&&&&&&&&&&&} &&&&&&&&&&&&&&&&return &&&&&&&&} &&&&&&&&/** &&&&&&&& * 文件转换为字符串 &&&&&&&& * &&&&&&&& * @param in&&&&&&&&&&&&字节流 &&&&&&&& * @param charset 文件的字符集 &&&&&&&& * @return 文件内容 &&&&&&&& */ &&&&&&&&public static String stream2String(InputStream in, String charset) { &&&&&&&&&&&&&&&&StringBuffer sb = new StringBuffer(); &&&&&&&&&&&&&&&&try { &&&&&&&&&&&&&&&&&&&&&&&&Reader r = new InputStreamReader(in, charset); &&&&&&&&&&&&&&&&&&&&&&&&int length = 0; &&&&&&&&&&&&&&&&&&&&&&&&for (char[] c = new char[1024]; (length = r.read(c)) != -1;) { &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&sb.append(c, 0, length); &&&&&&&&&&&&&&&&&&&&&&&&} &&&&&&&&&&&&&&&&&&&&&&&&r.close(); &&&&&&&&&&&&&&&&} catch (UnsupportedEncodingException e) { &&&&&&&&&&&&&&&&&&&&&&&&e.printStackTrace(); &&&&&&&&&&&&&&&&} catch (FileNotFoundException e) { &&&&&&&&&&&&&&&&&&&&&&&&e.printStackTrace(); &&&&&&&&&&&&&&&&} catch (IOException e) { &&&&&&&&&&&&&&&&&&&&&&&&e.printStackTrace(); &&&&&&&&&&&&&&&&} &&&&&&&&&&&&&&&&return sb.toString(); &&&&&&&&} }
(代码写得粗糙，异常没做认真处理）
运行结果：
-----------------readTextA_ByClassPath--------------------- aaaaaaaaa sssssssss -----------------readTextA_ByProjectRelativePath--------------------- aaaaaaaaa sssssssss -----------------readTextB_ByProjectRelativePath--------------------- bbbbbbbbbbb Process finished with exit code 0
这是通过IDEA开发工具运行的，结果没问题，如果换成控制台执行，那么使用了项目相对路径的读取方式会失败，原因是，此时已经脱离了项目的开发环境，-----这个问题常常困扰着一些菜鸟，代码在开发工具好好的，发布后执行就失败了！
下面我截个图：
5、获取CLASSPATH下文件的绝对路径
当使用相对路径写入文件时候，就需要用到绝对路径。下面是个例子：
package com. import java.io.F /** * CLASSPATH文件的绝对路径获取测试 * * @author leizhimin
9:33:02 */ public class Test { &&&&&&&&//classpath的文件路径 &&&&&&&&private static String cp = "/com/lavasoft/cfg/syscfg.properties"; &&&&&&&&public static void main(String[] args) { &&&&&&&&&&&&&&&&//当前类的绝对路径 &&&&&&&&&&&&&&&&System.out.println(Test.class.getResource("/").getFile()); &&&&&&&&&&&&&&&&//指定CLASSPATH文件的绝对路径 &&&&&&&&&&&&&&&&System.out.println(Test.class.getResource(cp).getFile()); &&&&&&&&&&&&&&&&//指定CLASSPATH文件的绝对路径 &&&&&&&&&&&&&&&&File f = new File(Test.class.getResource(cp).getFile()); &&&&&&&&&&&&&&&&System.out.println(f.getPath()); &&&&&&&&} }
/D:/projects/bbt/code/cdn/planrpt/out/production/planrpt/ /D:/projects/bbt/code/cdn/planrpt/out/production/planrpt/com/lavasoft/cfg/syscfg.properties D:\projects\bbt\code\cdn\planrpt\out\production\planrpt\com\lavasoft\cfg\syscfg.properties Process finished with exit code 0
使用工程相对路径是靠不住的。
使用CLASSPATH路径是可靠的。
对于程序要读取的文件，尽可能放到CLASSPATH下，这样就能保证在开发和发布时候均正常读取。
-----------------------
推荐资源：
分享到朋友圈
关注作者，不错过每一篇精彩Java输入输出流的使用详细介绍
转载 &发布时间：日 11:06:30 & 作者：
本篇文章介绍了，在Java中输入输出流的使用详细分析。需要的朋友参考下
& & & Java中I/O操作主要是指使用Java进行输入，输出操作.&Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。&&
& & & Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库 java.nio中采用的便是块IO。
　　流IO的好处是简单易用，缺点是效率较低。块IO效率很高，但编程比较复杂。&& & & Java IO模型 &:& & & Java的IO模型设计非常优秀，它使用Decorator模式，按功能划分Stream，您可以动态装配这些Stream，以便获得您需要的功能。例如，您需要一个具有缓冲的文件输入流，则应当组合使用FileInputStream和BufferedInputStream。&
& & & &数据流是一串连续不断的数据的集合，就象水管里的水流，在水管的一端一点一点地供水，而在水管的另一端看到的是一股连续不断的水流。数据写入程序可以是一段、一段地向数据流管道中写入数据，这些数据段会按先后顺序形成一个长的数据流。对数据读取程序来说，看不到数据流在写入时的分段情况，每次可以读取其中的任意长度的数据，但只能先读取前面的数据后，再读取后面的数据。不管写入时是将数据分多次写入，还是作为一个整体一次写入，读取时的效果都是完全一样的。&
& & & “流是磁盘或其它外围设备中存储的数据的源点或终点。”
& & 在电脑上的数据有三种存储方式，一种是外存，一种是内存，一种是缓存。比如电脑上的硬盘，磁盘，U盘等都是外存，在电脑上有内存条，缓存是在CPU里面的。外存的存储量最大，其次是内存，最后是缓存，但是外存的数据的读取最慢，其次是内存，缓存最快。这里总结从外存读取数据到内存以及将数据从内存写到外存中。对于内存和外存的理解，我们可以简单的理解为容器，即外存是一个容器，内存又是另外一个容器。那又怎样把放在外存这个容器内的数据读取到内存这个容器以及怎么把内存这个容器里的数据存到外存中呢？
& & &在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:
& & & & &标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流等等，java中将输入输出抽象称为流，就好像水管，将两个容器连接起来。将数据冲外存中读取到内存中的称为输入流，将数据从内存写入外存中的称为输出流。
& &&流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。
& & & 总结的基本概念如下：1) 数据流：
& & 一组有序，有起点和终点的字节的数据序列。包括输入流和输出流。
&&2) 输入流（Input &Stream）：
& & & 程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…)，即是将数据源读入到程序的通信通道
& & &&3) 输出流：
& & 程序向输出流写入数据。将程序中的数据输出到外界（显示器、打印机、文件、网络…）的通信通道。
采用数据流的目的就是使得输出输入独立于设备。
Input &Stream不关心数据源来自何种设备（键盘，文件，网络）Output &Stream不关心数据的目的是何种设备（键盘，文件，网络）4 数据流分类：
流序列中的数据既可以是未经加工的原始二进制数据，也可以是经一定编码处理后符合某种格式规定的特定数据。因此Java中的流分为两种：&1) &字节流：数据流中最小的数据单元是字节&2) &字符流：数据流中最小的数据单元是字符， Java中的字符是Unicode编码，一个字符占用两个字节。
& & &&Java程序可通过命令行参数与外界进行简短的信息交换，同时，也规定了与标准输入、输出设备，如键盘、显示器进行信息交换的方式。而通过文件可以与外界进行任意数据形式的信息交换。1. 命令行参数 代码如下:public class TestArgs {&&&&& public static void main(String[] args) {&&&&&&&&& for (int i = 0; i & args. i++) {&&&&&&&&&&&&& System.out.println("args[" + i + "] is &" + args[i] + "&");&&&&&&&&& }&&&&& }& }&
运行结果：
args[0] is &Java&
args[1] is &C&
args[2] is &VB&
2. 标准输入，输出数据流
java系统自带的标准数据流：java.lang.System: 代码如下:java.lang.System&& public final class System& extends Object{&& && static& PrintStream&//标准错误流（输出）&& && static& InputStream&//标准输入(键盘输入流)&& && static& PrintStream&//标准输出流(显示器输出流)&& }&
注意：（1）System类不能创建对象，只能直接使用它的三个静态成员。（2）每当main方法被执行时,就自动生成上述三个对象。
1) 标准输出流&System.out
& &System.out向标准输出设备输出数据，其数据类型为PrintStream。方法：
& & & Void print(参数)
& & & Void println(参数)
2)标准输入流&System.in
& & System.in读取标准输入设备数据（从标准输入获取数据，一般是键盘），其数 据类型为InputStream。方法：
& & & & int read()&&//返回ASCII码。若,返回值=-1，说明没有读取到任何字节读取工作结束。
& & & & &int read(byte[] b)//读入多个字节到缓冲区b中返回值是读入的字节数
例如： 代码如下:public class StandardInputOutput {& &&& public static void main(String args[]) {& &&&&&&&& &&&&&&& try {& &&&&&&&&&&& System.out.println("please Input:");& &&&&&&&&&&& while ((b = System.in.read()) != -1) {& &&&&&&&&&&&&&&& System.out.print((char) b);& &&&&&&&&&&& }& &&&&&&& } catch (IOException e) {& &&&&&&&&&&& System.out.println(e.toString());& &&&&&&& }& &&& }& }&
等待键盘输入，键盘输入什么，就打印出什么：
3)标准错误流
& &System.err输出标准错误，其数据类型为PrintStream。可查阅API获得详细说明。
& & 标准输出通过System.out调用println方法输出参数并换行，而print方法输出参数但不换行。println或print方法都通 过重载实现了输出基本数据类型的多个方法，包括输出参数类型为boolean、char、int、long、float和double。同时，也重载实现 了输出参数类型为char[]、String和Object的方法。其中，print（Object）和println（Object）方法在运行时将调 用参数Object的toString方法。 代码如下:import java.io.BufferedR& import java.io.IOE& import java.io.InputStreamR& public class StandardInputOutput {& &&& public static void main(String args[]) {& &&&&&&& S& &&&&&&& // 创建缓冲区阅读器从键盘逐行读入数据&& &&&&&&& InputStreamReader ir = new InputStreamReader(System.in);& &&&&&&& BufferedReader in = new BufferedReader(ir);& &&&&&&& System.out.println("Unix系统: ctrl-d 或 ctrl-c 退出"& &&&&&&&&&&&&&&& + "\nWindows系统: ctrl-z 退出");& &&&&&&& try {& &&&&&&&&&&& // 读一行数据，并标准输出至显示器&& &&&&&&&&&&& s = in.readLine();& &&&&&&&&&&& // readLine()方法运行时若发生I/O错误，将抛出IOException异常&& &&&&&&&&&&& while (s != null) {& &&&&&&&&&&&&&&& System.out.println("Read: " + s);& &&&&&&&&&&&&&&& s = in.readLine();& &&&&&&&&&&& }& &&&&&&&&&&& // 关闭缓冲阅读器&& &&&&&&&&&&& in.close();& &&&&&&& } catch (IOException e) { // Catch any IO exceptions.&& &&&&&&&&&&& e.printStackTrace();& &&&&&&& }& &&& }& }&
& & &在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader；一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了
& & & Java I/O主要包括如下几个层次，包含三个部分：
& &1.流式部分――IO的主体部分；
& &2.非流式部分――主要包含一些辅助流式部分的类，如：File类、RandomAccessFile类和FileDescriptor等类；
& &3.其他类--文件读取部分的与安全相关的类，如：SerializablePermission类，以及与本地操作系统相关的文件系统的类，如：FileSystem类和Win32FileSystem类和WinNTFileSystem类。
& &主要的类如下：
& & &1. File（文件特征与管理）：用于文件或者目录的描述信息，例如生成新目录，修改文件名，删除文件，判断文件所在路径等。
& & &2. InputStream（二进制格式操作）：抽象类，基于字节的输入操作，是所有输入流的父类。定义了所有输入流都具有的共同特征。
& & &3. OutputStream（二进制格式操作）：抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。
& & &Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。
& & &4. Reader（文件格式操作）：抽象类，基于字符的输入操作。
& & &5. Writer（文件格式操作）：抽象类，基于字符的输出操作。
& & &6. RandomAccessFile（随机文件操作）：它的功能丰富，可以从文件的任意位置进行存取（输入输出）操作。
& & &Java中IO流的体系结构如图：
在Java语言的java.io包中，由File类提供了描述文件和目录的操作与管理方法。但File类不是InputStream、OutputStream或Reader、Writer的子类，因为它不负责数据的输入输出，而专门用来管理磁盘文件与目录。
作用：File类主要用于命名文件、查询文件属性和处理文件目录。
代码如下:public&&& class&& File&& extends Object&& &&& implements Serializable,Comparable& {}&&&&&&&&&&&&&&&&& File类共提供了三个不同的构造函数，以不同的参数形式灵活地接收文件和目录名信息。构造函数：1）File (String & pathname) &&
& & &例:File &f1=new File("FileTest1.txt");&//创建文件对象f1，f1所指的文件是在当前目录下创建的FileTest1.txt2）File (String &parent &, &String child)
& & &例:File f2=new &File(“D:\\dir1","FileTest2.txt") ;// &注意：D:\\dir1目录事先必须存在，否则异常3）File (File & &parent &, String child)& & &例:File &f4=new File("\\dir3");& & & & & File &f5=new File(f4,"FileTest5.txt");&&//在如果 \\dir3目录不存在使用f4.mkdir()先创建
& & && &一个对应于某磁盘文件或目录的File对象一经创建， 就可以通过调用它的方法来获得文件或目录的属性。 & &
& & & &1）public boolean exists( ) 判断文件或目录是否存在& & & &2）public boolean isFile( ) 判断是文件还是目录&& & & &3）public boolean isDirectory( ) 判断是文件还是目录& & & &4）public String getName( ) 返回文件名或目录名& & & &5）public String getPath( ) 返回文件或目录的路径。& & & &6）public long length( ) 获取文件的长度&& & & &7）public String[ ] list ( ) 将目录中所有文件名保存在字符串数组中返回。&
& & & &File类中还定义了一些对文件或目录进行管理、操作的方法，常用的方法有：& & & &1）&public boolean renameTo( File newFile ); & &重命名文件& & & &2）&public void delete( ); &&删除文件& & & &3）&&public boolean mkdir( );&创建目录
例子： 代码如下:import java.io.F& import java.io.IOE& public class TestFile {& &&& public static void main(String args[]) throws IOException {& &&&&&&& File dir = new File("\\root");& &&&&&&& File f1 = new File(dir, "fileOne.txt");& &&&&&&& File f2 = new File(dir, "fileTwo.java");& &&&&&&& // 文件对象创建后，指定的文件或目录不一定物理上存在&& &&&&&&& if (!dir.exists())& &&&&&&&&&&& dir.mkdir();& &&&&&&& if (!f1.exists())& &&&&&&&&&&& f1.createNewFile();& &&&&&&& if (!f2.exists())& &&&&&&&&&&& f2.createNewFile();& &&&&&&& System.out.println("f1's AbsolutePath=& " + f1.getAbsolutePath());& &&&&&&& System.out.println("f1 Canread=" + f1.canRead());& &&&&&&& System.out.println("f1's len= " + f1.length());& &&&&&&& String[] FL;& &&&&&&& int count = 0;& &&&&&&& FL = dir.list();& &&&&&&& for (int i = 0; i & FL. i++) {& &&&&&&&&&&& count++;& &&&&&&&&&&& System.out.println(FL[i] + "is in \\root");& &&&&&&& }& &&&&&&& System.out.println("there are" + count + "file in //root");& &&& }& }&
说明：File类的方法:(1) exists()测试磁盘中指定的文件或目录是否存在(2) mkdir()创建文件对象指定的目录（单层目录）(3) createNewFile()创建文件对象指定的文件
(4) list()返回目录中所有文件名字符串
1. io流的四个基本类
& & & java.io包中包含了流式I/O所需要的所有类。在java.io包中有四个基本类：InputStream、OutputStream及Reader、Writer类，它们分别处理字节流和字符流：
基本数据流的I/O输入/输出
Inputstream
OutputStream
& & &Java中其他多种多样变化的流均是由它们派生出来的:
& & & JDK1.4版本开始引入了新I/O类库，它位于java.nio包中，新I/O类库利用通道和缓冲区等来提高I/O操作的效率。
& & & 在java.io包中， java.io.InputStream 表示字节输入流， java.io.OutputStream表示字节输出流，处于java.io包最顶层。这两个类均为抽象类，也就是说它们不能被实例化，必须生成子类之后才能实现一定的功能。
1. io流的具体分类
一、按I/O类型来总体分类：
& & &1. Memory&1）从/向内存数组读写数据: CharArrayReader、 CharArrayWriter、ByteArrayInputStream、ByteArrayOutputStream& & & & & & & & & &2）从/向内存字符串读写数据 StringReader、StringWriter、StringBufferInputStream& & &2.Pipe管道 &实现管道的输入和输出（进程间通信）: PipedReader、PipedWriter、PipedInputStream、PipedOutputStream& & &3.File 文件流。对文件进行读、写操作 ：FileReader、FileWriter、FileInputStream、FileOutputStream& & &4. ObjectSerialization 对象输入、输出 ：ObjectInputStream、ObjectOutputStream& & &5.DataConversion数据流&按基本数据类型读、写（处理的数据是Java的基本类型（如布尔型，字节，整数和浮点数））：DataInputStream、DataOutputStream& & &6.Printing 包含方便的打印方法 ：PrintWriter、PrintStream& & &7.Buffering缓冲&&在读入或写出时，对数据进行缓存，以减少I/O的次数：BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream& & &8.Filtering 滤流，在数据进行读或写时进行过滤：FilterReader、FilterWriter、FilterInputStream、FilterOutputStream过& & &9.Concatenation合并输入 把多个输入流连接成一个输入流 ：SequenceInputStream & & 10.Counting计数& 在读入数据时对行记数 ：LineNumberReader、LineNumberInputStream& & 11.Peeking Ahead 通过缓存机制，进行预读 ：PushbackReader、PushbackInputStream& & 12.Converting between Bytes and Characters 按照一定的编码/解码标准将字节流转换为字符流，或进行反向转换（Stream到Reader,Writer的转换类）：InputStreamReader、OutputStreamWriter
二、按数据来源（去向）分类：&1、File（文件）： FileInputStream, FileOutputStream, FileReader, FileWriter&2、byte[]：ByteArrayInputStream, ByteArrayOutputStream&3、Char[]: CharArrayReader, CharArrayWriter&4、String: StringBufferInputStream, StringReader, StringWriter&5、网络数据流：InputStream, OutputStream, Reader, Writer&
&1. InputStream抽象类&
& & & InputStream 为字节输入流，它本身为一个抽象类，必须依靠其子类实现各种功能，此抽象类是表示字节输入流的所有类的超类。&继承自InputStream& 的流都是向程序中输入数据的，且数据单位为字节（8bit）；
InputStream是输入字节数据用的类，所以InputStream类提供了3种重载的read方法.Inputstream类中的常用方法：&　　（1） public abstract int read( )：读取一个byte的数据，返回值是高位补0的int类型值。若返回值=-1说明没有读取到任何字节读取工作结束。　　（2） public int read(byte b[ ])：读取b.length个字节的数据放到b数组中。返回值是读取的字节数。该方法实际上是调用下一个方法实现的&　　（3） public int read(byte b[ ], int off, int len)：从输入流中最多读取len个字节的数据，存放到偏移量为off的b数组中。&　　（4） public int available( )：返回输入流中可以读取的字节数。注意：若输入阻塞，当前线程将被挂起，如果InputStream对象调用这个方法的话，它只会返回0，这个方法必须由继承InputStream类的子类对象调用才有用，&　　（5） public long skip(long n)：忽略输入流中的n个字节，返回值是实际忽略的字节数, 跳过一些字节来读取&　　（6） public int close( ) ：我们在使用完后，必须对我们打开的流进行关闭.&
& & & & &主要的子类：
& & & & &1） FileInputStream把一个文件作为InputStream，实现对文件的读取操作 & &&　　 &2） ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用&　　 &3） StringBufferInputStream：把一个String对象作为InputStream&　　 &4） PipedInputStream：实现了pipe的概念，主要在线程中使用&　　 &5） SequenceInputStream：把多个InputStream合并为一个InputStream&
&2．OutputStream抽象类&　　OutputStream提供了3个write方法来做数据的输出，这个是和InputStream是相对应的。&　　1. public void write(byte b[ ])：将参数b中的字节写到输出流。&　　2. public void write(byte b[ ], int off, int len) ：将参数b的从偏移量off开始的len个字节写到输出流。&　　3. public abstract void write(int b) ：先将int转换为byte类型，把低字节写入到输出流中。&　　4. public void flush( ) : 将数据缓冲区中数据全部输出，并清空缓冲区。&　　5. public void close( ) : 关闭输出流并释放与流相关的系统资源。&
& & & &主要的子类：
& & &&1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中&& & & 2) FileOutputStream：把信息存入文件中&& & & 3) PipedOutputStream：实现了pipe的概念，主要在线程中使用&& & & 4) SequenceOutputStream：把多个OutStream合并为一个OutStream&
流结束的判断：方法read()的返回值为-1时；readLine()的返回值为null时。3. 文件输入流： FileInputStream类
& & & FileInputStream可以使用read()方法一次读入一个字节，并以int类型返回，或者是使用read()方法时读入至一个byte数组，byte数组的元素有多少个，就读入多少个字节。在将整个文件读取完成或写入完毕的过程中，这么一个byte数组通常被当作缓冲区，因为这么一个byte数组通常扮演承接数据的中间角色。
作用：以文件作为数据输入源的数据流。或者说是打开文件，从文件读数据到内存的类。使用方法(1) & && &File &fin=new File("d:/abc.txt");&& FileInputStream in=new FileInputStream( fin);
使用方法(2)& &FileInputStream &in=new&&FileInputStream(“d: /abc.txt”);
程序举例：将InputFromFile.java的程序的内容显示在显示器上
代码如下:import java.io.IOE& import java.io.FileInputS& public class TestFile {& &&& public static void main(String args[]) throws IOException {& &&&&&&& try{&&&&& &&&&&&&&&&&&&& FileInputStream rf=new&& FileInputStream("InputFromFile.java");& &&&&&&&&&&&&&& int n=512;&& byte& buffer[]=new& byte[n];&&&& &&&&&&&&&&&&&& while((rf.read(buffer,0,n)!=-1)&&(n&0)){& &&&&&&&&&&&&&&&&&& System.out.println(new String(buffer) );& &&&&&&&&&&&&&&& }& &&&&&&&&&&&&&&& System.out.println();& &&&&&&&&&&&&&&& rf.close();& &&&&&&& } catch(IOException& IOe){&&&&&&& &&&&&&&&&&&&& System.out.println(IOe.toString());& &&&&&&& }& &&& }& }&&&&&&&&&&&&& 4.文件输出流:FileOutputStream类　 &作用：用来处理以文件作为数据输出目的数据流；或者说是从内存区读数据入文件
& & & FileOutputStream类用来处理以文件作为数据输出目的数据流；一个表示文件名的字符串，也可以是File或FileDescriptor对象。&　　创建一个文件流对象有两种方法：&　　方式1：&　　&File & f=new &File (“d:/myjava/write.txt ");& & & & FileOutputStream &out= new FileOutputStream (f);　　方式2：&　　FileOutputStream out=new FileOutputStream(“d:/myjava/write.txt ");&　　方式3：构造函数将 FileDescriptor()对象作为其参数。&　　FileDescriptor() fd=new FileDescriptor();&　　FileOutputStream f2=new FileOutputStream(fd);&　　方式4：构造函数将文件名作为其第一参数，将布尔值作为第二参数。&　　FileOutputStream f=new FileOutputStream("d:/abc.txt",true);&　　注意：&（1）文件中写数据时，若文件已经存在，则覆盖存在的文件；（2）的读/写操作结束时，应调用close方法关闭流。&
程序举例：使用键盘输入一段文章，将文章保存在文件write.txt中 代码如下:import java.io.IOE& import java.io.FileOutputS& public class TestFile {& &&& public static void main(String args[]) throws IOException {& &&&&&&& try {& &&&&&&&&&&& System.out.println("please Input from&&&&& Keyboard");& &&&&&&&&&&& int count, n = 512;& &&&&&&&&&&& byte buffer[] = new byte[n];& &&&&&&&&&&& count = System.in.read(buffer);& &&&&&&&&&&& FileOutputStream wf = new FileOutputStream("d:/myjava/write.txt");& &&&&&&&&&&& wf.write(buffer, 0, count);& &&&&&&&&&&& wf.close(); // 当流写操作结束时，调用close方法关闭流。&& &&&&&&&&&&& System.out.println("Save to the write.txt");& &&&&&&& } catch (IOException IOe) {& &&&&&&&&&&& System.out.println("File Write Error!");& &&&&&&& }& &&& }& }&&&&&&&&& 5. FileInputStream流和FileOutputStream的应用
利用程序将文件file1.txt 拷贝到file2.txt中。 代码如下:import java.io.F& import java.io.IOE& import java.io.FileOutputS& import java.io.FileInputS& public class TestFile {& &&& public static void main(String args[]) throws IOException {& &&&&&&& try {& &&&&&&&&&&& File inFile = new File("copy.java");& &&&&&&&&&&& File outFile = new File("copy2.java");& &&&&&&&&&&& FileInputStream finS = new FileInputStream(inFile);& &&&&&&&&&&& FileOutputStream foutS = new FileOutputStream(outFile);& &&&&&&&&&&&& &&&&&&&&&&& while ((c = finS.read()) != -1) {& &&&&&&&&&&&&&&& foutS.write(c);& &&&&&&&&&&& }& &&&&&&&&&&& finS.close();& &&&&&&&&&&& foutS.close();& &&&&&&& } catch (IOException e) {& &&&&&&&&&&& System.err.println("FileStreamsTest: " + e);& &&&&&&& }& &&& }& }&
6. 缓冲输入输出流&BufferedInputStream/&BufferedOutputStream& & & &&
& & & &计算机访问外部设备非常耗时。访问外存的频率越高，造成CPU闲置的概率就越大。为了减少访问外存的次数，应该在一次对外设的访问中，读写更多的数据。为此，除了程序和流节点间交换数据必需的读写机制外，还应该增加缓冲机制。缓冲流就是每一个数据流分配一个缓冲区，一个缓冲区就是一个临时存储数据的内存。这样可以减少访问硬盘的次数,提高传输效率。
BufferedInputStream:当向缓冲流写入数据时候，数据先写到缓冲区，待缓冲区写满后，系统一次性将数据发送给输出设备。
BufferedOutputStream :当从向缓冲流读取数据时候，系统先从缓冲区读出数据，待缓冲区为空时，系统再从输入设备读取数据到缓冲区。
1）将文件读入内存：
将BufferedInputStream与FileInputStream相接
& FileInputStream&in=new&&FileInputStream( “file1.txt ” );
& BufferedInputStream&bin=new&&BufferedInputStream(&in);&
2）将内存写入文件：
将BufferedOutputStream与&FileOutputStream相接
FileOutputStreamout=new&FileOutputStream(“file1.txt”);
BufferedOutputStream&&bin=new&BufferedInputStream(out);3）键盘输入流读到内存
将BufferedReader与标准的数据流相接&
&InputStreamReader&sin=new&InputStreamReader (System.in) ；
BufferedReader bin=new & & & & & &&BufferedReader(sin); 代码如下:import java.io.*;& public class ReadWriteToFile {& &&& public static void main(String args[]) throws IOException {& &&&&&&& InputStreamReader sin = new InputStreamReader(System.in);& &&&&&&& BufferedReader bin = new BufferedReader(sin);& &&&&&&& FileWriter out = new FileWriter("myfile.txt");& &&&&&&& BufferedWriter bout = new BufferedWriter(out);& &&&&&&& S& &&&&&&& while ((s = bin.readLine()).length() & 0) {& &&&&&&&&&&& bout.write(s, 0, s.length());& &&&&&&& }& &&& }& }& 程序说明：从键盘读入字符，并写入到文件中BufferedReader类的方法：String readLine()作用：读一行字符串，以回车符为结束。BufferedWriter类的方法：bout.write(String s,offset,len)作用：从缓冲区将字符串s从offset开始，len长度的字符串写到某处。
& & & &&Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。
1. Reader抽象类
& &&用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。& & & &
1) FileReader :与FileInputStream对应 主要用来读取字符文件，使用缺省的字符编码，有三种构造函数： (1）将文件名作为字符串 ：FileReader f=new FileReader(“c:/temp.txt”); (2）构造函数将File对象作为其参数。 File f=new file(“c:/temp.txt”); FileReader f1=new FileReader(f); (3) 构造函数将FileDescriptor对象作为参数 FileDescriptor() fd=new FileDescriptor() FileReader f2=new FileReader(fd); (1) 用指定字符数组作为参数：CharArrayReader(char[]) (2) 将字符数组作为输入流:CharArrayReader(char[], int, int) 读取字符串，构造函数如下： public StringReader(String s); 2) CharArrayReader：与ByteArrayInputStream对应 3) StringReader : 与StringBufferInputStream对应 4) InputStreamReader 从输入流读取字节，在将它们转换成字符:Public inputstreamReader(inputstream is); 5) FilterReader: 允许过滤字符流 protected filterReader(Reader r); 6) BufferReader :接受Reader对象作为参数，并对其添加字符缓冲器，使用readline()方法可以读取一行。 Public BufferReader(Reader r); & & & 主要方法：
& & &&(1) &public&int&read()&throws&IOE&//读取一个字符，返回值为读取的字符&
　　(2) &public&int&read(char&cbuf[])&throws&IOE&/*读取一系列字符到数组cbuf[]中，返回值为实际读取的字符的数量*/&　　(3) &public&abstract&int&read(char&cbuf[],int&off,int&len)&throws&IOE&　　/*读取len个字符，从数组cbuf[]的下标off处开始存放，返回值为实际读取的字符数量，该方法必须由子类实现*/&2. Writer抽象类
& & &写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。 其子类如下：
& & &&1） FileWrite:&与FileOutputStream对应 &　　将字符类型数据写入文件，使用缺省字符编码和缓冲器大小。&　　Public FileWrite(file f);&　　2) &chararrayWrite:与ByteArrayOutputStream对应 ,将字符缓冲器用作输出。&　　 & &Public CharArrayWrite();&　　3) PrintWrite:生成格式化输出&　　 & &public PrintWriter(outputstream os);&　　4) filterWriter:用于写入过滤字符流&　　 & &protected FilterWriter(Writer w);&　　5) PipedWriter：与PipedOutputStream对应 &&
& & &&6) StringWriter：无与之对应的以字节为导向的stream &
& & & 主要方法：
　　(1) &public&void&write(int&c)&throws&IOException；&//将整型值c的低16位写入输出流&　　(2) &public&void&write(char&cbuf[])&throws&IOException；&//将字符数组cbuf[]写入输出流&　　(3) &public&abstract&void&write(char&cbuf[],int&off,int&len)&throws&IOException；&//将字符数组cbuf[]中的从索引为off的位置处开始的len个字符写入输出流&　　(4) &public&void&write(String&str)&throws&IOException；&//将字符串str中的字符写入输出流&　　(5) &public&void&write(String&str,int&off,int&len)&throws&IOException；&//将字符串str&中从索引off开始处的len个字符写入输出流&　　(6) &flush(&) //刷空输出流，并输出所有被缓存的字节。&　　(7)close()&&&&关闭流&public&abstract&void&close()&throws&IOException3 .InputStream与Reader差别 OutputStream与Writer差别InputStream和OutputStream类处理的是字节流，数据流中的最小单位是字节(8个bit)Reader与Writer处理的是字符流，在处理字符流时涉及了字符编码的转换问题 代码如下:import java.io.*;& public class EncodeTest {& &&& private static void readBuff(byte [] buff) throws IOException {& &&&&&& ByteArrayInputStream in =new ByteArrayInputStream(buff);& &&&&&&&& &&&&&&& while((data=in.read())!=-1)&& System.out.print(data+"& ");& &&&&&&& System.out.println();&&&& in.close();&&&& }& && public static void main(String args[]) throws IOException {& &&&&&& System.out.println("内存中采用unicode字符编码：" );& &&&&&& char&& c='好';& &&&&&& int lowBit=c&0xFF;&&&& int highBit=(c&0xFF00)&&8;& &&&&&& System.out.println(""+lowBit+"&& "+highBit);& &&&&&& String s="好";& &&&&&& System.out.println("本地操作系统默认字符编码：");& &&&&&& readBuff(s.getBytes());& &&&&&& System.out.println("采用GBK字符编码：");& &&&&&& readBuff(s.getBytes("GBK"));& &&&&&& System.out.println("采用UTF-8字符编码：");&&&&&&& &&&&&& readBuff(s.getBytes("UTF-8"));&&&&& }& }& Reader类能够将输入流中采用其他编码类型的字符转换为Unicode字符，然后在内存中为其分配内存Writer类能够将内存中的Unicode字符转换为其他编码类型的字符，再写到输出流中。
1.public class &EOFException ：& &非正常到达文件尾或输入流尾时，抛出这种类型的异常。2.public class FileNotFoundException：& &当文件找不到时，抛出的异常。3.public class InterruptedIOException：& &当I/O操作被中断时，抛出这种类型的异常。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具