Java 为for循环中的数组赋值

因此我必须执行以下操作：

在Java程序中声明100个数字，计算其平均值，并找出有多少个数字高于平均值

公共类主{
公共静态void main（字符串[]args）{
double[]列表=新的double[100]；
int x=1；
while（x在while循环中有一个for循环。这意味着当x为100时，for循环将用100填充数组。

不需要while循环。试试看

  for(int i = 0; i<100; i++)    
    {    
         list[i] = i+1;   
    }

for（int i=0；i您不需要
循环，而
循环将使数组的每个索引包含相同的值，因此只需替换此循环即可

    while(x<=100){
        for(int i = 0; i<100; i++){
            list[i] = x;
        }
        x++;
    }

    for(int i = 0; i<100; i++){
        list[i] = i+1;
    }

while（xwhile循环中有一个嵌套循环。对于x，（0-100），数组中的项将被更新。在x=100的最后一个外部循环中，数组将具有所有值100的值。您有两个循环，但只需要一个

public static void main(String[] args) {
        double[] list = new double[100];

        for(int i = 0; i<list.length; i++){
            list[i] = i+1;
        }


        double sum = 0;

        for(double d : list){
            sum += d; 
        }

        double average = sum/list.length;

        for(double d : list){
            if(d > average){
                System.out.println(d + " is larger than the average");    
            }
        }

    }

publicstaticvoidmain（字符串[]args）{
double[]列表=新的double[100]；
对于（int i=0；i平均值）{
System.out.println（d+“大于平均值”）；
}
}
}
如果您总是有一个算术序列，则无需再次遍历数组来查找和。使用公式，在您的情况下，它是：
（n*（n+1））/2
。如果它不是算术序列，则在为数组赋值时再次查找
和

public static void main(String[] args) {
    double[] list = new double[100];
    Random rand = new Random();
    double sum = 0;
    for (int i = 0; i < 100; i++) {
        list[i] = rand.nextInt(100);
        sum += list[i];
    }
    double average = sum / list.length;
    for (int i = 0; i < 100; i++) {
        if (list[i] > average) {
            System.out.println(list[i] + " is larger than the average");
        }
    }
}

以下是您的简化代码：

public static void main(String[] args) {
    double[] list = new double[100];
    for (int i = 0; i < 100; i++) {
        list[i] = (i + 1);
    }
    double sum = (100 * 101) / 2;
    double average = sum / list.length;
    for (int i = 0; i < 100; i++) {
        if (list[i] > average) {
            System.out.println(list[i] + " is larger than the average");
        }
    }
}

publicstaticvoidmain（字符串[]args）{
double[]列表=新的double[100]；
对于（int i=0；i<100；i++）{
列表[i]=（i+1）；
}
双和=（100*101）/2；
双倍平均值=总和/列表长度；
对于（int i=0；i<100；i++）{
如果（列表[i]>平均值）{
System.out.println（列表[i]+“大于平均值”）；
}
}
}

编辑：以防您要为数组分配随机数

public static void main(String[] args) {
    double[] list = new double[100];
    Random rand = new Random();
    double sum = 0;
    for (int i = 0; i < 100; i++) {
        list[i] = rand.nextInt(100);
        sum += list[i];
    }
    double average = sum / list.length;
    for (int i = 0; i < 100; i++) {
        if (list[i] > average) {
            System.out.println(list[i] + " is larger than the average");
        }
    }
}

publicstaticvoidmain（字符串[]args）{
double[]列表=新的double[100]；
Random rand=新的Random（）；
双和=0；
对于（int i=0；i<100；i++）{
列表[i]=兰特·耐克斯汀（100）；
总和+=列表[i]；
}
双倍平均值=总和/列表长度；
对于（int i=0；i<100；i++）{
如果（列表[i]>平均值）{
System.out.println（列表[i]+“大于平均值”）；
}
}
}
可以通过以下简单方式完成：

int[] list = new int[100];
int sum = 0;
double average = 0;
 for(int i=0; i<100 ; i++){
     list[i] = i+1;
     sum = sum + list[i];
 }
  average = (double) sum / list.length; // casting to double 
 for(int i=0; i<100 ; i++){
      if(list[i] > average){
         System.out.println(list[i] + " is larger than the average");
      }
 }

int[]list=newint[100]；
整数和=0；
双平均=0；
对于（inti=0；i像这样尝试

public class Main {

    public static void main(String[] args) {
        int[] list = new int[100];
        int x = 1;

        while (x <= 100) {
            for (int i = 0; i < 100; i++) {
                list[i] = x;
                x++;
            }
        }

        double sum = 0;
        int j = 0;
        double average = 0;
        while (j < list.length) {
            sum += list[j];
            j++;
        }
        average = sum / list.length;

        System.out.println("Sum:" + sum);
        System.out.println("Avg:" + average);

        for (int i = 0; i < 100; i++) {
            if (list[i] > average) {
                System.out.println(list[i] + "is larger than the average");
            }
        }
    }    
}

公共类主{
公共静态void main（字符串[]args）{
int[]列表=新int[100]；
int x=1；
而（x平均值）{
System.out.println（列表[i]+“大于平均值”）；
}
}
}    
}
在Java 8中，您可以使用一行程序来完成此操作：


