stream() 应用

/**
     * @ClassName: MyListDemo
     * @Description: TODO(这里用一句话描述这个类的作用)
     * @author dongwei_qi
     * @date 2020-10-13
     *
     */

public class MyListDemo {
	
	public static void main(String[] args) {
		List<BigDecimal> lis = new ArrayList<BigDecimal>();
		lis.add(new BigDecimal(123.23));
		lis.add(new BigDecimal(12.1));
		lis.add(new BigDecimal(122.2));
		lis.add(new BigDecimal(3.23));
		lis.add(new BigDecimal(23.23));
//		BigDecimal 计算
		BigDecimal nu = lis.stream().reduce(BigDecimal.ZERO, BigDecimal :: add);
		System.out.println("BigDecimal : " + nu);
		List<Double> list = new ArrayList<Double>();
		list.add(12.1);
		list.add(12.2);
		list.add(12.3);
		list.add(12.4);
		Optional<Double> num = list.stream().reduce((x,y)->x+y);
//		基本数字类型计算
		Double sum2=list.stream().reduce((double) 0,(x,y)->x+y);
		System.out.println("double : " + num);
		System.out.println(sum2);
		
		List<String> lists = new ArrayList<>();
		lists.add("ddd");
		lists.add("aaa");
		lists.add("bbb");
		lists.add("nnn");
		lists.add("ddd");
//		遍历
		lists.forEach(e -> {
			System.out.println("遍历 ： " + e);
		});
		// 去重
		List<String> aa = lists.stream().distinct().collect(Collectors.toList());	
		System.out.println("去重：" + aa.toString());
//		排序
		List<String> sa = lists.stream().sorted().collect(Collectors.toList());
		System.out.println("排序：" + sa.toString());
//		转大写           
		List<String> ss = lists.stream().map(String::toUpperCase).collect(Collectors.toCollection(ArrayList::new));
		System.out.println("转大写：" + ss.toString());
		
		List<User> li = new ArrayList<>();
		li.add(new User("123", 321.0));
		li.add(new User("3", 321.1));
		li.add(new User("23", 321.2));
		double NUM = li.stream().map(User :: getNum).reduce(0.0, (X,Y) -> (X + Y));
	     System.out.println("实体类属性计算：" + NUM);
	     
	    List<Double> numList = li.stream().map(User :: getNum).collect(Collectors.toList());
	    System.out.println("得到user中num属性集合"+ numList.toString());
	    
	    Map<String,Object> maps = li.stream().collect(Collectors.toMap(User :: getKey, User :: getNum));
	    System.out.println("list转map值为某个属性： " + maps.toString());
	    
	    Map<String,Object> maps1 = li.stream().collect(Collectors.toMap(User :: getKey, user -> user));
	    System.out.println("list转map值为实体类： " + maps1.toString());
	    
	    List<Map<String,Object>> l = new ArrayList<>();
	    Map<String,Object> ma = new HashMap<String, Object>();
	    ma.put("123", 321);
	    Map<String,Object> ma1 = new HashMap<String, Object>();
	    ma1.put("123", 21);
	    Map<String,Object> ma2 = new HashMap<String, Object>();
	    ma2.put("123", 1);
	    Collections.addAll(l, ma,ma1,ma2);
	    
//	    l.stream().map(str -> str.get("123"));
//	    取某个key 值为键，当前map为值得到新集合
	    Map<Object, Object> ls = l.stream().collect(Collectors.toMap( map -> map.get("123"),key -> key));
	    System.out.println("list集合得到一个新的map: " + ls.toString());
//    根据实体类某个值去重得到信息list
		List<User> lt = new ArrayList<User>();
		lt.add(new User("1", 23.9));
		lt.add(new User("1", 22.9));
		lt.add(new User("2", 23.8));
		lt.add(new User("3", 23.1));
		List<User> unilt = lt.stream().collect(Collectors.collectingAndThen(
				Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(User::getKey))), ArrayList::new));
		System.out.println("根据实体类中的某个值进行去重：" + unilt.toString());
		//		条件过滤
		List lsd = lt.stream().filter(user -> user.getKey().equals("1")).collect(Collectors.toList());
		System.out.println(lsd.toString());
		// 多条件过滤
				
		long count = lt .stream().filter( e-> e.getKey().equals("1")).filter(e -> e.getNum() == 23.9).count();
		System.out.print(count);
		
		Map<String,Double> map = new HashMap<>();
        map.put("1_U",1.1);
        map.put("5_U",1.5);
        map.put("2_U",1.2);
        map.put("3_U",1.3);
        map.put("4_U",1.4);
        // 取值最大
        Optional<Double> value = map.values().stream().max(Comparator.comparing(Double::doubleValue));
        Double v = value.get();
        System.out.println(v);
        // 取值最小的
        Optional<Double> ma = map.entrySet().stream().map(k -> k.getValue()).min(Comparator.comparing(Double::doubleValue));
        System.out.println(ma.get());
        // 根据最大的值返回key
        Optional<Map.Entry<String, Double>> m = map.entrySet().stream().filter(k -> k.getValue() == v).findAny();
        System.out.println(m.get().getKey());
    }

	}

}

    /**  
     * @Title: User.java
     * @Package javaDemo.threadLocal
     * @Description: TODO(用一句话描述该文件做什么)
     * @author dongwei_qi
     * @date 2020-10-13 10:29:10 
     * @version V1.0  
     */
    
package javaDemo.threadLocal;


    /**
     * @ClassName: User
     * @Description: TODO(这里用一句话描述这个类的作用)
     * @author dongwei_qi
     * @date 2020-10-13
     *
     */

public class User {

	private String key;
	
	private Double num;
	
	public User(String key,Double num) {
		this.key = key;
		this.num = num;
	}

	
	/**
	 * @return key
	 */
	
	public String getKey() {
		return key;
	}

	
	/**
	 * @param paramtheparamthe{bare_field_name} to set
	 */
	
	public void setKey(String key) {
		this.key = key;
	}

	
	/**
	 * @return num
	 */
	
	public Double getNum() {
		return num;
	}

	
	/**
	 * @param paramtheparamthe{bare_field_name} to set
	 */
	
	public void setNum(Double num) {
		this.num = num;
	}


	@Override
	public String toString() {
		return "User [key=" + key + ", num=" + num + "]";
	}
	
	
}