流(Stream)、文件(File)和IO

+--------------------+       +------+   +------+   +---+   +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+       +------+   +------+   +---+   +-------+

List<Integer> transactionsIds = 
widgets.stream()
             .filter(b -> b.getColor() == RED)
             .sorted((x,y) -> x.getWeight() - y.getWeight())
             .mapToInt(Widget::getWeight)
             .sum();

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

public class Java8Tester {
   public static void main(String args[]){
      System.out.println("使用 Java 7: ");
        
      // 计算空字符串
      List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
      System.out.println("列表: " +strings);
      long count = getCountEmptyStringUsingJava7(strings);
        
      System.out.println("空字符数量为: " + count);
      count = getCountLength3UsingJava7(strings);
        
      System.out.println("字符串长度为 3 的数量为: " + count);
        
      // 删除空字符串
      List<String> filtered = deleteEmptyStringsUsingJava7(strings);
      System.out.println("筛选后的列表: " + filtered);
        
      // 删除空字符串，并使用逗号把它们合并起来
      String mergedString = getMergedStringUsingJava7(strings,", ");
      System.out.println("合并字符串: " + mergedString);
      List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
        
      // 获取列表元素平方数
      List<Integer> squaresList = getSquares(numbers);
      System.out.println("平方数列表: " + squaresList);
      List<Integer> integers = Arrays.asList(1,2,13,4,15,6,17,8,19);
        
      System.out.println("列表: " +integers);
      System.out.println("列表中最大的数 : " + getMax(integers));
      System.out.println("列表中最小的数 : " + getMin(integers));
      System.out.println("所有数之和 : " + getSum(integers));
      System.out.println("平均数 : " + getAverage(integers));
      System.out.println("随机数: ");
        
      // 输出10个随机数
      Random random = new Random();
        
      for(int i=0; i < 10; i++){
         System.out.println(random.nextInt());
      }
        
      System.out.println("使用 Java 8: ");
      System.out.println("列表: " +strings);
        
      count = strings.stream().filter(string->string.isEmpty()).count();
      System.out.println("空字符串数量为: " + count);
        
      count = strings.stream().filter(string -> string.length() == 3).count();
      System.out.println("字符串长度为 3 的数量为: " + count);
        
      filtered = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.toList());
      System.out.println("筛选后的列表: " + filtered);
        
      mergedString = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(", "));
      System.out.println("合并字符串: " + mergedString);
        
      squaresList = numbers.stream().map( i ->i*i).distinct().collect(Collectors.toList());
      System.out.println("Squares List: " + squaresList);
      System.out.println("列表: " +integers);
        
      IntSummaryStatistics stats = integers.stream().mapToInt((x) ->x).summaryStatistics();
        
      System.out.println("列表中最大的数 : " + stats.getMax());
      System.out.println("列表中最小的数 : " + stats.getMin());
      System.out.println("所有数之和 : " + stats.getSum());
      System.out.println("平均数 : " + stats.getAverage());
      System.out.println("随机数: ");
        
      random.ints().limit(10).sorted().forEach(System.out::println);
        
      // 并行处理
      count = strings.parallelStream().filter(string -> string.isEmpty()).count();
      System.out.println("空字符串的数量为: " + count);
   }
    
   private static int getCountEmptyStringUsingJava7(List<String> strings){
      int count = 0;
        
      for(String string: strings){
        
         if(string.isEmpty()){
            count++;
         }
      }
      return count;
   }
    
   private static int getCountLength3UsingJava7(List<String> strings){
      int count = 0;
        
      for(String string: strings){
        
         if(string.length() == 3){
            count++;
         }
      }
      return count;
   }
    
   private static List<String> deleteEmptyStringsUsingJava7(List<String> strings){
      List<String> filteredList = new ArrayList<String>();
        
      for(String string: strings){
        
         if(!string.isEmpty()){
             filteredList.add(string);
         }
      }
      return filteredList;
   }
    
   private static String getMergedStringUsingJava7(List<String> strings, String separator){
      StringBuilder stringBuilder = new StringBuilder();
        
      for(String string: strings){
        
         if(!string.isEmpty()){
            stringBuilder.append(string);
            stringBuilder.append(separator);
         }
      }
      String mergedString = stringBuilder.toString();
      return mergedString.substring(0, mergedString.length()-2);
   }
    
   private static List<Integer> getSquares(List<Integer> numbers){
      List<Integer> squaresList = new ArrayList<Integer>();
        
      for(Integer number: numbers){
         Integer square = new Integer(number.intValue() * number.intValue());
            
         if(!squaresList.contains(square)){
            squaresList.add(square);
         }
      }
      return squaresList;
   }
    
   private static int getMax(List<Integer> numbers){
      int max = numbers.get(0);
        
      for(int i=1;i < numbers.size();i++){
        
         Integer number = numbers.get(i);
            
         if(number.intValue() > max){
            max = number.intValue();
         }
      }
      return max;
   }
    
   private static int getMin(List<Integer> numbers){
      int min = numbers.get(0);
        
      for(int i=1;i < numbers.size();i++){
         Integer number = numbers.get(i);
        
         if(number.intValue() < min){
            min = number.intValue();
         }
      }
      return min;
   }
    
   private static int getSum(List numbers){
      int sum = (int)(numbers.get(0));
        
      for(int i=1;i < numbers.size();i++){
         sum += (int)numbers.get(i);
      }
      return sum;
   }
    
   private static int getAverage(List<Integer> numbers){
      return getSum(numbers) / numbers.size();
   }
}

