在springboot项目中已存在的一个名为date的数组分成14组，这个数据组中有null值，要求排出这些null值，用一段java程序按顺序计算每24个的最大值最小值，前168个数据的最大值和后168个数据的最小值。再计算第一组的所有数据和第8组所有数据的环比，后第二组和第9组环比，第3组和第10组的环比，第4组和第11组环比，第5组和第12组的环比，第6组和第13组环比，第7组和第14组的环比，
根据您的描述，可能需要一些数据处理和计算。以下是我能提供的一个Java程序例子，可以实现这个功能。
import java.util.Arrays;
public class ContactsManager {
public static void main(String[] args) {
Integer[] data = {3,4,null,6,8,7,null,10,15,13,null,9,1,2,null,14,12,11,null,5};
// 去除 null 值
Integer[] newData = Arrays.stream(data)
.filter(d -> d != null)
.toArray(Integer[]::new);
int len = newData.length;
int sectionSize = len / 14;
int minIndex = 0;
int maxIndex = sectionSize - 1;
double maxFirst168 = Double.MIN_VALUE;
double minLast168 = Double.MAX_VALUE;
for (int i = 0; i < 14; i++) {
double max24 = Double.MIN_VALUE;
double min24 = Double.MAX_VALUE;
for (int j = minIndex; j <= maxIndex; j++) {
max24 = Math.max(max24, newData[j]);
min24 = Math.min(min24, newData[j]);
if (i == 0 && j < 168) {
maxFirst168 = Math.max(maxFirst168, newData[j]);
}
if (i == 13 && j >= len - 168) {
minLast168 = Math.min(minLast168, newData[j]);
}
}
double ratio = i % 7 == 0 ? 1 : newData[24 * (i - 1) + 23] / (double) newData[24 * i];
System.out.printf("第%d组24个数据的最大值为%f，最小值为%f\n", i + 1, max24, min24);
System.out.printf("第%d组和第%d组的环比为%f\n", i + 1, i % 7 == 0 ? 1 : i - 6, ratio);
minIndex = maxIndex + 1;
maxIndex += sectionSize;
}
System.out.printf("前168个数据的最大值为%f\n", maxFirst168);
System.out.printf("后168个数据的最小值为%f\n", minLast168);
}
}
在上面的程序中，我首先把原始数据中的 null 值去掉。接着通过一些循环计算得到每个 24 个数据段的最大值、最小值以及相邻两个数据段的环比，并且同时计算前 168 个数据的最大值和后 168 个数据的最小值。
这一步可选：date数组中的对象实现Comparable接口，方便做排序。如果对象可直接比较大小则不需要。
原数组：T[] arr，T是你数组中数据的类型
数组转为List：List list = Arrays.asList(arr);
使用List的流计算过滤null后排序，生成新的数组：T[] arr1 = list.stream().filter(i -> i !=null).sorted().toArray(T[]::new)
再使用循环遍历数组，从数组中找每组数据的最大值、值小值，存入另一数组，用于进行环比。
我可以使用Java对一个名为"date"的数组进行处理并满足以上要求。首先需要排除掉数组中的null元素，可以使用Java 8中的Stream API来实现。然后需要按顺序计算每24个元素的最大值和最小值，可以使用一个循环来实现。接着需要计算前168个元素的最大值和后168个元素的最小值，同样可以使用循环，只需要加一个判断条件即可。最后需要计算每组的环比，可以先用一个循环把元素分成14组，然后再用循环计算每组的环比，并将结果存储在一个数组中。代码如下：
import java.util.Arrays;
import java.util.stream.IntStream;
public class DateProcessor {
private static final int GROUP_SIZE = 24;
private static final int NUM_GROUPS = 14;
public static void main(String[] args) {
// 假设date数组已经被初始化
Date[] date = ...
// 排除null元素
Date[] filtered = Arrays.stream(date)
.filter(d -> d != null)
.toArray(Date[]::new);
// 计算每24个元素的最大值和最小值
double[] max24 = new double[NUM_GROUPS];
double[] min24 = new double[NUM_GROUPS];
for (int i = 0; i < NUM_GROUPS; i++) {
int start = i * GROUP_SIZE;
int end = start + GROUP_SIZE;
max24[i] = Arrays.stream(filtered, start, end)
.mapToDouble(Date::getTime)
.max()
.orElse(Double.NaN);
min24[i] = Arrays.stream(filtered, start, end)
.mapToDouble(Date::getTime)
.min()
.orElse(Double.NaN);
}
// 计算前168个元素的最大值和后168个元素的最小值
double max168 = Arrays.stream(filtered, 0, 168)
.mapToDouble(Date::getTime)
.max()
.orElse(Double.NaN);
double min168 = Arrays.stream(filtered, filtered.length - 169, filtered.length)
.mapToDouble(Date::getTime)
.min()
.orElse(Double.NaN);
// 计算每组的环比
double[] yoy = new double[NUM_GROUPS];
for (int i = 0; i < NUM_GROUPS; i++) {
int start = i * GROUP_SIZE;
int end = start + GROUP_SIZE;
int prevStart = (i == 0) ? start : (start - GROUP_SIZE);
int nextEnd = (i == NUM_GROUPS - 1) ? (end) : (end + GROUP_SIZE);
double prev = Arrays.stream(filtered, prevStart, start)
.mapToDouble(Date::getTime)
.max()
.orElse(Double.NaN);
double next = Arrays.stream(filtered, end, nextEnd)
.mapToDouble(Date::getTime)
.min()
.orElse(Double.NaN);
yoy[i] = (next - prev) / prev;
}
// 输出结果
System.out.println("Max24: " + Arrays.toString(max24));
System.out.println("Min24: " + Arrays.toString(min24));
System.out.println("Max168: " + max168);
System.out.println("Min168: " + min168);
System.out.println("YoY: " + Arrays.toString(yoy));
}
}