【问题标题】：Printing methods from main method not working - Java从主要方法打印方法不起作用 - Java
【发布时间】：2017-09-03 18:16:08
【问题描述】：

所以我被指示编写一个生成数组（带返回）的类，对生成的数组进行排序，将排序后的数组反转（带返回），然后检查排序后是否有任何 2 个相邻的 # 是相同（如果有则返回 True，如果没有则返回 False）。

到目前为止，我已经设法写出了我能说的所有内容，但是我的最后一组指令是用 print 语句填充 main，这些语句调用我编写的低级方法，以按写入的顺序显示。

我设法让原始随机生成的数组被调用和打印，但是我在调用任何其他方法时都没有运气，就像我第一次那样，我已经尝试了我能想到的所有方法来获取它们只需使用提供的“This is the blah blah blah:”打印他们的结果

如果有人能指出我正确的方向，只要能够调用其他方法来打印他们的结果，以及每个打印输出都包含一个基本语句，如“随机数组是：”、“排序数组是："，"反转数组是："，"它是 (TRUE/FALSE) 这个数组有相邻的重复项。"我将不胜感激。我在这一点上尝试过的任何事情都没有奏效，而且我处于完全静止状态。我一直在尝试与熟悉 java 的朋友一起工作，但我们似乎也被困住了。这是我目前写的...

import java.util.*;

public class SortedSequence 
{
   public static void main(String[] args) 
{
  int[] randomNumbers = new int[20];
  randomNumbers = generateRandom(20);
  printArray(randomNumbers);

 // This is where Im getting stuck at. Everything I've tried makes a compile error

}

  public static int[] generateRandom(int n) 
  {
     int[] genNumbers = new int[n];

     Random rand = new Random();
        for (int i = 0; i < genNumbers.length; i++) 
     {
        int bubble = rand.nextInt(100);
        genNumbers[i] = bubble; 
     }
        return genNumbers;
     }

  public static void sortArray(int[] genNumbers) 
     {
        Arrays.sort(genNumbers); 
     }

  public static int[] reverse(int[] x) 
      { 
        int[] sortArray = new int[x.length]; 
        for (int i = 0; i < x.length; i++) { 
        sortArray[i] = x[x.length - 1 -i];
      }
        return sortArray; 
      }


  public static boolean adjacentDuplicates(int[] boo)
     {
        boolean duplicates = false;
        for (int i = 0; !duplicates && i < boo.length-1; i++)
        if (boo[i] == boo[i+1]);
     {
        duplicates = true;
     }
        return duplicates;
     }

  public static void printArray(int[] print)
     {
        for (int i = 0; i < print.length; i++) {
        System.out.print(print[i] + " "); }
        System.out.println();
     }
}

【问题讨论】：

标签： java methods printing method-call

【解决方案1】：

我编译了代码，我没有收到任何错误。

我在主类中添加了一个printArray(reverse(randomNumbers));，如下所示：

   public static void main(String[] args) 
{
  int[] randomNumbers = new int[20];
  randomNumbers = generateRandom(20);
  printArray(randomNumbers);
  printArray(reverse(randomNumbers));

 // This is where Im getting stuck at. Everything I've tried makes a compile error

}

在运行程序时，它返回：

28 87 13 22 85 0 60 59 90 30 52 15 32 72 9 76 83 89 36 39 
39 36 89 83 76 9 72 32 15 52 30 90 59 60 0 85 22 13 87 28

这似乎是您的编译器的问题，或者您调用该类的方式。

后续问题的答案。

这是排序类所需的内容。 Arrays.sort() 方法获取数组并在其中手动移动它们。：

  public static int[] sortArray(int[] genNumbers) 
     {
        Arrays.sort(genNumbers); 
        return genNumbers;
     }

此外，您将其返回设置为 void，而不是 int[]。

相邻的重复项

老实说，我不知道相邻的副本到底发生了什么。看起来 if 和 for 方法什么也没做，因为你在 ) 后面直接放了一个 ;。

您的代码需要位于) 和; 的末尾之间，或者您需要在for 循环声明之后使用{}（如下所示）。

另外，使用那些下一行括号不利于可读性，我建议不要这样做。这里是相邻Duplicates 方法的样子。

  public static boolean adjacentDuplicates(int[] boo) {
        boolean duplicates = false;
        for (int i = 0; !duplicates && i < boo.length-1; i++) {
            if (boo[i] == boo[i+1]) duplicates = true;
        }
        return duplicates;
     }

运行那个

现在，我们可以通过以下方式打印所有内容并获取可读信息：

   public static void main(String[] args) 
{
  int[] randomNumbers = new int[20];
  randomNumbers = generateRandom(20);


  System.out.print("Array: ");
  printArray(randomNumbers);
  System.out.print("Reversed: ");
  printArray(reverse(randomNumbers));
  System.out.print("Sorted: ");
  printArray(sortArray(randomNumbers));
  System.out.print("Adjacent Duplicates?: ");
  System.out.println(adjacentDuplicates(randomNumbers));
  // If we sort out the numbers, then any duplicates will become adjacent to each other
  System.out.print("Duplicates at all?: ");
  System.out.println(adjacentDuplicates(sortArray(randomNumbers)));

 // This is where Im getting stuck at. Everything I've tried makes a compile error

}

