java SteamAPI练习（流的创建、流的操作、流的终止）

练习题一

给定一个数字列表，如何返回一个由每个数的平方构成的列表呢？
，给定【1，2，3，4，5】， 应该返回【1，4，9，16，25】

public class Problem1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<Integer> list1 = Arrays.asList(1,2,3,4,5);
		List<Integer> list2 = list1.stream().map((x)->x*x).collect(Collectors.toList());
		System.out.println(list2);
	}

}

练习题二

交易员类Trader 属性(name、city)
交易类Transaction 属性(Trader 、year、value)

public class TestTransaction {
    List<Transaction> transaction=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");

        transaction=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年发生的所有交易，并按交易额排序(从低到高)

2、交易员都在哪些不同的城市工作过？

3、查找所有来自剑桥(Cambridge)的交易员，并按姓名排序

4、返回所有交易员的姓名字符串，按字母顺序排序

5、有没有交易员是在米兰工作的？

6、打印生活在剑桥的交易员的所有交易额

7、所有交易中，最高的交易额是多少？

8、找到交易额最小的交易

Trader类代码

public class Transaction {
	private Trader trader;
	private int year;
	private int value;
	
	public Transaction() {
		// TODO Auto-generated constructor stub
	}
	public Transaction(Trader trader, int year, int value) {
		super();
		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 + "]";
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((trader == null) ? 0 : trader.hashCode());
		result = prime * result + value;
		result = prime * result + year;
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Transaction other = (Transaction) obj;
		if (trader == null) {
			if (other.trader != null)
				return false;
		} else if (!trader.equals(other.trader))
			return false;
		if (value != other.value)
			return false;
		if (year != other.year)
			return false;
		return true;
	}
	
	
}

Transaction类代码

public class Transaction {
	private Trader trader;
	private int year;
	private int value;
	
	public Transaction() {
		// TODO Auto-generated constructor stub
	}
	public Transaction(Trader trader, int year, int value) {
		super();
		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 + "]";
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((trader == null) ? 0 : trader.hashCode());
		result = prime * result + value;
		result = prime * result + year;
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Transaction other = (Transaction) obj;
		if (trader == null) {
			if (other.trader != null)
				return false;
		} else if (!trader.equals(other.trader))
			return false;
		if (value != other.value)
			return false;
		if (year != other.year)
			return false;
		return true;
	}
	
	
}

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

import org.junit.Before;
import org.junit.Test;

public class TestTransaction {
	List<Transaction> transaction = 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");

		transaction = 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));
	}

	@Test
	public void test1() {
		transaction.stream().filter(x -> x.getYear() == 2011).sorted((x1, x2) -> {
			return x1.getValue() - x2.getValue();
		}).forEach(System.out::println);
	}

	@Test
	public void test2() {
		transaction.stream()
		.map(x -> (x.getTrader().getName() + "  " + x.getTrader().getCity()))
		.distinct()
		.forEach(System.out::println);
	}

	@Test
	public void test3() {
		transaction.stream().filter((x) -> x.getTrader().getCity() == "Cambridge")
				.map((x)->x.getTrader())
				.sorted((x1, x2) -> x1.getName().compareTo(x2.getName()))
				.distinct()
				.forEach(System.out::println);
	}
	@Test
	public void test4(){
		transaction.stream().map(x->x.getTrader().getName())
		.sorted((x1,x2)->x1.compareTo(x2))
		.distinct()
		.forEach(System.out::println);
		
	}
	@Test
	public void test5(){
		boolean b = transaction.stream().map((x)->x.getTrader().getCity())
		.distinct()
		.anyMatch((x)->x.equals("Milan"));
		System.out.println(b);
	}
	@Test
	public void test6(){
		Optional<Integer> op = transaction.stream().filter((x)->x.getTrader().getCity().equals("Cambridge"))
		.map((x)->x.getValue())
		.reduce(Integer::sum);
		System.out.println(op.get());
	}
	@Test
	public void test7(){
		Optional<Integer> mmax = transaction.stream().map((x)->x.getValue())
		.sorted((x1,x2)->-x1.compareTo(x2))
		.findFirst();
		System.out.println(mmax.get());
	}
	@Test
	public void test8(){
		Optional<Integer> mmin = transaction.stream().map((x)->x.getValue())
				.sorted()
				.findFirst();
		//System.out.println(mmin.get());
		Optional<Transaction> ot = transaction.stream().filter((x)->x.getValue()==mmin.get())
		.findFirst();
		System.out.println(ot.get());
		
	}
}