16 SequenceInputStream、PrintStream、Properties、递归、编码
-
- SequenceInputStream
- 合并两个文件
- 合并多个文件
- ObjectOutputStream ObjectInputStream
- Properties文件
- Properties案例
- PrintStream
- 编码与解码
- InputStreamReaderOutputStreamWriter
- 递归案例
- SequenceInputStream
SequenceInputStream
SequenceInputStream(序列流)
案例：合并文件内容
合并两个文件
采用传统方法
public static void merge1() throws IOException{
//找到目标文件
File inFile1 = new File("F:\\a.txt");
File inFile2 = new File("F:\\b.txt");
File outFile = new File("F:\\c.txt");
//建立数据的输入输出通道
FileOutputStream fileOutputStream = new FileOutputStream(outFile);
FileInputStream fileInputStream1 = new FileInputStream(inFile1);
FileInputStream fileInputStream2 = new FileInputStream(inFile2);
//把输入流存储到集合中，然后再从集合中读取
ArrayList<FileInputStream> list = new ArrayList<FileInputStream>();
list.add(fileInputStream1);
list.add(fileInputStream2);
//准备一个缓冲数组
byte[] buf = new byte[1024];
int length = 0 ;
for(int i = 0 ; i< list.size() ; i++){
FileInputStream fileInputStream = list.get(i);
while((length = fileInputStream.read(buf))!=-1){
fileOutputStream.write(buf,0,length);
}
//关闭资源
fileInputStream.close();
}
fileOutputStream.close();
}使用SequenceInputStream合并文件。自身不具备读写能力，所以关闭方法close关闭的是传递的参数
// 使用SequenceInputStream合并文件。
public static void merge2() throws IOException{
//找到目标文件
File inFile1 = new File("F:\\a.txt");
File inFile2 = new File("F:\\b.txt");
File outFile = new File("F:\\c.txt");
//建立数据的输入输出通道
FileOutputStream fileOutputStream = new FileOutputStream(outFile);
FileInputStream fileInputStream1 = new FileInputStream(inFile1);
FileInputStream fileInputStream2 = new FileInputStream(inFile2);
//建立序列流对象
SequenceInputStream inputStream = new SequenceInputStream(fileInputStream1,fileInputStream2);
byte[] buf = new byte[1024];
int length = 0 ;
while((length = inputStream.read(buf))!=-1){
fileOutputStream.write(buf,0,length);
}
//关闭资源
inputStream.close();
fileOutputStream.close();
}合并多个文件
使用Enumeration集合
//把三个文件合并成一个文件
public static void merge3() throws IOException{
//找到目标文件
File file1 = new File("F:\\a.txt");
File file2 = new File("F:\\b.txt");
File file3 = new File("F:\\c.txt");
File file4 = new File("F:\\d.txt");
//建立对应 的输入输出流对象
FileOutputStream fileOutputStream = new FileOutputStream(file4);
FileInputStream fileInputStream1 = new FileInputStream(file1);
FileInputStream fileInputStream2 = new FileInputStream(file2);
FileInputStream fileInputStream3 = new FileInputStream(file3);
//创建序列流对象
Vector<FileInputStream> vector = new Vector<FileInputStream>();
vector.add(fileInputStream1);
vector.add(fileInputStream2);
vector.add(fileInputStream3);
Enumeration<FileInputStream> e = vector.elements();
SequenceInputStream sequenceInputStream = new SequenceInputStream(e);
//读取文件数据
byte[] buf = new byte[1024];
int length = 0;
while((length = sequenceInputStream.read(buf))!=-1){
fileOutputStream.write(buf,0,length);
}
//关闭资源
sequenceInputStream.close();
fileOutputStream.close();
}ObjectOutputStream &&ObjectInputStream
对象的输入输出流 : 对象的输入输出流 主要的作用是用于写对象的信息与读取对象的信息。 对象信息一旦写到文件上那么对象的信息就可以做到持久化了
对象的输出流： ObjectOutputStream
对象的输入流: ObjectInputStream对象输入输出流要注意的细节：
- 如果对象需要被写出到文件上，那么对象所属的类必须要实现Serializable接口。 Serializable接口没有任何的方法，是一个标识接口而已。
- 对象的反序列化创建对象的时候并不会调用到构造方法的
- serialVersionUID 是用于记录class文件的版本信息的，serialVersionUID这个数字是通过一个类的类名、成员、包名、工程名算出的一个数字。
- 使用ObjectInputStream反序列化的时候，ObjeectInputStream会先读取文件中的serialVersionUID，然后与本地的class文件的serialVersionUID进行对比，如果这两个id不一致，那么反序列化就失败了。
- 如果序列化与反序列化的时候可能会修改类的成员，那么最好一开始就给这个类指定一个serialVersionUID，如果一类已经指定的serialVersionUID（private static final long serialVersionUID = 1L;），然后在序列化与反序列化的时候，jvm都不会再自己算这个 class的serialVersionUID了。
- 如果一个对象某个数据不想被序列化到硬盘上，可以使用关键字transient修饰。
- 如果一个类维护了另外一个类的引用，那么另外一个类也需要实现Serializable接口。
//定义方法把对象的信息写到硬盘上------>对象的序列化。 public static void writeObj() throws IOException{ //把user对象的信息持久化存储。 Address address = new Address("中国","广州"); User user = new User("admin","123",15,address); //找到目标文件 File file = new File("F:\\obj.txt"); //建立数据输出流对象 FileOutputStream fileOutputStream = new FileOutputStream(file); //建立对象的输出流对象 ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream); //把对象写出 objectOutputStream.writeObject(user); //关闭资源 objectOutputStream.close(); }反序列化
//把文件中的对象信息读取出来-------->对象的反序列化 public static void readObj() throws IOException, ClassNotFoundException{ //找到目标文件 File file = new File("F:\\obj.txt"); //建立数据的输入通道 FileInputStream fileInputStream = new FileInputStream(file); //建立对象的输入流对象 ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream); //读取对象信息 User user = (User) objectInputStream.readObject(); //创建对象肯定要依赖对象所属的class文件。 System.out.println("对象的信息："+ user); }
Properties文件
Properties（配置文件类）: 主要用于生产配置文件与读取配置文件的信息。
Properties要注意的细节：- 如果配置文件的信息一旦使用了中文，那么在使用store方法生成配置文件的时候只能使用字符流解决，如果使用字节流生成配置文件的话，默认使用的是iso8859-1码表进行编码存储，这时候会出现乱码。所以输出流使用FileWriter（字符流）。
- 如果Properties中的内容发生了变化，一定要重新使用Properties生成配置文件，否则配置文件信息不会发生变化。
properties使用以及产生配置文件
注意：properties只能存储字符串//保存配置文件文件的信息。 public static void creatProperties() throws IOException{ //创建Properties Properties properties = new Properties(); properties.setProperty("狗娃", "123"); properties.setProperty("狗剩","234"); properties.setProperty("铁蛋","345"); // 遍历Properties /*Set<Entry<Object, Object>> entrys = properties.entrySet(); for(Entry<Object, Object> entry :entrys){ System.out.println("键："+ entry.getKey() +" 值："+ entry.getValue()); }*/ //使用Properties生产配置文件。 //properties.store(new FileOutputStream("F:\\persons.properties"), "haha"); //第一个参数是一个输出流对象，第二参数是使用一个字符串描述这个配置文件的信息。 properties.store(new FileWriter("F:\\persons.properties"), "hehe");读取配置文件以及修改：
//读取配置文件爱你的信息 public static void readProperties() throws IOException{ //创建Properties对象 Properties properties = new Properties(); //加载配置文件信息到Properties中 properties.load(new FileReader("F:\\persons.properties")); //遍历 Set<Entry<Object, Object>> entrys = properties.entrySet(); for(Entry<Object, Object> entry :entrys){ System.out.println("键："+ entry.getKey() +" 值："+ entry.getValue()); } //修改狗娃的密码 //把修改后的Properties再生成一个配置文件 properties.setProperty("狗娃", "007"); properties.store(new FileWriter("F:\\persons.properties"), "hehe"); }
Properties案例
注意此案例中的FileOutputStream如果要单独形成一个变量一定要在load之后，因为创建一个新的流对象，会清空里面的内容（不能加true，因为true是续写）。
public static void main(String[] args) throws IOException {
File file = new File("F:\\count.properties");
if(!file.exists()){
//如果配置文件不存在，则创建该配置文件
file.createNewFile();
}
//创建Properties对象。
Properties properties = new Properties();
//把配置文件的信息加载到properties中
properties.load(new FileInputStream(file));
//FileOutputStream fileOutputStream = new FileOutputStream(file);
int count = 0; //定义该变量是用于保存软件的运行次数的。
//读取配置文件的运行次数
String value = properties.getProperty("count");
if(value!=null){
count = Integer.parseInt(value);
}
//判断使用的次数是否已经达到了三次，
if(count==3){
System.out.println("你已经超出了试用次数，请购买正版软件！！");
System.exit(0);
}
count++;
System.out.println("你已经使用了本软件第"+count+"次");
properties.setProperty("count",count+"");
//使用Properties生成一个配置文件
properties.store(new FileOutputStream(file),"runtime");
}PrintStream
打印流（printStream） 打印流可以打印任意类型的数据，而且打印数据之前都会先把数据转换成字符串再进行打印。(如果采用FileOutpurtStream要采用getBytes)
其实System.out里面也保存了一个PrintSteam的对象，可以通过setOut方法重置标准的输出流，如果这个输出流绑定了文件，那么输出会保存在文件中，而不是显示在控制台。
//打印流可以打印任何类型的数据，而且打印数据之前都会先把数据转换成字符串再进行打印。 File file = new File("F:\\a.txt"); //创建一个打印流 PrintStream printStream = new PrintStream(file); printStream.println(97); printStream.println(3.14); printStream.println('a'); printStream.println(true); Animal a = new Animal("老鼠", "黑色"); printStream.println(a);//调用toString的方法 //默认标准的输出流就是向控制台输出的， //System.setOut(printStream); //重新设置了标准的输出流对象 //System.out.println("哈哈，猜猜我在哪里！！");PrintStream使用：收集异常信息
这里用FileOutputStream包装是为了获得追加功能File logFile = new File("F:\\2015年1月8日.log"); PrintStream logPrintStream = new PrintStream( new FileOutputStream(logFile,true) ); try{ int c = 4/0; System.out.println("c="+c); int[] arr = null; System.out.println(arr.length); }catch(Exception e){ e.printStackTrace(logPrintStream);
编码与解码
编码与解码
编码： 把看得懂的字符变成看不懂码值这个过程我们称作为编码。
解码： 把码值查找对应的字符，我们把这个过程称作为解码
注意： 以后编码与解码一般我们都使用统一的码表。否则非常容易出乱码。
getBytes采用平台默认的gbk编码表，String类也是String str = "中国"; byte[] buf = str.getBytes("utf-8");// 平台默认的编码表是gbk编码表。 编码 System.out.println("数组的元素："+Arrays.toString(buf)); // str = new String(buf,"utf-8"); //默认使用了gbk码表去解码。可以指定码表 System.out.println("解码后的字符串："+ str);// //Unicode知识一个规范 String str = "a中国"; // -2，-1，0, 97, 78, 45, 86, -3，前面-2 -1代表Unicode编码 byte[] buf = str.getBytes("unicode"); //编码与解码的时候指定的码表是unicode实际上就是用了utf-16. System.out.println("数组的内容："+ Arrays.toString(buf));解码错误后的还原，能还原的前提是，对于每个编码都有相应的字符对应
String str = "大家好"; byte[] buf = str.getBytes(); //使用gbk进行编码 System.out.println("字节数组："+ Arrays.toString(buf)); // -76, -13, -68, -46, -70, -61 str = new String(buf,"iso8859-1"); // 解码不一致后的还原 byte[] buf2 = str.getBytes("iso8859-1"); str = new String(buf2,"gbk"); System.out.println(str);
InputStreamReader&&OutputStreamWriter
转换流:
输入字节流的转换流：InputStreamReader 是字节流通向字符流的桥
InputStreamReader输出字节流的转换流：
OutputStreamWriter 可以把输出字节流转换成输出字符流 。转换流的作用：
- 如果目前所获取到的是一个字节流需要转换字符流使用，这时候就可以使用转换流。 字节流—-> 字符流
- 使用转换流可以指定编码表进行读写文件。
示例
InputStream in = System.in; //获取了标准的输入流。 //System.out.println("读到 的字符："+ (char)in.read()); //read()一次只能读取一个字节。 //需要把字节流转换成字符流。 InputStreamReader inputStreamReader = new InputStreamReader(in); //使用字符流的缓冲类 BufferedReader bufferedReader = new BufferedReader(inputStreamReader); String line = null; while((line = bufferedReader.readLine())!=null){ System.out.println("内容："+ line); }//使用输出字节流的转换流指定码表写出数据 public static void writeTest2() throws IOException{ File file = new File("F:\\a.txt"); //建立数据的输出通道 FileOutputStream fileOutputStream = new FileOutputStream(file); //把输出字节流转换成字符流并且指定编码表。 OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "utf-8"); outputStreamWriter.write("新中国好啊"); //关闭资源 outputStreamWriter.close(); } //使用输入字节流的转换流指定码表进行读取文件数据 public static void readTest2() throws IOException{ File file = new File("F:\\a.txt"); FileInputStream fileInputStream = new FileInputStream(file); //创建字节流的转换流并且指定码表进行读取 InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"utf-8"); char[] buf = new char[1024]; int length = 0; while((length = inputStreamReader.read(buf))!=-1){ System.out.println(new String(buf,0,length)); } }
递归案例
//删除了一个非空的目录
public static void deleteDir(File dir){
File[] files = dir.listFiles(); //列出了所有的子文件
for(File file : files){
if(file.isFile()){
file.delete();
}else if(file.isDirectory()){
deleteDir(file);
}
}
dir.delete();
}
public static void listFiles3(File dir,String space){ //space 存储的是空格
File[] files = dir.listFiles(); //列出所有 的子文件
for(File file : files){
if(file.isFile()){
System.out.println(space+file.getName());
}else if(file.isDirectory()){
System.out.println(space+file.getName());
listFiles3(file,"| "+space);
}
}
}
//列出一个文件夹的子孙文件与目录。并显示目录结构
public static void listFiles2(File dir,String space){ //space 存储的是空格
File[] files = dir.listFiles(); //列出所有 的子文件
for(File file : files){
if(file.isFile()){
System.out.println(space+file.getName());
}else if(file.isDirectory()){
System.out.println(space+file.getName());
listFiles2(file," "+space);
}
}
}
//列出一个文件夹的子孙文件与目录。
public static void listFiles1(File dir){
File[] files = dir.listFiles(); //列出所有 的子文件
for(File file : files){
if(file.isFile()){
System.out.println("文件名："+file.getName());
}else if(file.isDirectory()){
System.out.println("文件夹："+file.getName());
listFiles1(file);
}
}
}