stream的学习

stream的学习

	应用场景：当你需要从数据库查询出某些数据的时候，不应该是在for循环里一遍一遍去查询数据库，
			而是提取出for循环中的所有条件组成一个集合去一次性把数据库中满足条件的数据全部查出来，放到内存中来做比对，
			可以利用下面的知识点得出你想要的结果，这样数据库的性能得到优化，并且查询的速度更快。

1、从一个数组中筛选出符合条件的对象

DpQuotationUnitPrice dpQuotationUnitPrice = dpUnitPrices.stream().filter(dpPrice -> 
		dpPrice.getCustomerNo().equals("") && 
		dpPrice.getDpTypeNo().equals(dpOrder.getDpTypeNo()) &&
		dpPrice.getDpHandleNo().equals("") &&
		dpPrice.getDpColorNo().equals("")).findFirst().orElse(null);
		if(dpQuotationUnitPrice != null) {
			return dpQuotationUnitPrice.getUnitPrice();
        }

2、从一个数组中筛选出符合条件的数组

List<DpOrderResult> dpSplitResultOfHandles = 		dpOrder.getDpOrderElements().stream().flatMap(ele -> 			ele.getDpOrderResults().stream()).filter(result -> result.getDpSplitResultType() == DpSplitResultType.HANDLE.getIndex()).collect(Collectors.toList());

3、从一个对象数组中抽取该对象的某一个字段重新生成一个新的集合

Set<String> allHandleItemNos = dpOrder.getDpOrderElements().stream().map(DpOrderElement::getDpHandleItemNo).collect(Collectors.toSet());

4、将一个List<Object[]>转成一个list<对象>

应用场景：在sql语句只查询一个对象的某几个字段时使用

SQL语句:只查询itemNo,UnitPrice两个字段
@Query("select i.itemNo,i.quotationUnitPrice from ItemMaster i where i.itemNo in :itemNos")
	List<Object[]> getAllGeneralDpHandleUnitPrices(@Param(value = "itemNos") Set<String> itemNos);
	
Service层：
private List<ItemMaster> genItemMastersWithDpHandleUnitPrice(Set<String> allDPHandleItemNos) {
		List<Object[]> allGeneralDpHandleUnitPrices = itemMasterRepository.getAllGeneralDpHandleUnitPrices(allDPHandleItemNos);
		return allGeneralDpHandleUnitPrices.stream().map(item -> genItemMasterWithDpHandleUnitPrice(item)).collect(Collectors.toList());
	}
	
private ItemMaster genItemMasterWithDpHandleUnitPrice(Object[] itemObject) {
        ItemMaster itemMaster = new ItemMaster();
        if(itemObject != null) {
        itemMaster.setItemNo(itemObject[0].toString());
        itemMaster.setQuotationUnitPrice((float)itemObject[1]);
    }
    return itemMaster;
}

5、遍历某一个对象集合，将该集合中每一个对象的字段内容赋值到一个用来构建新对象的函数中，最终结果返回新对象的集合

/*
	遍历dpOrder.getDpOrderElements()的所有明细，用每一项明细中的内容去赋值给构建DpQuotationOrderElement对象的函数，返回DpQuotationOrderElement对象，再使用.collect(Collectors.toList())生成 List<DpQuotationOrderElement>集合。
	构建对象函数中的被注释的方法可以根据自己的实际需求书写，在这里只给出大概的架子，先看明白，之后里面内容自己填写。
*/
private List<DpQuotationOrderElement> createDpQuotationOrderElements(DpOrder dpOrder, QuotationRemarkParameter remarkParameterConfig) {
		List<DpQuotationOrderElement> dpQuotationOrderElements = dpOrder.getDpOrderElements().stream().map(orderEle -> createDpQuotationOrderElement(dpOrder, orderEle, remarkParameterConfig)).collect(Collectors.toList());
		return dpQuotationOrderElements;
	}
	
