需求:
1.有一组数据集合,数据集合中的数据为动态;
举例如下:
[{province=陕西省, city=西安市}, {province=陕西省, city=咸阳市}, {province=陕西省, city=宝鸡市}, {province=陕西省, city=延安市}, {province=陕西省, city=汉中市}, {province=四川省, city=成都市}, {province=四川省, city=成都市}, {province=四川省, city=广元市}, {province=四川省, city=绵阳市}, {province=陕西省, city=西安市}, {province=陕西省, city=西安市}, {province=陕西省, city=宝鸡市}, {province=江苏省, city=南京市}, {province=江苏省, city=南京市}, {province=江苏省, city=扬州市}, {province=河北省, city=石家庄市}, {province=山东省, city=济南市}, {province=山东省, city=青岛市}, {province=山东省, city=烟台市}, {province=山东省, city=潍坊市}]
2.通过计算得出统计的数据;省按照大小排序,动态展示,城市按照大小排序,动态展示;
最终绘制如下:
备注::以下看到的函数名称大多是自定义封装的。
当前案例代码中需要用到的知识技能:
1.Set集合去重:Set hashSet = new HashSet<>();
2.Set集合转数组:String[] provinceArr = hashSet.toArray(new String[hashSet.size()]);
3.一维双数组排序:BubblSortUtils.bubbleSortDescMultiple(provinceSort,provinceArr);
4.创建集合数组(数组里面的元素为set集合):Set[] setArr = new Set[provinceArr.length];
5.创建二维数组(set集合数组转二维数组):String[][] stringArr = new String[provinceArr.length][];
6.二维数组,双数组根据第二维度排序:BubblSortUtils.bubbleSortDescMultiple2(countArr,stringArr);
7.String,Int数组间的互相转化;
8.百分比计算函数封装;
9.一维数组和二维数组组合:计算一维数组在二维中的中间位置;
10.返回数据封装:二维数组转一维数组;
需求分析:前端二级图表要求返回的最终数据格式为数组格式:
数组1:[“西安市”,“宝鸡市”,“延安市”,“咸阳市”,“汉中市”,“成都市”,“绵阳市”,“广元市”,“青岛市”,“济南市”,“烟台市”,“潍坊市”,“南京市”,扬州市",“石家庄市”]
数组2:[“3”, “2”, “1”, “1”, “1”, “2”, “1”, “1”, “1”, “1”, “1”, “1”, “2”, “1”, “1” ]
数组3:[“15.00%”,“10.00%”,“5.00%”,“5.00%”,“5.00%”,“10.00%”,“5.00%”,“5.00%”,“5.00%”,“5.00%”,“5.00%”,“5.00%”,“10.00%”,“5.00%”,“5.00%” ]
数组4:[“”, “”, “陕西省”, “”, “”, “”, “四川省”,“”, “”, “山东省”, “”, “”, “江苏省”,“”, “河北省” ]
原则:省份放数组中间,奇数为中间位,偶数左偏一位;
数组5:[“true”,“false”,“false”,“false”,“false”, “true”,“false”,“false”, “true”,“false”,“false”,“false”, “true”,“false”, “true” ]
原则:每个省城市开始为true,其余为false,前端划分数据使用;
数据分析:数据展示如下:
0:[Ljava.lang.String;@6442b0a6
二级维度城市类型和数量:西安市--3--15.00%--#--true
二级维度城市类型和数量:宝鸡市--2--10.00%--#--false
二级维度城市类型和数量:延安市--1--5.00%--陕西省--false
二级维度城市类型和数量:咸阳市--1--5.00%--#--false
二级维度城市类型和数量:汉中市--1--5.00%--#--false
1:[Ljava.lang.String;@60f82f98
二级维度城市类型和数量:成都市--2--10.00%--#--true
二级维度城市类型和数量:绵阳市--1--5.00%--四川省--false
二级维度城市类型和数量:广元市--1--5.00%--#--false
2:[Ljava.lang.String;@35f983a6
二级维度城市类型和数量:青岛市--1--5.00%--#--true
二级维度城市类型和数量:济南市--1--5.00%--山东省--false
二级维度城市类型和数量:烟台市--1--5.00%--#--false
二级维度城市类型和数量:潍坊市--1--5.00%--#--false
3:[Ljava.lang.String;@7f690630
二级维度城市类型和数量:南京市--2--10.00%--江苏省--true
二级维度城市类型和数量:扬州市--1--5.00%--#--false
4:[Ljava.lang.String;@edf4efb
二级维度城市类型和数量:石家庄市--1--5.00%--河北省--true
Demo案例一:代码逻辑比较复杂,需耐心看!
package com.day01;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class day24 {
public static void main(String[] args) {
// 模拟测试数据:开始
List<Map<String,Object>> list = new ArrayList<>();
Map<String,Object> map1 = new HashMap<>();
map1.put("province","陕西省");
map1.put("city","西安市");
Map<String,Object> map2 = new HashMap<>();
map2.put("province","陕西省");
map2.put("city","咸阳市");
Map<String,Object> map3 = new HashMap<>();
map3.put("province","陕西省");
map3.put("city","宝鸡市");
Map<String,Object> map4 = new HashMap<>();
map4.put("province","陕西省");
map4.put("city","延安市");
Map<String,Object> map5 = new HashMap<>();
map5.put("province","陕西省");
map5.put("city","汉中市");
Map<String,Object> map6 = new HashMap<>();
map6.put("province","四川省");
map6.put("city","成都市");
Map<String,Object> map7 = new HashMap<>();
map7.put("province","四川省");
map7.put("city","成都市");
Map<String,Object> map8 = new HashMap<>();
map8.put("province","四川省");
map8.put("city","广元市");
Map<String,Object> map9 = new HashMap<>();
map9.put("province","四川省");
map9.put("city","绵阳市");
Map<String,Object> map10 = new HashMap<>();
map10.put("province","陕西省");
map10.put("city","西安市");
Map<String,Object> map11 = new HashMap<>();
map11.put("province","陕西省");
map11.put("city","西安市");
Map<String,Object> map12 = new HashMap<>();
map12.put("province","陕西省");
map12.put("city","宝鸡市");
Map<String,Object> map13 = new HashMap<>();
map13.put("province","江苏省");
map13.put("city","南京市");
Map<String,Object> map14 = new HashMap<>();
map14.put("province","江苏省");
map14.put("city","南京市");
Map<String,Object> map15 = new HashMap<>();
map15.put("province","江苏省");
map15.put("city","扬州市");
Map<String,Object> map16 = new HashMap<>();
map16.put("province","河北省");
map16.put("city","石家庄市");
Map<String,Object> map17 = new HashMap<>();
map17.put("province","山东省");
map17.put("city","济南市");
Map<String,Object> map18 = new HashMap<>();
map18.put("province","山东省");
map18.put("city","青岛市");
Map<String,Object> map19 = new HashMap<>();
map19.put("province","山东省");
map19.put("city","烟台市");
Map<String,Object> map20 = new HashMap<>();
map20.put("province","山东省");
map20.put("city","潍坊市");
list.add(map1);
list.add(map2);
list.add(map3);
list.add(map4);
list.add(map5);
list.add(map6);
list.add(map7);
list.add(map8);
list.add(map9);
list.add(map10);
list.add(map11);
list.add(map12);
list.add(map13);
list.add(map14);
list.add(map15);
list.add(map16);
list.add(map17);
list.add(map18);
list.add(map19);
list.add(map20);
System.out.println("入参数据:"+list);
// 模拟测试数据:结束
/*
*
* 需求分析:前端要求返回的最终数据格式为数组格式:
*
* 数组1:["西安市","宝鸡市","延安市","咸阳市","汉中市","成都市","绵阳市","广元市","青岛市","济南市","烟台市","潍坊市","南京市","扬州市","石家庄市"]
* 数组2:["3", "2", "1", "1", "1", "2", "1", "1", "1", "1", "1", "1", "2", "1", "1" ]
* 数组3:["15.00%","10.00%","5.00%","5.00%","5.00%","10.00%","5.00%","5.00%","5.00%","5.00%","5.00%","5.00%","10.00%","5.00%","5.00%" ]
* 数组4:["", "", "陕西省", "", "", "", "四川省","", "", "山东省", "", "", "江苏省","", "河北省" ]
* 原则:省分放数组中间,奇数为中间位,偶数左偏一位;
* 数组5:数组5:[“true”,“false”,“false”,“false”,“false”, “true”,“false”,“false”, “true”,“false”,“false”,“false”, “true”,“false”, “true” ]
* 原则:每个省城市开始为true,其余为false,前端划分数据使用;
*
*/
// 一:获取一级维度:
// 创建Set集合:获取一级维度数据的数据集:去重
Set<String> hashSet = new HashSet<>();
for (int i = 0; i < list.size(); i++) {
String province = String.valueOf(list.get(i).get("province"));
hashSet.add(province);
}
// 创建一级维度省份数组:
String[] provinceArr = new String[hashSet.size()];
// 创建一级维度省份数量数组:
int[] provinceSort = new int[hashSet.size()];
// Set转数组
if(list.size() > 0){
provinceArr = hashSet.toArray(new String[hashSet.size()]);
}
// 根据一级维度省份数组:计算一级维度省份数量数组;
for (int i = 0; i < provinceArr.length; i++) {
for (int j = 0; j < list.size(); j++) {
if(provinceArr[i].equals(String.valueOf(list.get(j).get("province")))){
provinceSort[i] = provinceSort[i] + 1;
}
}
}
// 排序:一级维度省份数组;
BubblSortUtils.bubbleSortDescMultiple(provinceSort,provinceArr);
// 封装集合测试输出:
System.out.println("--------------------");
List<Map<String,Object>> listFinal= new ArrayList<>();
for (int i = 0; i < provinceArr.length; i++) {
Map<String,Object> map = new HashMap<>();
map.put("title",provinceArr[i]);
map.put("value",provinceSort[i]);
listFinal.add(map);
}
System.out.println("一级维度省份类型和数量:"+listFinal);
// 二:获取二级维度:
// 创建集合数组(数组里面的元素为set集合)
Set[] setArr = new Set[provinceArr.length];
// 创建二维数组(set集合数组转二维数组)
String[][] stringArr = new String[provinceArr.length][];
// 集合数组:获取二级维度城市类型数据的数据集:去重
for (int i = 0; i < provinceArr.length; i++) {
Set<String> hashSet2 = new HashSet<>();
// 获取城市数组;
for (int j = 0; j < list.size(); j++) {
if(provinceArr[i].equals(String.valueOf(list.get(j).get("province")))){
hashSet2.add(String.valueOf(list.get(j).get("city")));
}
}
setArr[i] = hashSet2;
}
// 二维数组:set集合城市数组转二维城市数组;
for (int i = 0; i < setArr.length; i++) {
Set<String> hashSet2 = setArr[i];
String[] provinceArr2 = new String[hashSet2.size()];
if(list.size() > 0){
provinceArr2 = hashSet2.toArray(new String[hashSet2.size()]);
}
stringArr[i] = provinceArr2;
}
// 创建城市数量二维数组;
String[][] countArr = new String[provinceArr.length][];
// 二维数组:根据二维城市类型数组计算:二维城市数量数组;
for (int i = 0; i < stringArr.length; i++) {
String [] s = stringArr[i];
String[] temp = new String[s.length];
for (int j = 0; j < s.length; j++) {
for (int k = 0; k < list.size(); k++) {
if(s[j].equals(String.valueOf(list.get(k).get("city")))) {
if(String.valueOf(temp[j]).equals("null")) {
temp[j] = "1";
}
else {
temp[j] = String.valueOf(Integer.valueOf(temp[j]) + 1);
}
}
}
}
countArr[i] = temp;
}
// 数组排序:城市数组和数量数组排序;
BubblSortUtils.bubbleSortDescMultiple2(countArr,stringArr);
// 三:百分比二维数组:计算百分比
String[][] percentageArr = new String[provinceArr.length][];
int sum = list.size();
for (int i = 0; i < countArr.length; i++) {
String [] s = countArr[i];
String[] temp = new String[s.length];
for (int j = 0; j < s.length; j++) {
if(list.size() > 0) {
temp[j] = percentageConversion(Integer.valueOf(s[j]),sum);
}
}
percentageArr[i] = temp;
}
System.out.println("------------------:");
// 四:数据封装返回:
/*
* 分析:当前得到了四个数组;
* 一维数组:provinceArr
* 二维数组:stringArr,countArr,percentageArr
*
* 需要将一维数组:provinceArr也转成二维数组并且将数据放在中间位置;
*
*/
// 将省份添加到每个二维城市数组的末位;用临时二维数组stringArrTemp接收;
String[][] stringArrTemp = new String[provinceArr.length][];
for (int i = 0; i < stringArr.length; i++) {
String[] s = stringArr[i];
String[] temp = new String[s.length+1];
for (int j = 0; j < s.length; j++) {
temp[j] = s[j];
temp[s.length] = provinceArr[i];
}
stringArrTemp[i] = temp;
}
// 1.计算一维数组在二维中的中间位置;
String[][] provinceNewArr = new String[provinceArr.length][];
for (int i = 0; i < stringArrTemp.length; i++) {
String[] s = stringArrTemp[i];
String[] temp = new String[s.length-1];
int num = s.length-1;
for (int j = 0; j < s.length-1; j++) {
if(j == num/2) { // 找数组中间位置
if(num % 2 ==0) { // 中间位置为偶数
if(j>0) { // 首位判断>0
temp[j-1] = s[s.length-1]; // 数据向左偏
temp[j] = "#"; // 数据左偏完后下个数据需修正;
}
}
else { // 中间位置为奇数
temp[j] = s[s.length-1];
}
}
else {
temp[j] = "#";
}
}
provinceNewArr[i] = temp;
}
// 2.计算二级名称的起始与终止位置:provinceNewArr;深拷贝二维数组;
String[][] provinceStartEndArr = new String[provinceNewArr.length][];
for (int i = 0; i < provinceStartEndArr.length; i++) {
provinceStartEndArr[i] = Arrays.copyOf(provinceNewArr[i], provinceNewArr[i].length); // 深拷贝二维数组;
}
// 计算二维数组的起始位置(每个二维数组内部开始为true,其余为false);
for (int i = 0; i < provinceStartEndArr.length; i++) {
for (int j = 0; j < provinceStartEndArr[i].length; j++) {
if(j == 0){
provinceStartEndArr[i][0] = "true";
}
else{
provinceStartEndArr[i][j] = "false";
}
}
}
// String 数组转布尔数组;
Boolean[][] provinceStartEndArr2 = new Boolean[provinceNewArr.length][];
for (int i = 0; i < provinceStartEndArr.length; i++) {
Boolean[] tem = new Boolean[provinceStartEndArr[i].length];
for (int j = 0; j < provinceStartEndArr[i].length; j++) {
tem[j] = Boolean.parseBoolean(provinceStartEndArr[i][j]);
}
provinceStartEndArr2[i] = tem;
}
// 返回方式一:
// 最终得到五个二维数组:province(省份),cityType(城市类型),cityCount城市数量),cityPercentage(城市百分比),cityGrade(省份的起始和终止位置,Boolean类型)
// 二维数组封装Map返回;
Map<String,Object> mapResult1 = new HashMap<>();
mapResult1.put("province", provinceNewArr);
mapResult1.put("cityType", stringArr);
mapResult1.put("cityCount", countArr);
mapResult1.put("cityPercentage", percentageArr);
mapResult1.put("cityGrade", provinceStartEndArr2);
System.out.println("返回方式一:最终MAP"+mapResult1);
// 最终:测试输出:
for (int i = 0; i < stringArr.length; i++) {
System.out.println(i+":"+stringArr[i]);
String[] s1 = stringArr[i];
String[] s2 = countArr[i];
String[] s3 = percentageArr[i];
String[] s4 = provinceNewArr[i];
String[] s5 = provinceStartEndArr[i];
for (int j = 0; j < s1.length; j++) {
System.out.println("二级维度城市类型和数量:"+s1[j]+"--"+s2[j]+"--"+s3[j]+"--"+s4[j]+"--"+s5[j]);
}
}
// 返回方式二:
// 前端要求:所有的数据把二维数组拼接成一维数组返回;
// 二维数组转集合
List<String> listArr1 = new ArrayList<>();
List<String> listArr2 = new ArrayList<>();
List<String> listArr3 = new ArrayList<>();
List<String> listArr4 = new ArrayList<>();
List<Boolean> listArr5 = new ArrayList<>();
for (int i = 0; i < provinceNewArr.length; i++) {
String[] s1 = provinceNewArr[i];
String[] s2 = stringArr[i];
String[] s3 = countArr[i];
String[] s4 = percentageArr[i];
Boolean[] s5 = provinceStartEndArr2[i];
for (int j = 0; j < s1.length; j++) {
listArr1.add(s1[j]);
listArr2.add(s2[j]);
listArr3.add(s3[j]);
listArr4.add(s4[j]);
listArr5.add(s5[j]);
}
}
// 集合转一维数组;
String[] provinceNewArr2 = new String[listArr1.size()];
String[] stringArr2 = new String[listArr2.size()];
String[] countArr2 = new String[listArr3.size()];
String[] percentageArr2 = new String[listArr4.size()];
Boolean[] gradeArr2 = new Boolean[listArr5.size()];
for (int i = 0; i < listArr1.size(); i++) {
provinceNewArr2[i] = listArr1.get(i);
stringArr2[i] = listArr2.get(i);
countArr2[i] = listArr3.get(i);
percentageArr2[i] = listArr4.get(i);
gradeArr2[i] = listArr5.get(i);
}
// 封装Map返回
Map<String,Object> mapResult2 = new HashMap<>();
mapResult2.put("province", provinceNewArr2);
mapResult2.put("cityType", stringArr2);
mapResult2.put("cityCount", countArr2);
mapResult2.put("cityPercentage", percentageArr2);
mapResult2.put("cityGrade", gradeArr2);
System.out.println("返回方式二:最终MAP"+mapResult2);
}
public static String percentageConversion(long divisor, long dividend) {
String percentage = "";// 接受百分比的值
double y = divisor * 1.0;
double z = dividend * 1.0;
if (y == 0 || z == 0) {
return "0.00%";
}
double result = y / z;
DecimalFormat decimalFormat = new DecimalFormat("##.00%"); // ##.00%
percentage = decimalFormat.format(result);
// ##.00% 使用这种转换方式,整数位如果是0 则会被删除 即0.35% 会出现 .35%的情况
char c = percentage.charAt(0);
if (String.valueOf(c).equals(".")) {
StringBuffer sb = new StringBuffer();
sb.append("0").append(percentage);
return String.valueOf(sb);
}
return percentage;
}
}
代码中数组排序方法查看:【Java 排序】冒泡排序(升降序,Int类型,Double类型,多数组,多维数组)(111)
测试输出:
入参数据:[{province=陕西省, city=西安市}, {province=陕西省, city=咸阳市}, {province=陕西省, city=宝鸡市}, {province=陕西省, city=延安市}, {province=陕西省, city=汉中市}, {province=四川省, city=成都市}, {province=四川省, city=成都市}, {province=四川省, city=广元市}, {province=四川省, city=绵阳市}, {province=陕西省, city=西安市}, {province=陕西省, city=西安市}, {province=陕西省, city=宝鸡市}, {province=江苏省, city=南京市}, {province=江苏省, city=南京市}, {province=江苏省, city=扬州市}, {province=河北省, city=石家庄市}, {province=山东省, city=济南市}, {province=山东省, city=青岛市}, {province=山东省, city=烟台市}, {province=山东省, city=潍坊市}]
--------------------
一级维度省份类型和数量:[{title=陕西省, value=8}, {title=四川省, value=4}, {title=山东省, value=4}, {title=江苏省, value=3}, {title=河北省, value=1}]
------------------:
返回方式一:最终MAP{cityType=[[Ljava.lang.String;@506e6d5e, cityGrade=[[Ljava.lang.Boolean;@96532d6, province=[[Ljava.lang.String;@3796751b, cityCount=[[Ljava.lang.String;@67b64c45, cityPercentage=[[Ljava.lang.String;@4411d970}
0:[Ljava.lang.String;@6442b0a6
二级维度城市类型和数量:西安市--3--15.00%--#--true
二级维度城市类型和数量:宝鸡市--2--10.00%--#--false
二级维度城市类型和数量:延安市--1--5.00%--陕西省--false
二级维度城市类型和数量:咸阳市--1--5.00%--#--false
二级维度城市类型和数量:汉中市--1--5.00%--#--false
1:[Ljava.lang.String;@60f82f98
二级维度城市类型和数量:成都市--2--10.00%--#--true
二级维度城市类型和数量:绵阳市--1--5.00%--四川省--false
二级维度城市类型和数量:广元市--1--5.00%--#--false
2:[Ljava.lang.String;@35f983a6
二级维度城市类型和数量:青岛市--1--5.00%--#--true
二级维度城市类型和数量:济南市--1--5.00%--山东省--false
二级维度城市类型和数量:烟台市--1--5.00%--#--false
二级维度城市类型和数量:潍坊市--1--5.00%--#--false
3:[Ljava.lang.String;@7f690630
二级维度城市类型和数量:南京市--2--10.00%--江苏省--true
二级维度城市类型和数量:扬州市--1--5.00%--#--false
4:[Ljava.lang.String;@edf4efb
二级维度城市类型和数量:石家庄市--1--5.00%--河北省--true
返回方式二:最终MAP{cityType=[Ljava.lang.String;@2f7a2457, cityGrade=[Ljava.lang.Boolean;@566776ad, province=[Ljava.lang.String;@6108b2d7, cityCount=[Ljava.lang.String;@1554909b, cityPercentage=[Ljava.lang.String;@6bf256fa}
案例二:使用场景:
public Map<String, Object> getViolateSceneData(HttpServletRequest request, Map<String, Object> paramMap) {
List<Map<String,Object>> list = getCountData(request,paramMap,"0");
if(list.size() == 0){
Map<String,Object> mapResult2 = new HashMap<>();
String[] ar1 = {""};
String[] ar2 = {""};
String[] ar3 = {""};
String[] ar4 = {""};
Boolean[] ar5 = {false};
mapResult2.put("businessSegment",ar1);
mapResult2.put("violateSceneType", ar2);
mapResult2.put("violateSceneCount", ar3);
mapResult2.put("violateScenePercentage", ar4);
mapResult2.put("violateSceneGrade", ar5);
return mapResult2;
}
// 一:获取一级维度:
// 创建Set集合:获取一级维度数据的数据集:去重
Set<String> hashSet = new HashSet<>();
for (int i = 0; i < list.size(); i++) {
String province = String.valueOf(list.get(i).get("businessSegment"));
hashSet.add(province);
}
// 创建一级维度省份数组:
String[] provinceArr = new String[hashSet.size()];
// 创建一级维度省份数量数组:
int[] provinceSort = new int[hashSet.size()];
// Set转数组
if(list.size() > 0){
provinceArr = hashSet.toArray(new String[hashSet.size()]);
}
// 根据一级维度省份数组:计算一级维度省份数量数组;
for (int i = 0; i < provinceArr.length; i++) {
for (int j = 0; j < list.size(); j++) {
if(provinceArr[i].equals(String.valueOf(list.get(j).get("businessSegment")))){
provinceSort[i] = provinceSort[i] + 1;
}
}
}
// 排序:一级维度省份数组;
GetJsonDataUtil.BubbleSort(provinceSort,provinceArr);
// 二:获取二级维度:
// 创建集合数组(数组里面的元素为set集合)
Set[] setArr = new Set[provinceArr.length];
// 创建二维数组(set集合数组转二维数组)
String[][] stringArr = new String[provinceArr.length][];
// 集合数组:获取二级维度城市类型数据的数据集:去重
for (int i = 0; i < provinceArr.length; i++) {
Set<String> hashSet2 = new HashSet<>();
// 获取城市数组;
for (int j = 0; j < list.size(); j++) {
if(provinceArr[i].equals(String.valueOf(list.get(j).get("businessSegment")))){
hashSet2.add(String.valueOf(list.get(j).get("violateScene")));
}
}
setArr[i] = hashSet2;
}
// 二维数组:set集合城市数组转二维城市数组;
for (int i = 0; i < setArr.length; i++) {
Set<String> hashSet2 = setArr[i];
String[] provinceArr2 = new String[hashSet2.size()];
if(list.size() > 0){
provinceArr2 = hashSet2.toArray(new String[hashSet2.size()]);
}
stringArr[i] = provinceArr2;
}
// 创建城市数量二维数组;
String[][] countArr = new String[provinceArr.length][];
// 二维数组:根据二维城市类型数组计算:二维城市数量数组;
for (int i = 0; i < stringArr.length; i++) {
String [] s = stringArr[i];
String[] temp = new String[s.length];
for (int j = 0; j < s.length; j++) {
for (int k = 0; k < list.size(); k++) {
if(s[j].equals(String.valueOf(list.get(k).get("violateScene")))) {
if(String.valueOf(temp[j]).equals("null")) {
temp[j] = "1";
}
else {
temp[j] = String.valueOf(Integer.valueOf(temp[j]) + 1);
}
}
}
}
countArr[i] = temp;
}
// 数组排序:城市数组和数量数组排序;
GetJsonDataUtil.bubbleSortDescMultiple2(countArr,stringArr);
// 三:百分比二维数组:计算百分比
String[][] percentageArr = new String[provinceArr.length][];
int sum = list.size();
for (int i = 0; i < countArr.length; i++) {
String [] s = countArr[i];
String[] temp = new String[s.length];
for (int j = 0; j < s.length; j++) {
if(list.size() > 0) {
temp[j] = DateUtil.percentageConversion(Integer.valueOf(s[j]),sum);
temp[j]= temp[j].replace("%","");
}
}
percentageArr[i] = temp;
}
// 四:数据封装返回:
/*
* 分析:当前得到了四个数组;
* 一维数组:provinceArr
* 二维数组:stringArr,countArr,percentageArr
*
* 需要将一维数组:provinceArr也转成二维数组并且放在中间位置;
*
*/
// 将省份添加到每个二维城市数组的末位;用临时二维数组stringArrTemp接收;
String[][] stringArrTemp = new String[provinceArr.length][];
for (int i = 0; i < stringArr.length; i++) {
String[] s = stringArr[i];
String[] temp = new String[s.length+1];
for (int j = 0; j < s.length; j++) {
temp[j] = s[j];
temp[s.length] = provinceArr[i];
}
stringArrTemp[i] = temp;
}
// 计算一维数组在二维中的中间位置;
String[][] provinceNewArr = new String[provinceArr.length][];
for (int i = 0; i < stringArrTemp.length; i++) {
String[] s = stringArrTemp[i];
String[] temp = new String[s.length-1];
int num = s.length-1;
for (int j = 0; j < s.length-1; j++) {
if(j == num/2) { // 找数组中间位置
if(num % 2 ==0) { // 中间位置为偶数
if(j>0) { // 首位判断>0
temp[j-1] = s[s.length-1]; // 数据向左偏
temp[j] = "";
}
}
else { // 中间位置为奇数
temp[j] = s[s.length-1];
}
}
else {
temp[j] = "";
}
}
provinceNewArr[i] = temp;
}
// 深拷贝二维数组;
String[][] provinceStartEndArr = new String[provinceNewArr.length][];
for (int i = 0; i < provinceStartEndArr.length; i++) {
provinceStartEndArr[i] = Arrays.copyOf(provinceNewArr[i], provinceNewArr[i].length);
}
// 计算二维数组的起始位置(每个二维数组内部开始为true,其余为false);
for (int i = 0; i < provinceStartEndArr.length; i++) {
for (int j = 0; j < provinceStartEndArr[i].length; j++) {
if(j == 0){
provinceStartEndArr[i][0] = "true";
}
else{
provinceStartEndArr[i][j] = "false";
}
}
}
// String数组转Boolean数组;
Boolean[][] provinceStartEndArr2 = new Boolean[provinceNewArr.length][];
for (int i = 0; i < provinceStartEndArr.length; i++) {
Boolean[] tem = new Boolean[provinceStartEndArr[i].length];
for (int j = 0; j < provinceStartEndArr[i].length; j++) {
tem[j] = Boolean.parseBoolean(provinceStartEndArr[i][j]);
}
provinceStartEndArr2[i] = tem;
}
// 最终得到五个二维数组:provinceNewArr,stringArr,countArr,percentageArr,provinceNewArr2
// 封装数据返回前端方式一:
// Map<String,Object> map = new HashMap<>();
// map.put("businessSegment", provinceNewArr);
// map.put("violateSceneType", stringArr);
// map.put("violateSceneCount", countArr);
// map.put("violateScenePercentage", percentageArr);
// map.put("violateSceneGrade", provinceNewArr2);
// return map;
// 封装数据返回前端方式二:
// 二维数组转集合;
List<String> listArr1 = new ArrayList<>();
List<String> listArr2 = new ArrayList<>();
List<String> listArr3 = new ArrayList<>();
List<String> listArr4 = new ArrayList<>();
List<Boolean> listArr5 = new ArrayList<>();
for (int i = 0; i < provinceNewArr.length; i++) {
String[] s1 = provinceNewArr[i];
String[] s2 = stringArr[i];
String[] s3 = countArr[i];
String[] s4 = percentageArr[i];
Boolean[] s5 = provinceStartEndArr2[i];
for (int j = 0; j < s1.length; j++) {
listArr1.add(s1[j]);
listArr2.add(s2[j]);
listArr3.add(s3[j]);
listArr4.add(s4[j]);
listArr5.add(s5[j]);
}
}
// 集合转一维数组;
String[] provinceNewArr2 = new String[listArr1.size()];
String[] stringArr2 = new String[listArr2.size()];
String[] countArr2 = new String[listArr3.size()];
String[] percentageArr2 = new String[listArr4.size()];
Boolean[] gradeArr2 = new Boolean[listArr5.size()];
for (int i = 0; i < listArr1.size(); i++) {
provinceNewArr2[i] = listArr1.get(i);
stringArr2[i] = listArr2.get(i);
countArr2[i] = listArr3.get(i);
percentageArr2[i] = listArr4.get(i);
gradeArr2[i] = listArr5.get(i);
}
// 业务环节,违规场景编号转中文,
List<Map<String, String>> listDicVal = questionListMapper.getListDicVal();
for (int i = 0; i < provinceNewArr2.length; i++) {
for (int j = 0; j < listDicVal.size(); j++) {
String dicValueFirst = String.valueOf(listDicVal.get(j).get("dicValueFirst"));
String dicNameFirst = String.valueOf(listDicVal.get(j).get("dicNameFirst"));
if(provinceNewArr2[i].equals(dicValueFirst)){
provinceNewArr2[i] = dicNameFirst;
}
}
}
for (int i = 0; i < stringArr2.length; i++) {
for (int j = 0; j < listDicVal.size(); j++) {
String dicValueSecond = String.valueOf(listDicVal.get(j).get("dicValueSecond"));
String dicNameSecond = String.valueOf(listDicVal.get(j).get("dicNameSecond"));
if(stringArr2[i].equals(dicValueSecond)){
stringArr2[i] = dicNameSecond;
}
}
}
// 封装Map返回
Map<String,Object> mapResult2 = new HashMap<>();
mapResult2.put("businessSegment", provinceNewArr2);
mapResult2.put("violateSceneType", stringArr2);
mapResult2.put("violateSceneCount", countArr2);
mapResult2.put("violateScenePercentage", percentageArr2);
mapResult2.put("violateSceneGrade", gradeArr2);
return mapResult2;
}
备注:代码中已包含两种返回值的方式:
Postman接口测试:按照二维数组返回:封装数据返回前端方式一
{
"data": {
"businessSegment": [
"差旅",
"",
"",
"",
"预防",
"",
"",
"安全",
"",
"招标",
"",
"实验室"
],
"violateScenePercentage": [
"38.71",
"3.23",
"12.90",
"9.68",
"6.45",
"3.23",
"3.23",
"9.68",
"3.23",
"3.23",
"3.23",
"3.23"
],
"violateSceneType": [
"差旅违规",
"费用违规",
"关联关系",
"第二职业",
"采购",
"项目公示",
"吃空饷",
"工作纪律",
"其它",
"其它",
"竞标违规",
"资产"
],
"violateSceneGrade": [
true,
false,
true,
false,
false,
false,
false,
true,
false,
true,
false,
true
],
"violateSceneCount": [
"12",
"1",
"4",
"3",
"2",
"1",
"1",
"3",
"1",
"1",
"1",
"1"
]
},
"code": 200,
"message": "OK"
}