JavaSE 进阶 (8) Stream

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public static void main(String[] args){
	//集合的批量添加
	ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子", "谢广坤"));
	
	//遍历list1,把以张开头的元素添加到1ist2中。
	ArrayList<String> list2 = new ArrayList<>();
	for (String s : list1){
		if(s.startswith("张")){
			list2.add(s);
		}
	}

	//遍历list2集合，把其中长度为3的元素，再添加到1ist3中。
	ArrayList<String> list3 = new ArrayList<>();
	for (String s : list2){
		if(s.length() == 3){
			list3.add(s);
		}
	}
	
	//遍历list3集合，输出打印
	for(String s : list3){
		System.out.println(s);
	}
}

1
2
3

list1.stream().filter(s -> s.startswith("张"))
		.filter(s -> s.length() == 3)
		forEach(s -> System.out.println(s));

1
2
3
4
5
6
7
8
9

public static void main(String[] args){
	//单列集合
	ArrayList<String> list = new ArrayList<>();
	list.add("aaa");
	list.add("bbb");
	list.add("ccc");
	Stream<String> stream = list.stream();
	stream.forEach(s -> System.out.println(s));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public static void main(String[] args){
	HashMap<String,Integer> hm = new HashMap<>();
	hm.put("zhangsan", 23);
	hm.put("lisi", 24);
	hm.put("wangwu", 25);
	hm.put("zhaoliu", 26);
	hm.put("qianqi", 27);

	//双列集合不能直接获取Stream流
	//keyset
	//先获取到所有的键
	//再把这个Set集合中所有的键放到stream流中
	hm.keyset().stream().forEach(s -> system.out.println(s)); //zhangsan,lisi,wangwu,zhaoliu,qianqi

	//entryset
	//先获取到所有的键值对对象
	//再把这个Set集合中所有的键值对对象放到Stream流中
	hm.entryset().stream().forEach(s -> System.out.println(s));//zhangsan=23,lisi=24......
}

1
2
3
4
5
6
7
8
9

public static void main(String[] args){
	int[] arr = {1, 2, 3, 4, 5};
	Arrays.stream(arr).forEach(new IntConsumer(){
		@Override
		public void accept (int value){
			System.out.println(value);
		}
	});
}

1
2
3
4
5
6
7
8

public static void main(String[] args){
	Stream.of (1, 2, 3, 4, 5, 6, 7, 8, 9).forEach (new Consumer<Integer>(){
		@Override
		public void accept(Integer integer){
			System.out.println(integer);
		}
	});
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

//filter方法获取流中的每一个数据
//而test方法中的s,就依次表示流中的每一个数据。
//我们只要在test方法中对s进行判断就可以了，
//如果判断的结果为true,则当前的数据留下
//如果判断的结果为false,则当前数据就不要。
list.stream().filter(
	new Predicate<string>(){
		@Override
		public boolean test(string s){
			boolean result = s.startsWith("张");
			return result;
		}
	}
)
.forEach(s -> System.out.println(s));

list.stream().filter(s -> s.startWith("张")).forEach(s -> System.out.println(s));

1
2
3

Stream<String> stream1 = list.stream();
Stream<String> stream2 = list2.stream();
Stream<String> stream3 = Stream.concat(stream1, stream2);

1

Optional<String> first = list.stream().findFirst();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import java.util.*;  
import java.util.concurrent.atomic.AtomicInteger;  
import java.util.stream.Collectors;  
  
public class StreamExample {  
    public static void main(String[] args) {  
        List<Integer> ints = Arrays.asList(50, 10, 2, 40, 9, 8);  
  
        // 使用顺序流计算列表中所有数字的总和  
        long sumSequential = ints.stream()  
                .mapToLong(n -> n)  
                .sum();  
  
        System.out.println("Sum using sequential stream: " + sumSequential);  
  
        // 使用并行流计算列表中所有数字的总和  
        long sumParallel = ints.parallelStream()  
                .mapToLong(n -> n)  
                .sum();  
  
        System.out.println("Sum using parallel stream: " + sumParallel);  
    }  
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

//字母排序
List<String> string1 = Arrays.asList("abc", "bc", "bcf", "efg", "abcd", "bca", "jkl", "jkl");
List<String> sorted = string1.stream().sorted().collect(Collectors.toList());

//数字排序
List<Integet> ints = Arrays.asList(50, 10, 2, 40, -9, 8);
List<Integet> collect = ints.stream().sorted().collect(Collectors.toList());

//汉字排序
List<String> strings2 = Arrays.asList("张三", "李四", "王五", "赵柳", "张哥", "李哥", "王哥");
List<String> collect1 = strings2.stream().sorted(Collections.reverseOrder(Collator.getInstance(Locale.CHINA))).collect(Collectors.toList());
//Collections.reverseOrder(Collator.getInstance(Locale.CHINA)) 的意思就是，通过中国地域设置的 Collator 实例来创建一个逆序比较器。这个比较器会按照中国地域设置的规则，对字符串进行逆序比较和排序。

//根据比较器指定的规则排序
List<Teacher> l = new ArrayList<>();
l.add(new Teacher(14,"zs"));
l.add(new Teacher(11,"ww"));
l.add(new Teacher(24,"ls"));
l.add(new Teacher(24,"ks"));
List<Teacher> collect = l.stream().sorted((a, b) -> {
    int i = a.getAge() - b.getAge();
    i = i == 0 ? a.getName().compareTo(b.getName()) : i;
    return i;
}).collect(Collectors.toList());

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

//在forEach方法的底层，会循环获取到流中的每一个数据。
//并循环调用accept方法，并把每一个数据传递给accept方法
//s就依次表示了流中的每一个数据
//所以，我们只要在accept方法中，写上处理的业务逻辑就可以了
list.stream().forEach(
	new Consumer<String>(){
		@Override
		public void accept(string s){
			System.out.println(s);
		}
	}
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public class Mystream6{
	public static void main(String[] args){
		ArrayList<Integer> list = new ArrayList<>();
		for(int i = 1; i <= 10; i++){
			list.add(i);
		}
		
		list.stream().filter(number -> number%2 == 0).forEach(number -> System.out.println(number));
		//---------------------------------------
		for(Integer integer : list){
			System.out.println(integer);
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Test{
	public static void main(String[] args){
		//filter负责过滤数据
		//collect负责收集数据
		//获取流中剩余的数据，但是他不负责创建容器，也不负责把数据添加到容器中，
		//Collectors.toList():在底层会创建一个List集合。并把所有的数据添加到List集合中
		List<Integer> list = list1.stream().filter(number -> number%2 == 0)
			.collect(Collectors.toList());
	}
}

1
2
3
4
5
6

Stream<String> stream1 = manList.stream().filter(s -> s.length() == 3).limit(2);
Stream<String> stream2 = womanList.stream().filter(s -> s.startWith("杨")).skip(1);
Stream.concat(stream1, stream2).foreach(s -> 
		Actor a = new Actor(s);
		System.out.println(a);
	);

1
2
3

int a = 10;
int [] arr = {1,2,3,4,5};
ArrayList<String> list = new ArrayList<>();

1
2

String path = "C:\\it\\a.txt";
File file = new File(path);

1
2
3
4

String path1 = "c:\\it";
String path2 = "a.txt";
File file = new File(path1, path2);//把两个路径拼接。
System.out.println(file); //"C:\it\a.txt"

1
2
3
4

File file1 = new File("C:\\it");
String path = "a.txt";
File file = new File(file1, path);
System.out.println(file);  //"C:\it\a.txt"

1

File file1 = new File("C:\\it\\a.txt");

1
2

File file2 = new File("a.txt");
File file3 = new File("模块名\\a.txt");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class FileDemo2{
	public static void main(String[] args){
		//这个路径固定不变了
		File file = new File("D:\\it\\a.txt");

		//当前项目下的 a.txt
		File file2 = new File("a.txt");

		//当前项目下---指定模块下的 a.txt
		File file3 = new File("filemodule\\a.txt");
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public boolean mkdirs() {
    if (exists()) {
        return false;
    }
    if (mkdir()) {
        return true;
    }
    File canonFile = null;
    try {
        canonFile = getCanonicalFile();
    } catch (IOException e) {
        return false;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public static void method1(){
	File file = new File("C:\\it\\a.txt");
	boolean result1 = file.isFile();
	boolean result2 = file.isDirectory();
	System.out.println(result1);  //true
	System.out.println(result2);  //false
}

public static void method2(){
	File file = new File("C:\\it");
	boolean result1 = file.isFile();
	boolean result2 = file.isDirectory();
	System.out.println(result1);  //false
	System.out.println(result2);  //true
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public static void main(String[] args){
	File file = new File("filemodule\\aaa\\a.txt");
	file.createNewFile();  //报错,原因:aaa文件夹不存在
	
	//注意点：文件所在的文件夹必须要存在
	File file1 = new File("filemodule\\aaa");
	if(!file1.exists()){
		//如果文件夹不存在，就创建出来
		file1.mkdirs();
	}
	File newFile = new File(file1, "a.txt"); //将 "filemodule\\aaa" 和 "a.txt" 拼接起来
	newFile.createNewFile();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

private static void deleteDir(File src){
	//先删掉这个文件夹里面所有的内容，
	//递归:方法在方法体中自己调用自己。
	//注意：可以解决所有文件夹和递归相结合的题目
	//1.进入---得到src文件夹里面所有内容的File对象。
	File[] files = src.listFiles();
	
	//2.遍历---因为我想得到src文件夹里面每一个文件和文件夹的File对象
	for(File file : files){
		if(file.isFile()){
			//3.判断---如果遍历到的File对象是一个文件，那么直接删除
			file.delete();
		}else{
			//4.判断
			//递归
			deleteDir(file);  //参数一定要是src文件夹里面的文件夹File对象
		}
	}

	//最后再删除这个文件夹
	src.delete();
}

1
2
3
4

txt: 3个
doc: 4个
jpg: 6个
……

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

public static void main(String[] args){
	//统计一个文件夹中，每种文件出现的次数。
	//统计---定义一个变量用来统计。---弊端：同时只能统计一种文件
	//利用map集合进行数据统计，键---文件后缀名  值----次数
	File file = new File("filemodule");  //相对路径,当前模块
	HashMap<String, Integer> hm = new HashMap<>();
	getcount(hm, file);
	System.out.println(hm);
}

private static void getCount(HashMap<String, Integer> hm,File file){
	File[] files = file.listFiles();
	for(File f : files){
		if(f.isFile()){
			String fileName = f.getName();
			String[] fileNameArr = fileName.split("\\.");  //只统计常规的,例如:aaa.txt,不考虑a.b.txt这样的
			if(fileNameArr.length == 2){
				String fileEndName = fileNameArr[1];
				if(hm.containskey(fileEndName)){ //判断集合中是否存在这个键
					//已经存在
					//将已经出现的次数获取出来
					Integer count = hm.get(fileEndName);
					//这种文件又出现了一次
					count++;
					//把己经出现的次数给覆盖掉
					hm.put(fileEndName,count);
				}else{
					//不存在
					//表示当前文件是第一次出现
					hm.put(fileEndName, 1);
				}
			}
		}else{
			getCount(hm, f);
		}
	}
}

1
2
3
4
5
6

/**
 * fileName: 临时文件的名字, 生成后的文件名字将会是【fileName + 随机数】
 * suffix： 文件后缀，例如.txt, .tmp
 * parentFile: 临时文件目录，如果不指定，则默认把临时文件存储于系统临时文件目录上       
*/
public static File createTempFile(String fileName, String suffix, File parentFile)

1
2
3

File file = new File("D:\\test\\1.txt");
boolean res = file.createNewFile();
if(!res)System.out.println("创建失败！");

1
2
3
4
5

//立即删除文件
file.delete();

//在JVM退出时删除文件
file.deleteOnExit();