Question

我是编程新手，并决定加入初学者在线Java课程。

我被要求做两件事：

在一行上打印一个带有前后空格的数字序列。假设方法参数centerDigit只能取0到9之间的值。例如：printSequenceDigits（2,7）导致：“01210”
借助printSequenceDigits（）方法在终端窗口上打印数字菱形图案。例如：printDigitDiamond（2）导致：
```
"   0   "           
"  010  "         
" 01210 "        
"  010  "          
"   0   "
```

到目前为止，我已经能够完成任务1，但我不确定如何使用第一个任务中的“for”循环来实现第二个任务以显示钻石。

如果有人能让我在途中，我将不胜感激

到目前为止，这是我的代码：

/**
 * Method which prints a sequence of digits with preceding and trailing white spaces on a single line 
 * of the terminal window.
 * 
 * @author  
 * @version 
 */
public class PrintSequenceDigits
{

    /**
     * Constructor which prints a sequence of digits with preceding and trailing white spaces on a single 
     * line of the terminal window
     */
    public static void printSequenceDigits(int centerDigit, int length) {
        // declare variables
        int integerCenterDigit, integerLength, integerStringLength, integerNetLength;
        String stringResults = "";
        // calculate length of stringResults
        integerStringLength = centerDigit * 2 + 1; // for printNumberLine( 2, 7 ) --> 2*2+1=5
        // calculate length of int length
        integerNetLength = (length - integerStringLength) / 2; // for printNumberLine( 2, 7 ) --> (7-5)/2=1
        for(integerCenterDigit = 0; 
            integerCenterDigit < integerNetLength; 
            integerCenterDigit++){
            stringResults = stringResults + ' '; // print blank space before
        }
        for(integerCenterDigit = 0; // print 0 
            integerCenterDigit <= centerDigit; // print 1 
            // print length +1 etc depending on input length
            integerCenterDigit++){
            stringResults = stringResults + integerCenterDigit; // for printNumberLine( 2, 7 ) print 012
        }
        for(integerCenterDigit = centerDigit -1; // print length -1 (=1)
            integerCenterDigit >= 0; 
            // print length -1 etc depending on input length
            integerCenterDigit--){
            stringResults = stringResults + integerCenterDigit; // for printNumberLine( 2, 7 ) print 10
        }
        for(integerCenterDigit = 0; 
            integerCenterDigit < integerNetLength; 
            integerCenterDigit++){ 
            stringResults = stringResults + ' '; // print blank space after
        }
        System.out.println(stringResults); // prints total of the above = " 01210 "
    }

    /**
     * Method which prints a diamond pattern of numbers on the terminal window 
     * 
     * @param
     * @return
     */
    public static void printDigitDiamond(int diamondCenter) {
        int integerDiamondCenter;

    }
}

我在这里是正确的轨道还是我必须修改任务1中的for循环？这个循环可以用不同的方式构造，以便更容易将结果从task1传递给任务2吗？

Answer 1

你走在正确的轨道上。你的第一种方法完成它的任务，对吧？检查列表中的内容。现在你需要使用第一种方法打印钻石数字，对吧？您可以通过以下两种方式实现：

让第一种方法进行打印。您的第二个任务使用适当的参数调用第一个任务，以便根据需要打印整个数字菱形。
通过返回字符串从等式中删除“打印”。

第二种解决方案与您的第一种解决方案一样好，但一般而言，第二种解决方案总体上更好。如果你考虑一下，生成字符串 AND 打印它是两个单独的任务。您可能并不总是想要两者兼顾，所以从逻辑上讲，您应该将它们分开。

实际打印有点微不足道，但如果不是，那么我建议创建一个单独的方法来执行该操作，如果有的话，创建一个调用两者的方法，以便生成和打印字符串。通过这种方式，您可以获得完整的功能，并且不会重复您的代码。

除此之外，如果您需要将3个以上的字符串附加在一起，我会推荐一个小优化。有一个名为StringBuilder的类，它具有优化字符串构造的愚蠢任务，这就是全部。

所以说，你的方法将成为：

public static void generateSequenceDigits(int centerDigit, int length) {
    int integerCenterDigit, integerLength, integerStringLength, integerNetLength;
    StringBuilder stringResults = new StringBuilder();

    integerStringLength = centerDigit * 2 + 1; 

    integerNetLength = (length - integerStringLength) / 2; 
    for(integerCenterDigit = 0; 
        integerCenterDigit < integerNetLength; 
        integerCenterDigit++){
        stringResults.append(' '); 
    }
    for(integerCenterDigit = 0;
        integerCenterDigit <= centerDigit; 
        // print length +1 etc depending on input length
        integerCenterDigit++){
        stringResults.append(integerCenterDigit);
    }
    for(integerCenterDigit = centerDigit -1; 
        integerCenterDigit >= 0; 

        integerCenterDigit--){
        stringResults.append(integerCenterDigit); 
    }
    // Not strictly necessary
    /*
    for(integerCenterDigit = 0; 
        integerCenterDigit < integerNetLength; 
        integerCenterDigit++){ 
        stringResults.append(' ');
    }
    */
    return stringResults.toString();  // <-- Build final string
}

