个人小结：数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。根据处理数据类型的不同可分为：字符流和字节流。本篇主要介绍IO流中的字节流。
一、字节流
1、如果要操作除文本数据类型之外的数据，比如图片，就要用到 字节流。
<span style="font-family:Microsoft YaHei;font-size:12px;">/*
需求：
复制一个图片
思路：
1、用字节读取流对象和图片关联
2、用字节写入流对象创建一个图片文件，用于存储获取到的图片数据
3、通过循环读写，完成数据存储
4、关闭资源
注意：不要用字符流来处理除文本以外的文件，容易出问题！
*/
import java.io.*;
class CopyPic
{
public static void main(String[] args)
{
FileInputStream fis= null;
FileOutputStream fos= null;
try
{
//读取流关联要复制的文件
fis = new FileInputStream("D:\\JAVA学习\\线程运行状态.jpg");
//写入流关联指定复制的文件名
fos = new FileOutputStream("c:\\1.jpg");
//定义一个缓冲数组
byte[] buf = new byte[1024];
int len = 0;
//边读边写
while ((len = fis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
}
catch (IOException e)
{
throw new RuntimeException("复制文件失败！");
}
finally
{
try
{
if(fis!=null)
fis.close();//关流
}
catch (IOException e)
{
throw new RuntimeException("读取关闭失败");
}
try
{
if(fis!=null)
fos.close();//关流
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败");
}
}
}
}</span>
二、字节流缓冲区
BufferedOutputStream，BufferedInputStream 1、作用：提高了字节流的读写效率。 2、特点： read()：会将字节byte型值提升为int型值
write()：会将int型强转为byte型，即保留二进制数的最后八位。
3、原理：先将数据读取一部分，循环，直到数据全部读取完毕。
4、自定义读取字节流缓冲区
需求：根据字节流缓冲区的原理，自定义一个字节流缓冲区。
注意：
1、字节流的读一个字节的read方法为什么返回值类型不是byte，而是int。
因为有可能会读到连续8个二进制1的情况，8个二进制1对应的十进制是-1。那么就会出现数据还没有读完就结束的情况。因为我们判断读取结束是通过结尾标记-1来确定的。
所以，为了避免这种情况将读到的字节进行int类型的提升。并在保留原字节数据的情况前面了补了24个0，变成了int类型的数值。而在写入数据时，只写该int类型数据的最低8位。
2、byte类型的-1提升为int类型时还是-1。原因：因为在二进制位中的8个1前面补的全是1导致的。如果在8个1前面补0，既可以保留原字节数据不变，又可以避免-1的出现。这时只用将byte型数据 &255 即可。
示例代码：演示自定义缓冲区，并用来拷贝MP3文件。
<span style="font-family:Microsoft YaHei;font-size:12px;">import java.io.*;
class MyBufferedInputStream
{
private InputStream in;
private byte[] buf = new byte[1024*4];
private int pos = 0,count=0;
MyBufferedInputStream(InputStream 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&255;//返回的byte类型提升为int类型
}
else if (count>0)//如果数组中数据还没被读完，就继续读
{
byte b = buf[pos];
count--;
pos++;
return b&0xff;//返回的byte类型提升为int类型
}
return -1;
}
//定义关闭资源动作
public void myClose() throws IOException
{
in.close();
}
}</span>
//通过自定义缓冲区，演示MP3的复制。
import java.io.*;
class CopyMp3
{
public static void main(String[] args) throws IOException
{
long start = System.currentTimeMillis();
copy_2();
long end = System.currentTimeMillis();
System.out.println((end-start)+"毫秒");//查看复制所需时间
}
//通过自定义缓冲区演示
public static void copy_2() throws IOException
{
//创建缓冲区，并关联复制对象文件
MyBufferedInputStream bufis = new MyBufferedInputStream(new FileInputStream("c:\\0.mp3"));
//创建缓冲区，关联目标文件
BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\1.mp3"));
int by = 0 ;
System.out.println("第一个字节："+bufis.myRead());
//不停地读取写入
while ((by=bufis.myRead())!=-1)
{
bufos.write(by);
}
bufos.close();//关资源
bufis.myClose();//关资源
}
}
三、读取键盘录入 System.out: 标准输出设备：控制台
System.in : 标准输入设备：键盘 示例： 需求：通过键盘录入数据，当录入一行数据后，就将该行数据转成大写并进行打印，如果录入的数据是over，那么停止录入。
代码：
<span style="font-family:Microsoft YaHei;font-size:12px;">import java.io.*;运行结果：
class ReadIn
{
public static void main(String[] args) throws IOException
{
//获取键盘录入对象。
InputStream in = System.in;
//创建一个容器存储键盘录入的数据
StringBuilder sb = new StringBuilder();
while (true)
{
int ch= in.read();
if(ch=='\r')
continue;
if(ch=='\n')
{
String s = sb.toString();
if("over".equals(s))//如果录入的数据是over，那么停止录入
break;
System.out.println(s.toUpperCase());//将读取的字符串转成大写后打印
sb.delete(0,sb.length());
}
else
sb.append((char)ch);
}
}
}</span>
四、读取转换流
通过刚才的键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理，即 readLine()方法。 那么能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？
不能！由于readLine方法是BufferedReader类中的方法，而键盘录入的read方法是字节流InputStream的方法。
那么能不能将字节流转成字符流再使用字符流缓冲区的readLine方法呢？可以！用转换流 InputStreamReader！ 那么上例代码可改为：
<span style="font-family:Microsoft YaHei;font-size:12px;">import java.io.*;
class TransStreamDemo
{
public static void main(String[] args) throws IOException
{
//获取键盘录入对象。
//InputStream in = System.in;
//将字节流对象转成字符流对象，使用转换流，InputStreamReader
//InputStreamReader isr = new InputStreamReader(in);
//为了提高效率，将字符流进行缓冲区技术的高效操作，使用BufferedReader
//BufferedReader bufr = new BufferedReader(isr);
//键盘录入最常见写法！强记！
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
/*
OutputStream out = System.out;
OutputStreamWriter osw = new OutputStreamWriter(out);
BufferedWriter bufw = new BufferedWriter(osw);
*/
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();
}
}</span>
五、IO流操作规律(最重要部分)
1、需求：将键盘输入数据打印出来
源：键盘录入
目的：控制台
2、需求：想把键盘录入的数据存储到一个文件中
源：键盘
目的：文件
3、需求：想要将一个文件的数据打印在控制台上。
源：文件
目的：控制台
最痛苦的就是流对象有很多，不知道该用哪个？
通过三个明确来完成：
1、明确源和目的。
源：输入流。InputStream 、Reader
目的：输出流。OutputStream 、Writer
2、操作的数据是否是纯文本？
是：用字符流
不是：用字节流
3、当体系明确后，再明确要使用哪个具体对象，
通过设备来进行区分：
源设备：内存，硬盘，键盘
目的设备：内存，硬盘，控制台
应用规律实例分析： 需求1：将一个文本文件中的数据存储到另一个文件中，复制文件
1、源：因为是源，所以使用读取流：InputStream 或 Reader
是不是操作文本文件？是！这时就可以选择 Reader
2、接下来明确要使用该体系中的哪个对象？
明确设备：硬盘上的一个文件
Reader体系中可以操作文件的对象是FileReader
3、是否要提高效率？
是！加入Reader体系中的缓冲区： BufferedReader。
4、写出代码： FileReader fr = new FileReader("a.txt");
BufferedReader bufr = new BufferedReader(fr);
5、目的：是目的就要用 OutputStream 或者Writer
是不是纯文本？ 是！用Writer!
6、明确设备：硬盘的一个文件
Writer 体系中可以操作文件的对象是FileWriter
7、是否需要提高效率？
是！ 加入Writer体系中的缓冲区： BufferedWriter
8、写出代码： FileWriter fw = new FileWriter("b.txt");
BufferedWriter bufw = new BufferedWriter(fw);
练习：将一个图片文件中的数据存储到另一个文件中，复制文件，要按照以上格式自己完成三个明确。
1、源：硬盘中的一个文件
是不是操作文本文件？--不是！所以用 InputStream.
明确使用该体系中哪个对象？--设备是硬盘，所以用 FileInputStream
是否要提高效率？--要！加入该体系中的缓冲区 BufferedInputStream
2、目的：硬盘
是不是操作文本？--不是，所以用 OutputStream
用哪个对象？--设备是硬盘，FileOutputStream
是否要提高效率？--要！加入该体系中的缓冲区 BufferedOutputStream
需求2：将键盘录入的数据保存到一个文件中。
1、源：InputStream 或 Reader
是不是纯文本？是！用 Reader
设备：键盘。对应的对象是 System.in.
不是选择Reader吗？ System.in 不是字节流吗？
为了操作键盘的文本数据方便，转成字符流 按照字符串来操作最方便。
所以，既然明确了Reader，那么就将System.in转成字符流Reader,
用到了 Reader体系中的转换流，即 InputStreamReader.
InputstreamReader isr = new InputStreamReader(System.in);
要提高效率吗？要！ 用 BufferedReader
代码：BufferedReader bufr = new BufferedReader(isr);
2、目的：OutputStream 或 Writer
是否是纯文本？是！ 用 Writer
设备：硬盘，一个文件，使用FileWriter
需要提高效率吗？需要！用BufferedWriter 代码：FileWriter fw = new FileWriter("c.txt");
BufferedWriter bufw =new BufferedWriter(fw);
扩展一下，想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。
目的：OutputStream 或 Writer
是否是纯文本？是！ 用 Writer
设备：硬盘，一个文件，使用FileWriter，但是 FileWriter是使用默认编码表：GBK。
因为存储时需要加入指定的编码表UTF-8，而指定的编码表只有转换流才可以指定。所以要使用的对象是OutputStreamWriter
而该转换流对象要接收一个字节输出流，而且还可以操作文件的字节输出流。
所以代码：OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");
需要高效吗？要！BufferedWriter bufw = new BufferedWriter(osw);
所以，记住！转换流什么时候用呢？
转换流是字符和字节之间的桥梁，通常涉及到字符编码转换时需要用到。
练习：将一个文本数据打印在控制台上。按照以上格式完成三个明确。
1、源：文本，所以 Reader
设备：硬盘，一个文件，所以 FileReader
效率：要！所以BufferedReader
2、目的：文本，so Writer
设备：控制台，so System.out
但System.out是字节流，所以需要先转换成Writer，这就要用到Writer体系中的转换流：OutputStreamWriter
代码：OutputStreamWriter osw = new OutputStreamWriter(System.out);
要提高效率：BufferedWriter = new BufferedWriter(osw); 示例代码：
<span style="font-family:Microsoft YaHei;font-size:12px;">import java.io.*;
class TransStreamDemo2
{
public static void main(String[] args) throws IOException
{
System.setIn(new FileInputStream("PersonDemo.java"));//设置源
System.setOut(new PrintStream("zzz.txt"));//设置目的
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));//需求2
//new BufferedReader(new InputStreamReader(new FileInputStream("CopyPic.java")));//需求3
//new BufferedReader(new FileReader("out0.txt"));
BufferedWriter bufw =
//new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out0.txt")));//需求2
new BufferedWriter(new OutputStreamWriter(System.out));//需求2
String line = null;
while ((line=bufr.readLine())!=null)
{
if ("over".equals(line))
break;
bufw.write(line);
bufw.newLine();
bufw.flush();
}
bufr.close();
}
}</span>
六、保存异常的日志信息
正常开发中，程序在执行的时候出现的问题，需要用文件存储起来，这样方便查看和调整。
示例：
<span style="font-family:Microsoft YaHei;font-size:12px;">import java.io.*;
import java.util.*;
import java.text.*;
class ExceptionInfo
{
public static void main(String[] args) throws IOException
{
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("EXCEPTIONINFO.log");
ps.println(s);//打印时间
System.setOut(ps);//设置输出
}
catch (IOException ex)
{
throw new RuntimeException("日志文件创建失败！");
}
//将异常信息输出到指定输出流
e.printStackTrace(System.out);
}
}
}</span>
七、将系统属性信息保存到指定文本中
示例代码：
<span style="font-family:Microsoft YaHei;font-size:12px;">import java.util.*;
import java.io.*;
class SystemInfo
{
public static void main(String[] args) throws IOException
{
Properties prop = System.getProperties();//获取系统信息
//System.out.println(prop);
//prop.list(System.out);
prop.list(new PrintStream("sysinfo.txt"));
}
}</span>
八、File类 1、它是文件和目录路径名的抽象表现形式
2、用来将文件或文件夹封装成对象
3、方便对文件与文件夹的属性信息进行操作 4、File对象可以作为参数传递给流的构造函数
4、File类的实例是不可变的；即File 对象一旦创建，其表示的抽象路径名将永不改变
九、File类的常见方法
1、创建
blooean createNewFile(); 在指定位置创建文件，返回true,如果该文件已存在，则不创建，并返回false.
和输出流不一样，输出流对象一创建文件，如果该文件已存在，则会直接覆盖。
boolean mkdir():创建文件夹
boolean mkdirs():创建多级文件夹
2、删除
boolean delete();//删除文件或目录。文件存在，返回true；文件不存在或者正在被执行，返回false。
void deleteOnExit();//当程序结束时才删掉文件。
3、判断
boolean canExecute();//是否是可执行文件
boolean exists()://文件是否存在,用的较频繁。
isFile();//是否是文件
isDirectory();//是否是文件夹
isHidden(); //是否是隐藏文件
isAbsolute();//文件是否是绝对路径
4、获取信息
getName();//获取文件名
getPath(); //获取文件的相对路径（即创建的对象传入的参数是什么就获取到什么）
getParent();//获取文件父目录。返回的是绝对路径中的父目录。如果是相对路径，则返回null。如果相对路径中有上一层目录，那么该目录就是返回结果。
getAbsolutePath();//获取文件的绝对路径
long lastModified();//返回文件最后一次被修改的时间
long length();//返回文件长度
代码示例：
import java.io.*;
class FileDemo
{
public static void main(String[] args) throws IOException
{
//conMethod();
//method_1();
//method_2();
//method_3();
//method_4();
method_5();
}
public static void method_5()
{
File f1 = new File("c:\\yuanwenjian.txt");
File f2 = new File("c:\\hahha.java");
sop("rename:"+f1.renameTo(f2));
}
public static void method_4()
{
File f = new File("c:\\abc\\a.txt");
sop("path:"+f.getPath());
sop("abspath:"+f.getAbsolutePath());
sop("parent:"+f.getParent());//该方法返回的是绝对路径中的父目录。
//如果获取的是相对路径，返回空null.
//如果相对路径中有上一层目录，那么该目录就是返回结果.
}
public static void method_3() throws IOException
{
File f = new File("D:\\java0913\\day20\\kkk\\file1.txt");
//f.createNewFile();
f.mkdir();
//记住：在判断文件是否是文件或者目录时，必须要先判断该文件
//对象封装的内容是否存在，通过exists判断。
sop("dir:"+f.isDirectory());
sop("file:"+f.isFile());
sop(f.isAbsolute());
}
public static void method_2()
{
File f = new File("file.txt");
//sop("execute:"+f.canExecute());
//sop("exists:"+f.exists());
//创建文件夹
File dir = new File("abc");
sop("mkdir:"+dir.mkdir());
//创建多级文件夹
File dirs = new File("D:\\java0913\\day20\\kk\\hh\\yy\\fdfdfd");
sop("mkdirs:"+dirs.mkdirs());
}
public static void method_1() throws IOException
{
File f = new File("file.txt");
sop("create:"+f.createNewFile());
}
//创建File对象
public static void conMethod()
{
//将a.txt封装成File对象。可以将已有的和未出现的文件或者文件夹封装成对象。
File f1 = new File("a.txt");
//目录和文件分开
File f2 = new File("c:\\abc","b.txt");
File d = new File("c:\\abc");
File f3 = new File(d,"c.txt");
sop("f1:"+f1);
sop("f2:"+f2);
sop("f3:"+f3);
File f4 = new File("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");
sop("f4:"+f4);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
5、列出文件及文件过滤
static File[ ] listRoots();//列出可用的文件系统根目录，即系统盘符
String[ ] list(); //列出当前目录下所有文件，包括隐藏。调用list方法的file对象必须是封装了一个目录。该目录还必须存在。
String[ ]list(FilenameFilter filter);//返回一个字符串数组，获取目录中满足指定过滤器的文件或目录。
FilenameFilter：文件名过滤器，是一个接口，其中包含一个方法，accept(Filedir,String name)，返回的是boolean型，对不符合条件的文件过滤掉。
File[ ] listFiles();//返回一个抽象路径名数组，获取当前文件夹下的所有文件和文件夹
File[ ] ListFiles(FilenameFilterfilter);//返回抽象路径名数组，获取目录中满足指定过滤器的文件或目录。 代码示例：
import java.io.*;
class FileDemo2
{
public static void main(String[] args)
{
//listRootsDemo();
//listDemo();
File dir = new File("c:\\");
File[] files = dir.listFiles();//listFiles返回的是所指定目录下的文件及文件夹的对象所包装成的数组。
for (File f : files )
{
System.out.println(f.getName()+"::"+f.length());
}
}
public static void listDemo2()
{
File dir = new File("d:\\java0913\\day18");
String[] arr = dir.list(new FilenameFilter()//list返回的是所指定目录下的文件及文件夹的名称所包装成的数组。
{
public boolean accept(File dir,String name)
{
//System.out.println("dir:"+dir+"....name::"+name);
return name.endsWith(".java");
}
});
for (String name : arr )
{
System.out.println(name);
}
}
public static void listDemo()
{
File f = new File("c:\\abc.txt");
String[] names = f.list();//调用list方法的file对象必须是封装了一个目录，该目录还必须存在。
for (String name : names )
{
System.out.println(name);
}
System.out.println(names.length);//此时因为abc.txt文件夹存在，所以返回来一个长度为0的数组。
}
public static void listRootsDemo()
{
File[] files = File.listRoots();
for (File f :files)
{
System.out.println(f);
}
}
}
十、递归 需求：列出指定目录下文件或者文件夹，包含子目录中的内容也就是列出指定目录下所有内容。 分析：因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可，在列出过程中出现的还是目录的话，还可以再次调用本功能。也就是函数自身调用自身，这种编程方式称为：递归！ 注意：
1、限定条件，是来结束循环调用，否则是死循环。
2、要注意递归的次数，尽量避免内存溢出。因为每次调用自身的时候都会先执行下一次调用自己的方法，所以会不断在栈内存中开辟新空间，次数过多，会导致内存溢出。
代码示例：
import java.io.*;运行结果：
class FileDemo3
{
public static void main(String[] args)
{
//关联指定路径
File dir = new File("d:\\java0913");
showDir(dir,0);//列出指定路径下的所有.java文件
//toBin(6);
//long n = getSum(1000);//内存溢出
//System.out.println("n="+n);
}
//带层次的列表
public static String getLevel(int level)
{
StringBuilder sb = new StringBuilder();
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);
else//否则列出文件
System.out.println(getLevel(level)+files[x]);
}
}
//用递归求和
public static long getSum(long n)
{
if(n==1)
return 1;
return n+getSum(n-1);
}
//用递归转二进制
public static void toBin(int num)
{
if (num>0)
{
toBin(num/2);
System.out.println(num%2);
}
}
}
练习：删除一个带内容的目录
/*练习：将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。建立一个java文件列表文件。
删除一个带内容的目录
删除原理：
在windows中，删除目录是从里面往外删。
既然是从里往外删除，那就需要用到递归。
*/
import java.io.*;
class RemoveDir
{
public static void main(String[] args)
{
File dir = new File("testDir");//指定目录
removeDir(dir);
}
//删除目录封装成方法
public static void removeDir(File dir)
{
//列出目录下的所有文件和文件夹
File[] files = dir.listFiles();
for (int x= 0; x<files.length;x++ )
{
if(files[x].isDirectory())
removeDir(files[x]);//如果还是目录，继续调用本函数
else
System.out.println(files[x].toString()+"::"+files[x].delete());//删除文件
}
System.out.println(dir+"::dir::"+dir.delete());//删除目录
}
}
/*运行结果：
练习：
将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。
建立一个java文件列表文件。
思路：
1.对指定的目录进行递归。
2、获取递归过程中所有的java文件的路径
3、将这些路径存储到集合中。
4、将集合中的数据写入到一个文件中。
*/
import java.io.*;
import java.util.*;
class JavaFileList
{
public static void main(String[] args)
{
File dir = new File("d:\\java0913"); //指定目录
List<File> list = new ArrayList<File>();//定义一个List集合，用于存储.java文件的File对象
fileToList(dir,list);//调用获取文件路径方法
System.out.println(list.size());//打印集合大小
File file = new File(dir,"javaListFile.txt");//指定存入目的文件
writeToFile(list,file.toString());//调用写入文件方法
}
//获取指定文件夹内的所有java文件的绝对路径，并存入集合中的方法
public static void fileToList(File dir,List<File> list)
{
File[] files = dir.listFiles();//列出dir路径下的所以文件和目录
for (File file : files )
{
if (file.isDirectory())
fileToList(file,list);
else //将是.java文件的绝对路径存入
if(file.getName().endsWith(".java"))
list.add(file);
}
}
//将集合中元素写入到一个文本文件中的方法
public static void writeToFile(List<File> list,String javaList)
{
BufferedWriter bufw = null;
try
{
//使用字符流缓冲区对象关联目的文件
bufw = new BufferedWriter(new FileWriter(javaList));
for (File f : list)
{
String path = f.getAbsolutePath();//获取绝对路径
bufw.write(path);//写入路径
bufw.newLine();//换行
bufw.flush();//刷新
}
}
catch (IOException e)
{
throw new RuntimeException("创建列表文件失败");
}
finally
{
try
{
if(bufw!=null)
bufw.close();//关资源
}
catch (IOException e)
{
throw new RuntimeException("关闭资源失败");
}
}
}
}
十一、Properties类
Properties 是hashtable的子类。也就是说他具备map集合的特点，而且他里面存储的键值对都是字符串。它是集合中和IO技术相结合的集合容器。
特点：可以用于键值对形式的配置文件。
那么在加载数据时，需要数据有固定格式：键=值。
示例代码：
import java.io.*;练习：用于记录应用程序运行次数。如果使用次数已到，那么给出注册提示。
import java.util.*;
class PropertiesDemo
{
public static void main(String[] args) throws IOException
{
//setAndGet();
//method_1();
loadDemo();
}
public static void loadDemo() throws IOException
{
Properties prop = new Properties();
FileInputStream fis = new FileInputStream("info.txt");
//将流中的数据加载进集合。用load方法
prop.load(fis);
prop.setProperty("wangwu","85");
FileOutputStream fos = new FileOutputStream("info.txt");
prop.store(fos,"haha");
//System.out.println(prop);
prop.list(System.out);
fos.close();
fis.close();
}
//演示：如何将流中的数据存储到集合中。
//想要将info.txt中键值数据存到集合中进行操作。
/*
思路：
1、用一个流和info.txt文件关联。
2、读取一行数据，将该行数据用"="切割
3、等号左边作为键，右边作为值，存入到Properties集合中即可。
*/
public static void method_1() throws IOException
{
//使用字符读取缓冲流关联文件
BufferedReader bufw = new BufferedReader(new FileReader("info.txt"));
String line = null;
//定义Properties集合
Properties prop = new Properties();
while((line=bufw.readLine())!=null)
{
String[] arr = line.split("=");//切割
//System.out.println(arr[0]+"......."+arr[1]);
prop.setProperty(arr[0],arr[1]);//将等号左边存为键，将等号右边存为值
}
bufw.close();//关流
System.out.println(prop);
}
//设置和获取元素。
public static void setAndGet()
{
Properties prop = new Properties();
prop.setProperty("zhangsan","30");
prop.setProperty("lisi","39");
System.out.println(prop);
String value = prop.getProperty("lisi");
System.out.println(value);
prop.setProperty("lisi",89+"");
Set<String> names = prop.stringPropertyNames();//返回此属性列表中的键集，其中该键及其对应值是字符串.
for (String s : names )
{
System.out.println(s+"::"+prop.getProperty(s));
}
}
}
/*
练习：用于记录应用程序运行次数。如果使用次数已到，那么给出注册提示。
很容易想到的是：计数器
可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行了自增，
可是随着该应用程序的退出，该计数器也在内存中消失了，
下一次再启动该程序，又重新开始从0计数。这不是我们想要的。
程序即使结束，该计数器的值也存在，下次程序启动再会先加载该计数器的值并加1后再重新存储起来。
所以要建立一个配置文件，用于记录该软件的使用次数。
该配置文件使用键值对的形式。这样便于阅读数据，并操作数据。
键值对数据是map集合。数据是以文件形式存储，使用io技术。
那么map+io-->properties
配置文件可以实现应用程序数据的共享。
*/
import java.io.*;
import java.util.*;
class RunCount
{
public static void main(String[] args) throws IOException
{
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)//如果值不为null，则将其赋值给count
{
count = Integer.parseInt(value);
if(count>=5)
{
//如果程序被使用了超过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.
示例：
import java.io.*;
class PrintStreamDemo
{
public static void main(String[] args) throws IOException
{
//缓冲区关联键盘录入
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
//打印流关联文件，自动刷新，不用flush
PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);
String line = null;
while ((line=bufr.readLine())!=null)
{
if("over".equals(line))//结束字符
break;
//out.write(line.toUpperCase());
out.println(line.toUpperCase());//转成大写并输出
//out.flush(); 如果上方PrintWriter方法里的，第二个参数是autoFlush 为true,则自动刷新。
}
out.close();//关流
bufr.close();
}
}
运行结果：
十三、序列流
SequenceInputStream 用于对多个流进行合并。
常见合并多个流文件步骤：
1、创建集合，并将流对象添加进集合
2、创建Enumeration对象，将集合元素加入
3、创建SequenceInputStream对象，合并流对象
4、创建写入流对象，FileOutputStream关联写入文件
5、利用SequenceInputStream对象和FileOutputStream对象读数据进行反复读写操作。
示例：
/*运行结果：
需求：将三个文本文件中的数据合并到一个文本文件中
思路：1、创建Vector集合，将三个文本文件字节流添加到集合中
2、创建Enumeration对象，创建SequnceInputStream对象关联Enumeration
3、输出流关联新文本文件
4、反复读写操作
*/
import java.io.*;
import java.util.*;
class SequenceDemo
{
public static void main(String[] args) throws IOException
{
//创建vector
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枚举对象
Enumeration<FileInputStream> en = v.elements();
//合并流
SequenceInputStream sis = new SequenceInputStream(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();
}
}
练习：切割文件 和 合并文件
/*
练习：切割文件 和 合并文件
需求：将一个图片文件切割成几部分，然后根据这个及部分合并成一张图片
*/
import java.io.*;
import java.util.*;
class SplitFile
{
public static void main(String[] args) throws IOException
{
//SplitFile();//切割方法
merge();//合并方法
}
//切割方法
public static void SplitFile() throws IOException
{
//关联要切割的文件
FileInputStream fis = new FileInputStream("1.bmp");
FileOutputStream fos = null;
//定义1M大小存储容器
byte[] buf = new byte[1024*1024];
int len = 0;
int count = 1;//定义1个计数器，作为部分编号
while ((len = fis.read(buf))!=-1)
{
//每满1M就写入一个新文件中
fos = new FileOutputStream("splitfiles\\"+(count++)+".part");
fos.write(buf,0,len);
fos.close();//每写完一个部分文件要关流
}
fis.close();
}
//合并方法
public static void merge() throws IOException
{
//定义一个集合存储这些部分文件并关联路径数据
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for (int x= 1; x<5 ; x++ )
{
al.add(new FileInputStream("splitfiles\\"+x+".part"));
}
final Iterator<FileInputStream> it = al.iterator();
//由于Enumeration是Vector的迭代方法，这里创建一个Enumeration类型的匿名内部类
Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()
{
public boolean hasMoreElements()
{
return it.hasNext();
}
public FileInputStream nextElement()
{
return it.next();
}
};
//关联Enumeration对象
SequenceInputStream sis = new SequenceInputStream(en);
//将合并的文件数据写入指定文件中
FileOutputStream fos = new FileOutputStream("splitfiles\\tupian.bmp");
byte[] buf = new byte[1024];
int len= 0;
while ((len= sis.read(buf))!=-1)
{
fos.write(buf,0,len);//边读边写
}
fos.close();//关流
sis.close();
}
}