为什么我的阵列不起作用？ [复制]

Question

我发誓我把它们放对了。他们应该生成/使用从 -100 到 100 的 25 个数字，并且我使用的程序编译得非常好，但输出以下内容：

 ----jGRASP exec: java IntegerArrayRunner
Numbers Array: [I@3343c8b3
Numbers Array Element Count: 25
Numbers Array Sum: 0
Numbers Array Average: 0
Evens Array: [I@272d7a10
Evens Array Element Count: 25
Evens Array Sum: 0
Evens Array Average: 0
Odds Array: [I@1aa8c488
Odds Array Element Count: 25
Odds Array Sum: 0
Odds Array Average: 0
Negatives Array: [I@3dfeca64
Negatives Array Element Count: 25
Negatives Array Sum: 0
Negatives Array Average: 0

 ----jGRASP: operation complete.

说真的，这是怎么回事？为什么它会打印出那些奇怪的符号和字符组合？他们甚至是什么意思？以下是使用的程序。

public class IntegerArrayMain
{      
   private int[] numbers = new int [25];
   private int[] evens = new int [25];
   private int[] odds = new int [25];
   private int[] negatives = new int [25];
   private int sum;
   private int numbersSum;
   private int evenSum;
   private int oddSum;
   private int negaSum;
   private int avg;
   private int numbersAvg;
   private int evenAvg;
   private int oddAvg;
   private int negaAvg;

   DiceClass rng = new DiceClass(200);

   //============================NUMBERS====================================

   /**
   *Generates the 25 numbers.
   */
   public int[] setNumbers()
   {
      for(int i = 0; i < numbers.length; i++)
      {
         numbers[0] = (rng.getRoll() - 100);
         sum += numbers[i];
      }
      return numbers;
   }
   /**
   *Returns the numbers.
   */
   public int[] getNumbers()
   {
      return numbers;
   }
   /**
   *Finds and returns the sum of the numbers.
   */
   public int setNumsSum()
   {
      int numbersSum = 0;
      for( int i = 0; i < numbers.length; i++) {
         sum += numbers[i];
      }
      return numbersSum;
   }
   /**
   *Returns the numbers' sum.
   */
   public int getNumsSum()
   {
      return numbersSum;
   } 
   /**
   *Finds and returns the average of the numbers.
   */
   public double setNumsAvg()
   {
       double numbersAvg = sum/numbers.length;
       return numbersAvg;
   }
   /**
   *Returns the numbers' average.
   */
   public int getNumsAvg()
   {
      return numbersAvg;
   }  
   //============================EVENS======================================

   /**
   *Locates the even numbers.
   */
   public void findEvens()
   {
      int n = 0;
      for(int i : numbers){
         if((i % 2) == 0){
         evens[n] = i;
         }
         n++;
      }
   }
   /**
   *Returns the even numbers.
   */
   public int[] getEvens()
   {
      return evens;
   }
   /**
   *Finds and returns the sum of the evens.
   */
   public int setEvensSum()
   {
      int evenSum = 0;
      for( int i = 0; i < evens.length; i++) {
         sum += evens[i];
      }
      return evenSum;
   }
   /**
   *Returns the even numbers' sum.
   */
   public int getEvensSum()
   {
      return evenSum;
   }  
   /**
   *Finds and returns the average of the evens.
   */
   public double setEvensAvg()
   {
       double evenAvg = sum/evens.length;
       return evenAvg;
   }
   /**
   *Returns the even numbers' average.
   */
   public int getEvensAvg()
   {
      return evenAvg;
   }  

   //============================ODDS=======================================

   /**
   *Locates the odd numbers.
   */
   public void findOdds()
   {
      int n = 0;
      for(int i : numbers){
         if((i % 1) == 0){
         odds[n] = i;
         }
         n++;
      }
   }
   /**
   *Returns the odd numbers.
   */
   public int[] getOdds()
   {
      return odds;
   }
   /**
   *Finds and returns the sum of the odds.
   */
   public int setOddsSum()
   {
      int oddSum = 0;
      for( int i = 0; i < odds.length; i++) {
         sum += odds[i];
      }
      return oddSum;
   }
   /**
   *Returns the odd numbers' sum.
   */
   public int getOddsSum()
   {
      return oddSum;
   }  
   /**
   *Finds and returns the average of the odds.
   */
   public double setOddsAvg()
   {
       double oddAvg = sum/odds.length;
       return oddAvg;
   } 
   /**
   *Returns the odd numbers' average.
   */
   public int getOddsAvg()
   {
      return oddAvg;
   }  

   //============================NEGATIVES==================================

   /**
   *Locates the negative numbers.
   */
   public void findNegatives()
   {
      int n = 0;
      for(int i : numbers){
         if((i % 2) == 0){
         negatives[n] = i;
         }
         n++;
      }
   }
   /**
   *Returns the negative numbers.
   */
   public int[] getNegatives()
   {
      return negatives;
   }
   /**
   *Finds and returns the sum of the negatives.
   */
   public int setNegativesSum()
   {
      int negaSum = 0;
      for( int i = 0; i < negatives.length; i++) {
         sum += negatives[i];
      }
      return negaSum;
   }
   /**
   *Returns the negatives numbers' sum.
   */
   public int getNegativesSum()
   {
      return negaSum;
   }  
   /**
   *Finds and returns the average of the negatives.
   */
   public double setNegativesAvg()
   {
       double negaAvg = sum/negatives.length;
       return negaAvg;
   }
   /**
   *Returns the negative numbers' average.
   */
   public int getNegativesAvg()
   {
      return negaAvg;
   }  
}

还有一个：

import java.util.Scanner;

public class IntegerArrayRunner
{
   public static void main(String[] args)
   {

      System.out.println("Numbers Array: " + getNumbers());
      System.out.println("Numbers Array Element Count: " + numbers.length());
      System.out.println("Numbers Array Sum: " + getNumsSum());
      System.out.println("Numbers Array Average: " + getNumsAvg());

      System.out.println("Evens Array: " + getEvens());
      System.out.println("Evens Array Element Count: " + evens.length());
      System.out.println("Evens Array Sum: " + getEvensSum());
      System.out.println("Evens Array Average: " + getEvensAvg());

      System.out.println("Odds Array: " + getOdds());
      System.out.println("Odds Array Element Count: " + odds.length());
      System.out.println("Odds Array Sum: " + getOddsSum());
      System.out.println("Odds Array Average: " + getOddsAvg());

      System.out.println("Negatives Array: " + getNegatives());
      System.out.println("Negatives Array Element Count: " + negatives.length());   
      System.out.println("Negatives Array Sum: " + getNegativesSum());
      System.out.println("Negatives Array Average: " + getNegativesAvg());

   }
}

Answer 1

您所指的奇怪字符是该数组的内存地址。

您需要遍历您的数组以打印内容，或者只需使用Arrays.toString(array) 打印出数组的内容。

在一个单独的 Java 文件上试试这个进行练习：

int[] a = {3,5,4,31,23};
System.out.println(a);  // Prints [I@15bdc50
System.out.println(Arrays.toString(a)); // Prints [3, 5, 4, 31, 23]

Answer 2

您正在打印数组，例如在第一行打印：

System.out.println("Numbers Array: " + getNumbers());

您正在打印结果中的数组引用"Numbers Array: " + getNumbers() 将调用ToString()on getNumbers() 结果将返回实例的哈希码，您需要改为执行getNumbers().length 我猜？

Answer 3

您打印的是数组对象的值，而不是数组的内容。如果要打印数组的内容，请考虑编写一个函数以返回格式化的内容字符串，或者将您的打印语句更改为如下内容：

由于你多次使用这个，我建议你写一个函数来打印一个格式化的字符串。

您可以在文件顶部写上import java.util.Arrays，如果您愿意，可以使用Arrays.toString(numbers) 函数，但是如果您定义了一个函数，那么您可以随时通过编辑函数来更改它的外观。

public String arrayToString(int[] array)
{
    String s = "";
    for (int i; i < array.length - 1; i++)
    {
        s += s + ", ";
    }
    //add last element of the array to the string without a comma
    s += "" + array[array.length - 1];

    //if the array is [1, 2, 3, 4]
    //this will return "1, 2, 3, 4"
    return s;
}

然后只需使用函数值打印即可：

System.out.println("Numbers array: " + arrayToString(numbers));

Answer 4

那些“符号和字符的奇数组合”是通过在对象上调用hashcode() 方法获得的对象的哈希码。当您打印一个对象时，Java 会自动调用该对象的toString() 方法。现在，在某些对象（例如int）中，toString() 已被覆盖以打印实际值（check the course code for Integer）。但是，在数组的情况下，toString() 方法并没有被覆盖；所以它回退到 Object 类定义的内容，它只是打印对象的哈希码 (check the source code of Object's toString())。

Answer 5

您的 getNumbers()、getEvens()、getOdds()、getNegatives() 应该打印数组内容吗？ 如果是这样，您应该阅读以下内容：Java overloading toString() method when array of class is given

这个问题似乎是重复的。