Java学习之IO流(三)

###22.01_IO流(序列流)(了解)

• 1.什么是序列流
  • 序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推.
• 2.使用方式
  • 整合两个: SequenceInputStream(InputStream, InputStream)

  •   FileInputStream fis1 = new FileInputStream("a.txt");			//创建输入流对象,关联a.txt
      FileInputStream fis2 = new FileInputStream("b.txt");			//创建输入流对象,关联b.txt
      SequenceInputStream sis = new SequenceInputStream(fis1, fis2);	//将两个流整合成一个流
      FileOutputStream fos = new FileOutputStream("c.txt");			//创建输出流对象,关联c.txt
      
      int b;
      while((b = sis.read()) != -1) {									//用整合后的读
      	fos.write(b);												//写到指定文件上
      }
      
      sis.close();
      fos.close(); 
    

###22.02_IO流(序列流整合多个)(了解)

• 整合多个: SequenceInputStream(Enumeration)

•   FileInputStream fis1 = new FileInputStream("a.txt");	//创建输入流对象,关联a.txt
    FileInputStream fis2 = new FileInputStream("b.txt");	//创建输入流对象,关联b.txt
    FileInputStream fis3 = new FileInputStream("c.txt");	//创建输入流对象,关联c.txt
    Vector<InputStream> v = new Vector<>();					//创建vector集合对象
    v.add(fis1);											//将流对象添加
    v.add(fis2);
    v.add(fis3);
    Enumeration<InputStream> en = v.elements();				//获取枚举引用
    SequenceInputStream sis = new SequenceInputStream(en);	//传递给SequenceInputStream构造
    FileOutputStream fos = new FileOutputStream("d.txt");
    int b;
    while((b = sis.read()) != -1) {
    	fos.write(b);
    }
  
    sis.close();
    fos.close();
  

###22.03_IO流(对象操作流ObjecOutputStream)(了解)

• 1.什么是对象操作流
  • 该流可以将一个对象写出, 或者读取一个对象到程序中. 也就是执行了序列化和反序列化的操作.
• 2.使用方式

  • 写出: new ObjectOutputStream(OutputStream), writeObject()

      public class Demo3_ObjectOutputStream {
    
      	/**
      	 * @param args
      	 * @throws IOException 
      	 * 将对象写出,序列化
      	 */
      	public static void main(String[] args) throws IOException {
      		Person p1 = new Person("张三", 23);
      		Person p2 = new Person("李四", 24);
      //		FileOutputStream fos = new FileOutputStream("e.txt");
      //		fos.write(p1);
      //		FileWriter fw = new FileWriter("e.txt");
      //		fw.write(p1);
      		//无论是字节输出流,还是字符输出流都不能直接写出对象
      		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));//创建对象输出流
      		oos.writeObject(p1);
      		oos.writeObject(p2);
      		oos.close();
      	}
      
      }
    

###22.04_IO流(对象操作流ObjectInputStream)(了解)

• 读取: new ObjectInputStream(InputStream), readObject()

  •   public class Demo3_ObjectInputStream {
    
      	/**
      	 * @param args
      	 * @throws IOException 
      	 * @throws ClassNotFoundException 
      	 * @throws FileNotFoundException 
      	 * 读取对象,反序列化
      	 */
      	public static void main(String[] args) throws IOException, ClassNotFoundException {
      		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e.txt"));
      		Person p1 = (Person) ois.readObject();
      		Person p2 = (Person) ois.readObject();
      		System.out.println(p1);
      		System.out.println(p2);
      		ois.close();
      	}
      
      }
    

###22.05_IO流(对象操作流优化)(了解)
*　将对象存储在集合中写出

Person p1 = new Person("张三", 23);
Person p2 = new Person("李四", 24);
Person p3 = new Person("马哥", 18);
Person p4 = new Person("辉哥", 20);

ArrayList<Person> list = new ArrayList<>();
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("f.txt"));
oos.writeObject(list);									//写出集合对象

oos.close();

• 读取到的是一个集合对象

    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("f.txt"));
    	ArrayList<Person> list = (ArrayList<Person>)ois.readObject();	//泛型在运行期会被擦除,索引运行期相当于没有泛型
    //想去掉黄色可以加注解			
    @SuppressWarnings("unchecked")
    	for (Person person : list) {
    		System.out.println(person);
    	}
    
    ois.close();
  

###22.6_IO流(Properties的概述和作为Map集合的使用)(了解)
Properties 配置文件
XML 配置文件

• A:Properties的概述
  • Properties 类表示了一个持久的属性集。
  • Properties 可保存在流中或从流中加载。
  • 属性列表中每个键及其对应值都是一个字符串。
• B:案例演示
  • Properties作为Map集合的使用

###22.16_IO流(Properties的特殊功能使用)(了解)

• A:Properties的特殊功能

  • public Object setProperty(String key,String value)
  • public String getProperty(String key)
  • public Enumeration stringPropertyNames()

  Enumeration en = (Enumeration) prop.propertyNames();
  while(en.hasMoreElements()) {
  String key = en.nextElement(); //获取Properties中的每一个键
  String value = prop.getProperty(key); //根据键获取值
  System.out.println(key + “=”+ value);
  }

  扫描二维码关注公众号，回复： 9754406 查看本文章

• B:案例演示

  • Properties的特殊功能

###22.7_IO流(Properties的load()和store()功能)(了解)

• A:Properties的load()和store()功能
• B:案例演示
  • Properties的load()和store()功能

需求:1,从键盘接收一个文件夹路径,统计该文件夹大小
* 从键盘接收一个文件夹路径
* 1,创建键盘录入对象
* 2,定义一个无限循环
* 3,将键盘录入的结果存储并封装成File对象
* 4,对File对象判断
* 5,将文件夹路径对象返回
*
* 统计该文件夹大小
* 1,定义一个求和变量
* 2,获取该文件夹下所有的文件和文件夹listFiles();
* 3,遍历数组
* 4,判断是文件就计算大小并累加
* 5,判断是文件夹,递归调用