试运行：

Array: 92 18 5 16 68 10 85 58 50 56 91 48 45 28 63 98 94 15 93 64 
Reversed: 64 93 15 94 98 63 28 45 48 91 56 50 58 85 10 68 16 5 18 92 
Sorted: 5 10 15 16 18 28 45 48 50 56 58 63 64 68 85 91 92 93 94 98 
Adjacent Duplicates?: false
Duplicates at all?: false

Here's the full class.在底部再次列出。

换行符

您似乎希望它采用不同的格式。我会让你享受这样做的乐趣，但请注意：

System.out.print("bla")

将打印此内容，而不是在末尾添加换行符

System.out.println("blap");

将打印字符串并添加换行符。

所以

System.out.print("bla");
System.out.println("blap");
System.out.print("blo");

就像跑步一样

System.out.print("bla blap\n blo")

两者都会打印：

bla blap
blo

Here's all of that code

【讨论】：

我正在使用 jgrasp。这对我有用，也许只是因为我一直坚持使用带有编译问题的 sortArray 方法。你会说因为它没有返回，这就是为什么它不断返回编译错误？
@Matt 你遇到了什么错误？
如果你能从那里考虑我的情况，我更新了我已经完成的工作。
@MattJackson，我已经更新了我的问题。请参阅原始答案下方的新部分。

【解决方案2】：

所以我得到了 3 个 int 数组来打印。

不确定如何从 main 打印布尔 T 或 F...

也不确定我是如何设法让初始随机数组打印在与我需要在数组之前呈现的 txt 相同的行上，但确实如此，尤其是在所有其他代码相同且不做相同的情况下东西……

关于让数组与描述性文本在同一行打印的建议？我的布尔情况呢？

 /**
 * This class generates a random array of 20 int long, sorts
 * the array, reverses the array, check to see if there are
 * any duplicate adjacent numbers, prints true if there are or
 * false if there aren't, and then prints the results.
 *
 *@author Matthew Jackson
 *@version 9/5/2017
 *
 */
 import java.util.*;

 public class SortedSequence 
 {
  public static void main(String[] args) 
  {
  System.out.print("The Random array is: ");
  int[] randomNumbers = new int[20];
  randomNumbers = generateRandom(20);
  printArray(randomNumbers);
  System.out.println();

  System.out.println("The Sorted array is: ");
  sortArray(randomNumbers);
  printArray(randomNumbers);
  System.out.println();

  System.out.println("The Reverse array is: ");
  printArray(reverse(randomNumbers));
  System.out.println();

  System.out.println("It is" + "this array has adjacent duplicates");
  if(adjacentDuplicates(randomNumbers))
  {
     // Put something here to print the boolean T/F?
  }

}

 /**
  * Generate an array of type int and size n that returns
  * this array from the method
  *
  *@param n Generate random number array
  *@return Return array list that was generated
  */

  public static int[] generateRandom(int n) 
  {
     int[] genNumbers = new int[n];

     Random rand = new Random();
        for (int i = 0; i < genNumbers.length; i++) {
        int bubble = rand.nextInt(100);
        genNumbers[i] = bubble; }
        return genNumbers;
   }

 /**
  *Sort array of randomly generated numbers
  *
  *@param genNumbers Calls method of randomly generated number array
  */

  public static void sortArray(int[] genNumbers) 
     {
        Arrays.sort(genNumbers); 
     }

  /**
   *Reverse array of sorted array numbers
   *
   *@param Reverses list of sorted array numbers.
   *@return Return array in reverse original order
   */

  public static int[] reverse(int[] x) 
      { 
        int[] sortArray = new int[x.length]; 
        for (int i = 0; i < x.length; i++) { 
        sortArray[i] = x[x.length - 1 -i];
      }
        return sortArray; 
      }

   /**
    *Check array list to see if there are any duplicates
    *adjacent to each other
    *
    *@param duplicates True if adjacent numbers are same,
    *                  false if not.
    *@return Returns True/False if there are adjacent duplicates or not
    */

  public static boolean adjacentDuplicates(int[] boo)
     {
        boolean duplicates = false;
        for (int i = 0; !duplicates && i < boo.length-1; i++)
        if (boo[i] == boo[i+1]);
        { //else infront of the {?
        duplicates = true;
     }
        return duplicates;
     }

   /**
     *Prints given array
     *
     *@param print Prints any method called to it
     */ 

  public static void printArray(int[] print)
     {
        for (int i = 0; i < print.length; i++) {
        System.out.print(print[i] + " "); }
        System.out.println();
     }
}

【讨论】：