private DpQuotationOrderElement createDpQuotationOrderElement(DpOrder dpOrder, DpOrderElement orderEle, QuotationRemarkParameter remarkParameterConfig) {
		DpQuotationOrderElement dpQuotationOrderElement = new DpQuotationOrderElement();
		/*setDpQuoOrderEleFirstHalf(orderEle, dpQuotationOrderElement);
		setDpQuoOrderEleAmount(dpOrder, orderEle, remarkParameterConfig, dpQuotationOrderElement);*/
		return dpQuotationOrderElement;
	}

6、遍历DpOrder对象中的dpOrderElements集合，使用flatMap来使dpOrderElements对象中的dpOrderResults集合扁平化，变成一个DpOrderResult集合输出，可以再对该DpOrderResult集合进行筛选，得到想要的数据

public class DpOrder {
    @ElementCollection(fetch = FetchType.LAZY)
	private List<DpOrderElement> dpOrderElements;
}

public class DpOrderElement {
    @ElementCollection(fetch = FetchType.LAZY)
	private List<DpOrderResult> dpOrderResults;
}

public class DpOrderResult {
    private int dpSplitResultType;
}

List<DpOrderResult> handleDpOrderResults = dpOrder.getDpOrderElements().stream().flatMap(ele -> ele.getDpOrderResults().stream()).filter(result -> result.getDpSplitResultType() == DpSplitResultType.HANDLE.getIndex()).collect(Collectors.toList());

7、对某一个对象集合中的数字字段进行求和

/*使用summingDouble关键字*/
float subDpArea = dpQuotationOrderElements.stream().collect(Collectors.summingDouble(DpQuotationOrderElement::getDpArea)).floatValue();

8、使用groupingBy可以进行分组求和，用来合并某些相同内容的对象

/*
	因为groupingBy可以根据多个字段进行分组，但是当字段过多时，可以创建一个分组类用于分组。就拿本案例来说，使用GeneralDpPpOrderDatailGroup分组类对GeneralDpPpOrderDetail对象集合根据分组类中构造器的字段进行分组，分完组后是一个map<分组类，List<被分组对象>>的集合，可以再次使用.map来遍历该集合，对每组中的list集合做进一步操作，比如求和，因为list集合中的每个对象是根据分组类来分组的，那么根据分组类分组的那几个字段的内容是相同的，可以把不相同的字段进行其他操作，比如对数量字段进行遍历求和。
*/
public class GeneralDpPpOrderDatailGroup {
	public GeneralDpPpOrderDatailGroup(GeneralDpPpOrderDetail generalDpPpOrderDetail) {
		this.dPNo = generalDpPpOrderDetail.getdPNo();
		this.dpColorNo = generalDpPpOrderDetail.getDpColorNo();
		this.dpWidth = generalDpPpOrderDetail.getDpWidth();
		this.dpHeight = generalDpPpOrderDetail.getDpHeight();
		this.openDoorWayNo = generalDpPpOrderDetail.getOpenDoorWayNo();
		this.dpHandleItemNo = generalDpPpOrderDetail.getDpHandleItemNo();
		this.handleFixWay = generalDpPpOrderDetail.getHandleFixWay();
		this.hingePosition = generalDpPpOrderDetail.getHingePosition();
		this.dpBorderItemNo = generalDpPpOrderDetail.getDpBorderItemNo();
		this.backPanelItemNo = generalDpPpOrderDetail.getBackPanelItemNo();
		this.remark = generalDpPpOrderDetail.getRemark();
		this.dpColorWidth = generalDpPpOrderDetail.getDpColorWidth();
		this.dpColorHeight = generalDpPpOrderDetail.getDpColorHeight();
		this.borderWidth = generalDpPpOrderDetail.getBorderWidth();
		this.borderHeight = generalDpPpOrderDetail.getBorderHeight();
		this.backPanelWidth = generalDpPpOrderDetail.getBackPanelWidth();
		this.backPanelHeight = generalDpPpOrderDetail.getBackPanelHeight();
		this.handleLength = generalDpPpOrderDetail.getHandleLength();
	}    
}