然后打印出来，你会System.out.println(generateSequenceDigits(2, 7));。

通过这种方式，您可以在第二种方法中重复使用generateSequenceDigits。就像我在第一个中所做的那样，您可以使用StringBuilder追加行，然后以巨大的String返回它们。在您的主要内容中，您只需将其打印出来，但您可以将其写入文件或将其保存到数据库中，而如果您只是打印它，则必须首先调整您的方法。我把另一种方法留给你做。

PS - 另请注意，最后一个追加空格的循环不可见，因此我将其评论出来。可能有一些奇怪的情况，你可能需要它，所以我只是留下它注释掉。祝你好运！

Answer 2

这是为鲍里斯做的“Java方式”...

<强> dtest.java ：

import edu.iastate.its.niads.demo.Diamond;

public class dtest {
    public static void main(String[] args) {
        Diamond d = new Diamond(4);
        System.out.println(d);
    }
}

<强> Diamond.java ：

package edu.iastate.its.niads.demo;
public class Diamond {
        private static final int DEF_SIZE = 4;
        private int size;

        public Diamond ( ) { this(DEF_SIZE); }
        public Diamond ( int size ) { setSize(size); }
        public void setSize ( int size ) { this.size = size; }
        public int getSize ( ) { return size; }

        @Override
        public int hashCode ( ) { return size; }

        @Override
        public boolean equals ( Object obj ) {
                if (!(obj instanceof Diamond)) return false;
                return (((Diamond)obj).size == this.size);
        }

        /* called printSequenceDigits() in the assignment */
        private String line ( int mx, int wid ) {
                StringBuilder sb = new StringBuilder(wid + 1);
                for (int s = 0; s < (wid/2) - mx; ++s) sb.append(' ');
                for (int u = 0; u < mx; ++u) sb.append(u);
                for (int d = mx; d >= 0; --d) sb.append(d);
                for (int s = 0; s < (wid/2) - mx; ++s) sb.append(' ');
                sb.append('\n');
                return sb.toString();
        }

        /* replaces printDigitDiamond() in the assignment */
        @Override
        public String toString () {
                int dim = (2 * size) + 3;
                StringBuilder sb = new StringBuilder(dim * (dim+1));
                for (int u = 0; u < size; ++u) sb.append(line(u, dim));
                for (int d = size; d >= 0; --d) sb.append(line(d, dim));
                return sb.toString();
        }
}

示例运行：

john% java dtest
     0     
    010    
   01210   
  0123210  
 012343210 
  0123210  
   01210   
    010    
     0

Answer 3

您在解决方案中使用了太多循环。您的代码作为初学者很好，但如果您想要了解更多信息，那么这是printDiamond()和printSequenceDigits()函数的更好实现。

我还添加了评论，让您更好地理解该计划。如果您想了解任何特定部分，请随意发表评论。

以下是代码段：

public static void main (String[] args)
{
    /* Print Diamond */
    printDiamond(4);
}

/**
 * Print Diamond
 * Arguments: Length of the diamond
**/
private static void printDiamond(int num) {
    /* Check Input Number */
    if(num < 0 || num > 9) {
        System.out.println("Invalid Input!");
        return;
    }

    /* Length = num*2 + 1 */
    for(int i = 0; i < num*2 + 1; i++) {
        /* Print Sequence Digits */
        printSequenceDigits(i <= num ? i : num*2 - i, num*2 + 1);
    }
}

/**
 * Print Sequence Digits
 * Arguments: Row Index, Total Length of Row
**/
private static void printSequenceDigits(int x, int length) {
    /* Crate Row Sequence */
    char[] ptr = new char[x*2+1];

    /* Fill The Values */
    for(int i = 0; i < ptr.length/2 + 1; i++) {
        /* First Half = Other Half (Reversed) */
        ptr[i] = ptr[ptr.length - 1 - i] = (char) (i + '0');
    }

    /* Pad Extra Spaces */
    char[] padding = new char[(length - ptr.length)/2];
    Arrays.fill(padding,' ');

    /* Print Sequence */
    System.out.println("\" " + new String(padding) + new String(ptr) 
                             + new String(padding) + " \"");
}

输出：

"     0     "
"    010    "
"   01210   "
"  0123210  "
" 012343210 "
"  0123210  "
"   01210   "
"    010    "
"     0     "

Answer 4

您可以使用以下逻辑打印钻石。

    int  number = 3;
    int space = number -1;
    for (int i = 1; i < number; i++) {

        for(int s = 1; s <= space; s++) {
            System.out.print(" ");
        }
        space--;
        for (int j = 0; j < i; j++) {
            System.out.print(j);
        }
        for (int p = i - 2 ; p >= 0; p--) {
            System.out.print(p);
        }
        System.out.print("\n");
    }
    space = 0;
    for (int i = number; i > 0; i--) {

        for(int s = 0; s < space; s++) {
            System.out.print(" ");
        }
        space++;
        for (int j = 0; j < i; j++) {
            System.out.print(j);
        }
        for (int p = i - 2 ; p >= 0; p--) {
            System.out.print(p);
        }
        System.out.print("\n");
    }

我需要一个返回数字菱形图案的Java方法

4 个答案: