java怎样将集合中的数值数据分区间统计个数：例如（0-1000）有几个人数据，1000-2000有几个数据

Posted 2023-04-20

区间是以千为单位划分的 最终区间个数取决于集合中的最大值，如果最大值大于等于30000那么就有nums=max%1000==0?max/1000:max/1000+1 个区间，然后统计每个区间数值个数

集合分组统计处理, 实现的方法很多,简单的写几种方法供参考;(理解后,自行扩展完善)

方法一:(Java8流处理粗略版) 该版本存在的问题:有些区间没有数据,就不打印显示该区间

import java.util.*;
import java.util.stream.*;

public class NumberDemo 
public static void main(String[] args) 

ArrayList<Integer> list = new ArrayList<Integer>();
int numbers = 10;// 集合里数字的个数
int space = 1000;// 区间的间隔

// 给集合里添加数字
Random rd = new Random();
for (int i = 0; i < numbers; i++) 
list.add(rd.nextInt(5000)); // 集合里每个数字的范围是0~4999


funStream(list, space);


private static void funStream(ArrayList<Integer> list, int space) 
// 使用流处理 把 数字分组
Map<String, List<Integer>> map = list.stream().collect(Collectors.groupingBy((num) -> 
return "区间:[" + num / space * space + "," + (num / space + 1) * space + ")";// 分组规则
));
map.forEach((k,v)->
System.out.println(k);
System.out.println("\\t"+v.size()+"个数据");
);

方法二:(Java8流处理详细版) 就算有的区间是0个数据,照样打印出来

import java.util.*;
import java.util.stream.*;

public class NumberDemo2 
public static void main(String[] args) 
ArrayList<Integer> list = new ArrayList<Integer>();
int numbers = 10;// 集合里数字的个数
int space = 1000;// 区间的间隔

// 给集合里添加数字
Random rd = new Random();
for (int i = 0; i < numbers; i++) 
list.add(rd.nextInt(5000)); // 集合里每个数字的范围是0~4999


funStream(list, space);


private static void funStream(ArrayList<Integer> list, int space) 
// 使用流处理 把 数字分组
Map<Integer, List<Integer>> map = list.stream().collect(Collectors.groupingBy((num) -> 
return num / space;// 分组规则
));

// 获取集合里的最大值
Optional<Integer> maxop = list.stream().collect(Collectors.maxBy(Integer::compareTo));
int max = maxop.orElse(0);
// 计算出区间的数量
int groups = max % space == 0 ? max / space : max / space + 1;
// 打印结果
for (int i = 0; i < groups; i++) 
System.out.println("区间:[" + i * space + "," + (i + 1) * space + ")");
System.out.println("\\t有" + (map.get(i)==null?0:map.get(i).size()) + "个数据");
// System.out.println("\\t"+map.get(i));//把数据打印出来

方法三:(比较传统的方法)

import java.util.*;

public class NumberDemo3 
public static void main(String[] args) 
ArrayList<Integer> list = new ArrayList<Integer>();
int numbers = 10;// 集合里数字的个数
int space = 1000;// 区间的间隔

//给集合里添加数字
Random rd = new Random();
for (int i = 0; i < numbers; i++) 
list.add(rd.nextInt(5000)); // 集合里每个数字的范围是0~4999


fun(list,space);

private static void fun(ArrayList<Integer> list, int space) 
Collections.sort(list);//排序
int max= list.get(list.size()-1);//取得最大值
int groups = max % space == 0 ? max / space : max / space + 1;//取得区间的数量
HashMap<Integer,ArrayList<Integer>> map=new HashMap<Integer, ArrayList<Integer>>();//存区间和该区间的数字
for (int i = 0; i < groups; i++) 
map.put(i, new ArrayList<>());

//把元素添加到指定的区间
for (int i = 0; i < list.size(); i++) 
map.get(list.get(i)/space).add(list.get(i));

//打印结果
for (int i = 0; i < groups; i++) 
System.out.println("区间:[" + i * space + "," + (i + 1) * space + ")");
System.out.println("\\t有"+ map.get(i).size()+"个数据");
//System.out.println("\\t"+map.get(i));//把数据打印出来

测试效果如下