private void setGeneralDpPpOrderDetail(DpOrder dpOrder,GeneralDpPpOrder generalDpPpOrder) {
		List<GeneralDpPpOrderDetail> groupedDpPpDetails = 	dpOrder.getDpOrderElements().stream().map(element -> genDpPpDetailOfNoGroup(element, dpOrder.getBackPanelItemNo()))				.collect(Collectors.groupingBy(GeneralDpPpOrderDatailGroup::new)).entrySet().stream()
.map(entry -> genDpPpOrderDetail(entry)).collect(Collectors.toList());
		generalDpPpOrder.setGeneralDpPpOrderDetails(groupedDpPpDetails);
}

private GeneralDpPpOrderDetail genDpPpOrderDetail(
    Entry<GeneralDpPpOrderDatailGroup, List<GeneralDpPpOrderDetail>> entry) {
    GeneralDpPpOrderDetail detail = new GeneralDpPpOrderDetail();
    if (entry.getValue() != null && entry.getValue().size() > 0) {
        setGeneralDpPpOrderSumField(entry.getValue(), detail);
    }
    return detail;
}

	private void setGeneralDpPpOrderSumField(List<GeneralDpPpOrderDetail> generalDpPpOrderDetails,
			GeneralDpPpOrderDetail generalDpPpOrderDetail) {
		float totalArea = 0;
		int totalNumber = 0;
		for (GeneralDpPpOrderDetail generalDetail : generalDpPpOrderDetails) {
			totalArea += generalDetail.getDpWidth() * generalDetail.getDpHeight() * generalDetail.getDpQty() / 1000000;
			totalNumber += generalDetail.getDpQty();
		}
		GeneralDpPpOrder generalDpPpOrder = new GeneralDpPpOrder();
		generalDpPpOrder.setTotalArea(totalArea);
		generalDpPpOrder.setTotalNumber(totalNumber);

}

9、根据对象中的某个字段对该对象集合进行排序

/*
	下面这个案例是根据DpQuotationOrderElement中的数量字段，根据数量的大小对List<DpQuotationOrderElement>进行升序排序。
*/
List<DpQuotationOrderElement> dpQuotationOrderElements = dpQuotationOrderElements.stream().sorted(Comparator.comparing(DpQuotationOrderElement::getDpQty)).collect(Collectors.toList());

/*
	降序排列，在后面添加.reversed()。
*/
List<DpQuotationOrderElement> dpQuotationOrderElements = dpQuotationOrderElements.stream().sorted(Comparator.comparing(DpQuotationOrderElement::getDpQty).reversed()).collect(Collectors.toList());

10、遍历某个集合

/*使用foreach关键字*/
dpQuotationOrderElements.forEach(ele -> System.out.println(ele.getDpQty()));

11、过滤集合中相同元素

/*使用distinct关键字*/
List<DpQuotationOrderElement> distinctElements = dpQuotationOrderElements.stream().distinct().collect(Collectors.toList());

12、比较对象的某个字段从集合中找出最大值/最小值的对象

/*找出数量最多的对象，使用max关键字*/
DpQuotationOrderElement dpQuotationOrderElement = dpQuotationOrderElements.stream().max(Comparator.comparing(DpQuotationOrderElement::getDpQty)).get();

/*找出数量最少的对象，使用min关键字*/
DpQuotationOrderElement dpQuotationOrderElement = dpQuotationOrderElements.stream().min(Comparator.comparing(DpQuotationOrderElement::getDpQty)).get();

13、对某一个对象集合中的数字字段取平均值

/*使用averagingInt关键字*/
float avgQty = dpQuotationOrderElements.stream().collect(Collectors.averagingInt(DpQuotationOrderElement::getDpQty)).floatValue();