java parsing array input control

There is a neat solution, involving Regular Expressions, Streams and some lambdas. Core concept is that we define the input format through a regular expression. We need some sequence of digits, followed by a 'D' or a 'd', followed by a " ", followed by a sequence of digits, followed by a C or c,... I will skip derivation of this pattern, it is explained in the regular expression tutorial I linked above. We will find that

final String regex = "([0-9]+)[D|d]\\ ([0-9]+)[C|c]\\ ([0-9]+)[P|p]\\ ([0-9]+)[H|h]";

satisfies our needs. With this regular expression we can now determine whether our input String has the right format (input.matches(regex)), as well as extract the bits of information we are actually interested in (input.replaceAll(regex, "$1 $2 $3 $4"). Sadly, replaceAll yields another String, but it will contain the four digit sequences we are interested in, divided by a " ". We will use some stream-magic to transform this String into a long[] (where the first cell holds the D-value, the second holds the C-value,...). The final program looks like this:

import java.util.Arrays;

public class Test {
    public static void main(String... args) {
        final String input = args[0];
        final String regex =
                "([0-9]+)[D|d]\\ ([0-9]+)[C|c]\\ ([0-9]+)[P|p]\\ ([0-9]+)[H|h]";

        if (input.matches(regex) == false) {
            throw new IllegalArgumentException("Input is malformed.");
        }

        long[] values = Arrays.stream(input.replaceAll(regex, "$1 $2 $3 $4").split(" "))
                .mapToLong(Long::parseLong)
                .toArray();

        System.out.println(Arrays.toString(values));
    }
}

If you want to have a List<Long> instead a long[] (or a List<Integer> instead of an int[]), you would use

        List<Long> values = Arrays.stream(input.replaceAll(regex, "$1 $2 $3 $4").split(" "))
                .map(Long::parseLong)
                .collect(Collectors.toList());

It is necessary to change mapToLong to map to receive a Stream<Long> instead of a LongStream. I am sure that one could somehow write a custom Collector for LongStream to transform it into a List<Long>, but I found this solution more readable and reliable (after all, the Collector used comes from Oracle, I trust they test their code extensively).

Here is some example call:

$> java Test "10D 9c 8p 7H"
[10, 9, 8, 7]

$> java Test "10E 9C 8P 7H"
Exception in thread "main" java.lang.IllegalArgumentException: Input is malformed.
        at Test.main(Test.java:10)

$> java Test "10D 9C 8P 7H 10D 9C 8P 7H"
Exception in thread "main" java.lang.IllegalArgumentException: Input is malformed.
        at Test.main(Test.java:10)

Question1

You can actually check if the input is what it's supposed to be with simple checks. For example, you can check the first element like this:

if(tokens[0].charAt(1).equals("D")) 
    return true;
else
    return false;

Another way to check if the input is correct is by using Regular Expressions, but I assume you are a beginner and this is too much trouble for you, although it is the better way. So I leave it to you to look through it later.

Question2

You can actually listen to your friend and do as they said. You can write it as follows:

for(int i = 0; i < 4; i++) 
   System.out.print(" " + tokens[i])

System.out.println();

Or you may use

System.out.println(Arrays.toString(newArray));

And you have saved newArray like this:

newArray[0] = " " + tokens[0];

you could use the .equals() method to see if what a user has typed in matches what you have

if (currencyIn.equals("CurrencyFormat"))
{
 ...
}

this is probably the simplest way i can think of!