/*
 * 从键盘接收一个文件夹路径
 * 1,返回值类型File
 * 2,参数列表无
 */
public static File getDir() {
	//1,创建键盘录入对象
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入一个文件夹路径:");
	//2,定义一个无限循环
	while(true) {
		//3,将键盘录入的结果存储并封装成File对象
		String line = sc.nextLine();
		File dir = new File(line);
		//4,对File对象判断
		if(!dir.exists()) {
			System.out.println("您录入的文件夹路径不存在,请输入一个文件夹路径:");
		}else if(dir.isFile()) {
			System.out.println("您录入的是文件路径,请输入一个文件夹路径:");
		}else {
			//5,将文件夹路径对象返回
			return dir;
		}
	}
	
}

/*
 * 统计该文件夹大小 
 * 1,返回值类型long
 * 2,参数列表File dir
 */
public static long getFileLength(File dir) {	//dir = F:\day06\day07
	//1,定义一个求和变量
	long len = 0;
	//2,获取该文件夹下所有的文件和文件夹listFiles();
	File[] subFiles = dir.listFiles();			//day07 Demo1_Student.class Demo1_Student.java
	//3,遍历数组
	for (File subFile : subFiles) {
		//4,判断是文件就计算大小并累加
		if(subFile.isFile()) {
			len = len + subFile.length();
		//5,判断是文件夹,递归调用
		}else {
			len = len + getFileLength(subFile);
		}
	}
	return len;
}

需求:2,从键盘接收一个文件夹路径,删除该文件夹
* 删除该文件夹
* 分析:
* 1,获取该文件夹下的所有的文件和文件夹
* 2,遍历数组
* 3,判断是文件直接删除
* 4,如果是文件夹,递归调用
* 5,循环结束后,把空文件夹删掉

 /*
 * 删除该文件夹
 * 1,返回值类型 void
 * 2,参数列表File dir
 */
public static void deleteFile(File dir) {	
	//1,获取该文件夹下的所有的文件和文件夹
	File[] subFiles = dir.listFiles();		
	//2,遍历数组
	for (File subFile : subFiles) {
		//3,判断是文件直接删除
		if(subFile.isFile()) {
			subFile.delete();
		//4,如果是文件夹,递归调用
		}else {
			deleteFile(subFile);			
		}
	}
	//5,循环结束后,把空文件夹删掉
	dir.delete();
}

需求:3,从键盘接收两个文件夹路径,把其中一个文件夹中(包含内容)拷贝到另一个文件夹中
* 1,在目标文件夹中创建原文件夹
* 2,获取原文件夹中所有的文件和文件夹,存储在File数组中
* 3,遍历数组
* 4,如果是文件就用io流读写
* 5,如果是文件夹就递归调用

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

public class Digui {
public static void main(String args[]) throws Exception {
File src = getDir();
File dest = getDir();
if(src.equals(dest)) {
System.out.println(“目标文件夹是源文件夹的子文件夹”);
}else {
copy(src,dest);
}

}

public static File getDir() {
	//1.创建键盘录入对象
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入一个文件夹路径:");
	//2.定义一个无限循环
	while(true) {
		//3.将键盘录入的结果存储并封装成File对象
		String line = sc.nextLine();
		File dir = new File(line);
		//4.对File对象判断
		if(!dir.exists()) {
			System.out.println("您录入的文件夹路径不存在,请输入一个文件夹路径:");
		}else if(dir.isFile()) {
			System.out.println("您录入的是文件路径,请输入一个文件夹路径:");
		}else {
			//5.将文件夹路径对象返回
			return dir;
		}
	}
}
public static void copy(File src, File dest) throws IOException {
	//1.在目标文件夹中创建原文件夹
	File newDir = new File(dest, src.getName());
	newDir.mkdir();
	//2.获取原文件夹中所有的文件和文件夹,存储在File数组中
	File[] subFiles = src.listFiles();
	//3.遍历数组
	for (File subFile : subFiles) {
		//4.如果是文件就用io流读写
		if(subFile.isFile()) {
			BufferedInputStream bis = new BufferedInputStream(
							new FileInputStream(subFile));
			BufferedOutputStream bos = new BufferedOutputStream(
							new FileOutputStream(new File(newDir,subFile.getName())));
			
			int b;
			while((b = bis.read()) != -1) {
				bos.write(b);
			}
			
			bis.close();
			bos.close();
		//5.如果是文件夹就递归调用
		}else {
			copy(subFile,newDir);
		}
	}
}

}

/**
 * @param args
 * 约瑟夫环
 * * 幸运数字
 */
public static void main(String[] args) {
	System.out.println(getLucklyNum(8));
}

/*
 * 获取幸运数字
 * 1,返回值类型int
 * 2,参数列表int num
 */
public static int getLucklyNum(int num) {
	ArrayList<Integer> list = new ArrayList<>();		
	//创建集合存储1到num的对象
	for(int i = 1; i <= num; i++) {
		list.add(i);									
		//将1到num存储在集合中
	}
	
	int count = 1;										
	//用来数数的,只要是3的倍数就杀人
	for(int i = 0; list.size() != 1; i++) {				
		//只要集合中人数超过1,就要不断的杀
		if(i == list.size()) {							
			//如果i增长到集合最大的索引+1时
			i = 0;										
			//重新归零
		}
		
		if(count % 3 == 0) {							
			//如果是3的倍数
			list.remove(i--);								
			//就杀人
		}
		count++;
	}
	
	return list.get(0);
}