数据最常见的体现形式是：文件
需求：在硬盘上，创建一个文件，并写入一些文字数据。
用于操作操作文件的Writer的子类FileWriter，后缀名是父类名。前缀名是该流对象的功能。
操作步骤：
1.创建一个FileWriter对象。该对象一被初始化就必须明确要被操作的文件，该文件会被创建到指定目录下，如果该目录下已经有同名文件，将被覆盖
FileWriter fw=new FileWriter("demo.txt");
2.调用write方法，将字符串写入到流中。
fw.write();
3.刷新流对象中的缓冲中的数据，将数据刷到目的地
fw.flush();
4.关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据，将数据刷到目的地中。和flush的区别，flush刷新后，流可以继续使用，close刷新后
将会将流关闭。
fw.close();
文件的续写：
传递一个true参数，代表不覆盖已有文件，并在已知文件的末尾处进行数据续写。
FileWriter fw=new FileWriter("demo.txt"，true);
换行转义字符：\r\n
文件的读取方式一：
FileReader();
1.创建一个FileReader对象。文件读取流对象，和指定名称的文件相关联，要保证该文件是已经存在的，如果不存在会发生异常
FileReader fr=new FileReader("demo.txt");
2.调用读取流的对象的read方法
(1)int ch=fr.read();一次读一个字符，会自动往下读。
(2)读出所有字符
while（(ch=fr.read())!=-1）
{
System.out.println((char)ch);
}
3.关闭流资源，
fr.close();
文件的读取方式2：通过字符数组进行读取
1.创建一个FileReader对象。文件读取流对象，和指定名称的文件相关联，要保证该文件是已经存在的，如果不存在会发生异常
FileReader fr=new FileReader("demo.txt");
2.定一个字符数组，用于存储读到字符，该rrad(char[])返回的是读到的字符个数。
char[] buf=new char[1024]；一般定义1024-2个字节。
int num=0;
while（(num=fr.read(buf))!=-1）
{
System.out.println((new String(buf,0,num));
}
二 ：字符流的缓冲区：
缓冲区的出现提高了对数据的读写效率
对应类：
BUfferWriter
BufferedReader
特点：缓冲区要结合流才可以使用，在创建缓冲区之前，必须要有流对象。在流的基础上对流的功能进行了增强。
BUfferWriter步骤:
1.创建一个字符写入流对象
FileWriter fw=new FileWriter("a.txt");
2.将需要被提高效率的流对象作为参数传递给缓冲区的构造函数
bufferedWriter bufw=new BufferedWriter(fw);
buff.write("asdasdas");
bufw.newLine();//换行符，跨平台的
3.将缓冲区刷新
bufw.flush;
4.关闭缓冲区，就是在关闭缓冲区中的流对象
bufw.close();
BufferedReader步骤
1.创建一个字符写入流对象
FileReader fr=new FileReader ("a.txt");
2.将需要被提高效率的流对象作为参数传递给缓冲区的构造函数
BufferedReader bufr=new BufferedReader (fr);
3.读取流对象:该缓冲区提供了一个一次读取一行的方法。当返回null时表示，文件读到末尾
String line=null;
while((line=bufr.readLine())!=null)
{
String s=line;}
4.关闭
bufr.close();
readLine()方法的原理：
无论是读一行，获取多个字符，最终都是在硬盘上一个一个读取，最终使用额还是read方法一次读一个的方法。
自定义一个功能和readline一致的方法，来模拟下BufferedReader();
public class MyBufferedReader extends Reader {
private Reader r;
public MyBufferedReader(Reader r) {
super();
this.r = r;
}
//可以一次读取一行的方法
public String myReadLine() throws IOException
{
//定义一个临时容器。StringBulider容器，应用于存储字符数组
StringBuilder sb=new StringBuilder();
int ch=0;
while((ch=r.read())!=-1){
if(ch=='\r')
continue;
if(ch=='\n')
return sb.toString();
else
sb.append((char)ch);
}
if(sb.length()!=0)
return sb.toString();
return null;
}
}
三 ：装饰设计模式
当想要对已有的独享进行功能增强时，可以定义类，将已有的对象传入，基于已经有的功能，
并提供加强功能，那么自定义的该类称为装饰类
装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。
代码演示：
已知类：
Person()
{
public void chifan(){}
}
增强类：
superPerson()
{
private Person p;
superPerson(Person p)
{
this.p=p;
}
public void superchifan()
{
p.chifan();
//要增强的吃饭的内容
{
}
四：带有行号的缓冲区：
LineNumberReader lnr=new LineNumberReader();
获取行号:lnr.getLineNumber();
设置行号从几开始：lnr.setLineNumber(100);
LineNumberReader 步骤
1.创建一个字符写入流对象
FileReader fr=new FileReader ("a.txt");
2.将需要被提高效率的流对象作为参数传递给缓冲区的构造函数
LineNumberReader lnfr=new LineNumberReader (fr);
3.读取流对象:该缓冲区提供了一个一次读取一行的方法。当返回null时表示，文件读到末尾
String line=null;
while((line=lnfr.readLine())!=null)
{
String s=line;
String linenum=lnfr.getLineNumber();
}
4.关闭
lnfr.close();
五：字节流：
字符流只能操作文本文件，要操作其他数据就要用到字节流。
字符流使用的是字符数组char[]，字节流使用的是字节数组byte[]。
字节流:
InputStream 读
Outputstream 写
读取
FileInputStream fis=new FileInputStream ("a.txt");
byte[] buf=new byte[fis].available(0)];//定义一个刚刚好的缓冲区，不用再循环了
fis.read(buf);
System.out.println(new String(buf));
fis.close();
练习：复制图片
class CopyFile{
FileOutputStream fw=null;
FileInputStream fr=null;
try {
fos=new FileOutputStream("b.jpg");
fis=new FileInputStream("a.jpg");
byte[] buf=new byte[1024];
int num=0;
while ((num=fis.read(buf))!=-1){
fis.write(buf,0,num);
}
}
catch (IOException e) {
e.printStackTrace();
}
finally
{
try {
if(fis!=null)
fis.close();
}catch (IOException e) {
e.printStackTrace();
}
try {
fos.close();
}catch (IOException e) {
e.printStackTrace();
}
}
}
六：日常的日志信息和系统信息
使用printStream();
输出到控制台：
System.SetOut(new PrintStream("sysinfo.txt"))
e.printStackTrace(System.out）；
上面这两句就相当于
e.printStackTrace(new PrintStream("sysinfo.txt"));//将日志文件打印到文件中
获取系统信息：
Properties prop =System.getProperties();
prop.list(System.out);//打印到控制台
prop.list(new PrintStream("sysinfo.txt"));//打印到文件中
七：字节流的缓冲区
通过字节流的缓冲区复制MP3
BufferedOutputStream
BufferedInputStream
代码：
BufferedInputStream bufis=new
BufferedInputStream(new FileInputStream("a.txt"));
BufferedOutputStream bufos=new
BufferedOutputStream(new FileOutputStream("b.txt"));
int len=0;
while((len=bufis.read())!=-1){
bufos.write(len);
}
八：读取键盘录入
/*
* 读取键盘，转换大写，保存到文本文件
* 读取文件，转换大写，输出控制台
* 读取文件，转换大写，输出另一个
*
*/
import java.io.*;
public class TranseDemo3 {
public static void main(String[] args)throws IOException {
InputStream in = new FileInputStream("src\\cn\\itcast\\iostream\\CopyText3.java");
InputStreamReader isr = new InputStreamReader(in);
BufferedReader bfr = new BufferedReader(isr);
OutputStream out = new FileOutputStream("c:\\123.java");
OutputStreamWriter osw = new OutputStreamWriter(out);
BufferedWriter bfw = new BufferedWriter(osw);
String line = null;
while((line = bfr.readLine())!=null){
if("over".equals(line))break;
bfw.write(line.toUpperCase());
bfw.newLine();
bfw.flush();
}
bfw.close();
bfr.close();
}
}
九：转换流：
读取转换流：InputStreamReader
写入转换流：OutputStreamReader
读取转换流：InputStreamReader 字节流通向字符流的桥梁
步骤 ：
1.获取键盘录入对象
Inputstream in=System.in
2.将字节流对象转换成字符流对象，使用转换流InputStreamReader
InputStreamReader isr=new InputStreamReader(in);
3.提高效率使用字符流缓冲区 BufferedReader进行读取
BufferedReader bf=new BufferedReader(is);
String line=null;
while((line=bf.readLine())!=null)
{
if("over".equals(line))
break;
sop(line);
}
bufr.close;
写入转换流：OutputStreamReader 字符流通向字节流的桥梁
步骤
1.获取输出对象
Outputstream out=System.out
2.将字符流对象转换成字节流对象，使用转换流OutputstreamWriter
OutputstreamWriter osw=new OutputstreamWriter(out);
3.提高效率使用字符流缓冲区 BufferedWriter进行写入
BufferedWriter bw=new BufferedWriter(osw);
String line=null;
while((line=bf.readLine())!=null)
{
if("over".equals(line))
break;
bw.write(line);
bufw.newLine();
}
bufr.close;
十：流操作基本规律：
两个明确:
1.明确源和目的
源：输入流。InputStream字节流 Reader 字符流
目的：输出流 OutPutStream 字节流 Writer 字符流
2.操作的数据是否是纯文本
是 就是字符流 如果设备是键盘 就将字节流转换为字符流
不是 就是 字节流
3.当体系明确后，在明确要是用那个具体的对象
通过设备来区分
源设备 内存 硬盘 键盘
目的设备 内存 硬盘 控制台
4.是否需要提高效率 是 BufferedReader BufferedInputStream
否 BuffreredWriter BufferedOutputStream
案例分析 ：
1.将一个文本文件中的数据存储到另一个文件中，复制文件
源： InputStream字节流 Reader 字符流
是否是纯文本 是 Reader
设备： 文件 操作文件的对象 就是FileReader
是否需要高效
是 BufferedReader
FileReader fr=new FileReader("a.txt");
BufferedReader bufr=new BufferedReader(fr);
目的 OutPutStream 字节流 Writer 字符流
是否是纯文本 ：是 Writer
设备: 文件 写入文件的对象 就是 FileWriter
是否需要高效 是 BufferedWriter
FileWriter fw=new FileWriter("b.txt");
BufferedWriter bufw=new BufferedWriter(fw);
2.将一个图片文件数据存储到另一个文件中，复制文件。
分析
源：
是否是纯文本 : 不是 InputStream
设备 文件 就是 FileInputStream
是否高效 是
BufferedInputStream
FileInputStream isr=new FileInputStream("a.jpg");
BufferedInputStream bufis=new BufferedInputStream(isr);
目的
是否纯文本 ：不是 OutPutStream
设备：文件 FileOutPutStream
是否高效 是
BufferedOutputStream
FileOutPutStream osw=new FileOutPutStream("b.jpg");
BufferedOutputStream bufos=new BufferedOutputStream(osw);
3.需求将键盘录入的数据保存到一个文件中 。
源：键盘 字节流
是否纯文本 Reader
设备 ：键盘 ,对应的对象时 System.in 对应的是字节流 ，为了操作方便 转成字符流
既然明确了Reader 就将System.in 转换成字符流 InputStreamReader
InputStreamReader isr=new InputStreamReader(System.in);
需要高效吗 ?
BufferedReader bufr=new BufferedReader(isr);
目的： 文件
是否纯文本 是 Writer
设备：文件 FileWriter
需要高效吗？
是 BufferedWriter
4.扩展 ：想要吧录入的数据按照指定的编码表（utf-8）将数据存到文件中
目的:OutPutStream 字节流 Writer 字符流
是否是存文本：是 Writer
设备 ：文件 fileWriter
默认编码表是 gbk
编码标只有转换流可以指定。所以要使用的对象是写入转换流 OutputStreamWriter
转换流需要接受一个自己输出流，操作字节输出流的是FileOutputStream
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("b.txt"),"utf-8");
BufferedWriter bufw=new BufferedWriter (osw);
总结：通常涉及到字符编码转换的时候，就需要用到转换流。
十一：File类
创建File对象，
1.File f=new File("c:\\abc\a.txt");//将a.txt封装成FIle对象，可以将已有的和未出现的文件或者文件夹封装成对象。
2.File f=new File("c:\\abc","a.txt"); 第一个参数代表的是目录，第二个参数代表的是目录下的文件。
3.file d=new File("c\\abc"); 将路径封装成对象
File f=new File(d,"a.txt"); 调用路径对象
f代表的是文件路径
目录分隔符：\\
File.separator
常见方法:
1.创建
boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false
和写入流不一样，写入流创建文件会覆盖已经存在的文件。
案例 ：
File f=new File("a.txt");
f.createNewFile();
创建一级目录
File dir=new File("abc");
dir.mkdir();
创建多级目录
dir.mkdirs();
2.删除
boolean f.delete(); 删除失败，返回false，可能不能删除
void deleteOnExit();在程序退出时，删除指定文件。必须删除。不会失败
3.判断 ：在判断文件对象是都是文件或者目的时候，必须要先判断该文件对象封装的内容是否存在。
File f=new File("a.txt");
f.canExecute();是否能执行。
f.exits();返回boolean 文件是否存在
是否是目录
f.isDirectory();
是否是文件
f.isFile();
是否是隐藏的
f.isHidden();
是否是绝对路径
f.isAbsolute();
4.获取信息。
getName() //获取名称
getpath() //获取路径
getAbsolutePath() //获取绝对路径
getParent() //获取绝对路径下的父路径，如果获取的是相对路径返回null，如果相对路径中由上一级目录，该目录就是结果。
lastModified()//获取最后一次修改时间
length();//获取体积大小
5.其他
renameTo();改名，重命名，如果修改路径的话，同时路径也会修改
f1.renameTo(f2);
listRoots();返回 File 数组，列出可用的文件系统根（盘符）
例子：
File[] files=File.listRoots();
for(File f: files)
{
sop(f)
}
list():返回当前目录下所有文件,包括子目录
File f=new File("abc");
String[] namess=f.list();//调用list方法的file对象必须封装了一个目录，把那个目录必须存在
for(String f: names)
{
sop(f)
}
显示.bmp结尾的文件
list（FilenameFilter Filter） 返回String[] 指定目录中满足制定过滤器的文件和目录
File dir=new File("abc");
String[] namess=f.list(new FilenameFileter()
public boolean accept(File dir,String name)
{
return name.endsWith(".bmp");
}
);/
for(String f: names)
{
sop(f);
}
listFiles();返回当前路径下的文件对象。(不包括子目录)
FIle dir=new File("c:\\");
File[] files=dir.listFiles();
for(File f : files)
{
sop （f.getname()）
}
列出指定目录下所有内容:使用递归 。。函数自己调用自己
File dir=new File("d:\\");
sop(dir);
File[] files=dir.listFiles();
for(int x=0;x<files.length;x++)
{
if(files[x].isDirectory)
showDir(files[x]);
else
System.out.println(files[x]);
}
删除一个带内容的目录：
原理：从里面往外删除，就需要递归
File dir=new File("d:\\");
File[] files=dr.listFiles();
for(int x=0;x<files.length;x++)
{
if(files[x].isDirectory())
removeDir(files[x]);
sop(files[x].toString()+":-file-:"+files[x].delete(););
}
sop(dir+":-dir-:"+dir.delete();)
练习：讲一个指定目录下的jva文件的绝对路径，存储到一个文本文件中。
思路：
1.对指定目录进行递归
2.获取递归过程中所有以JAVA文件的路径
3.将这些目录存储到集合中，将集合中的数据写入到一个文件中。
十二：Properties集合：是hashtable的子类，具备map集合的特点，里面存储的键值对都是字符串。，，，文件流和 键值对相结合 就用此集合
是集合中和IO技术相结合的集合容器
该对象的特点：可以用于键值对形式的配置文件，可以操作键盘的数据。
//设置和获取元素。
Properties prop =new Properties();
prop.setProperty("张三","30");//添加，修改
sop(prop);
prop.getProperty("键");
循环获取
Set<String> names=prop.stringPropertyNames();
for(String s : names)
{
prop.getProperty(s);
}
Properties存取配置文件，将文本a.txt中的数据存到集合中进行操作。
步骤：1.用一个六和info.txt关联
2.读取一行数据，用该行数据用"="尽情切割
2.封号左边作为建，右边作为值，存储到Properties集合中即可
BufferedReader bufr=new BufferedReader(new FileReader("a.txt"));
String line=null;
Properties prop =new Propertites();
while((line=bufr.readLine())!=null)
{
String[] arr =line.split("=");
prop.setProperty(arr[0],arr[1]);
}
简便方法
Properties prop =new Propertites();
FileInputStream fis=new FileInputStream("a.txt");
//将流中的数据加载进集合
prop.load(fis);
prop.list(System.out);
练习，用于记录应用程序运行次数，如果使用次数已经到，就给出注册提示。
Properties prop=new Properties();
File file=new File ("count.ini");
if(!file.exists())
file.createNewFile();
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, "");
fos.close();
fis.close();
}
十三：其他流对象
打印流 ：该流提供了打印方法，可以将各种数据类型的数据都原样打印出来。
字节打印流
PrintStream
构造函数可以接受的参数类型
1.file对象 File
2.字符串路径 String
3.字节输出流 OutputStream
字符打印流
PrintWriter
构造函数可以接受的参数类型
1.file对象 File
2.字符串路径 String
3.字节输出流 OutputStream
4.字符输出流 Writer
练习
控制台输入后，打印在控制台
BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
PrintWriter Out=new PrintWriter（System.in,true)）;
String line=true;
while((line=bufr.readLine()))!=numm
{
if("over".equals(line))
break;
out.println(line);
}
out.close();
bufr.close();
合并流(序列流)：SeaquenceInputStream 对多个流进行合并。
vactor<FileInputStream> v=new vactor<FileInputStream>();
v.add(new FileInputStream("1.txt"));
v.add(new FileInputStream("2.txt"));
v.add(new FileInputStream("2.txt"));
Enumeration<FileInputStream> en=v.elements();
SeaquenceInputStream sis=new SeaquenceInputStream(en);
FileOutputStream fos=new FileOutputStream("4.txt");
byte[] buf=new byte[1024];
int len=0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}
fos.close();
sis.close();
286
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