// boolean mkdir() 创建由此抽象路径名命名的目录。
File f1 = new File("C:\\Users\\admin\\Desktop\\2");
if (!f1.exists()) { // 目录不存在
	f1.mkdir();
}
File f2 = new File("C:\\Users\\admin\\Desktop\\2\\22\\222");
System.out.println(f2.exists());
f2.mkdir(); // 注意：mkdir()上一级目录存在,不然创建失败

// boolean mkdirs () 创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录。
File f3 = new File("C:\\Users\\admin\\Desktop\\2\\22\\222");
f3.mkdirs();

// boolean createNewFile ()当且仅当具有该名称的文件尚不存在时，原子地创建一个由该抽象路径名命名的新的空文件。
File f4 = new File("C:\\Users\\admin\\Desktop\\2\\2.avi");
f4.createNewFile();

public class FileFilterTest {
	
	public static void main(String[] args) {
		File file = new File("./");
		// 列出目录下的所有文件和文件夹
		String[] files = file.list();
		for(int i = 0; i < files.length; i++) {
			 System.out.println(files[i]);
		}
		
		// 分别用FilenameFilter 和 FileFilter 实现过滤以.txt为后缀的文件
		String[] files1 = file.list(new MyFilenameFilter(".txt"));
		for(int i = 0; i < files1.length; i++) {
			 System.out.println(files1[i]);
		}
		
		// MyFileFilter过滤器用于 listFiles 函数
		File[] files2 = file.listFiles(new MyFileFilter(".txt"));
		for(int i = 0; i < files2.length; i++) {
			System.out.println(files2[i].getName());
		}
	}
}
 
class MyFilenameFilter implements FilenameFilter {
	// type为需要过滤的条件，比如如果type=".jpg"，则只能返回后缀为jpg的文件
	private String type;
 
	public MyFilenameFilter(String type) {
		this.type = type;
	}
	
	@Override
	// 返回true的文件则合格
	public boolean accept(File dir, String name) {
		// 这里如果需要使用文件的功能，则需要先进行封装
		File file = new File(dir,name);
		
		return name.endsWith(type) && file.isFile();
	}
}
 
class MyFileFilter implements FileFilter {
	private String type;
 
	public MyFileFilter(String type) {
		this.type = type;
	}
	
	@Override
	public boolean accept(File pathname) {
		// 这里如果需要使用文件的功能直接使用即可
		return pathname.getName().endsWith(type) && pathname.isFile();
	}
}

public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
        File f = new File("/1.txt");

        FileInputStream fis1 = new FileInputStream(f);
        int len1 = -1;
        byte[] buffer1 = new byte[1024];
        while ((len1 = fis1.read(buffer1)) != -1){
            System.out.print(new String(buffer1,0,len1));
        }

        System.out.println();
        FileInputStream fis2 = new FileInputStream(f);
        int len2 = -1;
        byte[] buffer2 = new byte[1024];
        while ((len2 = fis2.read(buffer2,1,3)) != -1){
            System.out.print(new String(buffer2,2,len2 - 1));
        }

        fis2.close();
        fis1.close();
    }
}

public class FileOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        File f = new File("/1.txt");
        FileOutputStream fos = new FileOutputStream(f);
        byte[] buffer = {'B','r','u','i','s','e','s','L'};
        fos.write(buffer, 0, buffer.length);
    }
}

public class CopyDemo {
    public static void main(String[] args) throws IOException {
        File f1 = new File("/1.txt");
        File f2 = new File("/2.txt");

        FileInputStream fis = new FileInputStream(f1);
        FileOutputStream fos = new FileOutputStream(f2);

        int len = -1;
        byte[] buffer = new byte[1024];
        while ((len = fis.read(buffer)) != -1){
            fos.write(buffer);
        }
        fos.close();
        fis.close();
    }
}

