package com.atguigu.java8;
public class Employee {
private int id;
private String name;
private int age;
private double salary;
private Status status;
public Employee () {
}
public Employee (String name) {
this .name = name;
}
public Employee (String name, int age) {
this .name = name;
this .age = age;
}
public Employee (int id, String name, int age, double salary) {
this .id = id;
this .name = name;
this .age = age;
this .salary = salary;
}
public Employee (int id, String name, int age, double salary, Status status) {
this .id = id;
this .name = name;
this .age = age;
this .salary = salary;
this .status = status;
}
public Status getStatus () {
return status;
}
public void setStatus (Status status) {
this .status = status;
}
public int getId () {
return id;
}
public void setId (int id) {
this .id = id;
}
public String getName () {
return name;
}
public void setName (String name) {
this .name = name;
}
public int getAge () {
return age;
}
public void setAge (int age) {
this .age = age;
}
public double getSalary () {
return salary;
}
public void setSalary (double salary) {
this .salary = salary;
}
public String show () {
return "测试方法引用!" ;
}
@Override
public int hashCode () {
final int prime = 31 ;
int result = 1 ;
result = prime * result + age;
result = prime * result + id;
result = prime * result + ((name == null ) ? 0 : name.hashCode());
long temp;
temp = Double.doubleToLongBits(salary);
result = prime * result + (int ) (temp ^ (temp >>> 32 ));
return result;
}
@Override
public boolean equals (Object obj) {
if (this == obj)
return true ;
if (obj == null )
return false ;
if (getClass() != obj.getClass())
return false ;
Employee other = (Employee) obj;
if (age != other.age)
return false ;
if (id != other.id)
return false ;
if (name == null ) {
if (other.name != null )
return false ;
} else if (!name.equals(other.name))
return false ;
if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
return false ;
return true ;
}
@Override
public String toString () {
return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + ", status=" + status
+ "]" ;
}
public enum Status {
FREE, BUSY, VOCATION;
}
}
package com.atguigu.exer;
import org.junit.Test;
import com.atguigu.java8.Employee;
import com.atguigu.java8.Employee.Status;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
public class TestStreamAPI {
/*
1. 给定一个数字列表,如何返回一个由每个数的平方构成的列表呢?
,给定【1 ,2 ,3 ,4 ,5 】, 应该返回【1 ,4 ,9 ,16 ,25 】。
*/
@Test
public void test1(){
Integer[] nums = new Integer[]{1 ,2 ,3 ,4 ,5 };
Arrays.stream(nums)
.map((x) -> x * x)
.forEach (System.out::println) ;
}
/*
2. 怎样用 map 和 reduce 方法数一数流中有多少个Employee 呢?
*/
List <Employee > emps = Arrays .asList (
new Employee(102 , "李四" , 59 , 6666.66 , Status.BUSY),
new Employee(101 , "张三" , 18 , 9999.99 , Status.FREE),
new Employee(103 , "王五" , 28 , 3333.33 , Status.VOCATION),
new Employee(104 , "赵六" , 8 , 7777.77 , Status.BUSY),
new Employee(104 , "赵六" , 8 , 7777.77 , Status.FREE),
new Employee(104 , "赵六" , 8 , 7777.77 , Status.FREE),
new Employee(105 , "田七" , 38 , 5555.55 , Status.BUSY)
) ;
@Test
public void test2 () {
Optional <Integer > count = emps .stream ()
.map ((e) -> 1 )
.reduce (Integer::sum) ;
System .out .println (count.get()) ;
}
}
package com.atguigu.exer;
public class Trader {
private String name;
private String city;
public Trader () {
}
public Trader (String name, String city) {
this .name = name;
this .city = city;
}
public String getName () {
return name;
}
public void setName (String name) {
this .name = name;
}
public String getCity () {
return city;
}
public void setCity (String city) {
this .city = city;
}
@Override
public String toString () {
return "Trader [name=" + name + ", city=" + city + "]" ;
}
}
package com.atguigu.exer;
public class Transaction {
private Trader trader;
private int year;
private int value ;
public Transaction () {
}
public Transaction (Trader trader, int year, int value ) {
this .trader = trader;
this .year = year;
this .value = value ;
}
public Trader getTrader () {
return trader;
}
public void setTrader (Trader trader) {
this .trader = trader;
}
public int getYear () {
return year;
}
public void setYear (int year) {
this .year = year;
}
public int getValue () {
return value ;
}
public void setValue (int value ) {
this .value = value ;
}
@Override
public String toString () {
return "Transaction [trader=" + trader + ", year=" + year + ", value="
+ value + "]" ;
}
}
package com.atguigu.exer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;
import org.junit.Before;
import org.junit.Test;
public class TestTransaction {
List<Transaction> transactions = null ;
@Before
public void before(){
Trader raoul = new Trader("Raoul" , "Cambridge" );
Trader mario = new Trader("Mario" , "Milan" );
Trader alan = new Trader("Alan" , "Cambridge" );
Trader brian = new Trader("Brian" , "Cambridge" );
transactions = Arrays.asList(
new Transaction(brian, 2011 , 300 ),
new Transaction(raoul, 2012 , 1000 ),
new Transaction(raoul, 2011 , 400 ),
new Transaction(mario, 2012 , 710 ),
new Transaction(mario, 2012 , 700 ),
new Transaction(alan, 2012 , 950 )
);
}
// 1. 找出2011 年发生的所有交易, 并按交易额排序(从低到高)
@Test
public void test1(){
transactions.stream()
.filter((t) -> t.getYear() == 2011 )
.sorted ((t1, t2) -> Integer.compare(t1.getValue(), t2.getValue()))
.forEach (System.out::println) ;
}
//2. 交易员都在哪些不同的城市工作过?
@Test
public void test2 () {
transactions .stream ()
.map ((t) -> t.getTrader().getCity())
.distinct ()
.forEach (System.out::println) ;
}
//3. 查找所有来自剑桥的交易员,并按姓名排序
@Test
public void test3 () {
transactions .stream ()
.filter ((t) -> t.getTrader().getCity().equals("Cambridge" ))
.map (Transaction::getTrader)
.sorted ((t1, t2) -> t1.getName().compareTo(t2.getName()))
.distinct ()
.forEach (System.out::println) ;
}
//4. 返回所有交易员的姓名字符串,按字母顺序排序
@Test
public void test4 () {
transactions .stream ()
.map ((t) -> t.getTrader().getName())
.sorted ()
.forEach (System.out::println) ;
System .out .println ("-----------------------------------" ) ;
String str = transactions .stream ()
.map ((t) -> t.getTrader().getName())
.sorted ()
.reduce ("" , String::concat) ;
System .out .println (str) ;
System .out .println ("------------------------------------" ) ;
transactions .stream ()
.map ((t) -> t.getTrader().getName())
.flatMap (TestTransaction::filterCharacter)
.sorted ((s1, s2) -> s1.compareToIgnoreCase(s2))
.forEach (System.out::print ) ;
}
public static Stream <String > filterCharacter (String str) {
List <String > list = new ArrayList <>() ;
for (Character ch : str.toCharArray()) {
list .add (ch.toString()) ;
}
return list .stream () ;
}
//5. 有没有交易员是在米兰工作的?
@Test
public void test5 () {
boolean bl = transactions .stream ()
.anyMatch ((t) -> t.getTrader().getCity().equals("Milan" )) ;
System .out .println (bl) ;
}
//6. 打印生活在剑桥的交易员的所有交易额
@Test
public void test6 () {
Optional <Integer > sum = transactions .stream ()
.filter ((e) -> e.getTrader().getCity().equals("Cambridge" ))
.map (Transaction::getValue)
.reduce (Integer::sum) ;
System .out .println (sum.get()) ;
}
//7. 所有交易中,最高的交易额是多少
@Test
public void test7 () {
Optional <Integer > max = transactions .stream ()
.map ((t) -> t.getValue())
.max (Integer::compare) ;
System .out .println (max.get()) ;
}
//8. 找到交易额最小的交易
@Test
public void test8 () {
Optional <Transaction > op = transactions .stream ()
.min ((t1, t2) -> Integer.compare(t1.getValue(), t2.getValue())) ;
System .out .println (op.get()) ;
}
}
package com.atguigu.java8;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
import org.junit.Test;
/*
* 一、 Stream 的操作步骤
*
* 1. 创建 Stream
*
* 2. 中间操作
*
* 3. 终止操作
*/
public class TestStreamAPI1 {
List<Employee> emps = Arrays.asList(
new Employee(102 , "李四" , 59 , 6666.66 ),
new Employee(101 , "张三" , 18 , 9999.99 ),
new Employee(103 , "王五" , 28 , 3333.33 ),
new Employee(104 , "赵六" , 8 , 7777.77 ),
new Employee(104 , "赵六" , 8 , 7777.77 ),
new Employee(104 , "赵六" , 8 , 7777.77 ),
new Employee(105 , "田七" , 38 , 5555.55 )
);
// 2. 中间操作
/*
映射
map——接收 Lambda , 将元素转换成其他形式或提取信息。接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素。
flatMap——接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流
*/
@Test
public void test1(){
Stream<String> str = emps.stream()
.map((e) -> e.getName()) ;
System .out .println ("-------------------------------------------" ) ;
List <String > strList = Arrays .asList ("aaa" , "bbb" , "ccc" , "ddd" , "eee" ) ;
Stream <String > stream = strList .stream ()
.map (String::toUpperCase) ;
stream .forEach (System.out::println) ;
Stream <Stream <Character >> stream2 = strList .stream ()
.map (TestStreamAPI1::filterCharacter) ;
stream2 .forEach ((sm) -> {
sm.forEach(System.out::println);
}) ;
System .out .println ("---------------------------------------------" ) ;
Stream <Character > stream3 = strList .stream ()
.flatMap (TestStreamAPI1::filterCharacter) ;
stream3 .forEach (System.out::println) ;
}
public static Stream <Character > filterCharacter (String str) {
List <Character > list = new ArrayList <>() ;
for (Character ch : str.toCharArray()) {
list .add (ch) ;
}
return list .stream () ;
}
/*
sorted () ——自然排序
sorted (Comparator com) ——定制排序
*/
@Test
public void test2 () {
emps .stream ()
.map (Employee::getName)
.sorted ()
.forEach (System.out::println) ;
System .out .println ("------------------------------------" ) ;
emps .stream ()
.sorted ((x, y) -> {
if (x.getAge() == y.getAge()){
return x.getName().compareTo(y.getName());
}else {
return Integer.compare(x.getAge(), y.getAge());
}
}) .forEach (System.out::println) ;
}
}
package com.atguigu.java8;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;
import org.junit.Test;
import com.atguigu.java8.Employee.Status;
/*
* 一、 Stream 的操作步骤
*
* 1. 创建 Stream
*
* 2. 中间操作
*
* 3. 终止操作
*/
public class TestStreamAPI2 {
List<Employee> emps = Arrays.asList(
new Employee(102 , "李四" , 59 , 6666.66 , Status.BUSY),
new Employee(101 , "张三" , 18 , 9999.99 , Status.FREE),
new Employee(103 , "王五" , 28 , 3333.33 , Status.VOCATION),
new Employee(104 , "赵六" , 8 , 7777.77 , Status.BUSY),
new Employee(104 , "赵六" , 8 , 7777.77 , Status.FREE),
new Employee(104 , "赵六" , 8 , 7777.77 , Status.FREE),
new Employee(105 , "田七" , 38 , 5555.55 , Status.BUSY)
);
// 3. 终止操作
/*
allMatch——检查是否匹配所有元素
anyMatch——检查是否至少匹配一个元素
noneMatch——检查是否没有匹配的元素
findFirst——返回第一个元素
findAny——返回当前流中的任意元素
count——返回流中元素的总个数
max——返回流中最大值
min——返回流中最小值
*/
@Test
public void test1(){
boolean bl = emps.stream()
.allMatch((e) -> e.getStatus().equals(Status.BUSY)) ;
System .out .println (bl) ;
boolean bl1 = emps .stream ()
.anyMatch ((e) -> e.getStatus().equals(Status.BUSY)) ;
System .out .println (bl1) ;
boolean bl2 = emps .stream ()
.noneMatch ((e) -> e.getStatus().equals(Status.BUSY)) ;
System .out .println (bl2) ;
}
@Test
public void test2 () {
Optional <Employee > op = emps .stream ()
.sorted ((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
.findFirst () ;
System .out .println (op.get()) ;
System .out .println ("--------------------------------" ) ;
Optional <Employee > op2 = emps .parallelStream ()
.filter ((e) -> e.getStatus().equals(Status.FREE))
.findAny () ;
System .out .println (op2.get()) ;
}
@Test
public void test3 () {
long count = emps .stream ()
.filter ((e) -> e.getStatus().equals(Status.FREE))
.count () ;
System .out .println (count) ;
Optional <Double > op = emps .stream ()
.map (Employee::getSalary)
.max (Double::compare) ;
System .out .println (op.get()) ;
Optional <Employee > op2 = emps .stream ()
.min ((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())) ;
System .out .println (op2.get()) ;
}
//注意:流进行了终止操作后,不能再次使用
@Test
public void test4 () {
Stream <Employee > stream = emps .stream ()
.filter ((e) -> e.getStatus().equals(Status.FREE)) ;
long count = stream .count () ;
stream .map (Employee::getSalary)
.max (Double::compare) ;
}
}
package com.atguigu.java8;
import java.util.Arrays;
import java.util.DoubleSummaryStatistics;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import org.junit.Test;
import com.atguigu.java8.Employee.Status;
public class TestStreamAPI3 {
List<Employee> emps = Arrays.asList(
new Employee(102 , "李四" , 79 , 6666.66 , Status.BUSY),
new Employee(101 , "张三" , 18 , 9999.99 , Status.FREE),
new Employee(103 , "王五" , 28 , 3333.33 , Status.VOCATION),
new Employee(104 , "赵六" , 8 , 7777.77 , Status.BUSY),
new Employee(104 , "赵六" , 8 , 7777.77 , Status.FREE),
new Employee(104 , "赵六" , 8 , 7777.77 , Status.FREE),
new Employee(105 , "田七" , 38 , 5555.55 , Status.BUSY)
);
// 3. 终止操作
/*
归约
reduce(T identity, BinaryOperator) / reduce(BinaryOperator) ——可以将流中元素反复结合起来,得到一个值。
*/
@Test
public void test1(){
List<Integer> list = Arrays.asList(1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10 );
Integer sum = list.stream()
.reduce(0 , (x, y) -> x + y) ;
System .out .println (sum) ;
System .out .println ("----------------------------------------" ) ;
Optional <Double > op = emps .stream ()
.map (Employee::getSalary)
.reduce (Double::sum) ;
System .out .println (op.get()) ;
}
//需求:搜索名字中 “六” 出现的次数
@Test
public void test2 () {
Optional <Integer > sum = emps .stream ()
.map (Employee::getName)
.flatMap (TestStreamAPI1::filterCharacter)
.map ((ch) -> {
if (ch.equals('六' ))
return 1 ;
else
return 0 ;
}) .reduce (Integer::sum) ;
System .out .println (sum.get()) ;
}
//collect ——将流转换为其他形式。接收一个 Collector 接口的实现,用于给Stream 中元素做汇总的方法
@Test
public void test3 () {
List <String > list = emps .stream ()
.map (Employee::getName)
.collect (Collectors.toList()) ;
list .forEach (System.out::println) ;
System .out .println ("----------------------------------" ) ;
Set <String > set = emps .stream ()
.map (Employee::getName)
.collect (Collectors.toSet()) ;
set .forEach (System.out::println) ;
System .out .println ("----------------------------------" ) ;
HashSet <String > hs = emps .stream ()
.map (Employee::getName)
.collect (Collectors.toCollection(HashSet::new )) ;
hs .forEach (System.out::println) ;
}
@Test
public void test4 () {
Optional <Double > max = emps .stream ()
.map (Employee::getSalary)
.collect (Collectors.maxBy(Double::compare)) ;
System .out .println (max.get()) ;
Optional <Employee > op = emps .stream ()
.collect (Collectors.minBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))) ;
System .out .println (op.get()) ;
Double sum = emps .stream ()
.collect (Collectors.summingDouble(Employee::getSalary)) ;
System .out .println (sum) ;
Double avg = emps .stream ()
.collect (Collectors.averagingDouble(Employee::getSalary)) ;
System .out .println (avg) ;
Long count = emps .stream ()
.collect (Collectors.counting()) ;
System .out .println (count) ;
System .out .println ("--------------------------------------------" ) ;
DoubleSummaryStatistics dss = emps .stream ()
.collect (Collectors.summarizingDouble(Employee::getSalary)) ;
System .out .println (dss.getMax()) ;
}
//分组
@Test
public void test5 () {
Map <Status , List <Employee >> map = emps .stream ()
.collect (Collectors.groupingBy(Employee::getStatus)) ;
System .out .println (map) ;
}
//多级分组
@Test
public void test6 () {
Map <Status , Map <String , List <Employee >>> map = emps .stream ()
.collect (Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {
if (e.getAge() >= 60 )
return "老年" ;
else if (e.getAge() >= 35 )
return "中年" ;
else
return "成年" ;
}))) ;
System .out .println (map) ;
}
//分区
@Test
public void test7 () {
Map <Boolean , List <Employee >> map = emps .stream ()
.collect (Collectors.partitioningBy((e) -> e.getSalary() >= 5000 )) ;
System .out .println (map) ;
}
//
@Test
public void test8 () {
String str = emps .stream ()
.map (Employee::getName)
.collect (Collectors.joining("," , "----" , "----" )) ;
System .out .println (str) ;
}
@Test
public void test9 () {
Optional <Double > sum = emps .stream ()
.map (Employee::getSalary)
.collect (Collectors.reducing(Double::sum)) ;
System .out .println (sum.get()) ;
}
}