Question

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

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

Answer 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个数据

Answer 2

这个问题可以通过数据结构里面的排序来完成，用快速排序法，先将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;
    }

Answer 3

创建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 个区间，然后统计每个区间数值个数

Answer 4

这种问题建议自学 jdk1.8 stream