这个构造函数是什么样的？

Question

public byte[] d

In this byte array, each byte represents a digits, where d[0] is the least significant digit, and a[d.length-1] is the most significant digit. For example, 543210 is stored as {0,1,2,3,4,5}. The most significant digit can't be a zero;

In the real implementation, this array should be private.

Constructor Detail: AdditionOnlyInt

public AdditionOnlyInt(java.lang.String a)

This is a constructor that construct an AdditionOnlyInt with value presented by the input string. For example, if input a = "00012340", this constructor will set the byte array to have value {0,4,3,2,1}. Note that the leading zeros in the input string should not be stored.

Parameters:a - is a string such as "00012340"

I do not know how to do this constructor does anyone?

I know its very wrong but I tried this

public AdditionOnlyInt(String number)  {
   int counter = number.length();
   number.replace("0","");
   data = new byte[number.length()];
   int i = 0;
   while(i<number.length())  {
      data[i] = (byte)number.charAt(counter);
      i++;
      counter--;
   }
}

and I do know converting to byte gives you different values.

Answer 1

You're in luck: only a handful of modifications need to be made to your program. You weren't entirely wrong. :)

First, these three statements are giving you fits:

int counter = number.length();
number.replace("0","");
data = new byte[number.length()];

You get a counter, which is the unbiased String (that is, with zeroes), which will undoubtedly be smaller than the String, without zeroes. You'd also be creating the array with the size of the unbiased list.

Well...it would be if your second statement did something. String is immutable, so anything that's done to modify it would only generate a new String , leaving the old one unmodified. That's fixable by this:

number = number.replace("0", "");

...but in reality, given your input set, it should be fixed by this:

number = String.valueOf(Integer.parseInt(number));

This way, you keep internal zeroes.

Now assuming that your byte[] is actually called data and not d , there's one little issue we have to fix: numbers in terms of a byte are quite large (that is, the character for '7' is 0x37, which is 55).

So we need to bias it. Whatever our byte number is, we need to subtract '0' from it; that is, we need to subtract 48 from it, to give us our correct value. I'll show you what that looks like in a moment.

Now, for your loop:

int i = 0;
while(i<number.length())  {
   data[i] = (byte)number.charAt(counter);
   i++;
   counter--;
}

I'm not sold on the necessity of counter, so let's get rid of it. Now we'll use i from now on. Essentially, what this means is that we have to move charAt from the end of the String to the front of the String , placing the values into the array as such. What that (mostly) looks like is this:

data[i] = (byte) (number.charAt(number.length() - 1 - i);

Pay close attention here - we have to subtract 1 from the length right off the bat, since we don't have a place on the String that's exactly equal to its maximum length. We then subtract i from that, so we get the effect of moving backwards on the String .

That is, for a string of length 10 without zeroes, if we start at i = 0 , we get the character at 10 - 1 - 0 = 9 , or the last character.

Remember what I said about biasing the result of that, though? After you've got the data, be sure to subtract '0' from it.

data[i] = (byte) (number.charAt(number.length() - 1 - i) - '0';

And really, that's all there is to it. You mostly got it, except the iteration and sanitization was a bit wonky.

Answer 2

public AdditionOnlyInt(String input)
{
    //remove trailing 0s
    int  relevStart = 0;
    while(input.charAt(relevStart) == '0')
    {
        relevStart++;
    }
    String relevantTerms = input.substring(relevStart);
    //flip the remaining chars
    int length = relevantTerms.length();
    data = new byte[length];
    for(int iter = 0; iter < length; iter++)
    {
        data[iter] = (byte) (relevantTerms.charAt(length - iter - 1) - '0');
    }
}

Answer 3

Hope this helps.

Step 1: Check whether its a number by using Integer value = Integer.valueOf(args);

Step 2: convert the Integer into a byte array by calling byte array[] = value.toString().getBytes();

Step 3: the byte array contains the value in forward fashion, So swapping all the values in the array will make the digit reverse as user requested.

for (int i = 0, j = array.length - 1; i < array.length / 2; i++, j--) {
                        byte temp = array[i];
                        array[i] = array[j];
                        array[j] = temp;
                    }

find the complete program below:

   public class AdditionOnlyInt {

        public static void main(String[] args) {
            // TODO Auto-generated method stub
            new AdditionOnlyInt("01010120");

        }

        public AdditionOnlyInt(String args) {
            try {
                Integer value = Integer.valueOf(args);

                byte array[] = value.toString().getBytes();

                for (int i = 0, j = array.length - 1; i < array.length / 2; i++, j--) {
                    byte temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }

                for (int i = 0; i < array.length; i++) {
                    System.out.print((char) array[i]);
                }
            } catch (Exception e) {
            }
        }
    }