public class TestBufferStream {
	public static void main (String[] args) throws IOException{
		BufferedInputStream bis=null;
		BufferedOutputStream bos=null;
		try {
			FileInputStream fis = new FileInputStream("/TestFileImportStream.java");
			FileOutputStream fos = new FileOutputStream("/out2.java");
			bis = new BufferedInputStream(fis); // 加了缓存的功能流BufferedInputStream
			bos = new BufferedOutputStream(fos);// 加了缓存的功能流BufferedOutputStream
			byte[] b = new byte[1024];
			int off=0;
			while ((off=bis.read(b))>0) {
				bos.write(b,0,off);
			}
			bis.close();
			bos.close();
		}catch (IOException e) {
			e.printStackTrace();
		}finally {
			bis.close();
			bos.close();
		}		
	}
}

// 为文件字节流 添加缓冲区功能， 一次读写一个字节数据，但内部缓冲区数组已经填满
private static void copyFile1(String src, String dest) throws IOException {
    // 创建流
    InputStream in = new BufferedInputStream(new FileInputStream(src));
    OutputStream os = new BufferedOutputStream(new FileOutputStream(dest));
    // 读写数据
    int data = in.read();
    while (data != -1) {
        os.write(data);
        data = in.read();
    }
    // 关闭流
    in.close();
    os.close();
}

// 为文件字节流 添加缓冲区功能， 一次读写一个字节数组数据，但内部缓冲区数组已经填满
private static void copyFile2(String src, String dest) throws IOException {
    // 创建流
    InputStream in = new BufferedInputStream(new FileInputStream(src));
    OutputStream os = new BufferedOutputStream(new FileOutputStream(dest));

    // 读写数据
    byte[] buffer = new byte[2048];
    int len = in.read(buffer);
    while (len != -1) {
        os.write(buffer, 0, len);
        len = in.read(buffer);
    }
    // 关闭流
    in.close();
    os.close();
}

public class TransStreamTest {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new FileWriter("/1.txt"));
		String line =null;
    // readLine()方法在进行读取一行时，只有遇到回车(\r)或者换行符(\n)才会返回读取结果
		while ((line=br.readLine())!=null) {
			if ("over".contentEquals(line)) {
				break;
			}
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
    bw.close();
    br.close();
	}

}

InputStream is = new FileInputStream("/1.txt");
InputStreamReader r = new InputStreamReader (is);
char[] cbuf = new char[10];
int len;
while((len = r.read(cbuf))!=-1){
	System.out.println(new String(cbuf,0,len));
}
r.close();

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("/1.txt"));
osw.write("罗新驰");
osw.close();

public class ObjectStreamTest {
	public static void main(String[] args) throws Exception{
		try {
			Person P=new Person("Jeccica",26);
			FileOutputStream fos=new FileOutputStream("/1.txt");
			ObjectOutputStream oos=new ObjectOutputStream(fos);
			oos.writeObject(P);
			oos.flush();
			oos.close();
		}catch(FileNotFoundException e) {
			e.printStackTrace();
		}catch(IOException e) {
			e.printStackTrace();
		}			
		
		FileInputStream fis=new FileInputStream("/1.txt");
		ObjectInputStream ois=new ObjectInputStream(fis);
		Person P2=(Person)ois.readObject();
		System.out.println(P2.name+"的年龄为"+P2.age);
	}

}

class Person implements Serializable{
	String name=null;
	int age=0;
	Person(String _name,int _age){
		name=_name;
		age=_age;
	}
}

public class DataStream {
	public static void main(String[] args) {
		ByteArrayOutputStream baos=new ByteArrayOutputStream();//创建字节数组流，同时会在内存里面创建数组
		DataOutputStream dos=new DataOutputStream(baos);//对字节数组流外封装成数据处理流
		try {
			dos.writeDouble(Math.random());//利用数据流里面的写入方法，写一个Double类型的随机数据
			dos.writeBoolean(true);
			ByteArrayInputStream bias=new ByteArrayInputStream(baos.toByteArray());//toByteArray()方法是创建一个新分配的字节数组。数组的大小和当前输出流的大小。这里指的是baos这个字节数组
			System.out.println(bias.available());
			DataInputStream dis=new DataInputStream(bias);
			System.out.println(dis.readDouble());
			System.out.println(dis.readBoolean());		
			dos.close();
			dis.close();
		}catch (IOException e) {
			e.printStackTrace();
		}
	}
}