溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本篇內容主要講解“怎么使用Java工具類實現高效編寫報表”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“怎么使用Java工具類實現高效編寫報表”吧!
對于報表數據大部分情況下使用寫sql的方式為大屏/報表提供數據來源，但是對于某些復雜情況下僅僅使用sql無法實現，或者實現起來困難的時候，會采取通過代碼實現復雜的邏輯最終將結果返回。
對于相對復雜的報表，經常需要做數據的連接即表與表的join，分組，計算等操作。sql天然支持這些操作，實現起來很輕松。但是當我們在java代碼中需要對數據進行連接時，原生支持的就并不那么友好，我們常常會這么實現
現在有兩個集合
List<ContractDetail> contractDetails; // 合同明細集合，合同會重復 List<ContractInfo> contractInfos; // 合同主要信息，不會有重復合同
對應數據結構
public class ContractDetail {
/**
* 合同編號
*/
private String contractNo;
/**
* 總金額
*/
private BigDecimal moneyTotal;
}
public class ContractInfo {
/**
* 合同編號
*/
private String contractNo;
/**
* 狀態
*/
private String status;
}需求
contractDetails 根據 contractNo關聯 contractInfos，過濾出status = '已簽訂’的數據
再根據 contractDetails 中的contractNo分組，分別求每個 contractNo對應的moneyTotal之和
最終輸出的應該為一個map
Map<String /* 合同編碼 */, BigDecimal /* 對應moneyTotal之和 */> result;
通常我們會這么實現
// setp 1 過濾出 已簽訂狀態的合同編碼
Set<String> stopContract = contractInfos.stream()
.filter(it -> "已簽訂".equals(it.getStatus()))
.map(ContractInfo::getContractNo).collect(Collectors.toSet());
//step2 根據 step1的合同編碼集合過濾出狀態正確的contractDetail
contractDetails = contractDetails.stream()
.filter(it -> stopContract.contains(it.getContractNo()))
.collect(Collectors.toList());
//step3 根據contractNo分別累加對應的moneyTotal
Map<String, BigDecimal> result = new HashMap<>();
contractDetails.stream().forEach(it -> {
BigDecimal moneyTotal = Optional.ofNullable(result.get(it.getContractNo()))
.orElse(BigDecimal.ZERO);
moneyTotal = moneyTotal.add(it.getMoneyTotal() != null ? it.getMoneyTotal() : BigDecimal.ZERO);
result.put(it.getContractNo(), moneyTotal);
});顯然這個實現時比較復雜的，因為使用sql的話無非就是 join 連接之后加上group by分組。求和。就可以輕易解決這個問題。那么看看后面這個工具類，再思考有沒有更簡單的辦法實現。
集合數據流CollectionDataStream的功能是通過接口對集合之間做關聯，實現了類似sql join和left join兩個操作
并且實現和java中的Stream相互轉換的功能。
聚合數據結構將集合轉換成類似表結構的數據結構，包含表名，數據
public class AggregationData {
Map<String, Map> aggregationMap;
private AggregationData(){
aggregationMap = new HashMap<>();
}
//key 為別名，value為對應對象
public AggregationData(String tableName, Object data) {
aggregationMap = new HashMap<>();
aggregationMap.put(tableName, BeanUtil.beanToMap(data));
}
public Map<String, Map> getRowAllData() {
return aggregationMap;
}
public Map getTableData(String tableName) {
if (!aggregationMap.containsKey(tableName)) {
throw new DataStreamException(tableName + ".not.exists");
}
return aggregationMap.get(tableName);
}
public void setTableData(String tableName, Object data) {
if(aggregationMap.containsKey(tableName)){
throw new DataStreamException(tableName+".has.been.exists!");
}
aggregationMap.put(tableName, BeanUtil.beanToMap(data));
}
private void setTableData(String tableName, Map<String, Object> data) {
Map<String, Object> tableData =
Optional.ofNullable(aggregationMap.get(tableName)).orElse(new HashMap<String, Object>());
tableData.putAll(data);
aggregationMap.put(tableName, tableData);
}
public AggregationData copyAggregationData() {
AggregationData aggregationData = new AggregationData();
for (String tableName : this.getRowAllData().keySet()) {
aggregationData.setTableData(tableName, this.getRowAllData().get(tableName));
}
return aggregationData;
}
}AggregationData代表一行數據，aggregationMap的key為表名，value為對應的數據
來詳細看看這個接口
import java.util.Collection;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Stream;
public interface CollectionDataStream<T> {
/**
*將集合轉化為數據流，并給一個別名
* @param tableName
* @param collection
* @return
*/
static CollectionDataStream<AggregationData> of(String tableName, Collection<?> collection) {
return new CollectionDataStreamImpl(tableName, collection);
}
/**
*將 Stream轉化為數據流，并給一個別名
* @param tableName
* @param collection
* @return
*/
static CollectionDataStream<AggregationData> of(String tableName, Stream<?> collection) {
return new CollectionDataStreamImpl(tableName, collection);
}
/**
* 內連接，可自定義連接條件，使用雙循環
*
* @param tableName
* @param collection
* @param predict
* @param <T1>
* @return
*/
<T1> CollectionDataStream<T> join(String tableName, Collection<T1> collection, JoinPredicate<T, T1> predict);
/**
* 等值內連接，使用map優化
*
* @param collection
* @param tableName
* @param aggregationMapper
* @param dataValueMapper
* @param <T1>
* @param <R>
* @return
*/
//等值條件推薦用法
<T1, R> CollectionDataStream<T> joinUseHashOnEqualCondition(String tableName, Collection<T1> collection, Function<T, R> aggregationMapper, Function<T1, R> dataValueMapper);
/**
* 左連接，可自定義連接條件，使用雙循環
*
* @param tableName
* @param collection
* @param predict
* @param <T1>
* @return
*/
<T1> CollectionDataStream<T> leftJoin(String tableName, Collection<T1> collection, JoinPredicate<T, T1> predict);
/**
* 等值左連接，使用map優化
*
* @param collection
* @param tableName
* @param aggregationMapper
* @param dataValueMapper
* @param <T1>
* @param <R>
* @return
*/
<T1, R> CollectionDataStream<T> leftJoinUseHashOnEqualCondition( String tableName, Collection<T1> collection,Function<T, R> aggregationMapper, Function<T1, R> dataValueMapper);
Stream<T> toStream();
Stream<Map> toStream(String tableName);
<R> Stream<R> toStream(String tableName, Class<R> clzz);
<R> Stream<R> toStream(Function<AggregationData, R> mapper);
}注意joinUseHashOnEqualCondition和join兩個方法的區別。
如果集合之間的連接時某個字段等值連接，那么使用joinUseHashOnEqualCondition，其內部使用的是map分組之后進行連接。而直接使用join的話連接條件可自定義，但是是通過雙重循環進行條件判斷，效率較低。因此等值情況下，使用joinUseHashOnEqualCondition效率更高。
還是已上面的需求為例
先進行兩個集合之間的連接
CollectionDataStream.of("t1", contractDetails) .joinUseHashOnEqualCondition(
contractInfos.stream().filter(it -> "已簽訂".equals(it.getStatus())).collect(Collectors.toList()),
"t2",
agg -> agg.getTableData("t1").get("contractNo"),
ContractInfo::getContractNo
);代碼解析
CollectionDataStream.of("t1", contractDetails)是將集合contractDetails轉換為表名為t1的數據流，
.joinUseHashOnEqualCondition(
contractInfos.stream().filter(
"t2",
it -> "已簽訂".equals(it.getStatus())).collect(Collectors.toList()),
agg -> agg.getTableData("t1").get("contractNo"),
ContractInfo::getContractNo
);內連接contractInfos，同時給contractInfos起別名t2，連接條件是等值連接 t1的contractNo和contractInfos的contractNol連接之后得到新的聚合數據流
當然也可以使用自定義的連接實現
CollectionDataStream.of("t1", contractDetails)
.join("t2",
contractInfos.stream().filter(it -> "已簽訂".equals(it.getStatus())).collect(Collectors.toList()),
(agg, data) -> agg.getTableData("t1").get("contractNo").equals(data.getContractNo())
)這里通過內連接，那么也起到了一個過濾的作用。連接完成之后我們還要分組進行計算，那么就需要用到下一個工具類
是對stram中原生Collectors的一個擴展，實現了更多做報表常用分組的一些操作，
MyCollectorspackage collector;
import utils.NumberUtil;
import java.math.BigDecimal;
import java.util.Comparator;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collector;
import java.util.stream.Collectors;
public class MyCollectors {
/**
* 返回一個Collector用于對集合進行分組并且，對于組內有多個元素，只返回最后一個，其他的忽略
* 適用于明確分組key唯一的情況，value可為空
* 謹慎使用，如果分組有多條，會丟失數據！！！
* @param keyMapper
* @param <T>
* @param <K>
* @param <U>
* @param <M>
* @return
*/
public static <T, K, U, M extends Map<K, U>>
Collector<T, ?, Map<K, U>> groupingByLast(Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper) {
return Collectors.groupingBy(keyMapper, Collectors.reducing(null, valueMapper, (o1, o2) -> o2));
}
/**
* 傳入一個keyMaper和一個比較器
* 根據key分組，組內使用比較器進行比較，最終得到一個最大結果
* @param keyMapper
* @param comparator
* @param <T>
* @param <K>
* @param <U>
* @param <M>
* @return
*/
public static <T, K, U, M extends Map<K, U>>
Collector<T, ?, Map<K, T>> groupingByMaxComparator(Function<? super T, ? extends K> keyMapper,
Comparator<T> comparator) {
return Collectors.groupingBy(keyMapper, Collectors.collectingAndThen(Collectors.maxBy(comparator), it -> it.orElse(null)));
}
/**
* 傳入一個keyMaper和一個比較器
* 根據key分組，組內使用比較器進行比較，最終得到一個最小結果
* @param keyMapper
* @param comparator
* @param <T>
* @param <K>
* @param <U>
* @param <M>
* @return
*/
public static <T, K, U, M extends Map<K, U>>
Collector<T, ?, Map<K, T>> groupingByMinComparator(Function<? super T, ? extends K> keyMapper,
Comparator<T> comparator) {
return Collectors.groupingBy(keyMapper, Collectors.collectingAndThen(Collectors.maxBy(comparator), it -> it.orElse(null)));
}
/**
* 分組后組內按照指定字段求和
* @param keyMapper
* @param <T>
* @param <K>
* @return
*/
public static <T, K>
Collector<T, ?, Map<K, BigDecimal>> groupingAndSum(Function<? super T, ? extends K> keyMapper,
Function<? super T, BigDecimal> valueMapper) {
return Collectors.groupingBy(keyMapper, Collectors.reducing(BigDecimal.ZERO, valueMapper, NumberUtil::addNumbers));
}
/**
* 根據對象某個字段進行求和
* @param mapper
* @param <T>
* @return
*/
public static <T>
Collector<T, ?, BigDecimal> sumByField(Function<? super T, ? extends BigDecimal> mapper) {
return Collectors.reducing(BigDecimal.ZERO, mapper, NumberUtil::addNumbers);
}
/**
* 求和
*/
public static Collector<BigDecimal, ?, BigDecimal> sum() {
return Collectors.reducing(BigDecimal.ZERO, NumberUtil::addNumbers);
}
} Map<String /* 合同變么 */, BigDecimal /* 對應moneyTotal之和 */> result = CollectionDataStream.of("t1", contractDetails)
.joinUseHashOnEqualCondition(
contractInfos.stream().filter(it -> "60".equals(it.getStatus())).collect(Collectors.toList()),
"t2",
agg -> agg.getTableData("t1").get("contractNo"),
ContractInfo::getContractNo
).toStream("s1", ContractDetail.class)//將數據流轉換為 java原生Stream
.collect(MyCollectors.groupingAndSum(ContractDetail::getContractNo, ContractDetail::getMoneyTotal));這樣的實現顯然更加簡單，也減少了出錯的的概率，減少了代碼量，提升了效率。
實現了集合之間的連接操作，并且是流式操作，可以一口氣不斷連接多個集合。
實現了與Stream之間的相互轉換。利用stream的功能可以實現各種復雜操作，例如過濾，轉換，分組等。
效率上有一定的保證，對于等值連接采用了Map優化，并且在內連接時，考慮使用后小表連大表進行優化，在一些情況下減少循環次數，在bean轉換為行聚合數據時使用cglib下的BeanMap減少內存的占用和性能的消耗
到此，相信大家對“怎么使用Java工具類實現高效編寫報表”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
