Question

所以我有一个22号的数组，从控制台读取一个数字并将数字添加到数组中。所以如果在阵列中读取123456将打印出来

12345600000000 ...沿着这些方向的东西。

我需要右对齐这个数字来执行算术运算，但我似乎无法正确地输出循环结构来输出数字！

int[] newlong = new int[22];
String inputline = "";

public void readNewLong()
{
    Scanner in = new Scanner(System.in);
    inputline = in.nextLine();

    try
    {
         for (int i = 0; i < inputline.length(); i ++)
         {
              char a = inputline.charAt(i);
              String b = "" + a;
              newlong[i] = Integer.parseInt(b);
         }

    }
    catch (NumberFormatException nfe)
    {
        System.out.println("NumberFormatException, you must enter a string of digits. " + nfe.getMessage());
    }
}

这是读取数字，输入行并将其存储在数组newLong中的内容。

以下方法是不起作用的......

public void rightJustify()
{
     printLong();
     System.out.println(inputline.length());

     for(int i = 0; i< inputline.length(); i++)
     {
         for(int j = 0; j < newlong.length; j++)
         {
              newlong[j] = (newlong[j] - (inputline.length() -i));
         }  
     }
     printLong();      
}

Answer 1

为什么你想要合理的权利实际上你可以按正确的顺序输入？

如果newlong []是全局的，那么在所有位置都有0

for (int i = inputline.length()-1; i>=0; i--)
{
    char a = inputline.charAt(i);
    String b = "" + a;
    newlong[22 - inputline.length() + i] = Integer.parseInt(b);
}

<强>编辑：如果你更喜欢你的对齐方法，我建议你：

public void rightJustify() {
    System.out.println(inputline.length());

    for (int i = inputline.length()-1; i>=0; i--) {
        newlong[22 - inputline.length() + i] = newlong[i];
        newlong[i] = 0;
    }
}

Answer 2

为什么在阅读数据时没有正确对齐？

Scanner in = new Scanner(System.in);
    String inputline = in.nextLine();

    StringBuilder inputData = new StringBuilder();
    try {
        for (int i = 0; i < inputline.length(); i++) {
            char a = inputline.charAt(i);
            inputData.append(a);
        }

        for (int i = 0; i < inputData.length(); i++) {
            newlong[newlong.length - inputData.length() + i] = Integer
                    .parseInt("" + inputData.charAt(i));
        }

        printLong(newlong);
    } catch (NumberFormatException nfe) {
        System.out
                .println("NumberFormatException, you must enter a string of digits. "
                        + nfe.getMessage());
    }

这是一个输出

    123456
    0000000000000000123456

Answer 3

这是一种解析整数的奇怪方法。尽管如此，您不需要嵌套循环来右对齐数组：

// len is the number of digits of input.
public void rightJustify(int[] digits, int len)
{
    int off = digits.length() - len;
    for (int i = len; i-- > 0; ) digits[i + off] = digits[j];
    for (int i = off; i-- > 0; ) digits[i] = 0;
}

Answer 4

好吧，这显然是家庭作业，这就是为什么我们使用for循环，但在实践中我只是使用：

// len is the number of digits of input.
public void rightJustify(int[] digits, int len) {
    System.arraycopy(digits, 0, digits, len, digits.length() - len);
    System.fill(digits, 0, len, 0);
}

没有理由重新发明轮子，即使这个功能对于它来说是微不足道的。

将数组的所有元素移动到右侧

4 个答案: