[置顶] JavaSE学习笔记_18：Java-IO流
2016-04-10 21:03
531 查看
IO流
概述
IO流是用来处理设备上数据的一种技术。该技术都被封装成不同的类，存放在java.io包中，供开发者使用。注意：流中所有的方法都有可能抛出异常，因此需解决异常问题。
1) 流按操作数据分为两种：字节流（通用流）与字符流
2) 流按流向分为两种：输入流，输出流
拓展：
字符流要用到编码表，写程序的时候可以指定编码表，这样就不至于乱码。编码表主要的特点就是映射。
在外国用的是ASCII码表：将字母与01二进代码对应起来
在中过用到是GB2312码表（之后扩容GBK）：将汉子与01二进制代码对应起来
把各国的文字统一起来，就有了国际标准码表，叫做Unicode码表。
该码表的特点：Unicode里面的无论什么字符都用两个字节表示，虽然能表示很多个字符，但是，有些字符只要8为就可以搞定，因此有点浪费空间，这时就出来一个UTF-8码表，即一个字节能装的下就用一个字节装，一个装不下就用两个表，按需分配。
IO流常用的基类：
字节流的抽象基类：InputStream（读）、OutputStream（写）。
字符流的抽象基类：Reader（读）、Writer（写）
Ps：这四个类派生出来的子类名称都是以其父类名作为子类的后缀。如：
InputStream的子类FileInputStream
Reader的子类FileReader
温馨提示：流对象对同一个文件进行读和写操作，要注意是否需要将读方法和写方法对应（比如readInt（）和writeInt（））从而保证读出来的内容和写进去的内容一样。字符流中的读写方法是以字符为单位的，字节流中的读写方法是以字节为单位的。
字符流
一、FileWriter
1、往文件中写入文字
在硬盘上，创建一个文件并写入一些文字数据。
import java.io.*;
class FileWriterDemo
{
/*
所用到的方法：
FileWriter(),write()，flush(),close()
都有可能发生I/O错误，都会抛出I/O异常。
*/
public static void main(String[] args)throws IOException
{
/*
创建一个FileWriter对象。
该对象一被初始化就必要确定被操作的文件。
而且该文件会被创建到指定目录下。
如果该目录下已有同名文件，将被覆盖。
其实该步就是在明确数据要存放的目的地。
现在是在当前目录下。
*/
FileWriter fw=new FileWriter("demo.txt");
/*
调用write（），将字符串写入到流缓冲区中。
*/
fw.write("hello java");
/*
刷新流缓冲区中
26bc8
的数据，
将数据刷新到目的地。
*/
fw.flush();//可以省略不写。
/*
关闭流，但是关闭之前会刷新一次内部缓冲区中
的数据，将数据刷新到目的地中。它和flush的区
别在于，flush刷新后，流还可以继续使用，close
刷新后，会将流关闭。
若流多时，需要一个一个关闭。
*/
fw.close();
}
}
//其实，IO流在调用windows底层资源，
//具体的工作都是windows底层自己做，
//很好地体现了平台无关性。
2、异常处理
|--IOException
|--FileNoFoundException
代码如下：
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args)
{
FileWriter fw=null;
try
{
fw=new FileWriter("demo.txt");
fw.write("agasfsdgs");
}
catch (IOException e)
{
System.out.println("catch1="+e.toString());
}
finally
{
try
{
if(fw!=null)
fw.close();
}
catch (IOException e)
{
System.out.println("catch2="+e.toString());
}
}
}
}
3、文本文件的续写
续写是指，我们进行第二次编译运行时，如果指定的目录
存在，则不去覆盖，而是接着已有内容写入数据。
代码如下：
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args)throws IOException
{
/*
创建流对象时，往里边再传递一个参数true，
代表不覆盖已有的文件。并在已有的文件的末尾
处进行数据的续写。
续写有两种方式：
方式一：
通过改动write（）方法中的参数。
方式二：
通过连续调用write（），较麻烦。
*/
FileWriter fw=new FileWriter("demo.txt",true);
fw.write("haofahfao;\r\nfjw");
fw.close();
}
}
ps：我们知道，创建一个写入文本文件流对象之后，我们通过调用write（String str），指定的内容可能先是被写入到了流缓冲区中，然后通过调用flush()或者是close（）才将缓冲区中的内容刷到目的地。目前还没有学习到BufferedWriter，因此认为指定的内容都是被写入到目的地。
4、BufferedWriter
该类称之为字符流的缓冲区。缓冲区的出现提供了对数据
写入速度。要结合流才可以使用，在流的基础上对流的功 能进行了增强。它同时提供了一个跨平台的换行符： newline（）。引入了缓冲区之后，一些写入、关流、刷 新 等方法 都由缓冲区对象进行调用。需要注意的是， 用到 缓冲区， 就要记得刷 新， 防止断电，数据流 失。
示例：
import java.io.*;
class BufferedWriterDemo
{
public static void main(String[] args)throws IOException
{
/*
创建一个字符写入流对象。
*/
FileWriter fw=new FileWriter("buf.txt");
/*
为了提高字符写入流效率，加入缓冲区技术。
只要将需要被提高效率的流对象作为参数传递给缓冲区
的构造函数即可。
*/
BufferedWriter bufw=new BufferedWriter(fw);
for(int x=1;x<=10;x++)
{
bufw.write("abcd"+x);
bufw.newLine();
bufw.flush();
}
bufw.flush();
bufw.close();
}
}
二、FileRead
1、文本文件的读取
方式一：
import java.io.*;
class FileReadDemo
{
public static void main(String[] args)throws IOException
{
/*
创建一个FileRead对象，
和指定名称的文件相关联，
要保证该文件是已经存在的，
如果不存在会发生异常FileNotFoundException。
*/
FileReader fr=new FileReader("demo.txt");
/*
调用read（），
该方法一次读取一个字符，
而且会自动往下读；
该方法返回值类型是int类型，到达流的末尾返回-1，
将读取到的字符以整数形式
展现。
*/
int ch = fr.read();
System.out.println("ch="+(char)ch);
int ch1 = fr.read();
System.out.println("ch1="+(char)ch1);
int ch2 = fr.read();
System.out.println("ch2="+(char)ch2);
fr.close();
}
}
优化：
import java.io.*;
class FileReadDemo
{
public static void main(String[] args)throws IOException
{
FileReader fr=new FileReader("demo.txt");
int ch=0;
while((ch=fr.read())!=-1)
{
System.out.println((char)ch);
}
/*
while(true)
{
if((ch=fr.read())!=-1)
System.out.println((char)ch);
else
break;
}
*/
fr.close();
}
}
方式二：
import java.io.*;
class FileReaderDemo
{
public static void main(String[] args)throws IOException
{
FileReader fr=new FileReader("demo.txt");
/*
定义一个字符数组，用于存储读到的字符。
*/
char[] buf=new char[1024];
/*
通过int read(char[] buf),
将读到字符放进数组，
返回值表示读到的字符个数，
这个个数由数组的长度（2）和流中剩余字符个数（1）决定。
自动往下读，
当读到流的末尾，返回-1。
再通过创建String类型，
将字符数组中的内容换成
字符串打印输出。
*/
int num=0；
while((num=fr.read(buf))!=-1)
{
System.out.println(new String(buf,0,num) );
}
fr.close();
}
}
2、文本文件读取练习
读取一个文件，并打印到控制台上。
import java.io.*;
class FileReaderDemo
{
public static void main(String[] args)throws IOException
{
FileReader fr=new FileReader("SystemDemo.java");
char[] buf=new char[1024];
int num=0;
while((num=fr.read(buf))!=-1)
{
System.out.println(new String(buf,0,num) );
}
fr.close();
}
}
运行结果如下图所示：
发现，打印出来的文件排版都没有变化。但是，我们想，当我们的文本文件大于2kB， 那么打印出来的排版格式一定会发生改变，因为我们不是接着打印的。因此我们通常将 System.out.println()换成System.out.print（）。
ps：我们知道，创建读取文本文件流对象，我们通过调用read（），或者是read（char[] buf）读取数据。当到达流末尾时，返回的是-1.
3、BufferedReader
该类称之为字符读取缓冲区。缓冲区的出现提供了对数据
读出速度。要结合流才可以使用，在流的基础上对流的功 能进行了增强，通过提供一个一次读一行的方法：String readLine（）：当返回null时，表示读到文件末尾，该 方 法返回的时候只返回回车符之前的数据内容，并不返 回回 车符。引入了缓冲区之后，一些写入、关流、刷 新 等 方 法 都由缓冲区对象进行调用。
示例：
import java.io.*;
class BufferedReaderDemo
{
public static void main(String[] args)throws IOException
{
/*
创建一个读取流对象和文件相关联。
*/
FileReader fr=new FileReader("buf.txt");
/*
为了提高效率。加入缓冲技术。
将字符读取流对象作为参数传递给缓冲对象的构造函数。
*/
BufferedReader bufr=new BufferedReader(fr);
String line=null;
while((line=bufr.readLine())!=null)
{
System.out.println(line);
}
bufr.close();
}
}
拓展：
|--BufferedReader
|--LineNumberReader
① 跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和
getLineNumber()，它们可 分别用于设置和获取当前行号。
② 默认情况下，行编号从 0 开始。该行号随数据读取 在每个行结束符处递增，并且可以通过调用 setLineNumber(int) 更改行号。但要注意的是， setLineNumber(int) 不会实际更改流中的当前位 置；它只更改将由 getLineNumber() 返回的值。
③ 可认为行在遇到以下符号之一时结束：换行符 （'\n'）、回车符（'\r'）、回车后紧跟换行符。
示例：
import java.io.*;
class LineNumberReaderDemo
{
public static void main(String[] args)throws IOException
{
FileReader fr=new FileReader("SystemDemo.java");
LineNumberReader lnr=new LineNumberReader(fr);
String line=null;
lnr.setLineNumber(6);
while((line=lnr.readLine())!=null)
{
System.out.println(lnr.getLineNumber()+"::"+line);
}
}
}
运行结果如下图所示：
三、FileWriter和FileReader的搭配应用
需求：将C盘下的一个文本文件复制到D盘下。
方式一：简洁版
import java.io.*;
class CopyText
{
public static void main(String[] args)throws IOException
{
FileReader fr=new FileReader("C:\\java.txt");
FileWriter fw=new FileWriter("D:\\java_copy.txt");
int ch=0;
while((ch=fr.read())!=-1)
{
fw.write((char)ch);
}
fr.close();
fw.close();
}
}
方式二：复杂版
import java.io.*;
class CopyText
{
public static void main(String[] args)
{
FileReader fr=null;
FileWriter fw=null;
try
{
fr=new FileReader("C:\\java.txt");
fw=new FileWriter("D:\\java_copy.txt");
int num=0;
char[] buf=new char[1024];
while((num=fr.read(buf))!=-1)
{
fw.write(buf,0,num);
}
}
catch (IOException e)
{
throw new RuntimeException("读写失败");
}
finally
{
try
{
if(fr!=null)
fr.close();
}
catch (IOException e)
{
}
try
{
if(fw!=null)
fw.close();
}
catch (IOException e)
{
}
}
}
}
四、BufferedReader和BufferedWriter的搭配使用
方式一：（简洁版）
import java.io.*;
class CopyTextBybuf
{
public static void main(String[] args)throws IOException
{
FileReader fr=new FileReader("C:\\java.txt");
FileWriter fw=new FileWriter("D:\\java_copy.txt");
BufferedReader bufr=new BufferedReader(fr);
BufferedWriter bufw=new BufferedWriter(fw);
String line=null;
while((line=bufr.readLine())!=null)
{
bufw.write(line);
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}
方式二：（复杂版）
import java.io.*;
class CopyTextBybuf
{
public static void main(String[] args)
{
FileReader fr=null;
FileWriter fw=null;
BufferedReader bufr=null;
BufferedWriter bufw=null;
try
{
fr=new FileReader("C:\\java.txt");
fw=new FileWriter("D:\\java_copy.txt");
bufr=new BufferedReader(fr);
bufw=new BufferedWriter(fw);
String line=null;
while((line=bufr.readLine())!=null)
{
bufw.write(line);
bufw.newLine();
bufw.flush();
}
}
catch (IOException e)
{
throw new RuntimeException("创建失败");
}
finally
{
if(bufr!=null)
try
{
bufr.close();
}
catch (IOException e)
{
throw new RuntimeException("读取关闭失败");
}
if(bufw!=null)
try
{
bufw.close();
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败");
}
}
}
}
装饰设计模式
一、什么是装饰设计模式
当想要对已有的对象进行功能增强时，又不想对已有功能 进行修改。此时可以定义一个新的类，建立新类的对象， 将已有对象传入，通过构造方法接收该已有对象，基于 已有对象的功能，提供更强的功能。那么自定义类称为装 饰类。
如：
class Person
{
public void chiFan()
{
System.out.println("吃饭");
}
}
//自定义一个类，作为装饰类。
class SuperPerson
{
private Person p;
SuperPerson(Person p)
{
this.p=p;
}
public void superChiFan()
{
System.out.println("开胃酒");
p.chiFan();
System.out.println("甜点");
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p=new Person();
SuperPerson sp=new SuperPerson(p);
sp.superChiFan();
}
}
二、装饰和继承的区别
想要给已有对象提供更强的功能：
1．如果是用继承来做
|--MyReader
|--MyTextReader
|--MyBufferTextReader
|--MyMediaReader
|--MyBufferMediaReader
|--MyDataReader
|--MyBufferDataReader
2．如果是用装饰来做
|--MyReader
|--MyTextReader
|--MyMediaReader
|--MyDataReader
|--MyBufferReader
class MyBufferReader
{
MyBufferReader(MyTextReader text)
{}
MyBufferReader(MyMediaReader media)
{}
}
多态思想：
class MyBufferReader
{
private MyReader r;
MyBufferReader(MyReader r)
{}
}
3、总结
综上所述，装饰模式比继承要灵活，避免了继承体系的臃肿。单独描述一下缓冲内容，将需要被缓冲的对象传递进来。
三、自定义装饰类
import java.io.*;
class MyBuffererReader extends Reader
{
private Reader r;
MyBufferedReader(Reader r)
{
this.r=r;
}
public String myReadLine()throws IOException
{
StringBuffer sb=new StringBuffer();
int ch=0;
while((ch=r.read())!=-1)
{
if(ch=='\r')
continue;
if(ch=='\n')
return sb.toString()
else
sb.append(ch);
}
if(sb.length()!=-1)
return sb.toString();
return null;
}
public void myClose()throws IOException
{
r.close();
}
//复写Read类中的抽象方法
public void close()throws IOException
{
r.close();
}
public int read(char[] cbuf,int off,int len)throws IOException
{
return r.read(cbuf,off,len);
}
}
字节流
字节流对象在写如数据时，无论什么情况下都不需要刷 新，直接往目的地里，因为它是最小的单位。处理图片都 需要用字节流。
一、FileInputStream
1、需求：
读取一个图片文件。
代码如下：
import java.io.*;
class FileInputStreamDemo
{
public static void main(String[] args)throws IOException
{
readFile_3();
}
//方法一：
/*
通过int read（）：从此输入流中读取下一个数据字节。
返回一个 0 到 255 范围内的 int 字节值。
如果因为已经到达流末尾而没有字节可用，则返回 -1。
*/
public static void readFile_1()throws IOException
{
FileInputStream fis=new FileInputStream("C:\\123.jpg");
int ch=0;
while ((ch=fis.read())!=-1)
{
System.out.print((char)ch);
}
fis.close();
}
//方法二：
/*
通过int read(byte[] b) ：
从此输入流中将 byte.length 个字节的数据读入一个 byte 数组中。
如果因为已经到达流末尾而没有更多的数据，则返回 -1。
*/
public static void readFile_2()throws IOException
{
FileInputStream fis=new FileInputStream("C:\\123.jpg");
int num=0;
byte[] buf=new byte[1024];
while ((num=fis.read(buf))!=-1)
{
System.out.print(new String(buf,0,num));
}
fis.close();
}
//方法三：
/*
通过调用available（）：获取文件中总的字节数。
根据该数目定义一个刚刚好的缓冲区，不用再循环。
*/
public static void readFile_3()throws IOException
{
FileInputStream fis=new FileInputStream("C:\\123.jpg");
byte[] buf=new byte[fis.available()];
fis.read(buf);
System.out.println(new String(buf));
fis.close();
}
}
2、BufferedInputStream
与BufferedReader功能类似，可以参照学习，
此处不做过多阐述。
二、FileOutputStream
1、需求：
写入一个文件。
代码如下：
import java.io.*;
class FileOutputStreamDemo
{
public static void main(String[] args)throws IOException
{
FileOutputStream fos=new FileOutputStream("C:\\fos.txt");
fos.write("coanoafds".getBytes());
fos.close();
}
}
2、BufferedOutputStream
与BufferedWriter功能类似，可以参照学习，
此处不做过多阐述。
三、FileInputStream和FileOutputStream的搭配应用
需求：将C盘下的图片文件复制到D盘下。
import java.io.*;
class CopyPic
{
public static void main(String[] args)
{
FileInputStream fis=null;
FileOutputStream fos=null;
try
{
fis=new FileInputStream("C:\\123.jpg");
fos=new FileOutputStream("D:\\123_copy.jpg");
int ch=0;
while((ch=fis.read())!=-1)
{
fos.write((char)ch);//也可以不强转
}
}
catch (IOException e)
{
throw new RuntimeException("复制失败");
}
finally
{
if(fis!=null)
try
{
fis.close();
}
catch (IOException e)
{
throw new RuntimeException("读取流关闭失败");
}
if(fos!=null)
try
{
fos.close();
}
catch (IOException e)
{
throw new RuntimeException("写入流关闭失败");
}
}
}
}
四、BufferedInputStream和BufferedOutputStream的搭配应用
1、需求：将C盘下的图片文件复制到D盘下。
import java.io.*;
class CopyPicBybuf
{
public static void main(String[] args)
{
long star=System.currentTimeMillis();
copy();
long end=System.currentTimeMillis();
System.out.println("time="+(end-star));
}
public static void copy()
{
FileInputStream fis=null;
FileOutputStream fos=null;
BufferedInputStream bufis=null;
BufferedOutputStream bufos=null;
try
{
fis=new FileInputStream("C:\\123.jpg");
fos=new FileOutputStream("D:\\123_copy.jpg");
bufis=new BufferedInputStream(fis);
bufos=new BufferedOutputStream(fos);
int ch=0;
while ((ch=bufis.read())!=-1)
{
bufos.write((char)ch);
}
}
catch (IOException e)
{
throw new RuntimeException("复制失败");
}
finally
{
if(bufis!=null)
try
{
bufis.close();
}
catch (IOException e)
{
throw new RuntimeException("读取流关闭失败");
}
if(bufos!=null)
try
{
bufos.close();
}
catch (IOException e)
{
throw new RuntimeException("写入流关闭失败");
}
}
}
}
运行结果如下图所示：
2、自定义读取字节流的缓冲区
import java.io.*;
class CopyPicByselfbuf
{
public static void main(String[] args)throws IOException
{
long star=System.currentTimeMillis();
copy();
long end=System.currentTimeMillis();
System.out.println();
}
public static void copy()throws IOException
{
FileInputStream fis=new FileInputStream("C:\\123.jpg");
FileOutputStream fos=new FileOutputStream("D:\\123_copy.jpg");
MyBufferedInputStream mbufis=new MyBufferedInputStream(fis);
BufferedOutputStream bufos=new BufferedOutputStream(fos);
int ch=0;
while((ch=mbufis.myRead())!=-1)
{
bufos.write(ch);
}
mbufis.myClose();
bufos.close();
}
}
class MyBufferedInputStream
{
private FileInputStream in;
private byte[] buf=new byte[1024];
private int pos=0;//字节数组的角标
private int count=0;//字节数组的元素个数
MyBufferedInputStream(FileInputStream in)
{
this.in=in;
}
public int myRead()throws IOException
{
//通过in对象读取硬盘上的数据，并存储buf中。
if(count==0)
{
count=in.read(buf);
if(count<0)
return -1;
pos=0;
byte b=buf[pos];
count--;
pos++;
return b;
}
else if(count>0)
{
byte b=buf[pos];
count--;
pos++;
return b;
}
else
return -1;
}
public void myClose()throws IOException
{
in.close();
}
}
编译运行之后，发现，图片副本内容为空。
分析：
我们知道，在内存中文件存在的形式是以01二进制代码形式存在的。myRead（）方法 每次返回的是一个int类型，我们想，如果第一个字节b的二进制形式是1111 1111， 那么它 被提升之后，1111 1111 1111 1111 1111 1111
1111 1111（-1），那 么copy（）中的while（）循环条件成立，流直接关闭，没有做任何事情，导致图片副 本为空。因此我们想在前面补0，这样既可以保留原字节数据不变，又可以避免-1的出 现，可以这样做，将返回值b与上一个255。
这样返回去的值就是int类型的值，想说读到的值和写入副本中的值不就不一样了
吗？这就要谈一谈write（）的特点了，它本身具有强转功能，只写入int类型的
最低8位。这样就保证了只有到达流的末尾才返回-1。
读取键盘录入
一、说明
System.out:对应的是标准的输出设备，控制台。
System.in:对应的是标准输入设备，键盘。
InputStream in=System.in；//获取键盘对象。
ps：无论从键盘录入什么，包括回车（有两个字符组成 “\r\n”）,读入之后打印到控制台上都是一整数形式出 现的。
二、需求：
1、通过键盘录入数据。
import java.io.*;
class ReadIn
{
public static void main(String[] args)throws IOException
{
InputStream in=System.in;
int by=in.read();
int by1=in.read();
int by2=in.read();
System.out.println(by);
System.out.println(by1);
System.out.println(by2);
}
}
运行过程如下图所示：
敲入字符按回车：
敲入字符，按ctrl+c：
温馨提示：这里的流对象不需要手动关闭，因为它是系统的，程序结束，就自动结 束了。
2、当录入一行数据后，就将该行数据进行打印。如 果 录入的数据是over，那么就停止录入。
import java.io.*;
class ReadIn
{
public static void main(String[] args)throws IOException
{
InputStream in=System.in;
StringBuffer sb=new StringBuffer();
while(true)
{
/*
in.read(),发挥两个作用：
1、开放了从键盘敲入字符的一个接口。
2、敲完字符进去以后，按下回车，就开始读取录入的字符。
*/
int ch=in.read();
if(ch=='\r')
continue;
if(ch=='\n')
{
String s=sb.toString();
if("over".equals(s))
break;
System.out.println(s.toUpperCase());
sb.delete(0,sb.length());
}
else
sb.append((char)ch);
}
}
}
转换流
一、将字节流转化成字符流，通过InputStreamReader
通过刚才的键盘录入一行数据并打印其大写的练习，我们可以发现其实就是读一行数据的原理，也就是readLine（）方法。但是readLine（）是BufferedReader中的方法，是属于字符流的范畴，而键盘录入是输入字节流的范畴，因此我们想到转换。
import java.io.*;
class TransStreamDemo
{
}
二、将字节流转化成字符流，通过OutputStreamWriter
同理，我们也可以将写入字节流转换成字符流。
import java.io.*;
class ReadIn
{
public static void main(String[] args)throws IOException
{
StringBuffer sb=new StringBuffer();
InputStream in=System.in;
OutputStream out=System.out;
OutputStreamWriter osw=new OutputStreamWriter(out);
BufferedWriter bufw=new BufferedWriter(osw);
while(true)
{
int ch=in.read();
if(ch=='\r')
continue;
if(ch=='\n')
{
String s=sb.toString();
if("over".equals(s))
break;
bufw.write(s.toUpperCase());
bufw.newLine();
bufw.flush();
sb.delete(0,sb.length());
}
else
sb.append((char)ch);
}
}
}
Ps:
转化流可以指定编码：
OutputStreamWriter osw=new OutputStreamWriter（
new FileOutputStream（“gbk.txt”）,"gbk"）;
osw.write("你好");
OutputStreamWriter osr=new OutputStreamWriter(
new FileOutputStream("utf.txt"),"utf");
osw.write("你好");
这是我们打开gbk.txt、utf.txt之后，里边的内容都是 “你好”，但是gbk编码的只需4个字节，而utf编码的
是6个字节。
以上就是不同编码的一点区别。
三、流的操作：弄清“源”和“目”
流操作规律：（三个明确）
① 明确“源”和“目”。
源：输入流。InputStream、Reader
目：输出流。OutputStream、Writer
② 操作的数据是否是纯文本。
是：字符流
不是：字节流
ps：如果“源”和“目”不同是，则字符优先。
不是字符的一方必须应用转换流转化成字符流。
③ 明确具体的流对象。通过设备来区分：
源设备：硬盘、键盘
目的设备：硬盘、控制台
1、把从键盘录入的字符，存放到控制台中。
1) 明确1：
“源”：InputStream、Reader
“目”：OutputStream、Writer
2）明确2：
不是：字节流
“源”：InputStream
“目”：OutputStream
3）明确3：
“源”：键盘
InputStream in=System.in;
“目”：控制台
OutputStream out=System.in
2、把从键盘录入的字符，存放到磁盘文件中。
1） 明确1：
“源”：InputStream、Reader
“目”：OutputStream、Writer
2）明确2：
以字符为准。
“源”：Reader
“目”：Writer
3）明确3：
“源”：键盘
InputStream in=System.in;
InputStreamReader isr=new InputStreamReader(in);
“目”：硬盘
FileWriter fw=new FileWriter(".....");
3、把磁盘文件中的内容，存放到控制台中。
1） 明确1：
“源”：InputStream、Reader
“目”：OutputStream、Writer
2）明确2：
以字符为准。
“源”：Reader
“目”：Writer
3）明确3：
“源”：硬盘
FileReader fr=new FileReader(".........");
“目”：控制台
OutputStream out=System.out;
OutputStreamWriter osw=new OutputStreamWriter(out);
l ps:转化流可以指定编码表
InputStreamReader(InputStream in,
Charset cs)
创建使用给定字符集的 InputStreamReader。
OutputStreamWriter(OutputStream out,
Charset cs)
创建使用给定字符集的 OutputStreamWriter
“源”和“目”只需指定一方。
l 练习:一般情况下，我们开发时，按照下列模板做。利用 转化流。
（1）把键盘录入的数据，存放到控制台中。
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args)throws IOException
{
InputStream in=System.in;
OutputStream out=System.out;
InputStreamReader isr=new InputStreamReader(in);
OutputStreamWriter osw=new OutputStreamWriter(out);
BufferedReader bufr=new BufferedReader(isr);
BufferedWriter bufw=new BufferedWriter(osw);
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}
（2）把键盘录入的数据，放到C盘下的一个文件中。
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args)throws IOException
{
InputStream in=System.in;
FileWriter fw=new FileWriter("C:\\687180q.txt");
InputStreamReader isr=new InputStreamReader(in);
BufferedReader bufr=new BufferedReader(isr);
BufferedWriter bufw=new BufferedWriter(fw);
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}
l 改变标准输入输出设备。
（1）static viod setIn(InputStream in):重新分配“标 准” 输入流。
（2）static void setOut（PrintStream out）：重新分 配“标准”输出流。
示例：
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args)throws IOException
{
System.setIn(new FileInputStream("SystemDemo.java"));
System.setOut(new PrintStream("C:\\z.txt"));
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}
可以选择注释：
System.setIn(new FileInputStream("SystemDemo.java"));
System.setOut(new PrintStream("C:\\z.txt"));
来改变“源”和“目”
拓展：
（1）异常的日志信息
import java.io.*;
import java.util.*;
import java.text.*;
class ExceptionInfo
{
public static void main(String[] args)
{
try
{
int[] arr=new int[2];
System.out.println(arr[3]);
}
catch (Exception e)
{
try
{
Date d=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
String s=sdf.format(d);
PrintStream ps=new PrintStream("exception.log");
ps.println(s);
System.setOut(ps);//改变输出流设备，位置任意。
}
catch (IOException ex)
{
throw new RuntimeException("日志文件创建失败");
}
e.printStackTrace(System.out);
}
}
}
（2）系统信息
import java.util.*;
import java.io.*;
class SystemInfo
{
public static void main(String[] args)throws IOException
{
Properties pro=System.getProperties();
System.out.println(pro);//不换行打印在控制台上。
pro.list(System.out);//换行打印在控制台上。
pro.list(new PrintStream("Systeminfo.txt"));//打印在文本文件中
}
}
四、转化流的字符编码
字符编码：
字符的出现为了方便操作字符，更重要的是加入编码转化
，通过了子类转化流来完成。InputStreamReader和
OutputStream。
编码表的由来：
计算机只能识别二进制数据，早期由来是电信号。为了方
便应用计算机，让它可以识别各个国家的文字，就将各个
国家的文字用数字来表示，并一一对应，形成一张表。这
就是编码表。
常见编码表：
ASCII：美国标准信息交换码。用一个字节的7位可以表
示。
ISO8859-1：拉丁码表。欧洲码表，用一个字节的8位表
示。不识别中文。
GB2312：中国的中文编码表。
GBK：中国的中文编码表升级，融合了更多的中文文字符
号。
Unicode：国际标准码表，融合了多种文字。所有文字都 用两个字节来表示，java语言使用的就是unicode。
UTF-8：最多用三个字节来表示，具体按需分配。
示例：
（1）：在转化流中
import java.io.*;
class EncodeDemo
{
public static void main(String[] args)throws IOException
{
//writeText();
readText();
}
public static void writeText()throws IOException
{
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("C:\\utf.txt"),"gbk");//不写的话，默认为GBK。
osw.write("你好！");
osw.close();
}
public static void readText()throws IOException
{
InputStreamReader isr=new InputStreamReader(new FileInputStream("C:\\utf.txt"),"gbk");
int ch=0;
while((ch=isr.read())!=-1)
{
System.out.print((char)ch);
}
}
}
ps：要注意对应关系。
（2）在一般情况中
字符串->字节：编码
String->byte[]:str.getBytes(charsetName);
字节->字符串：解码
byte[]->String：new String(byte[],charsetName);
import java.io.*;
import java.util.*;
class EncodeDemo
{
public static void main(String[] args)throws Exception
{
String s="你好";
/*编码*/
byte[] b1=s.getBytes("gbk");
System.out.println(Arrays.toString(b1));
/*解码*/
String s1=new String(b1,"gbk");
System.out.println(s1);
}
}
运行结果：[-60、-29、-70、-61]
你好
ps：要注意对应关系。
注意：如果不是对应关系，则就会出现解错码的问题，那
么有两种办法可以解决：
（1）更换编码表，是对应。
（2）再编一次。
如：
String s="你好";
byte[] b1=s.getBytes("gbk");
System.out.println(Arrays.toString(b1));
String s1=new String(b1,"ISO8859-1");
System.out.println("s1="+s1);
byte[] b2=s1.getBytes("ISO8859-1");
System.out.println(Arrays.toString(b2));
String s2=new String(b2,"gbk");
System.out.println("s2="+s2);
拓展：“联通”
现象：新建一个文本文档，往里边写入“你好”二字，
保存后关闭，再次打开还是“你好”二字。新建一个
文本文档，往里边写入“联通”二字，保存后关闭，
再次打开却不是“联通”二字。
这就是所谓的编码问题。
记事本也有编码解码过程。
练习：
/*
有5个学生，每个学生有3门课的成绩。
从键盘输入以上数据（包括姓名、三门课的成绩）
输入格式：如：zhangsan，30,40,50
计算出总成绩
并把学生信息和计算出的总分数按高低顺序村房子磁盘文件“stud.txt”中
*/
//思路：
/*
1、描述学生对象。
*/
class Student implements Comparable<Student>
{
private String name;
private int math,chinese,english;
private int sum;
Student(String name,int math,int chinese,int english)
{
this.name=name;
this.math=math;
this.chinese=chinese;
this.english=english;
sum=math+chinese+enlish;
}
public String getName()
{
return name;
}
public int getSum()
{
return sum;
}
public int compareTo(Student s)
{
int num=new Integer(this.sum)compareTo(new Integer(s.num));
if(num==0)
return this.name.compareTo(s.name);
return num;
}
public int hashCode()
{
return name.hashCode()+sum*87;
}
public boolean equals(Object obj)
{
if(!(obj instanceof(Student)))
throws new ClassCastException("类型不匹配");
Student s=(Student)obj;
return this.name.equals(s.name)&&this.sum==s.sum;
}
public String toString()
{
return "Student["+name+","+math+","+chinese+","+english;
}
}
class StudentInfoTool
{
public static Set<Student> getStudents()throws IOException
{
return getStudents(null);
}
public static Set<Student> getStudents(Comparator<Student>cmp)throws IOException
{
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
String line=null;
set<Student> stus=null;
if(cmp==null)
stu=new TreeSet<Student>();
else
stu=new TreeSet<Student>(cmp);
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
String[] info=line.split(",");
Student stu=new Student(info[0],Integer.parseInt(info[1]),Integer.parseInt(info[2]),Integer.parseInt(info[3]));
stu.add(stu);
}
bufr.close();
return stu;
}
public static void writeToFile(Set<Student> stus)throws IOException
{
BufferedWriter bufw=new BufferedWriter(new FileWriter("C:\\stuinfo.txt"));
for(Student stu:stus)
{
bufw.write(stu.toString()+"\t");
bufw.write(stu.getSum()+"");
bufw.newLine();
bufw.flush();
}
bufw.close();
}
}
class StudentInfoTest
{
public static void main(String[] args)throws IOException
{
Comparator<Student> cmp=Collection.reverseOrder();
Set<Student> stus=StudentInfoTool.getStudents(cmp);
StudentInfoTool.writeToFile(stus);
}
}
File
一、概述
1、用来将文件或者文件夹封装成对象。
2、方便对文件与文件夹的属性信息进行操做。
3、File对象可以作为参数传递给流的构造函数，
示例：
import java.io.*;
class FileDemo
{
public static void main(String[] args)
{
File f1=new File("a.txt");
System.out.println(f1);
File f2=new File("C:\\abc");
System.out.println(f2);
File f3=new File("C:\\abc\\c.txt");
System.out.println(f3);
File f4=new File(f2,"b.txt");
System.out.println(f4);
File f5=new File("C:\\abc","b.txt");
System.out.println(f5);
}
}
运行结果：
ps：封住之后，它们并没有真正存在。也可以封装已经存在的。
有一个跨平台的技巧：
可以将\\换成File.separator(与系统有关的默认名称分隔符，为了方便，它被表示为 一个字符串。)
二、功能
File类中常见的方法如下：
1、创建：
① static File createTempFile(String prefix,String suffix):在默认临时文件 目录中创建一个空文件（文件内容为空），使用给定前缀和后缀字符串生成其名称。
此文件类型不明确。
② static File createTempFile（String prefix，String suffix，File directory）：
在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。directory必须是已经存在的，否则会抛异常。此文件类型不明确。
③ boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建， 返回true。
如：创建一个不明类型的abc文件
File f=new File（"C:\\abc"）；
f.createNewFile();
如：创建一个.txt文件
File f=new File（"C:\\abc.txt"）；
f.createNewFile();
ps:这里只能封装一级目录。
④ boolean mkdir():创建单级或者多级文件夹。可以覆盖。
⑤ boolean mkdirs（）：创建单级或者多级文件夹。不可以覆盖。注意，此操作失 败时也可能已经成功地创建了一部分必需的父目录。
2、删除：
下列方法所属的对象都可以是已存在的也可以是还未存在的。
① boolean delete（）：删除失败返回false（程序可能中途发生异常，导致执行不 到）、文件在被占用时，无法删除，返回false。
② void deleteOnExit（）；在程序退出时删除指定文件。
3、判断：
下列方法所属的对象都可以是已存在的也可以是还未存在的。
若不存在，对象不管封装的是什么，都返回false
若存在，根据对象封装的是什么来判断。
上述规则不适用于isAbsolute（）。
① boolean exists():判断File对象是否存在。
② boolean isFile():判断File对象是否是文件。
③ boolean isDirectory():判断File对象是不是目录。
④ boolean isHidden():判断File对象是不是隐藏文件。
⑤ boolean isAbsolute():判断File对象是不是绝对路径。（如：C:\\abc\\c.txt）
⑥ boolean canExecute():判断File文件是否可以运行。
4、获取：
下列方法所属的对象都可以是已存在的也可以是还未存在的。
① String getName（）：返回最后一个名称。
② String getPath（）：返回File对象初始化内容。
③ String getParent（）：getPath（）-getName（）。
④ String getAbsolutePath（）：返回File对象初始化内容，即绝对路径。
⑤ String toString():返回File对象初始化内容。
⑥ long lastModified（）：返回File对象表示的文件或者文件夹最后一次被修改 的时间。
⑦ long length（）：返回File对象表示的文件或者文件夹的长度（单位：字节）。
三、功能的应用
1、文件列表
（1）String[] list()：列出指定目录下的内容。
import java.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException
{
File f=new File("F:\\JavaSDK");
String[] names=f.list();//f必须是已存在的目录，否则抛异常（无指向）。
for(String name:names)
{
System.out.println(name);
}
}
}
运行结果：
(2)Static File[] listRoots():列出可用的文件系统根。
import java.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException
{
File[] files=File.listRoots();
for(File f:files)
{
System.out.println(f);
}
}
}
运行结果：
(3)列出指定目录下的指定内容。过滤。
import java.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException
{
File dir=new File("F:\\JavaSDK\\day00\\");
String[] arr=dir.list(new FilenameFilter()
{
public boolean accept(File dir,String name)
{
System.out.println("dir:"+dir+"-------name:"+name);
return name.endsWith(".java");
}
});
System.out.println("len:"+arr.length);
for(String name:arr)
{
System.out.println(name);
}
}
}
（4）String[] list()和File[] listFiles()
1)
import java.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException
{
File f=new File("F:\\JavaSDK");
String[] arr=f.list();
for(String name:arr)
{
System.out.println(name);
}
}
}
运行结果：
2)
import java.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException
{
File f=new File("F:\\JavaSDK");
File[] arr=f.listFiles();
for(File name:arr)
{
System.out.println(name);
}
}
}
运行结果：
因此：一般我们优先采用File[] listFiles（）。
（5）列出指定目录下的所有内容，知道每一项没有内 容可列。--递归
递归要注意：
1）限定条件
2）要注意递归的次数。尽量避免内存溢出
import java.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException
{
File dir=new File("C:\\abc");
showDir(dir);
}
public static void showDir(File dir)
{
System.out.println(dir);
File[] files=dir.listFiles();
for(int x=0;x<files.length;x++)
{
if(files[x].isDirectory())
showDir(files[x]);
System.out.println(files[x]);
}
}
}
拓展：带有层次
import java.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException
{
File dir=new File("C:\\abc");
showDir(dir,0);
}
public static String getLevel(int level)
{
StringBuffer sb=new StringBuffer();
sb.append("|--");
for(int x=0;x<level;x++)
{
sb.insert(0,"| ");
}
return sb.toString();
}
public static void showDir(File dir,int level)
{
System.out.println(getLevel(level)+dir.getName());
level++;
File[] files=dir.listFiles();
for(int x=0;x<files.length;x++)
{
if(files[x].isDirectory())
showDir(files[x],level);
System.out.println(getLevel(level)+files[x]);
}
}
}
运行结果：
递归的其他应用：
将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。建立一个java 文件列表文件。
/*
思路：
1、对指定目录进行递归，
2、获取递归过程中所有的java文件的路径。
3、将这些路径存储到集合中。
4、将集合中的数据写入到一个文件中。
*/
import java.io.*;
import java.util.*;
class FileListDemo
{
public static void main(String[] args)throws IOException
{
File dir=new File("F:\\JavaSDK");
List<File> list=new ArrayList<File>();
fileToList(dir,list);
File file=new File(dir,"javaList.txt");
writeToFile(list,file.toString());
}
public static void fileToList(File dir,List<File> list)throws IOException
{
File[] files=dir.listFiles();
for(File file:files)
{
if(file.isDirectory())
fileToList(file,list);
else
{
if(file.getName().endsWith(".java"))
list.add(file);
}
}
}
public static void writeToFile(List<File>list ,String javaListFile)throws IOException
{
BufferedWriter bufw=new BufferedWriter(new FileWriter(javaListFile));
for(File f:list)
{
String path=f.getAbsolutePath();
bufw.write(path);
bufw.newLine();
bufw.flush();
}
bufw.close();
}
}
集合与IO相结合的容器：Propertie
一、如何使用
Properties是HashTable的子类，即是Map的子类，并 且集合中存的都是字符串。
重点掌握以下几个方法：
① Properties pro=new Properties（）；
② Object setProperties（String key，String value）；
③ String getProperties（String key）；
④ Set<String> StringPropertyNames（）；返回键集。
⑤ void load(InputStream inStream);将流关联的文件 加载到集合中去。
⑥ void store(OutputStream outStream,String comments):使集合和对应的流同步。
ps：键相同，则覆盖。
二、应用
1、“存”&“取”
import java.util.*;
class PropertiesDemo
{
public static void main(String[] args)
{
Properties pro=new Properties();
pro.setProperty("zhangsan","20");
pro.setProperty("zhangsan","30");
System.out.println(pro);
pro.setProperty("Lisi",10+"");
String value=pro.getProperty("zhangsan");
System.out.println(value);
Set<String> names=pro.stringPropertyNames();
for(String name:names)
{
System.out.println(name+"::"+pro.getProperty(name));
}
}
}
2、存取配置文件
假设现在有一个配置文件info.txt。
//现在想将info.txt中的键值数据存到集合中进行操作。
/*
思路：
1、将字符读取流与文件相关联。为提高效率，用字符缓冲读取流。
2、读取一行数据，将改行数据用“=”进行切割。
3、等号左边作为键，右边作为值，存入到Propertie集合中即可。
*/
import java.util.*;
import java.io.*;
class PropertiesDemo
{
public static void main(String[] args)throws IOException
{
Properties pro=new Properties();
BufferedReader bufr=new BufferedReader(new FileReader("G:\\info.txt"));
String line=null;
while((line=bufr.readLine())!=null)
{
String[] arr=line.split("=");
pro.setProperty(arr[0],arr[1]);
}
bufr.close();
System.out.println(pro);
}
}
运行结果：
优化：
通过查阅Properties的API，发现有一个方法已经帮我 们实现了这个功能：void load（FileInputStream inStream）；
import java.util.*;
import java.io.*;
class PropertiesDemo
{
public static void main(String[] args)throws IOException
{
Properties pro=new Properties();
FileInputStream in=new FileInputStream("G:\\info.txt");
pro.load(in);
System.out.println(pro);
//pro.list(System.out);
}
}
现在我们对集合进行一些设置，比如：
import java.util.*;
import java.io.*;
class PropertiesDemo
{
public static void main(String[] args)throws IOException
{
Properties pro=new Properties();
FileInputStream in=new FileInputStream("G:\\info.txt");
pro.load(in);
pro.setProperty("zhangsan","30");
System.out.println(pro);
}
}
运行结果：
但是在看一下文件：
想让文件也有同样的变化，则：
//现在想将info.txt中的键值数据存到集合中进行操作。
/*
思路：
1、将字符读取流与文件相关联。为提高效率，用字符缓冲读取流。
2、读取一行数据，将改行数据用“=”进行切割。
3、等号左边作为键，右边作为值，存入到Propertie集合中即可。
*/
import java.util.*;
import java.io.*;
class PropertiesDemo
{
public static void main(String[] args)throws IOException
{
Properties pro=new Properties();
FileInputStream in=new FileInputStream("G:\\info.txt");
pro.load(in);
pro.setProperty("zhangsan","30");
pro.store(new FileOutputStream("G:\\info.txt"),"haha");
pro.list(System.out);
}
}
运行结果：
现在，再看一下文件：
拓展：
配置文件有两种形式，一种是Properties，一种是xml文件。由于Properties形式的 配置文件有他的局限性，所以之后又出来了xml文件。
name=zhangsan
age=20
name=wangwu
age=30
<Persons
<person
<name>zhangsan</name>
<age>20</age>
/person>
<person
<name>wangwu</name>
<age>30<>
/person>
/Persons>
3、Properties练习
需求：记录应用程序运行的次数。如果使用次数已到，那 么给出注册提示。
/*
很容易想到的是计数器。
它的特点是：
该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。
随着该应用程序的退出，该计数器也在内存中消失，下一次再启动时，重新计数。
这不是我们想要的，我们希望，程序即使结束，该计数器的值也存在。
下次程序启动时会先加载该计数器的值并加1后重新存储起来。
因此，我们想到用配置文件来记录该软件的使用次数。
该配置文件使用键值对的形式，这样便于阅读数据，并操作数据。
键值对数据是Map集合，数据是以文件的形式存储的，使用io技术，
那么io+Map=Properties。
*/
import java.util.*;
import java.io.*;
class RunCount
{
public static void main(String[] args)throws IOException
{
Properties prop=new Properties();
File file=new File("C:\\count.txt");
FileInputStream fis=new FileInputStream(file);
prop.load(fis);
int count=0;
String value=prop.getProperty("time");
if(value!=null)
{
count=Integer.parseInt(value);
if(count>5)
{
System.out.println("您好，使用次数已到，请注册！");
return;
}
}
count++;
prop.setProperty("time",count+"");
FileOutputStream fos=new FileOutputStream(file);
prop.store(fos,"");
fis.close();
fos.close();
}
}
第一次编译运行后：
第二次运行后：
其他
一、PrintWriter
打印流。它提供了多种重载形式的打印方法，可以将各种 数据类型的数据打印到指定的位置。
import java.util.*;
import java.io.*;
class PrintStreamDemo
{
public static void main(String[] args)throws IOException
{
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
PrintWriter out=new PrintWriter(new FileWriter("C:\\a.txt"),true);
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
out.println(line.toUpperCase());
//out.flush();out初始化时，boolean参数为true，自动刷新
}
out.close();
bufr.close();
}
}
其实，我们可以把PrintWriter看成是FileWriter,PrintStream看成是 FileOutputStream来学习。那么这里的println（）就可以看成是write（）。只需要 特别注意一下PrintWriter构造函数所接受的参数即可，它可以接收的参数类型比较广 泛一些。
PrintStream构造函数可以接收的参数类型：
a. File对象
b. 字符串路径
c. 字节输出流对象
PrintWriter构造函数可以接收的参数类型：
a. File对象
b. 字符串路径
c. 字节输出流对象
d. 字符输出流对象
二、合并流（SequenceInputStream）
|--InputStream
|--SequenceInputStream
SequenceInputStream 表示其他输入流的逻辑串联。它从 输入流的有序集合开始，并从第一个输入流开始读取，直 到到达文件末尾，接着从第二个输入流读取，依次类推， 直到到达包含的最后一个输入流的文件末尾为止。
SequenceInputStream(Enumeration<?extends
InputStream> e) ：通过记住参数来初始化新创建的 SequenceInputStream，该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数。
练习：将1.txt、2.txt、3.txt中的内容写入到一个文件 中。
import java.util.*;
import java.io.*;
class SequenceDemo
{
public static void main(String[] args)throws IOException
{
Vector<FileInputStream> v=new Vector<FileInputStream>();
v.add(new FileInputStream("C:\\1.txt"));
v.add(new FileInputStream("C:\\2.txt"));
v.add(new FileInputStream("C:\\3.txt"));
Enumeration en=v.elements();
SequenceInputStream sis=new SequenceInputStream(en);
FileOutputStream fos=new FileOutputStream("C:\\a.txt");
byte[] buf=new byte[1024];
int len=0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
}
三、切割文件&合并文件
需求：将a.txt切割成三个文件，分别是1.txt、2.txt、 3.txt。 再将三个文件合并成一个文件b.txt。
import java.util.*;
import java.io.*;
class SplitFile
{
public static void main(String[] args)throws IOException
{
//splitFile();
merge();
}
public static void splitFile()throws IOException
{
FileInputStream fis=new FileInputStream("C:\\a.txt");
FileOutputStream fos=null;
byte[] buf=new byte[16];
int len=0;
int count=1;
while((len=fis.read(buf))!=-1)
{
fos=new FileOutputStream("C:\\"+(count++)+".txt");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}
public static void merge()throws IOException
{
/*
Vector<FileInputStream> v=new Vector<FileInputStream>();
v.add(new FileInputStream("1.txt"));
v.add(new FileInputStream("2.txt"));
v.add(new FileInputStream("3.txt"));
Enumeration en=v.elements();
*/
//由于Vector太低效，所以我们用ArrayList。
ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();
for(int x=1;x<=3;x++)
{
al.add(new FileInputStream("C:\\"+x+".txt"));
}
final Iterator<FileInputStream> it=al.iterator();
Enumeration<FileInputStream> en=new Enumeration<FileInputStream>()
{
public boolean hasMoreElements()
{
return it.hasNext();
}
public FileInputStream nextElement()
{
return it.next();
}
};
SequenceInputStream sis=new SequenceInputStream(en);
FileOutputStream fos=new FileOutputStream("C:\\hebin.txt");
byte[] buf=new byte[8];
int len=0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
sis.close();
fos.close();
}
}
四、对象的序列化
什么是对象的序列化？
把对象存放在硬盘上叫做对象的持久化存储（序列化）。
该对象所属的类必须实现Serializable接口。（该接口 没有方法，仅用于标识可序列化的语义。）
更细节划分操作对象的流:
ObjectInputStream/ObjectOutputStream
涉及到的方法：
① ObjectOutputStream oos=new ObjectOutputSteam（OutputStream out）；
② void writeObject（Object obj）：将指定的对象写入ObjectOutputStream；
③ objectInputStream ois=new ObjectInputStream(InputStream in);
④ void readObject();从 ObjectInputStream 读取对象
练习：将自定义类Person的对象存入到磁盘文件中，再 从文件中读取出来。
/*
实现了Serializable之后的类，编译后都会产生一个对应的uid。
它是根据类中不同的成员来算这个值的，给类做标记。
使对象所属的类文件始终保持是同一个uid。
通过：public static fianl long serialVersionUID=42L；
好处：
当我们往文件obj.txt中存储对象之后，我们改动了类中的成员变量，
比如，加一个新的修饰符。此时我们想从obj.txt中读取数据，编译运行后，
运行失败。原因就是序列号不统一。但是我们只要通过上面一行代码，我们
就可以解决这个问题。并且可以使obj.txt中的内容同步。
还有一点就是：静态不可以序列化，即存不进去，我们会将相应的该数据类型
默认初始化值代替初始化值存入进去。若非静态也不想序列化，我们可以通过
关键字transient修饰。
*/
import java.io.*;
class Person implements Serializable
{
public static final long serialVersionUID=42L;
private String name;
private int age;
private String country;
Person(String name,int age,String country)
{
this.name=name;
this.age=age;
this.country=country;
}
public String toString()
{
return name+":"+age+":"+country;
}
}
class ObjectStreamDemo
{
public static void main(String[] args)throws Exception
{
//writeObj();
readObj();
}
public static void writeObj()throws Exception
{
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("C:\\t.txt"));
oos.writeObject(new Person("zhangsn",20,"cn"));
oos.writeObject(new Person("wangwwu",23,"ke"));
oos.close();
}
public static void readObj()throws Exception
{
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("C:\\t.txt"));
Person p=(Person)ois.readObject();
System.out.println(p);//打印zhangsn：20：cn
ois.close();
}
}
五、管道流
管道流:
PipedInputStream/PipedOutputStreamm
PipedReader/PipedWriter
PipedInputStream in=new PipedInputStream();
PipedOutputStream out=new PipedOutputStream（）；
in.connect(out);
管道输入流应该连接到管道输出流，管道输入流提供要写 入管道输出流的所有数据。通常，数据由某个线程从管道 输入流对象读取，并由其他线程将其写入到相应的管道输 出流。
示例：
import java.io.*;
class Read implements Runnable
{
private PipedInputStream in;
Read(PipedInputStream in)
{
this.in=in;
}
public void run()
{
try
{
byte[] buf=new byte[1024];
System.out.println("读取前。。。没有数据阻塞");
int len=in.read(buf);
System.out.println("读取后。。。阻塞结束");
String s=new String(buf,0,len);
System.out.println(s);
in.close();
}
catch (IOException e)
{
throw new RuntimeException("管道读取流失败");
}
}
}
class Write implements Runnable
{
private PipedOutputStream out;
Write(PipedOutputStream out)
{
this.out=out;
}
public void run()
{
try
{
System.out.println("开始写入数据，等待6秒后");
Thread.sleep(6000);
out.write("pipe lai le".getBytes());
out.close();
}
catch (Exception e)
{
throw new RuntimeException("管道输出流失败");
}
}
}
class PipedStreamDemo
{
public static void main(String[] args)throws Exception
{
PipedInputStream in=new PipedInputStream();
PipedOutputStream out=new PipedOutputStream();
in.connect(out);
Read r=new Read(in);
Write w=new Write(out);
new Thread(w).start();
new Thread(r).start();
}
}
六、RandomAccessFile
简而言之，该类可以根据模式（r，rw）的不同对磁盘上 的文件进行随机的读和写。该类的对象就相当于一个文件 指针，通过调用类中的方法可以改变指针的所指的位置从 而实现随机。
重点掌握以下几个方法：
① RandomAccessFile(File file,String mode):创建从中读取和向其中写入（可选） 的随机访问文件流，该文件由File参数指定。
② RandomAccessFile（String name，String mode）：创建从中读取和向其中写入 （可选）的随机访问文件流，该文件具有指定名称。
③ void seek（long pos）：设置到此文件开头测量到的文件指针偏移量，在该位置 发生下一个读取或写入操作。
④ int skipBytes（int n）：尝试跳过输入的n个字节以丢弃跳过的字节。
⑤ int readInt（）：从此文件读取一个有符号的32位整数。
⑥ int read():从此文件中读取一个数据字节。
⑦ int read(byte[] b):将最多b.lenggh个数据字节从此文件读入byte。
⑧ void write（int b）：向此文件写入指定的字节。
⑨ void write（byte[] b）:将 b.length 个字节从指定 byte 数组写入到此文件， 并从当前文件指针开始。
⑩ void writeInt(int v):按四个字节将int写入该文件，先写高字节。
示例：
import java.io.*;
class RandomAccessFileDemo
{
public static void main(String[] arags)throws IOException
{
writeFile();
//readFile();
}
public static void writeFile()throws IOException
{
RandomAccessFile raf=new RandomAccessFile("C:\\t.txt","rw");
raf.write("lisi".getBytes());
/*
write()/具有强转的功能，为保证数据的原样性，只写最低八位。
而writeInt（）会写32位。且写入的其实是a，通过编码表查找。
*/
raf.writeInt(97);
//raf.writeBytes("\r\n");
//raf.seek(8);
raf.write("wangwu".getBytes());
raf.writeInt(258);
raf.close();
}
public static void readFile()throws IOException
{
RandomAccessFile raf=new RandomAccessFile("C:\\t.txt","r");
byte[] buf=new byte[4];
raf.read(buf);
String name=new String(buf);
//raf.seek(8);
//raf.skipBytes(4);
int age=raf.readInt();
System.out.println("name="+name+",age="+age);
}
}
总结：这个类也可以看成是FileWriter/FileWriter来 学习。就seek（）和skipBytes()特殊一点。
七、操作基本数据类型的流对象DataStream
DataInputStream/DataOutputStream
DataInputStream dis=new DataInputStream(InputStream in);
DataOutputStream dos=new DataOutputStream(OutputStream out);
readUTF();
writeUTF();
readInt();
writeInt();
readBoolean();
writeBoolean();
readDouble();
writeDouble();
温馨提示：这个类可以看成FileWriter和FileReader来 对照学习。
八、ByteArrayStream
ByteArrayInputStream/ByteArrayOutputStream
ByteArrayStream（byte[] buf）:
创建一个ByteArrayInputStream,使用buf作为其缓冲区 数组。
Ps：在构造的时候，需要接收数据源，而且数据源是一个 字节数组。
ByteArrayStream（）：创建一个新的byte数组输出流。
ps：在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节 数组。
因此，这两个流对象都操作的数组，并没有使用系统资源，
不用进行close（）关闭。
还需要掌握的方法：
ByteArrayInputStream:
read();
ByteArrayOutputStream:
write();
size();
toString();
write(OutputStream out);
2015-12-16至
2015-12-20著
概述
IO流是用来处理设备上数据的一种技术。该技术都被封装成不同的类，存放在java.io包中，供开发者使用。注意：流中所有的方法都有可能抛出异常，因此需解决异常问题。
1) 流按操作数据分为两种：字节流（通用流）与字符流
2) 流按流向分为两种：输入流，输出流
拓展：
字符流要用到编码表，写程序的时候可以指定编码表，这样就不至于乱码。编码表主要的特点就是映射。
在外国用的是ASCII码表：将字母与01二进代码对应起来
在中过用到是GB2312码表（之后扩容GBK）：将汉子与01二进制代码对应起来
把各国的文字统一起来，就有了国际标准码表，叫做Unicode码表。
该码表的特点：Unicode里面的无论什么字符都用两个字节表示，虽然能表示很多个字符，但是，有些字符只要8为就可以搞定，因此有点浪费空间，这时就出来一个UTF-8码表，即一个字节能装的下就用一个字节装，一个装不下就用两个表，按需分配。
IO流常用的基类：
字节流的抽象基类：InputStream（读）、OutputStream（写）。
字符流的抽象基类：Reader（读）、Writer（写）
Ps：这四个类派生出来的子类名称都是以其父类名作为子类的后缀。如：
InputStream的子类FileInputStream
Reader的子类FileReader
温馨提示：流对象对同一个文件进行读和写操作，要注意是否需要将读方法和写方法对应（比如readInt（）和writeInt（））从而保证读出来的内容和写进去的内容一样。字符流中的读写方法是以字符为单位的，字节流中的读写方法是以字节为单位的。
字符流
一、FileWriter
1、往文件中写入文字
在硬盘上，创建一个文件并写入一些文字数据。
import java.io.*;
class FileWriterDemo
{
/*
所用到的方法：
FileWriter(),write()，flush(),close()
都有可能发生I/O错误，都会抛出I/O异常。
*/
public static void main(String[] args)throws IOException
{
/*
创建一个FileWriter对象。
该对象一被初始化就必要确定被操作的文件。
而且该文件会被创建到指定目录下。
如果该目录下已有同名文件，将被覆盖。
其实该步就是在明确数据要存放的目的地。
现在是在当前目录下。
*/
FileWriter fw=new FileWriter("demo.txt");
/*
调用write（），将字符串写入到流缓冲区中。
*/
fw.write("hello java");
/*
刷新流缓冲区中
26bc8
的数据，
将数据刷新到目的地。
*/
fw.flush();//可以省略不写。
/*
关闭流，但是关闭之前会刷新一次内部缓冲区中
的数据，将数据刷新到目的地中。它和flush的区
别在于，flush刷新后，流还可以继续使用，close
刷新后，会将流关闭。
若流多时，需要一个一个关闭。
*/
fw.close();
}
}
//其实，IO流在调用windows底层资源，
//具体的工作都是windows底层自己做，
//很好地体现了平台无关性。
2、异常处理
|--IOException
|--FileNoFoundException
代码如下：
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args)
{
FileWriter fw=null;
try
{
fw=new FileWriter("demo.txt");
fw.write("agasfsdgs");
}
catch (IOException e)
{
System.out.println("catch1="+e.toString());
}
finally
{
try
{
if(fw!=null)
fw.close();
}
catch (IOException e)
{
System.out.println("catch2="+e.toString());
}
}
}
}
3、文本文件的续写
续写是指，我们进行第二次编译运行时，如果指定的目录
存在，则不去覆盖，而是接着已有内容写入数据。
代码如下：
import java.io.*;
class FileWriterDemo
{
public static void main(String[] args)throws IOException
{
/*
创建流对象时，往里边再传递一个参数true，
代表不覆盖已有的文件。并在已有的文件的末尾
处进行数据的续写。
续写有两种方式：
方式一：
通过改动write（）方法中的参数。
方式二：
通过连续调用write（），较麻烦。
*/
FileWriter fw=new FileWriter("demo.txt",true);
fw.write("haofahfao;\r\nfjw");
fw.close();
}
}
ps：我们知道，创建一个写入文本文件流对象之后，我们通过调用write（String str），指定的内容可能先是被写入到了流缓冲区中，然后通过调用flush()或者是close（）才将缓冲区中的内容刷到目的地。目前还没有学习到BufferedWriter，因此认为指定的内容都是被写入到目的地。
4、BufferedWriter
该类称之为字符流的缓冲区。缓冲区的出现提供了对数据
写入速度。要结合流才可以使用，在流的基础上对流的功 能进行了增强。它同时提供了一个跨平台的换行符： newline（）。引入了缓冲区之后，一些写入、关流、刷 新 等方法 都由缓冲区对象进行调用。需要注意的是， 用到 缓冲区， 就要记得刷 新， 防止断电，数据流 失。
示例：
import java.io.*;
class BufferedWriterDemo
{
public static void main(String[] args)throws IOException
{
/*
创建一个字符写入流对象。
*/
FileWriter fw=new FileWriter("buf.txt");
/*
为了提高字符写入流效率，加入缓冲区技术。
只要将需要被提高效率的流对象作为参数传递给缓冲区
的构造函数即可。
*/
BufferedWriter bufw=new BufferedWriter(fw);
for(int x=1;x<=10;x++)
{
bufw.write("abcd"+x);
bufw.newLine();
bufw.flush();
}
bufw.flush();
bufw.close();
}
}
二、FileRead
1、文本文件的读取
方式一：
import java.io.*;
class FileReadDemo
{
public static void main(String[] args)throws IOException
{
/*
创建一个FileRead对象，
和指定名称的文件相关联，
要保证该文件是已经存在的，
如果不存在会发生异常FileNotFoundException。
*/
FileReader fr=new FileReader("demo.txt");
/*
调用read（），
该方法一次读取一个字符，
而且会自动往下读；
该方法返回值类型是int类型，到达流的末尾返回-1，
将读取到的字符以整数形式
展现。
*/
int ch = fr.read();
System.out.println("ch="+(char)ch);
int ch1 = fr.read();
System.out.println("ch1="+(char)ch1);
int ch2 = fr.read();
System.out.println("ch2="+(char)ch2);
fr.close();
}
}
优化：
import java.io.*;
class FileReadDemo
{
public static void main(String[] args)throws IOException
{
FileReader fr=new FileReader("demo.txt");
int ch=0;
while((ch=fr.read())!=-1)
{
System.out.println((char)ch);
}
/*
while(true)
{
if((ch=fr.read())!=-1)
System.out.println((char)ch);
else
break;
}
*/
fr.close();
}
}
方式二：
import java.io.*;
class FileReaderDemo
{
public static void main(String[] args)throws IOException
{
FileReader fr=new FileReader("demo.txt");
/*
定义一个字符数组，用于存储读到的字符。
*/
char[] buf=new char[1024];
/*
通过int read(char[] buf),
将读到字符放进数组，
返回值表示读到的字符个数，
这个个数由数组的长度（2）和流中剩余字符个数（1）决定。
自动往下读，
当读到流的末尾，返回-1。
再通过创建String类型，
将字符数组中的内容换成
字符串打印输出。
*/
int num=0；
while((num=fr.read(buf))!=-1)
{
System.out.println(new String(buf,0,num) );
}
fr.close();
}
}
2、文本文件读取练习
读取一个文件，并打印到控制台上。
import java.io.*;
class FileReaderDemo
{
public static void main(String[] args)throws IOException
{
FileReader fr=new FileReader("SystemDemo.java");
char[] buf=new char[1024];
int num=0;
while((num=fr.read(buf))!=-1)
{
System.out.println(new String(buf,0,num) );
}
fr.close();
}
}
运行结果如下图所示：
发现，打印出来的文件排版都没有变化。但是，我们想，当我们的文本文件大于2kB， 那么打印出来的排版格式一定会发生改变，因为我们不是接着打印的。因此我们通常将 System.out.println()换成System.out.print（）。
ps：我们知道，创建读取文本文件流对象，我们通过调用read（），或者是read（char[] buf）读取数据。当到达流末尾时，返回的是-1.
3、BufferedReader
该类称之为字符读取缓冲区。缓冲区的出现提供了对数据
读出速度。要结合流才可以使用，在流的基础上对流的功 能进行了增强，通过提供一个一次读一行的方法：String readLine（）：当返回null时，表示读到文件末尾，该 方 法返回的时候只返回回车符之前的数据内容，并不返 回回 车符。引入了缓冲区之后，一些写入、关流、刷 新 等 方 法 都由缓冲区对象进行调用。
示例：
import java.io.*;
class BufferedReaderDemo
{
public static void main(String[] args)throws IOException
{
/*
创建一个读取流对象和文件相关联。
*/
FileReader fr=new FileReader("buf.txt");
/*
为了提高效率。加入缓冲技术。
将字符读取流对象作为参数传递给缓冲对象的构造函数。
*/
BufferedReader bufr=new BufferedReader(fr);
String line=null;
while((line=bufr.readLine())!=null)
{
System.out.println(line);
}
bufr.close();
}
}
拓展：
|--BufferedReader
|--LineNumberReader
① 跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和
getLineNumber()，它们可 分别用于设置和获取当前行号。
② 默认情况下，行编号从 0 开始。该行号随数据读取 在每个行结束符处递增，并且可以通过调用 setLineNumber(int) 更改行号。但要注意的是， setLineNumber(int) 不会实际更改流中的当前位 置；它只更改将由 getLineNumber() 返回的值。
③ 可认为行在遇到以下符号之一时结束：换行符 （'\n'）、回车符（'\r'）、回车后紧跟换行符。
示例：
import java.io.*;
class LineNumberReaderDemo
{
public static void main(String[] args)throws IOException
{
FileReader fr=new FileReader("SystemDemo.java");
LineNumberReader lnr=new LineNumberReader(fr);
String line=null;
lnr.setLineNumber(6);
while((line=lnr.readLine())!=null)
{
System.out.println(lnr.getLineNumber()+"::"+line);
}
}
}
运行结果如下图所示：
三、FileWriter和FileReader的搭配应用
需求：将C盘下的一个文本文件复制到D盘下。
方式一：简洁版
import java.io.*;
class CopyText
{
public static void main(String[] args)throws IOException
{
FileReader fr=new FileReader("C:\\java.txt");
FileWriter fw=new FileWriter("D:\\java_copy.txt");
int ch=0;
while((ch=fr.read())!=-1)
{
fw.write((char)ch);
}
fr.close();
fw.close();
}
}
方式二：复杂版
import java.io.*;
class CopyText
{
public static void main(String[] args)
{
FileReader fr=null;
FileWriter fw=null;
try
{
fr=new FileReader("C:\\java.txt");
fw=new FileWriter("D:\\java_copy.txt");
int num=0;
char[] buf=new char[1024];
while((num=fr.read(buf))!=-1)
{
fw.write(buf,0,num);
}
}
catch (IOException e)
{
throw new RuntimeException("读写失败");
}
finally
{
try
{
if(fr!=null)
fr.close();
}
catch (IOException e)
{
}
try
{
if(fw!=null)
fw.close();
}
catch (IOException e)
{
}
}
}
}
四、BufferedReader和BufferedWriter的搭配使用
方式一：（简洁版）
import java.io.*;
class CopyTextBybuf
{
public static void main(String[] args)throws IOException
{
FileReader fr=new FileReader("C:\\java.txt");
FileWriter fw=new FileWriter("D:\\java_copy.txt");
BufferedReader bufr=new BufferedReader(fr);
BufferedWriter bufw=new BufferedWriter(fw);
String line=null;
while((line=bufr.readLine())!=null)
{
bufw.write(line);
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}
方式二：（复杂版）
import java.io.*;
class CopyTextBybuf
{
public static void main(String[] args)
{
FileReader fr=null;
FileWriter fw=null;
BufferedReader bufr=null;
BufferedWriter bufw=null;
try
{
fr=new FileReader("C:\\java.txt");
fw=new FileWriter("D:\\java_copy.txt");
bufr=new BufferedReader(fr);
bufw=new BufferedWriter(fw);
String line=null;
while((line=bufr.readLine())!=null)
{
bufw.write(line);
bufw.newLine();
bufw.flush();
}
}
catch (IOException e)
{
throw new RuntimeException("创建失败");
}
finally
{
if(bufr!=null)
try
{
bufr.close();
}
catch (IOException e)
{
throw new RuntimeException("读取关闭失败");
}
if(bufw!=null)
try
{
bufw.close();
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败");
}
}
}
}
装饰设计模式
一、什么是装饰设计模式
当想要对已有的对象进行功能增强时，又不想对已有功能 进行修改。此时可以定义一个新的类，建立新类的对象， 将已有对象传入，通过构造方法接收该已有对象，基于 已有对象的功能，提供更强的功能。那么自定义类称为装 饰类。
如：
class Person
{
public void chiFan()
{
System.out.println("吃饭");
}
}
//自定义一个类，作为装饰类。
class SuperPerson
{
private Person p;
SuperPerson(Person p)
{
this.p=p;
}
public void superChiFan()
{
System.out.println("开胃酒");
p.chiFan();
System.out.println("甜点");
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p=new Person();
SuperPerson sp=new SuperPerson(p);
sp.superChiFan();
}
}
二、装饰和继承的区别
想要给已有对象提供更强的功能：
1．如果是用继承来做
|--MyReader
|--MyTextReader
|--MyBufferTextReader
|--MyMediaReader
|--MyBufferMediaReader
|--MyDataReader
|--MyBufferDataReader
2．如果是用装饰来做
|--MyReader
|--MyTextReader
|--MyMediaReader
|--MyDataReader
|--MyBufferReader
class MyBufferReader
{
MyBufferReader(MyTextReader text)
{}
MyBufferReader(MyMediaReader media)
{}
}
多态思想：
class MyBufferReader
{
private MyReader r;
MyBufferReader(MyReader r)
{}
}
3、总结
综上所述，装饰模式比继承要灵活，避免了继承体系的臃肿。单独描述一下缓冲内容，将需要被缓冲的对象传递进来。
三、自定义装饰类
import java.io.*;
class MyBuffererReader extends Reader
{
private Reader r;
MyBufferedReader(Reader r)
{
this.r=r;
}
public String myReadLine()throws IOException
{
StringBuffer sb=new StringBuffer();
int ch=0;
while((ch=r.read())!=-1)
{
if(ch=='\r')
continue;
if(ch=='\n')
return sb.toString()
else
sb.append(ch);
}
if(sb.length()!=-1)
return sb.toString();
return null;
}
public void myClose()throws IOException
{
r.close();
}
//复写Read类中的抽象方法
public void close()throws IOException
{
r.close();
}
public int read(char[] cbuf,int off,int len)throws IOException
{
return r.read(cbuf,off,len);
}
}
字节流
字节流对象在写如数据时，无论什么情况下都不需要刷 新，直接往目的地里，因为它是最小的单位。处理图片都 需要用字节流。
一、FileInputStream
1、需求：
读取一个图片文件。
代码如下：
import java.io.*;
class FileInputStreamDemo
{
public static void main(String[] args)throws IOException
{
readFile_3();
}
//方法一：
/*
通过int read（）：从此输入流中读取下一个数据字节。
返回一个 0 到 255 范围内的 int 字节值。
如果因为已经到达流末尾而没有字节可用，则返回 -1。
*/
public static void readFile_1()throws IOException
{
FileInputStream fis=new FileInputStream("C:\\123.jpg");
int ch=0;
while ((ch=fis.read())!=-1)
{
System.out.print((char)ch);
}
fis.close();
}
//方法二：
/*
通过int read(byte[] b) ：
从此输入流中将 byte.length 个字节的数据读入一个 byte 数组中。
如果因为已经到达流末尾而没有更多的数据，则返回 -1。
*/
public static void readFile_2()throws IOException
{
FileInputStream fis=new FileInputStream("C:\\123.jpg");
int num=0;
byte[] buf=new byte[1024];
while ((num=fis.read(buf))!=-1)
{
System.out.print(new String(buf,0,num));
}
fis.close();
}
//方法三：
/*
通过调用available（）：获取文件中总的字节数。
根据该数目定义一个刚刚好的缓冲区，不用再循环。
*/
public static void readFile_3()throws IOException
{
FileInputStream fis=new FileInputStream("C:\\123.jpg");
byte[] buf=new byte[fis.available()];
fis.read(buf);
System.out.println(new String(buf));
fis.close();
}
}
2、BufferedInputStream
与BufferedReader功能类似，可以参照学习，
此处不做过多阐述。
二、FileOutputStream
1、需求：
写入一个文件。
代码如下：
import java.io.*;
class FileOutputStreamDemo
{
public static void main(String[] args)throws IOException
{
FileOutputStream fos=new FileOutputStream("C:\\fos.txt");
fos.write("coanoafds".getBytes());
fos.close();
}
}
2、BufferedOutputStream
与BufferedWriter功能类似，可以参照学习，
此处不做过多阐述。
三、FileInputStream和FileOutputStream的搭配应用
需求：将C盘下的图片文件复制到D盘下。
import java.io.*;
class CopyPic
{
public static void main(String[] args)
{
FileInputStream fis=null;
FileOutputStream fos=null;
try
{
fis=new FileInputStream("C:\\123.jpg");
fos=new FileOutputStream("D:\\123_copy.jpg");
int ch=0;
while((ch=fis.read())!=-1)
{
fos.write((char)ch);//也可以不强转
}
}
catch (IOException e)
{
throw new RuntimeException("复制失败");
}
finally
{
if(fis!=null)
try
{
fis.close();
}
catch (IOException e)
{
throw new RuntimeException("读取流关闭失败");
}
if(fos!=null)
try
{
fos.close();
}
catch (IOException e)
{
throw new RuntimeException("写入流关闭失败");
}
}
}
}
四、BufferedInputStream和BufferedOutputStream的搭配应用
1、需求：将C盘下的图片文件复制到D盘下。
import java.io.*;
class CopyPicBybuf
{
public static void main(String[] args)
{
long star=System.currentTimeMillis();
copy();
long end=System.currentTimeMillis();
System.out.println("time="+(end-star));
}
public static void copy()
{
FileInputStream fis=null;
FileOutputStream fos=null;
BufferedInputStream bufis=null;
BufferedOutputStream bufos=null;
try
{
fis=new FileInputStream("C:\\123.jpg");
fos=new FileOutputStream("D:\\123_copy.jpg");
bufis=new BufferedInputStream(fis);
bufos=new BufferedOutputStream(fos);
int ch=0;
while ((ch=bufis.read())!=-1)
{
bufos.write((char)ch);
}
}
catch (IOException e)
{
throw new RuntimeException("复制失败");
}
finally
{
if(bufis!=null)
try
{
bufis.close();
}
catch (IOException e)
{
throw new RuntimeException("读取流关闭失败");
}
if(bufos!=null)
try
{
bufos.close();
}
catch (IOException e)
{
throw new RuntimeException("写入流关闭失败");
}
}
}
}
运行结果如下图所示：
2、自定义读取字节流的缓冲区
import java.io.*;
class CopyPicByselfbuf
{
public static void main(String[] args)throws IOException
{
long star=System.currentTimeMillis();
copy();
long end=System.currentTimeMillis();
System.out.println();
}
public static void copy()throws IOException
{
FileInputStream fis=new FileInputStream("C:\\123.jpg");
FileOutputStream fos=new FileOutputStream("D:\\123_copy.jpg");
MyBufferedInputStream mbufis=new MyBufferedInputStream(fis);
BufferedOutputStream bufos=new BufferedOutputStream(fos);
int ch=0;
while((ch=mbufis.myRead())!=-1)
{
bufos.write(ch);
}
mbufis.myClose();
bufos.close();
}
}
class MyBufferedInputStream
{
private FileInputStream in;
private byte[] buf=new byte[1024];
private int pos=0;//字节数组的角标
private int count=0;//字节数组的元素个数
MyBufferedInputStream(FileInputStream in)
{
this.in=in;
}
public int myRead()throws IOException
{
//通过in对象读取硬盘上的数据，并存储buf中。
if(count==0)
{
count=in.read(buf);
if(count<0)
return -1;
pos=0;
byte b=buf[pos];
count--;
pos++;
return b;
}
else if(count>0)
{
byte b=buf[pos];
count--;
pos++;
return b;
}
else
return -1;
}
public void myClose()throws IOException
{
in.close();
}
}
编译运行之后，发现，图片副本内容为空。
分析：
我们知道，在内存中文件存在的形式是以01二进制代码形式存在的。myRead（）方法 每次返回的是一个int类型，我们想，如果第一个字节b的二进制形式是1111 1111， 那么它 被提升之后，1111 1111 1111 1111 1111 1111
1111 1111（-1），那 么copy（）中的while（）循环条件成立，流直接关闭，没有做任何事情，导致图片副 本为空。因此我们想在前面补0，这样既可以保留原字节数据不变，又可以避免-1的出 现，可以这样做，将返回值b与上一个255。
这样返回去的值就是int类型的值，想说读到的值和写入副本中的值不就不一样了
吗？这就要谈一谈write（）的特点了，它本身具有强转功能，只写入int类型的
最低8位。这样就保证了只有到达流的末尾才返回-1。
读取键盘录入
一、说明
System.out:对应的是标准的输出设备，控制台。
System.in:对应的是标准输入设备，键盘。
InputStream in=System.in；//获取键盘对象。
ps：无论从键盘录入什么，包括回车（有两个字符组成 “\r\n”）,读入之后打印到控制台上都是一整数形式出 现的。
二、需求：
1、通过键盘录入数据。
import java.io.*;
class ReadIn
{
public static void main(String[] args)throws IOException
{
InputStream in=System.in;
int by=in.read();
int by1=in.read();
int by2=in.read();
System.out.println(by);
System.out.println(by1);
System.out.println(by2);
}
}
运行过程如下图所示：
敲入字符按回车：
敲入字符，按ctrl+c：
温馨提示：这里的流对象不需要手动关闭，因为它是系统的，程序结束，就自动结 束了。
2、当录入一行数据后，就将该行数据进行打印。如 果 录入的数据是over，那么就停止录入。
import java.io.*;
class ReadIn
{
public static void main(String[] args)throws IOException
{
InputStream in=System.in;
StringBuffer sb=new StringBuffer();
while(true)
{
/*
in.read(),发挥两个作用：
1、开放了从键盘敲入字符的一个接口。
2、敲完字符进去以后，按下回车，就开始读取录入的字符。
*/
int ch=in.read();
if(ch=='\r')
continue;
if(ch=='\n')
{
String s=sb.toString();
if("over".equals(s))
break;
System.out.println(s.toUpperCase());
sb.delete(0,sb.length());
}
else
sb.append((char)ch);
}
}
}
转换流
一、将字节流转化成字符流，通过InputStreamReader
通过刚才的键盘录入一行数据并打印其大写的练习，我们可以发现其实就是读一行数据的原理，也就是readLine（）方法。但是readLine（）是BufferedReader中的方法，是属于字符流的范畴，而键盘录入是输入字节流的范畴，因此我们想到转换。
import java.io.*;
class TransStreamDemo
{
}
二、将字节流转化成字符流，通过OutputStreamWriter
同理，我们也可以将写入字节流转换成字符流。
import java.io.*;
class ReadIn
{
public static void main(String[] args)throws IOException
{
StringBuffer sb=new StringBuffer();
InputStream in=System.in;
OutputStream out=System.out;
OutputStreamWriter osw=new OutputStreamWriter(out);
BufferedWriter bufw=new BufferedWriter(osw);
while(true)
{
int ch=in.read();
if(ch=='\r')
continue;
if(ch=='\n')
{
String s=sb.toString();
if("over".equals(s))
break;
bufw.write(s.toUpperCase());
bufw.newLine();
bufw.flush();
sb.delete(0,sb.length());
}
else
sb.append((char)ch);
}
}
}
Ps:
转化流可以指定编码：
OutputStreamWriter osw=new OutputStreamWriter（
new FileOutputStream（“gbk.txt”）,"gbk"）;
osw.write("你好");
OutputStreamWriter osr=new OutputStreamWriter(
new FileOutputStream("utf.txt"),"utf");
osw.write("你好");
这是我们打开gbk.txt、utf.txt之后，里边的内容都是 “你好”，但是gbk编码的只需4个字节，而utf编码的
是6个字节。
以上就是不同编码的一点区别。
三、流的操作：弄清“源”和“目”
流操作规律：（三个明确）
① 明确“源”和“目”。
源：输入流。InputStream、Reader
目：输出流。OutputStream、Writer
② 操作的数据是否是纯文本。
是：字符流
不是：字节流
ps：如果“源”和“目”不同是，则字符优先。
不是字符的一方必须应用转换流转化成字符流。
③ 明确具体的流对象。通过设备来区分：
源设备：硬盘、键盘
目的设备：硬盘、控制台
1、把从键盘录入的字符，存放到控制台中。
1) 明确1：
“源”：InputStream、Reader
“目”：OutputStream、Writer
2）明确2：
不是：字节流
“源”：InputStream
“目”：OutputStream
3）明确3：
“源”：键盘
InputStream in=System.in;
“目”：控制台
OutputStream out=System.in
2、把从键盘录入的字符，存放到磁盘文件中。
1） 明确1：
“源”：InputStream、Reader
“目”：OutputStream、Writer
2）明确2：
以字符为准。
“源”：Reader
“目”：Writer
3）明确3：
“源”：键盘
InputStream in=System.in;
InputStreamReader isr=new InputStreamReader(in);
“目”：硬盘
FileWriter fw=new FileWriter(".....");
3、把磁盘文件中的内容，存放到控制台中。
1） 明确1：
“源”：InputStream、Reader
“目”：OutputStream、Writer
2）明确2：
以字符为准。
“源”：Reader
“目”：Writer
3）明确3：
“源”：硬盘
FileReader fr=new FileReader(".........");
“目”：控制台
OutputStream out=System.out;
OutputStreamWriter osw=new OutputStreamWriter(out);
l ps:转化流可以指定编码表
InputStreamReader(InputStream in,
Charset cs)
创建使用给定字符集的 InputStreamReader。
OutputStreamWriter(OutputStream out,
Charset cs)
创建使用给定字符集的 OutputStreamWriter
“源”和“目”只需指定一方。
l 练习:一般情况下，我们开发时，按照下列模板做。利用 转化流。
（1）把键盘录入的数据，存放到控制台中。
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args)throws IOException
{
InputStream in=System.in;
OutputStream out=System.out;
InputStreamReader isr=new InputStreamReader(in);
OutputStreamWriter osw=new OutputStreamWriter(out);
BufferedReader bufr=new BufferedReader(isr);
BufferedWriter bufw=new BufferedWriter(osw);
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}
（2）把键盘录入的数据，放到C盘下的一个文件中。
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args)throws IOException
{
InputStream in=System.in;
FileWriter fw=new FileWriter("C:\\687180q.txt");
InputStreamReader isr=new InputStreamReader(in);
BufferedReader bufr=new BufferedReader(isr);
BufferedWriter bufw=new BufferedWriter(fw);
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}
l 改变标准输入输出设备。
（1）static viod setIn(InputStream in):重新分配“标 准” 输入流。
（2）static void setOut（PrintStream out）：重新分 配“标准”输出流。
示例：
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args)throws IOException
{
System.setIn(new FileInputStream("SystemDemo.java"));
System.setOut(new PrintStream("C:\\z.txt"));
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
bufw.close();
}
}
可以选择注释：
System.setIn(new FileInputStream("SystemDemo.java"));
System.setOut(new PrintStream("C:\\z.txt"));
来改变“源”和“目”
拓展：
（1）异常的日志信息
import java.io.*;
import java.util.*;
import java.text.*;
class ExceptionInfo
{
public static void main(String[] args)
{
try
{
int[] arr=new int[2];
System.out.println(arr[3]);
}
catch (Exception e)
{
try
{
Date d=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
String s=sdf.format(d);
PrintStream ps=new PrintStream("exception.log");
ps.println(s);
System.setOut(ps);//改变输出流设备，位置任意。
}
catch (IOException ex)
{
throw new RuntimeException("日志文件创建失败");
}
e.printStackTrace(System.out);
}
}
}
（2）系统信息
import java.util.*;
import java.io.*;
class SystemInfo
{
public static void main(String[] args)throws IOException
{
Properties pro=System.getProperties();
System.out.println(pro);//不换行打印在控制台上。
pro.list(System.out);//换行打印在控制台上。
pro.list(new PrintStream("Systeminfo.txt"));//打印在文本文件中
}
}
四、转化流的字符编码
字符编码：
字符的出现为了方便操作字符，更重要的是加入编码转化
，通过了子类转化流来完成。InputStreamReader和
OutputStream。
编码表的由来：
计算机只能识别二进制数据，早期由来是电信号。为了方
便应用计算机，让它可以识别各个国家的文字，就将各个
国家的文字用数字来表示，并一一对应，形成一张表。这
就是编码表。
常见编码表：
ASCII：美国标准信息交换码。用一个字节的7位可以表
示。
ISO8859-1：拉丁码表。欧洲码表，用一个字节的8位表
示。不识别中文。
GB2312：中国的中文编码表。
GBK：中国的中文编码表升级，融合了更多的中文文字符
号。
Unicode：国际标准码表，融合了多种文字。所有文字都 用两个字节来表示，java语言使用的就是unicode。
UTF-8：最多用三个字节来表示，具体按需分配。
示例：
（1）：在转化流中
import java.io.*;
class EncodeDemo
{
public static void main(String[] args)throws IOException
{
//writeText();
readText();
}
public static void writeText()throws IOException
{
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("C:\\utf.txt"),"gbk");//不写的话，默认为GBK。
osw.write("你好！");
osw.close();
}
public static void readText()throws IOException
{
InputStreamReader isr=new InputStreamReader(new FileInputStream("C:\\utf.txt"),"gbk");
int ch=0;
while((ch=isr.read())!=-1)
{
System.out.print((char)ch);
}
}
}
ps：要注意对应关系。
（2）在一般情况中
字符串->字节：编码
String->byte[]:str.getBytes(charsetName);
字节->字符串：解码
byte[]->String：new String(byte[],charsetName);
import java.io.*;
import java.util.*;
class EncodeDemo
{
public static void main(String[] args)throws Exception
{
String s="你好";
/*编码*/
byte[] b1=s.getBytes("gbk");
System.out.println(Arrays.toString(b1));
/*解码*/
String s1=new String(b1,"gbk");
System.out.println(s1);
}
}
运行结果：[-60、-29、-70、-61]
你好
ps：要注意对应关系。
注意：如果不是对应关系，则就会出现解错码的问题，那
么有两种办法可以解决：
（1）更换编码表，是对应。
（2）再编一次。
如：
String s="你好";
byte[] b1=s.getBytes("gbk");
System.out.println(Arrays.toString(b1));
String s1=new String(b1,"ISO8859-1");
System.out.println("s1="+s1);
byte[] b2=s1.getBytes("ISO8859-1");
System.out.println(Arrays.toString(b2));
String s2=new String(b2,"gbk");
System.out.println("s2="+s2);
拓展：“联通”
现象：新建一个文本文档，往里边写入“你好”二字，
保存后关闭，再次打开还是“你好”二字。新建一个
文本文档，往里边写入“联通”二字，保存后关闭，
再次打开却不是“联通”二字。
这就是所谓的编码问题。
记事本也有编码解码过程。
练习：
/*
有5个学生，每个学生有3门课的成绩。
从键盘输入以上数据（包括姓名、三门课的成绩）
输入格式：如：zhangsan，30,40,50
计算出总成绩
并把学生信息和计算出的总分数按高低顺序村房子磁盘文件“stud.txt”中
*/
//思路：
/*
1、描述学生对象。
*/
class Student implements Comparable<Student>
{
private String name;
private int math,chinese,english;
private int sum;
Student(String name,int math,int chinese,int english)
{
this.name=name;
this.math=math;
this.chinese=chinese;
this.english=english;
sum=math+chinese+enlish;
}
public String getName()
{
return name;
}
public int getSum()
{
return sum;
}
public int compareTo(Student s)
{
int num=new Integer(this.sum)compareTo(new Integer(s.num));
if(num==0)
return this.name.compareTo(s.name);
return num;
}
public int hashCode()
{
return name.hashCode()+sum*87;
}
public boolean equals(Object obj)
{
if(!(obj instanceof(Student)))
throws new ClassCastException("类型不匹配");
Student s=(Student)obj;
return this.name.equals(s.name)&&this.sum==s.sum;
}
public String toString()
{
return "Student["+name+","+math+","+chinese+","+english;
}
}
class StudentInfoTool
{
public static Set<Student> getStudents()throws IOException
{
return getStudents(null);
}
public static Set<Student> getStudents(Comparator<Student>cmp)throws IOException
{
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
String line=null;
set<Student> stus=null;
if(cmp==null)
stu=new TreeSet<Student>();
else
stu=new TreeSet<Student>(cmp);
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
String[] info=line.split(",");
Student stu=new Student(info[0],Integer.parseInt(info[1]),Integer.parseInt(info[2]),Integer.parseInt(info[3]));
stu.add(stu);
}
bufr.close();
return stu;
}
public static void writeToFile(Set<Student> stus)throws IOException
{
BufferedWriter bufw=new BufferedWriter(new FileWriter("C:\\stuinfo.txt"));
for(Student stu:stus)
{
bufw.write(stu.toString()+"\t");
bufw.write(stu.getSum()+"");
bufw.newLine();
bufw.flush();
}
bufw.close();
}
}
class StudentInfoTest
{
public static void main(String[] args)throws IOException
{
Comparator<Student> cmp=Collection.reverseOrder();
Set<Student> stus=StudentInfoTool.getStudents(cmp);
StudentInfoTool.writeToFile(stus);
}
}
File
一、概述
1、用来将文件或者文件夹封装成对象。
2、方便对文件与文件夹的属性信息进行操做。
3、File对象可以作为参数传递给流的构造函数，
示例：
import java.io.*;
class FileDemo
{
public static void main(String[] args)
{
File f1=new File("a.txt");
System.out.println(f1);
File f2=new File("C:\\abc");
System.out.println(f2);
File f3=new File("C:\\abc\\c.txt");
System.out.println(f3);
File f4=new File(f2,"b.txt");
System.out.println(f4);
File f5=new File("C:\\abc","b.txt");
System.out.println(f5);
}
}
运行结果：
ps：封住之后，它们并没有真正存在。也可以封装已经存在的。
有一个跨平台的技巧：
可以将\\换成File.separator(与系统有关的默认名称分隔符，为了方便，它被表示为 一个字符串。)
二、功能
File类中常见的方法如下：
1、创建：
① static File createTempFile(String prefix,String suffix):在默认临时文件 目录中创建一个空文件（文件内容为空），使用给定前缀和后缀字符串生成其名称。
此文件类型不明确。
② static File createTempFile（String prefix，String suffix，File directory）：
在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。directory必须是已经存在的，否则会抛异常。此文件类型不明确。
③ boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建， 返回true。
如：创建一个不明类型的abc文件
File f=new File（"C:\\abc"）；
f.createNewFile();
如：创建一个.txt文件
File f=new File（"C:\\abc.txt"）；
f.createNewFile();
ps:这里只能封装一级目录。
④ boolean mkdir():创建单级或者多级文件夹。可以覆盖。
⑤ boolean mkdirs（）：创建单级或者多级文件夹。不可以覆盖。注意，此操作失 败时也可能已经成功地创建了一部分必需的父目录。
2、删除：
下列方法所属的对象都可以是已存在的也可以是还未存在的。
① boolean delete（）：删除失败返回false（程序可能中途发生异常，导致执行不 到）、文件在被占用时，无法删除，返回false。
② void deleteOnExit（）；在程序退出时删除指定文件。
3、判断：
下列方法所属的对象都可以是已存在的也可以是还未存在的。
若不存在，对象不管封装的是什么，都返回false
若存在，根据对象封装的是什么来判断。
上述规则不适用于isAbsolute（）。
① boolean exists():判断File对象是否存在。
② boolean isFile():判断File对象是否是文件。
③ boolean isDirectory():判断File对象是不是目录。
④ boolean isHidden():判断File对象是不是隐藏文件。
⑤ boolean isAbsolute():判断File对象是不是绝对路径。（如：C:\\abc\\c.txt）
⑥ boolean canExecute():判断File文件是否可以运行。
4、获取：
下列方法所属的对象都可以是已存在的也可以是还未存在的。
① String getName（）：返回最后一个名称。
② String getPath（）：返回File对象初始化内容。
③ String getParent（）：getPath（）-getName（）。
④ String getAbsolutePath（）：返回File对象初始化内容，即绝对路径。
⑤ String toString():返回File对象初始化内容。
⑥ long lastModified（）：返回File对象表示的文件或者文件夹最后一次被修改 的时间。
⑦ long length（）：返回File对象表示的文件或者文件夹的长度（单位：字节）。
三、功能的应用
1、文件列表
（1）String[] list()：列出指定目录下的内容。
import java.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException
{
File f=new File("F:\\JavaSDK");
String[] names=f.list();//f必须是已存在的目录，否则抛异常（无指向）。
for(String name:names)
{
System.out.println(name);
}
}
}
运行结果：
(2)Static File[] listRoots():列出可用的文件系统根。
import java.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException
{
File[] files=File.listRoots();
for(File f:files)
{
System.out.println(f);
}
}
}
运行结果：
(3)列出指定目录下的指定内容。过滤。
import java.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException
{
File dir=new File("F:\\JavaSDK\\day00\\");
String[] arr=dir.list(new FilenameFilter()
{
public boolean accept(File dir,String name)
{
System.out.println("dir:"+dir+"-------name:"+name);
return name.endsWith(".java");
}
});
System.out.println("len:"+arr.length);
for(String name:arr)
{
System.out.println(name);
}
}
}
（4）String[] list()和File[] listFiles()
1)
import java.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException
{
File f=new File("F:\\JavaSDK");
String[] arr=f.list();
for(String name:arr)
{
System.out.println(name);
}
}
}
运行结果：
2)
import java.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException
{
File f=new File("F:\\JavaSDK");
File[] arr=f.listFiles();
for(File name:arr)
{
System.out.println(name);
}
}
}
运行结果：
因此：一般我们优先采用File[] listFiles（）。
（5）列出指定目录下的所有内容，知道每一项没有内 容可列。--递归
递归要注意：
1）限定条件
2）要注意递归的次数。尽量避免内存溢出
import java.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException
{
File dir=new File("C:\\abc");
showDir(dir);
}
public static void showDir(File dir)
{
System.out.println(dir);
File[] files=dir.listFiles();
for(int x=0;x<files.length;x++)
{
if(files[x].isDirectory())
showDir(files[x]);
System.out.println(files[x]);
}
}
}
拓展：带有层次
import java.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException
{
File dir=new File("C:\\abc");
showDir(dir,0);
}
public static String getLevel(int level)
{
StringBuffer sb=new StringBuffer();
sb.append("|--");
for(int x=0;x<level;x++)
{
sb.insert(0,"| ");
}
return sb.toString();
}
public static void showDir(File dir,int level)
{
System.out.println(getLevel(level)+dir.getName());
level++;
File[] files=dir.listFiles();
for(int x=0;x<files.length;x++)
{
if(files[x].isDirectory())
showDir(files[x],level);
System.out.println(getLevel(level)+files[x]);
}
}
}
运行结果：
递归的其他应用：
将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。建立一个java 文件列表文件。
/*
思路：
1、对指定目录进行递归，
2、获取递归过程中所有的java文件的路径。
3、将这些路径存储到集合中。
4、将集合中的数据写入到一个文件中。
*/
import java.io.*;
import java.util.*;
class FileListDemo
{
public static void main(String[] args)throws IOException
{
File dir=new File("F:\\JavaSDK");
List<File> list=new ArrayList<File>();
fileToList(dir,list);
File file=new File(dir,"javaList.txt");
writeToFile(list,file.toString());
}
public static void fileToList(File dir,List<File> list)throws IOException
{
File[] files=dir.listFiles();
for(File file:files)
{
if(file.isDirectory())
fileToList(file,list);
else
{
if(file.getName().endsWith(".java"))
list.add(file);
}
}
}
public static void writeToFile(List<File>list ,String javaListFile)throws IOException
{
BufferedWriter bufw=new BufferedWriter(new FileWriter(javaListFile));
for(File f:list)
{
String path=f.getAbsolutePath();
bufw.write(path);
bufw.newLine();
bufw.flush();
}
bufw.close();
}
}
集合与IO相结合的容器：Propertie
一、如何使用
Properties是HashTable的子类，即是Map的子类，并 且集合中存的都是字符串。
重点掌握以下几个方法：
① Properties pro=new Properties（）；
② Object setProperties（String key，String value）；
③ String getProperties（String key）；
④ Set<String> StringPropertyNames（）；返回键集。
⑤ void load(InputStream inStream);将流关联的文件 加载到集合中去。
⑥ void store(OutputStream outStream,String comments):使集合和对应的流同步。
ps：键相同，则覆盖。
二、应用
1、“存”&“取”
import java.util.*;
class PropertiesDemo
{
public static void main(String[] args)
{
Properties pro=new Properties();
pro.setProperty("zhangsan","20");
pro.setProperty("zhangsan","30");
System.out.println(pro);
pro.setProperty("Lisi",10+"");
String value=pro.getProperty("zhangsan");
System.out.println(value);
Set<String> names=pro.stringPropertyNames();
for(String name:names)
{
System.out.println(name+"::"+pro.getProperty(name));
}
}
}
2、存取配置文件
假设现在有一个配置文件info.txt。
//现在想将info.txt中的键值数据存到集合中进行操作。
/*
思路：
1、将字符读取流与文件相关联。为提高效率，用字符缓冲读取流。
2、读取一行数据，将改行数据用“=”进行切割。
3、等号左边作为键，右边作为值，存入到Propertie集合中即可。
*/
import java.util.*;
import java.io.*;
class PropertiesDemo
{
public static void main(String[] args)throws IOException
{
Properties pro=new Properties();
BufferedReader bufr=new BufferedReader(new FileReader("G:\\info.txt"));
String line=null;
while((line=bufr.readLine())!=null)
{
String[] arr=line.split("=");
pro.setProperty(arr[0],arr[1]);
}
bufr.close();
System.out.println(pro);
}
}
运行结果：
优化：
通过查阅Properties的API，发现有一个方法已经帮我 们实现了这个功能：void load（FileInputStream inStream）；
import java.util.*;
import java.io.*;
class PropertiesDemo
{
public static void main(String[] args)throws IOException
{
Properties pro=new Properties();
FileInputStream in=new FileInputStream("G:\\info.txt");
pro.load(in);
System.out.println(pro);
//pro.list(System.out);
}
}
现在我们对集合进行一些设置，比如：
import java.util.*;
import java.io.*;
class PropertiesDemo
{
public static void main(String[] args)throws IOException
{
Properties pro=new Properties();
FileInputStream in=new FileInputStream("G:\\info.txt");
pro.load(in);
pro.setProperty("zhangsan","30");
System.out.println(pro);
}
}
运行结果：
但是在看一下文件：
想让文件也有同样的变化，则：
//现在想将info.txt中的键值数据存到集合中进行操作。
/*
思路：
1、将字符读取流与文件相关联。为提高效率，用字符缓冲读取流。
2、读取一行数据，将改行数据用“=”进行切割。
3、等号左边作为键，右边作为值，存入到Propertie集合中即可。
*/
import java.util.*;
import java.io.*;
class PropertiesDemo
{
public static void main(String[] args)throws IOException
{
Properties pro=new Properties();
FileInputStream in=new FileInputStream("G:\\info.txt");
pro.load(in);
pro.setProperty("zhangsan","30");
pro.store(new FileOutputStream("G:\\info.txt"),"haha");
pro.list(System.out);
}
}
运行结果：
现在，再看一下文件：
拓展：
配置文件有两种形式，一种是Properties，一种是xml文件。由于Properties形式的 配置文件有他的局限性，所以之后又出来了xml文件。
name=zhangsan
age=20
name=wangwu
age=30
<Persons
<person
<name>zhangsan</name>
<age>20</age>
/person>
<person
<name>wangwu</name>
<age>30<>
/person>
/Persons>
3、Properties练习
需求：记录应用程序运行的次数。如果使用次数已到，那 么给出注册提示。
/*
很容易想到的是计数器。
它的特点是：
该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。
随着该应用程序的退出，该计数器也在内存中消失，下一次再启动时，重新计数。
这不是我们想要的，我们希望，程序即使结束，该计数器的值也存在。
下次程序启动时会先加载该计数器的值并加1后重新存储起来。
因此，我们想到用配置文件来记录该软件的使用次数。
该配置文件使用键值对的形式，这样便于阅读数据，并操作数据。
键值对数据是Map集合，数据是以文件的形式存储的，使用io技术，
那么io+Map=Properties。
*/
import java.util.*;
import java.io.*;
class RunCount
{
public static void main(String[] args)throws IOException
{
Properties prop=new Properties();
File file=new File("C:\\count.txt");
FileInputStream fis=new FileInputStream(file);
prop.load(fis);
int count=0;
String value=prop.getProperty("time");
if(value!=null)
{
count=Integer.parseInt(value);
if(count>5)
{
System.out.println("您好，使用次数已到，请注册！");
return;
}
}
count++;
prop.setProperty("time",count+"");
FileOutputStream fos=new FileOutputStream(file);
prop.store(fos,"");
fis.close();
fos.close();
}
}
第一次编译运行后：
第二次运行后：
其他
一、PrintWriter
打印流。它提供了多种重载形式的打印方法，可以将各种 数据类型的数据打印到指定的位置。
import java.util.*;
import java.io.*;
class PrintStreamDemo
{
public static void main(String[] args)throws IOException
{
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
PrintWriter out=new PrintWriter(new FileWriter("C:\\a.txt"),true);
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
out.println(line.toUpperCase());
//out.flush();out初始化时，boolean参数为true，自动刷新
}
out.close();
bufr.close();
}
}
其实，我们可以把PrintWriter看成是FileWriter,PrintStream看成是 FileOutputStream来学习。那么这里的println（）就可以看成是write（）。只需要 特别注意一下PrintWriter构造函数所接受的参数即可，它可以接收的参数类型比较广 泛一些。
PrintStream构造函数可以接收的参数类型：
a. File对象
b. 字符串路径
c. 字节输出流对象
PrintWriter构造函数可以接收的参数类型：
a. File对象
b. 字符串路径
c. 字节输出流对象
d. 字符输出流对象
二、合并流（SequenceInputStream）
|--InputStream
|--SequenceInputStream
SequenceInputStream 表示其他输入流的逻辑串联。它从 输入流的有序集合开始，并从第一个输入流开始读取，直 到到达文件末尾，接着从第二个输入流读取，依次类推， 直到到达包含的最后一个输入流的文件末尾为止。
SequenceInputStream(Enumeration<?extends
InputStream> e) ：通过记住参数来初始化新创建的 SequenceInputStream，该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数。
练习：将1.txt、2.txt、3.txt中的内容写入到一个文件 中。
import java.util.*;
import java.io.*;
class SequenceDemo
{
public static void main(String[] args)throws IOException
{
Vector<FileInputStream> v=new Vector<FileInputStream>();
v.add(new FileInputStream("C:\\1.txt"));
v.add(new FileInputStream("C:\\2.txt"));
v.add(new FileInputStream("C:\\3.txt"));
Enumeration en=v.elements();
SequenceInputStream sis=new SequenceInputStream(en);
FileOutputStream fos=new FileOutputStream("C:\\a.txt");
byte[] buf=new byte[1024];
int len=0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
}
三、切割文件&合并文件
需求：将a.txt切割成三个文件，分别是1.txt、2.txt、 3.txt。 再将三个文件合并成一个文件b.txt。
import java.util.*;
import java.io.*;
class SplitFile
{
public static void main(String[] args)throws IOException
{
//splitFile();
merge();
}
public static void splitFile()throws IOException
{
FileInputStream fis=new FileInputStream("C:\\a.txt");
FileOutputStream fos=null;
byte[] buf=new byte[16];
int len=0;
int count=1;
while((len=fis.read(buf))!=-1)
{
fos=new FileOutputStream("C:\\"+(count++)+".txt");
fos.write(buf,0,len);
fos.close();
}
fis.close();
}
public static void merge()throws IOException
{
/*
Vector<FileInputStream> v=new Vector<FileInputStream>();
v.add(new FileInputStream("1.txt"));
v.add(new FileInputStream("2.txt"));
v.add(new FileInputStream("3.txt"));
Enumeration en=v.elements();
*/
//由于Vector太低效，所以我们用ArrayList。
ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();
for(int x=1;x<=3;x++)
{
al.add(new FileInputStream("C:\\"+x+".txt"));
}
final Iterator<FileInputStream> it=al.iterator();
Enumeration<FileInputStream> en=new Enumeration<FileInputStream>()
{
public boolean hasMoreElements()
{
return it.hasNext();
}
public FileInputStream nextElement()
{
return it.next();
}
};
SequenceInputStream sis=new SequenceInputStream(en);
FileOutputStream fos=new FileOutputStream("C:\\hebin.txt");
byte[] buf=new byte[8];
int len=0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
sis.close();
fos.close();
}
}
四、对象的序列化
什么是对象的序列化？
把对象存放在硬盘上叫做对象的持久化存储（序列化）。
该对象所属的类必须实现Serializable接口。（该接口 没有方法，仅用于标识可序列化的语义。）
更细节划分操作对象的流:
ObjectInputStream/ObjectOutputStream
涉及到的方法：
① ObjectOutputStream oos=new ObjectOutputSteam（OutputStream out）；
② void writeObject（Object obj）：将指定的对象写入ObjectOutputStream；
③ objectInputStream ois=new ObjectInputStream(InputStream in);
④ void readObject();从 ObjectInputStream 读取对象
练习：将自定义类Person的对象存入到磁盘文件中，再 从文件中读取出来。
/*
实现了Serializable之后的类，编译后都会产生一个对应的uid。
它是根据类中不同的成员来算这个值的，给类做标记。
使对象所属的类文件始终保持是同一个uid。
通过：public static fianl long serialVersionUID=42L；
好处：
当我们往文件obj.txt中存储对象之后，我们改动了类中的成员变量，
比如，加一个新的修饰符。此时我们想从obj.txt中读取数据，编译运行后，
运行失败。原因就是序列号不统一。但是我们只要通过上面一行代码，我们
就可以解决这个问题。并且可以使obj.txt中的内容同步。
还有一点就是：静态不可以序列化，即存不进去，我们会将相应的该数据类型
默认初始化值代替初始化值存入进去。若非静态也不想序列化，我们可以通过
关键字transient修饰。
*/
import java.io.*;
class Person implements Serializable
{
public static final long serialVersionUID=42L;
private String name;
private int age;
private String country;
Person(String name,int age,String country)
{
this.name=name;
this.age=age;
this.country=country;
}
public String toString()
{
return name+":"+age+":"+country;
}
}
class ObjectStreamDemo
{
public static void main(String[] args)throws Exception
{
//writeObj();
readObj();
}
public static void writeObj()throws Exception
{
ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("C:\\t.txt"));
oos.writeObject(new Person("zhangsn",20,"cn"));
oos.writeObject(new Person("wangwwu",23,"ke"));
oos.close();
}
public static void readObj()throws Exception
{
ObjectInputStream ois=new ObjectInputStream(new FileInputStream("C:\\t.txt"));
Person p=(Person)ois.readObject();
System.out.println(p);//打印zhangsn：20：cn
ois.close();
}
}
五、管道流
管道流:
PipedInputStream/PipedOutputStreamm
PipedReader/PipedWriter
PipedInputStream in=new PipedInputStream();
PipedOutputStream out=new PipedOutputStream（）；
in.connect(out);
管道输入流应该连接到管道输出流，管道输入流提供要写 入管道输出流的所有数据。通常，数据由某个线程从管道 输入流对象读取，并由其他线程将其写入到相应的管道输 出流。
示例：
import java.io.*;
class Read implements Runnable
{
private PipedInputStream in;
Read(PipedInputStream in)
{
this.in=in;
}
public void run()
{
try
{
byte[] buf=new byte[1024];
System.out.println("读取前。。。没有数据阻塞");
int len=in.read(buf);
System.out.println("读取后。。。阻塞结束");
String s=new String(buf,0,len);
System.out.println(s);
in.close();
}
catch (IOException e)
{
throw new RuntimeException("管道读取流失败");
}
}
}
class Write implements Runnable
{
private PipedOutputStream out;
Write(PipedOutputStream out)
{
this.out=out;
}
public void run()
{
try
{
System.out.println("开始写入数据，等待6秒后");
Thread.sleep(6000);
out.write("pipe lai le".getBytes());
out.close();
}
catch (Exception e)
{
throw new RuntimeException("管道输出流失败");
}
}
}
class PipedStreamDemo
{
public static void main(String[] args)throws Exception
{
PipedInputStream in=new PipedInputStream();
PipedOutputStream out=new PipedOutputStream();
in.connect(out);
Read r=new Read(in);
Write w=new Write(out);
new Thread(w).start();
new Thread(r).start();
}
}
六、RandomAccessFile
简而言之，该类可以根据模式（r，rw）的不同对磁盘上 的文件进行随机的读和写。该类的对象就相当于一个文件 指针，通过调用类中的方法可以改变指针的所指的位置从 而实现随机。
重点掌握以下几个方法：
① RandomAccessFile(File file,String mode):创建从中读取和向其中写入（可选） 的随机访问文件流，该文件由File参数指定。
② RandomAccessFile（String name，String mode）：创建从中读取和向其中写入 （可选）的随机访问文件流，该文件具有指定名称。
③ void seek（long pos）：设置到此文件开头测量到的文件指针偏移量，在该位置 发生下一个读取或写入操作。
④ int skipBytes（int n）：尝试跳过输入的n个字节以丢弃跳过的字节。
⑤ int readInt（）：从此文件读取一个有符号的32位整数。
⑥ int read():从此文件中读取一个数据字节。
⑦ int read(byte[] b):将最多b.lenggh个数据字节从此文件读入byte。
⑧ void write（int b）：向此文件写入指定的字节。
⑨ void write（byte[] b）:将 b.length 个字节从指定 byte 数组写入到此文件， 并从当前文件指针开始。
⑩ void writeInt(int v):按四个字节将int写入该文件，先写高字节。
示例：
import java.io.*;
class RandomAccessFileDemo
{
public static void main(String[] arags)throws IOException
{
writeFile();
//readFile();
}
public static void writeFile()throws IOException
{
RandomAccessFile raf=new RandomAccessFile("C:\\t.txt","rw");
raf.write("lisi".getBytes());
/*
write()/具有强转的功能，为保证数据的原样性，只写最低八位。
而writeInt（）会写32位。且写入的其实是a，通过编码表查找。
*/
raf.writeInt(97);
//raf.writeBytes("\r\n");
//raf.seek(8);
raf.write("wangwu".getBytes());
raf.writeInt(258);
raf.close();
}
public static void readFile()throws IOException
{
RandomAccessFile raf=new RandomAccessFile("C:\\t.txt","r");
byte[] buf=new byte[4];
raf.read(buf);
String name=new String(buf);
//raf.seek(8);
//raf.skipBytes(4);
int age=raf.readInt();
System.out.println("name="+name+",age="+age);
}
}
总结：这个类也可以看成是FileWriter/FileWriter来 学习。就seek（）和skipBytes()特殊一点。
七、操作基本数据类型的流对象DataStream
DataInputStream/DataOutputStream
DataInputStream dis=new DataInputStream(InputStream in);
DataOutputStream dos=new DataOutputStream(OutputStream out);
readUTF();
writeUTF();
readInt();
writeInt();
readBoolean();
writeBoolean();
readDouble();
writeDouble();
温馨提示：这个类可以看成FileWriter和FileReader来 对照学习。
八、ByteArrayStream
ByteArrayInputStream/ByteArrayOutputStream
ByteArrayStream（byte[] buf）:
创建一个ByteArrayInputStream,使用buf作为其缓冲区 数组。
Ps：在构造的时候，需要接收数据源，而且数据源是一个 字节数组。
ByteArrayStream（）：创建一个新的byte数组输出流。
ps：在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节 数组。
因此，这两个流对象都操作的数组，并没有使用系统资源，
不用进行close（）关闭。
还需要掌握的方法：
ByteArrayInputStream:
read();
ByteArrayOutputStream:
write();
size();
toString();
write(OutputStream out);
2015-12-16至
2015-12-20著
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 对Java内存结构的一点思考和实践
- 20145205 《Java程序设计》第6周学习总结
- Java 链式编程
- 20145303 《Java程序设计》第六周学习总结
- java 转型
- JAVA继承，讨论字符串的细节
- 05.Java 集合 - LinkedList
- 20145308刘昊阳 《Java程序设计》实验一 Java开发环境的熟悉 实验报告
- Spring Boot中使用Spring-data-jpa
- 如何用java语言获取某个网页的源代码
- Eclipse更改主题，换个黑色的背景颜色吧，哈哈
- eclipse 常用快捷键
- LeetCode(java)7. Reverse Integer
- 20145222黄亚奇《Java程序设计》第6周学习总结
- 《Spring设计思想》AOP设计基本原理
- java 上传文件到 vsftpd ftp服务器
- eclipse编辑struts.xml 代码提示
- 20145212 《Java程序设计》第6周学习总结
- JVM(2)--java内存管理
- 20145313Java第一次实验