List 集合 分组，求和，排序，打乱顺序

List 集合 分组，求和，排序

已扑克牌为例

import lombok.Data;

/**
 * <p>
 *  扑克牌对象
 * </p>
 */
@Data
public class OnePoker {
    /**
     * 0;红 1；黑
     */
    private Integer color;

    /**
     * 花色 0；红桃 1；方片 2；黑桃 3；梅花 -1;无
     */
    private Integer design;
    /**
     * 名字
     */
    private String name;
    /**
     * 数值
     */
    private Integer num;

    public OnePoker() {
    }
    
    @Override
    public String toString() {
        String s = "";
        switch (design){
            case -1:
                if (color == 0){
                    s = "大王";
                }else {
                    s = "小王";
                }
                break;
            case 0:
                s = "红桃" + name;
                break;
            case 1:
                s = "方块" + name;
                break;
            case 2:
                s = "黑桃" + name;
                break;
            case 3:
                s = "梅花" + name;
                break;
            default:
                break;
        }
        return s;
    }
}

分组

		//得到一副打乱循序的牌 自定义的方法 见下打乱顺序
        List<OnePoker> ps = ArrangementPoker.getNewPoker();
        /**
         * 分组 按数值和颜色分组
          */
        Map<String, List<OnePoker>> collect = ps.stream().collect(Collectors.groupingBy(
                a -> a.getNum() + "-" + a.getColor() + "-" + a.toString()
        ));
        for(String key:collect.keySet()){
            System.out.println(key+":" +collect.get(key).size());
            System.out.println(collect.get(key));
       }

求和

		//取两位，方便确认
		ps = ps.subList(0,2);
        System.out.println("ps = " + ps);
        /**
         * 字段求和
         */
        Integer sum = ps.stream().map(OnePoker::getNum).reduce(0,Integer::sum);
        System.out.println("sum = " + sum);

排序（齐牌）

public static List<OnePoker> alignment(List<OnePoker> ps) throws InterruptedException {
        System.out.println("齐牌中。。。。。。。。。。");
        List<OnePoker> list = new ArrayList<>();
        for (OnePoker onePoker : ps) {
        	// 因为0为鬼牌，先选出鬼牌放在最前面
            if (onePoker.getNum() == 0){
                list.add(onePoker);
                ps.remove(onePoker);
            }
        }
        //先根据 数值，再根据花色排序
        ps = 	list.stream().sorted(Comparator.comparing(OnePoker::getNum).reversed().thenComparing(OnePoker::getDesign)).collect(Collectors.toList());
        // 只根据颜色排序
        list = ps.stream().sorted(Comparator.comparing(OnePoker::getColor)).collect(Collectors.toList());
        list.addAll(ps);
        Thread.sleep(100);
        System.out.println("齐牌结束。。。。。。。。。。");
        return list;
    }

打乱循序（洗牌）

	public static List<OnePoker> getNewPoker(){
        List<OnePoker> ps = new ArrayList();
        // Poker 为扑克 枚举类 获得一副新牌
        for (Poker p : Poker.values()) {
            ps.add(new OnePoker(p.getColor(),p.getDesign(),p.getName(),p.getNum()));
        }
        //乱序 操作
        Collections.shuffle(ps);
        return ps;
    }

集合去重

通过set去重
List<OnePoker> ps = new ArrayList();
        // Poker 为扑克 枚举类 获得两副牌
  		for(i=0;i<2;i++){
  			for (Poker p : Poker.values()) {
            	ps.add(new OnePoker(p.getColor(),p.getDesign(),p.getName(),p.getNum()));
        	}
  		}
        Set<OnePoker> set = new HashSet<>(ps );
            ps = new ArrayList<>(set );

更具条件去重

List<OnePoker> ps = new ArrayList();
        // Poker 为扑克 枚举类 获得两副牌
  		for(i=0;i<2;i++){
  			for (Poker p : Poker.values()) {
            	ps.add(new OnePoker(p.getColor(),p.getDesign(),p.getName(),p.getNum()));
        	}
  		}
  //根据花色去重
ps = ps .stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(OnePoker:: getColor))), ArrayList::new));