如何将 int 值 09 转换为 char 数组作为 {'0','9'}？

Question

I am working on the problem to find the next greatest number with the same set of digits.

For this I take a integer value input from the user and I want to convert to char array or int array so that I can access individual digits.

But when I take

int value=09 as the input and convert to char array it gives only 9 as it considers it to be octal value. How can I overcome this ?

Answer 1

It is not possible convert a 09 int value to a String of 9 since the value 09 can not be stored in an int .

int is not capable of storing trailing zeros.

Take this sample.

int foo = Integer.valueOf("09");
System.out.println(foo);

Output

9

So to solve your problem you should get a String from the user, validate it and parse it to an Integer[] .

Solution

public Integer[] parseToInteger(String number) {
    return Arrays.asList(number.toCharArray())
        .stream()
        .map(c -> Integer.valueOf(c.toString()))
        .toArray(size -> new Integer[size]);
}

Now you have an Array of Integer .

Answer 2

it is not possible in java to take the int values with leading zeros. so for the value with leading zeros take it in string format.

but we can insert zeros

int n=7;
String str=String.format("%04d", n); //4 denotes the size of the string
System.out.println(str); // o/p->0007

Answer 3

Since leading 0's are dropped from integers there is no reason to support assigning such a value to an int.

If I want to convert 9 to '9' I usually just add '0' to it.

You can also do the following:

char c = Character.forDigit(9,10);

If you have a string of characters, you can do the following:

        String str = "09";
        List<Character> chrs =
                str.chars().mapToObj(a -> Character.valueOf((char) a))
                        .collect(Collectors.toList());
        System.out.println(chrs);

Prints

[0,9]

Answer 4

I am working on the problem to find the next greatest number with the same set of digits.

For this I take a integer value input from the user and I want to convert to char array or int array so that I can access individual digits.

But when I take

int value=09 as the input and convert to char array it gives only 9 as it considers it to be octal value. How can I overcome this ?

Answer 5

You are asking how to parse a number starting with a leading zero, but I get the feeling that you are actually on the worng track given the problem you are trying to resolve. So let's take one step backward, and lets make sure I understand your problem correctly.

You say that you have to find the "next greatest number with the same set of digits". So you are playing "Scrabble" with digits, trying to find the smalest number composed with the same digits that is strictly greater to the original number. For example, given the input "09", you would output "90", and for "123", you would output "132". Is that right? Let assume so.

Now, the real challenge here is how to determine the smalest number composed with thise digits that is stricly greater to the original number. Actually, there's a few possible strategies:

1. Enumerate all possible permutations of those digits, then filter out those that are not strictly greater to the original number, and then, among the remaining values, find the smallest value. That would be a very innefficient strategy, requiring both disproportionate memory and processing power. Please, don't consider this seriously (that is, unless you are actually coding for a Quantum Computer ;) ).
2. Set a variable to the initial number, then iteratively increment that variable by one until you eventually get a number that is composed of the same digits as the original values. That one might look simple to implement, but it actually hides some complexities (ie determining that two numbers are composed from the same digits is not trivial , special handling would be required to avoid endless loop if the initial number is actually the greatest value that can be formed with those digits). Anyway, this strategy would also be rather innefficient, requiring considerable processing power.
3. Iterate over the digits themselves, and determine exactly which digits have to be swapped/reordered to get the next number. This is actually very simple to implement (I just wrote it in less that 5 minutes), but require some thinking first. The algorithm is O(n log n), where n is the length of the number (in digits). Take a sheet of paper, write example numbers in columns, and try to understand the logic behind it. This is definitely the way to go.

All three strategies have one thing in common: they all require that you work (at some point at least) with digits rather than with the number itself. In the last strategy, you actually never need the actual value itself. You are simply playing Scrabble, with digits rather than letters.

So assuming you indeed want to implement strategy 3, here is what your main method might looks like (I wont expand more on this one, comments should be far enough):

public static void main(String[] args) {

    // Read input number and parse it into an array of digit
    String inputText = readLineFromUser();
    int[] inputDigits = parseToDigits(inputText);

    // Determine the next greater number
    int[] outputDigits = findNextGreaterNumber(inputDigits);

    // Output the resulting value
    String outputText = joinDigits(outputDigits);
    println(outputText);
}

So here's the point of all this discussion: the parseToDigits method takes a String and return an array of digits (I used int here to keep things simpler, but byte would actually have been enough). So basically, you want to take the characters of the input string, and convert that array to an array of integer, with each position in the output containing the value of the corresponding digit in the input. This can be written in various ways in Java, but I think the most simple would be with a simple for loop:

public static int[] parseToDigits(String input) {

    char[] chars = input.toCharArray();
    int[] digits = new int[chars.length];

    for (int i = 0 ; i < chars.length ; i++)
        digits[i] = Character.forDigit(chars[i], 10);

    return digits;
}

Note that Character.forDigit(digit, radix) returns the value of character digit in base radix ; if digit is not valid for the given base, forDigit returns 0 . For simplicity, I'm skipping proper validation checking here. One could consider calling Character.isDigit(digit, radix) first to determine if a digit is acceptable, throwing an exception if it is not.

As to the opposite opperation, joinDigits , it would looks like:

public static String joinDigits(int[] digits) {
    char[] chars = new char[digits.length];

    for (int i = 0 ; i < digits.length ; i++)
        chars[i] = Character.digit(digits[i], 10);

    return new String(chars);
}

Hope that helps.