数字：
final int[]numbers=IntStream.rangeClosed（1100.toArray（）；
平均值：
final double average=IntStream.rangeClosed（1100）.average（）.getAsDouble（）；
高于平均值：
final int[]overaveragenumbers=IntStream.rangeClosed（1100）。filter（number->number>average）。toArray（）；

虽然这不是最佳解决方案，但看起来很酷：）

请记住，使用选项时，您需要检查它是否存在。
此外，我还重复了自己创建的
IntStream
，这看起来并不漂亮，但我不能重复使用同一个流两次——我建议也阅读一下。
如果不想以相同的方式创建它，可以使用
IntStream.of（numbers）
而不是第二个和第三个示例中的
IntStream.rangeClosed（1100）

你做错了什么以及为什么

在此循环中：

double[] list = new double[100];
int x = 1;
while(x<=100){
    for(int i = 0; i<100; i++){
        list[i] = x;
    }
    x++;
}

祝你好运！
你很困惑。让我们用方法来区分问题

public class Main {

    public static int[] getArray(int size) {
        int[] output = new int[size];
        for (int i = 0; i < size; i++) {
            output[i] = i + 1;
        }
        return output;
    }

    public static double avg(int[] input) {
        int sum = 0;
        for (int i = 0; i < input.length; i++) {
            sum += input[i];
        }        
        return sum / input.length; //Do not call this with an empty array
    }

    public static double largerCount(int[] input) {
        int larger = 0;
        double average = avg(input);
        for (int i = 0; i < input.length; i++) {
            if (input[i] > average) {
                larger++;
            }
        }
        return larger;
    }

    public static void main(String[] args) {
        int[] input = getArray(100);
        System.out.println(largerCount(input) + " elements are larger than the average of " + avg(input));
    }
}

公共类主{
公共静态int[]getArray（int size）{
int[]输出=新的int[size]；
对于（int i=0；i平均值）{
更大的++；
}
}
回报较大；
}
公共静态void main（字符串[]args）{
int[]输入=getArray（100）；
System.out.println（大计数（输入）+”元素大于“+平均值（输入）”的平均值）；
}
}

这样，代码更容易理解，您的工作也简化了。
您在
x
的每次迭代中都会覆盖列表，因为
x
增加到100，最后一次迭代会将
list
的每个元素设置为100。将赋值更改为
list[i]=i；
并删除
，同时
循环。另外，确定求和循环外的平均值。如果您拥有从1到100的所有数字，则可以将其简化很多。首先，您可以使用数学公式（n（n+1）/2）求和，而不是迭代，直接用和除以数组长度求平均值。不需要有这么多循环。这里有很多有用的答案，但你的答案帮助我很容易理解我为什么做错了，非常感谢！
for(int i=0; i < 100; i++){
    list[i] = i + 1;
}

public class Main {

    public static int[] getArray(int size) {
        int[] output = new int[size];
        for (int i = 0; i < size; i++) {
            output[i] = i + 1;
        }
        return output;
    }

    public static double avg(int[] input) {
        int sum = 0;
        for (int i = 0; i < input.length; i++) {
            sum += input[i];
        }        
        return sum / input.length; //Do not call this with an empty array
    }

    public static double largerCount(int[] input) {
        int larger = 0;
        double average = avg(input);
        for (int i = 0; i < input.length; i++) {
            if (input[i] > average) {
                larger++;
            }
        }
        return larger;
    }

    public static void main(String[] args) {
        int[] input = getArray(100);
        System.out.println(largerCount(input) + " elements are larger than the average of " + avg(input));
    }
}