Fatal编程技术网
  • java/
  • Java 如何在一定范围内收集生成的号码？

Java 如何在一定范围内收集生成的号码？

java arrays

Java 如何在一定范围内收集生成的号码？,java,arrays,integer,jcreator,Java,Arrays,Integer,Jcreator,目前我有一个生成200个0-100之间的随机数（每行10个）的代码，但现在我被卡住了，因为我想让它计算0-20,21-40,41-60,61-80,81-100之间的所有数字，并告诉我该范围内有多少个数字。我该怎么做？我试过了，但我刚刚生成了这些范围之间的数字。这是我目前的代码： （如果可能的话，如何使用数组？我是初学者，还在学习） import java.util.Random； 公共类随机统计1{ 公共静态void main（字符串[]args）{ Random Random=新的Rando

目前我有一个生成200个0-100之间的随机数（每行10个）的代码，但现在我被卡住了，因为我想让它计算0-20,21-40,41-60,61-80,81-100之间的所有数字，并告诉我该范围内有多少个数字。我该怎么做？我试过了，但我刚刚生成了这些范围之间的数字。这是我目前的代码： （如果可能的话，如何使用数组？我是初学者，还在学习）

import java.util.Random；
公共类随机统计1{
公共静态void main（字符串[]args）{
Random Random=新的Random（）；
System.out.println（“生成200个数字，每行10个：”）；
int NUMBERSONTISLINE=0；
对于（int i=0；i<200；i++）
{
int-nextNumber=random.nextInt（100）；
系统输出打印（下一个数字+“”）；
numbersonisline++；
if（numbersontisline==10）
{
系统输出打印（“\n”）；
numbersonisline=0；
}
}
}
}
创建一个
HashMap
并用值0、20、40、60和80（以及空集）初始化它：

生成完数字后，您将按范围对它们进行分组排序

备注：
集合不允许重复成员，因此如果要允许重复，请不要使用
哈希集合
，使用
列表
或其他允许它的数据结构。

创建
哈希映射
，并使用值0、20、40、60和80（以及空集合）对其进行初始化：

生成完数字后，您将按范围对它们进行分组排序

备注：
集合不允许重复成员，因此如果要允许重复，请不要使用
哈希集合
，使用
列表
或其他允许重复的数据结构。

首先，必须将它们存储在数据结构中，如
数组列表

private List<Integer> numbers = new ArrayList<>();

for(int i = 0; i < 200; i++){
 int nextNumber = random.nextInt(100);
 numbers.add(nextNumber);
}
并使用范围对其进行初始化：

for(int i = 0; i < 100; i+= 20){
 occurrences.put(new Range(i, i + 20), 0);
}
我知道这是精心设计的，可能不适合你的要求水平。至少这是我的思考过程，你可以从中随心所欲。毕竟，它可能对未来的浏览器有所帮助

更简单（无需额外上课）：

private List<Integer> numbers = new ArrayList<>();
private Map<Integer, Integer> occurrences = new HashMap<>();

for(int i = 0; i < 200; i++){
 int nextNumber = random.nextInt(100);
 numbers.add(nextNumber);
}

for(int i = 0; i < 100; i++){
 occurrences.put(i, 0);
}

for(int i : numbers){
 int sofar = occurrences.get(i);
 occurrences.put(i, sofar + 1);
}

private int[] occ = new int[5];

for(int i = 0; i < 200; i++){
 int nextNumber = random.nextInt(100);
 System.out.println(nextnumber);

 if(i <= 20) { occ[0]++; }
 if(i <= 40) { occ[1]++; }
 if(i <= 60) { occ[2]++; }
 if(i <= 80) { occ[3]++; }
 if(i <= 100) { occ[4]++; }
}

System.out.println("Numbers from 0 to 20: " + occ[0]); 
System.out.println("Numbers from 20 to 40: " + occ[1]); 
System.out.println("Numbers from 40 to 60: " + occ[2]); 
System.out.println("Numbers from 60 to 80: " + occ[3]); 
System.out.println("Numbers from 80 to 100: " + occ[4]); 

private List number=new ArrayList（）；
私有映射出现次数=new HashMap（）；
对于（int i=0；i<200；i++）{
int-nextNumber=random.nextInt（100）；
编号。添加（下一个编号）；
}
对于（int i=0；i<100；i++）{
（i，0）；
}
用于（int i：数字）{
int sofar=发生次数。获取（i）；
事件。put（i，sofar+1）；
}
要获得范围内的实际数据，请执行以下操作：

int count = 0;
for(int i = 0; i < 100; i++){
 count+= occurences.get(i);
 if(i % 20 == 0) {
  System.out.println("From " + i - 20 + " to " + i + ":" + count);
  count = 0;
 }
}

int count=0；
对于（int i=0；i<100；i++）{
计数+=发生次数。获取（i）；
如果（i%20==0）{
System.out.println（“从“+i-20+”到“+i+”：“+count”）；
计数=0；
}
}
使用数组，更简单，并且丢失单个值：

private List<Integer> numbers = new ArrayList<>();
private Map<Integer, Integer> occurrences = new HashMap<>();

for(int i = 0; i < 200; i++){
 int nextNumber = random.nextInt(100);
 numbers.add(nextNumber);
}

for(int i = 0; i < 100; i++){
 occurrences.put(i, 0);
}

for(int i : numbers){
 int sofar = occurrences.get(i);
 occurrences.put(i, sofar + 1);
}

private int[] occ = new int[5];

for(int i = 0; i < 200; i++){
 int nextNumber = random.nextInt(100);
 System.out.println(nextnumber);

 if(i <= 20) { occ[0]++; }
 if(i <= 40) { occ[1]++; }
 if(i <= 60) { occ[2]++; }
 if(i <= 80) { occ[3]++; }
 if(i <= 100) { occ[4]++; }
}

System.out.println("Numbers from 0 to 20: " + occ[0]); 
System.out.println("Numbers from 20 to 40: " + occ[1]); 
System.out.println("Numbers from 40 to 60: " + occ[2]); 
System.out.println("Numbers from 60 to 80: " + occ[3]); 
System.out.println("Numbers from 80 to 100: " + occ[4]); 

private int[]occ=new int[5]；
对于（int i=0；i<200；i++）{
int-nextNumber=random.nextInt（100）；
System.out.println（下一个编号）；

如果（i首先，您必须将它们存储在数据结构中，如
ArrayList


private List<Integer> numbers = new ArrayList<>();

for(int i = 0; i < 200; i++){
 int nextNumber = random.nextInt(100);
 numbers.add(nextNumber);
}


并使用范围对其进行初始化：


for(int i = 0; i < 100; i+= 20){
 occurrences.put(new Range(i, i + 20), 0);
}


我意识到它很复杂，可能不符合你的要求。至少这是我的思考过程，你可以从中随心所欲。它可能会帮助未来的浏览器

更简单（无需额外上课）：


private List<Integer> numbers = new ArrayList<>();
private Map<Integer, Integer> occurrences = new HashMap<>();

for(int i = 0; i < 200; i++){
 int nextNumber = random.nextInt(100);
 numbers.add(nextNumber);
}

for(int i = 0; i < 100; i++){
 occurrences.put(i, 0);
}

for(int i : numbers){
 int sofar = occurrences.get(i);
 occurrences.put(i, sofar + 1);
}



private int[] occ = new int[5];

for(int i = 0; i < 200; i++){
 int nextNumber = random.nextInt(100);
 System.out.println(nextnumber);

 if(i <= 20) { occ[0]++; }
 if(i <= 40) { occ[1]++; }
 if(i <= 60) { occ[2]++; }
 if(i <= 80) { occ[3]++; }
 if(i <= 100) { occ[4]++; }
}

System.out.println("Numbers from 0 to 20: " + occ[0]); 
System.out.println("Numbers from 20 to 40: " + occ[1]); 
System.out.println("Numbers from 40 to 60: " + occ[2]); 
System.out.println("Numbers from 60 to 80: " + occ[3]); 
System.out.println("Numbers from 80 to 100: " + occ[4]); 



private List number=new ArrayList（）；
私有映射出现次数=new HashMap（）；
对于（int i=0；i<200；i++）{
int-nextNumber=random.nextInt（100）；
编号。添加（下一个编号）；
}
对于（int i=0；i<100；i++）{
（i，0）；
}
用于（int i：数字）{
int sofar=发生次数。获取（i）；
事件。put（i，sofar+1）；
}


要获得范围内的实际数据，请执行以下操作：


int count = 0;
for(int i = 0; i < 100; i++){
 count+= occurences.get(i);
 if(i % 20 == 0) {
  System.out.println("From " + i - 20 + " to " + i + ":" + count);
  count = 0;
 }
}



int count=0；
对于（int i=0；i<100；i++）{
计数+=发生次数。获取（i）；
如果（i%20==0）{
System.out.println（“从“+i-20+”到“+i+”：“+count”）；
计数=0；
}
}


使用数组，更简单，并且丢失单个值：


private List<Integer> numbers = new ArrayList<>();
private Map<Integer, Integer> occurrences = new HashMap<>();

for(int i = 0; i < 200; i++){
 int nextNumber = random.nextInt(100);
 numbers.add(nextNumber);
}

for(int i = 0; i < 100; i++){
 occurrences.put(i, 0);
}

for(int i : numbers){
 int sofar = occurrences.get(i);
 occurrences.put(i, sofar + 1);
}



private int[] occ = new int[5];

for(int i = 0; i < 200; i++){
 int nextNumber = random.nextInt(100);
 System.out.println(nextnumber);

 if(i <= 20) { occ[0]++; }
 if(i <= 40) { occ[1]++; }
 if(i <= 60) { occ[2]++; }
 if(i <= 80) { occ[3]++; }
 if(i <= 100) { occ[4]++; }
}

System.out.println("Numbers from 0 to 20: " + occ[0]); 
System.out.println("Numbers from 20 to 40: " + occ[1]); 
System.out.println("Numbers from 40 to 60: " + occ[2]); 
System.out.println("Numbers from 60 to 80: " + occ[3]); 
System.out.println("Numbers from 80 to 100: " + occ[4]); 



private int[]occ=new int[5]；
对于（int i=0；i<200；i++）{
int-nextNumber=random.nextInt（100）；
System.out.println（下一个编号）；

如果（i因为您正处于学习阶段，应该使用数组，我只会给您一些建议：


  • nextInt（100）
    给出0到99之间的值，而不是100
    • 

  • 您的等尺寸范围为0-19、20-39、40-59、60-79、80-99。0-20是21个数字
    
（以上注释摘自）
    • 

  • 您可以使用一个数组来存储每个组的计数器。由于您有5个组，请将数组的大小也定义为5
    • 

  • 利用该语言的一些优势，两个数字的整数除法的结果是双精度结果的整数部分。换句话说，当用
    int x
    除以
    int y
    时，结果
    int z
    将是结果的整数部分，不需要考虑模数和浮点部分。例如：

      

    • 15/20=0
      • 

    • 20/20=1
      • 

    • 21/20=1
      • 

    • 

  • 通过上面的说明，您可以很容易地得到用作计数器的数组的索引，将生成的数字除以0和100，再除以20即可
    • 
一个小的伪代码：
    

    int counterSize <- 5
int groupSize <- 20
int[] counter = new int[counterSize]
for i <- 0 to 200
    int nextNumber <- random(100)
    int index <- nextNumber / groupSize
    counter[index] <- counter[index] + 1
end for

    

    int counterSize因为您正处于学习阶段，应该使用数组，所以我只提供以下建议：
    

  • nextInt（100）
    给出0到99之间的值，而不是100
    • 

  • 您的等尺寸范围为0-19、20-39、40-59、60-79、80-99。0-20是21个数字
    
（以上注释摘自）
    • 

  • 您可以使用一个数组来存储每个组的计数器。由于您有5个组，请将数组的大小也定义为5
    • 

  • 利用该语言的一些优势，两个数字的整数除的结果是双结果的整数部分。换句话说，当用
    int x
    除以
    int y
    时，结果
    int z
    将是整数pa														
    •