区间:[0,1000)
有5个数据
区间:[1000,2000)
有0个数据
区间:[2000,3000)
有1个数据
区间:[3000,4000)
有2个数据
区间:[4000,5000)
有2个数据

参考技术A

这个问题可以通过数据结构里面的排序来完成，用快速排序法，先将1000插入数据作为基准，排序完成后，在1000左边的是比它小的，右边的数据就是比1000大的，然后取右边的数据插入2000作为基准，再用排序法得到1000-2000的数据。

也可以用直接比较法，将所有的数据与这个区间进行比较，合适的就统计个数，这个算法比较简单容易实现，就是数据量大的时候效率稍微低一点。

看到补充的问题，这个就比较复杂一点，如果是分区间保存数据，有多个区间的话，应该是用哈希表的方法比较合适，哈希函数就选用 key / 1000，解决冲突的方法还是用链表法，这样如果数据比较分散而数据量不大的话，还是有效率的。

   public int[] quickSort(int[] data)  //快速排序，不稳定，最快速
        return quickSort(data, 0, data.length -1);
    
    
    public int[] quickSort(int[] data, int low, int high)
        int pivot = data[low];
        int i = low + 1;
        int j = high;
        int temp;
        while(i < j)
            while((j > i) && (pivot <= data[j]) )
                -- j;
            
            while((i < j) && (pivot >= data[i]))
                ++ i;
            
            if(i < j)
                temp = data[i];
                data[i] = data[j];
                data[j] = temp;
            
        
        if(data[j] < data[low])
            temp = data[low];
            data[low] = data[j];
            data[j] = temp;
        
        if(i - low > 1)
            quickSort(data, low, i - 1);
        if(high - j > 1)
            quickSort(data, j + 1, high);
        
        return data;
    

参考技术B 创建set的iterator
Set<Object> set = new HashSet<Object>();
Iterator<Object> it = set.iterator();
while(it.hasNext())//判断是否有下一个
it.next()取出元素
======================================
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

class ADD
public String a;

public static void main(String[] args)
ADD a = new ADD();
a.a = "a";
ADD b = new ADD();
b.a = "b";
Set<ADD> set = new HashSet<ADD>();
set.add(a);
set.add(b);
Iterator<ADD> it = set.iterator();
while(it.hasNext())
System.out.println(((ADD)it.next()).a);


追问

谢谢哈 我觉得你没懂我的意思 区间是以千为单位划分的 最终区间个数取决于集合中的最大值，如果最大值大于等于30000那么就有nums=max%1000==0?max/1000:max/1000+1 个区间，然后统计每个区间数值个数

参考技术C 这种问题建议自学 jdk1.8 stream

HDU2008 数值统计序列处理

数值统计
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 199584 Accepted Submission(s): 93225

Problem Description
统计给定的n个数中，负数、零和正数的个数。

Input
输入数据有多组，每组占一行，每行的第一个数是整数n（n<100），表示需要统计的数值的个数，然后是n个实数；如果n=0，则表示输入结束，该行不做处理。

Output
对于每组输入数据，输出一行a,b和c，分别表示给定的数据中负数、零和正数的个数。

Sample Input
6 0 1 2 3 -1 0
5 1 2 3 4 0.5
0

Sample Output
1 2 3
0 0 5

Author
lcy

Source
C语言程序设计练习（二）

问题链接：HDU2008 数值统计
问题简述：（略）
问题分析：
　　按Markdown格式重写了题解，旧版题解参见参考链接。
　　序列处理问题，按题意指定的条件进行统计就可以了。统计变量需要进行初始化，初值设置为0。
程序说明：（略）
参考链接：HDU2008 数值统计【入门】
题记：（略）

AC的C++语言程序如下：

/* HDU2008 数值统计 */

#include <stdio.h>

int main(void)
{
    int n, ncnt, zcnt, pcnt, i;
    float a;
    while (~scanf("%d", &n) && n) {
        ncnt = zcnt = pcnt = 0;
        for (i = 1; i <= n; i++) {
            scanf("%f", &a);

            if(a < 0) ncnt++;
            else if(a > 0) pcnt++;
            else zcnt++;
        }
        printf("%d %d %d\\n", ncnt, zcnt, pcnt);
    }

    return 0;
}