Java8Stream流练习package Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
le.gson.Gson;
public class StreamTest {
public static void main(String[] args) {
Runnable r = () -> System.out.println(111);
r.run();
// 1.创建流
// 1.1数组
Stream<Integer> intArrayStream = Stream.of(1, 2, 3, 4, 5, 6);
String[] strArr = new String[] { "暗夜猎⼿", "暗⿊元⾸", "暗裔剑魔", "vn", "球⼥", "剑魔" };
Stream<String> strArrayStream = Arrays.stream(strArr);
/
/ 1.2集合
List<Integer> nums = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
Stream<Integer> listStream = nums.stream();
Map<String, String> map = new HashMap<>();
map.put("1", "I");
map.put("2", "II");
map.put("3", "III");
map.put("4", "IV");
map.put("5", "V");
Stream<Entry<String, String>> mapstream = Set().stream();
Set<Character> set = new HashSet<>();
set.add('a');
set.add('A');
set.add('b');
set.add('z');
set.add('Z');
Stream<Character> setStream = set.stream();
// 2.转换流
// 2.1 map()
// 2.1.1接收⼀个函数作为参数，该函数会被应⽤到每个元素上，并将其映射成⼀个新的元素。
// 获取map中的所有value
String string = mapstream.map(Entry<String, String>::getValue).collect(Collectors.joining(",")).toString();  System.out.println(string);
// I,II,III,IV,V
// 2.1.2将set中的字母转换⼤⼩写
String string4 = set.stream().map(i -> (char) (i ^ 32)).List()).toString();
System.out.println(string4);
// [A, a, B, Z, z]
// 2.2 flatMap()
// 接收⼀个函数作为参数，将流中的每个值都换成另⼀个流，然后把所有流连接成⼀个流。
// 获取map中有⼏个字母
// 获取map中有⼏个字母
long count = Set().stream().flatMap(i -> Stream.Value().split(""))).distinct().count();
System.out.println(count);
/
/ 2.2 sorted()和sorted(Comparator<T>)
// 将set转换成list并将字母转换⼤⼩写并进⾏排序
String string2 = setStream.map(i -> (char) (i ^ 32)).sorted((i, j) -> j - i).List())
.toString();
String string3 = set.stream().map(i -> (char) (i ^ 32)).sorted().List()).toString();
String string5 = set.stream().map(i -> (char) (i ^ 32)).List()).toString();
System.out.println(string2);
// [z, a, Z, B, A]
System.out.println(string3);
// [A, B, Z, a, z]
System.out.println(string5);
/
/ [A, a, B, Z, z]
// 2.3 filter()
// 过滤流中的某些元素
/*
* 1.请在测试类main⽅法中完成以下需求已知有Integer[] arr = {-12345, 9999, 520,
* 0,-38,-7758520,941213}
* a)使⽤lambda表达式创建Predicate对象p1,p1能判断整数是否是⾃然数(⼤于等于0)
* b)使⽤lambda表达式创建Predicate对象p2,p2能判断整数的绝对值是否⼤于100
* c)使⽤lambda表达式创建Predicate对象p3,p3能判断整数是否是偶数
*
* 遍历arr，仅利⽤已创建的Predicate对象(不使⽤任何逻辑运算符)，完成以下需求 i.打印⾃然数的个数 ii.打印负整数的个数  * iii.打印绝对值⼤于100的偶数的个数 iv.打印是负整数或偶数的数的个数
*/
Integer[] arr = { -12345, 9999, 520, 0, -38, -7758520, 941213 };
Predicate<Integer> p1 = (s) -> s >= 0;
Predicate<Integer> p2 = (s) -> Math.abs(s) > 100;
Predicate<Integer> p3 = (s) -> s % 2 == 0;
int c1 = 0, c2 = 0, c3 = 0, c4 = 0;
for (Integer i : arr) {
if (p1.test(i)) {
c1++;
}
if (p1.negate().test(i)) {
c2++;
}
if (p2.and(p3).test(i)) {
c3++;
}
if (p1.negate().or(p3).test(i)) {
c4++;
}
}
System.out.println("count1=" + c1 + ",count2=" + c2 + ",count3=" + c3 + ",count4=" + c4);
// Predicate对象在Stream中的⽤法.filter(Predicate<? super T> predicate)
long count1 = Stream.of(arr).filter(p1).count();
long count2 = Stream.of(arr).ate()).count();
long count3 = Stream.of(arr).filter(p2.and(p3)).count();
long count4 = Stream.of(arr).ate().or(p3)).count();
System.out.println("count1=" + count1 + ",count2=" + count2 + ",count3=" + count3 + ",count4=" + count4);
nums.stream().filter(num -> num % 2 == 0).map(i -> i / 2).List())
.forEach(System.out::println);
List<Student> students = new ArrayList<Student>() {
private static final long serialVersionUID = 1L;
{
add(new Student("张三", "三年⼆班", "赵⽼师", "智慧⼩学"));
add(new Student("王五", "九年⼀班", "李⽼师", "智慧中学"));
add(new Student("王五", "九年⼀班", "李⽼师", "智慧中学"));
add(new Student("赵六", "九年⼆班", "徐⽼师", "⿇⽠中学"));
add(new Student("钱七", "九年三班", "鲁智深", "LOL学院"));
add(new Student("李四", "三年⼆班", "赵⽼师", "智慧⼩学"));
}
java stream};
students.stream().sorted((i, j) -> j.getSchool()School()))
.forEach(i -> System.out.println(new Gson().toJson(i)));
Map<String, List<Student>> collect2 = students.stream().upingBy(Student::getSchool));  Set().stream().map(Entry<String, List<Student>>::getValue)
.forEach(i -> System.out.println(new Gson().toJson(i)));
List<Student> lolSchoolStudent = students.stream().filter(student -> "LOL学院".School()))    .List());
Map<String, String> collect = students.stream().filter(student -> "三年⼆班".ClassName()))    .Map(i -> i.getName(), i -> i.getSchool()));
System.out.String());
lolSchoolStudent.stream().forEach(stu -> System.out.Name()));
// 將char数组中的字母转换⼤⼩写
char[] ens = { 'a', 'B', 'C', 'd', 'e' };
Stream<Character> charStream = new String(ens).chars().mapToObj(i -> (char) i);
charStream.map(i -> (char) (i ^ 32)).forEach(System.out::println);
}
}

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。