Core Classes

Notice the presence of an alternate implementation mask2(String s) employing yet not covered arrays being based on the Arrays.fill (...) library method.

Full code solution available here.

We present a step by step solution. We start by coding a loop creating the set of all substrings of length 13. Reading the String documentation the method substring(...) allows for accessing the set of all substrings of 13 adjacent digits:

public static void main(String[] args) {
  final String input = "731671765 ... 63450";

  final int NUM_OF_DIGITS = 13;   // The intended number of adjacent digits

  for (int i = 0; i < input.length() - NUM_OF_DIGITS + 1; i++) {
    final String thirteenDigitWord = input.substring(i, i + NUM_OF_DIGITS);
    System.out.println(thirteenDigitWord);
  }
}

This creates the following output:

7316717653133
3167176531330
1671765313306
  ...

5304207529634
3042075296345
0420752963450

The method charAt(int index) allows us to access each character within our string individually. We need to write a method which converts a digit like '4' to the value 4. Remember: The Unicode value of e.g. character '4' equals its ASCII value which is just 52. Thus we need a translation like:

private static int getDigitValue (final char digit) {
  switch(digit) {
    case '0': return 0;
    case '1': return 1;
    case '2': return 2;
    case '3': return 3;
    case '4': return 4;
    case '5': return 5;
    case '6': return 6;
    case '7': return 7;
    case '8': return 8;
    case '9': return 9;

    default:
         System.err.println("Character '" + digit + "' is no digit, exiting");
         System.exit(1);
         return 0;
  }
}

Since digit representations '0' to '9' appear »gap less« and in strictly ascending order this may be simplified:

private static int getDigitValue (final char digit) {
  return digit - '0';
}

Next we must compute a given string's product of digits. Taking the first value 7316717653133 from above we are looking for 7 × 3 ×1 × 6 ×7 × 1 ×7 × 6 × 5 × 3 × 1 × 3 × 3 = 5000940. We define:

private static int getDigitProduct(final String digitWord) {
  int product = 1;
  for (int i = 0; i < digitWord.length(); i++) {
    product *= getDigitValue(digitWord.charAt(i));
  }
  return product;
}

Unfortunately this method sometimes returns weird results: The argument "5397536978179" for example returns -1594459696. This negative value is due to an arithmetic overflow: The product 5 × 3 × 9 × 7 × 5 × 3 × 6 × 9 × 7 × 8 × 1 × 7 × 9 is actually 2,700,507,600. This exceeds MAX_VALUE of 2,147,483,647 being representable by a 4 byte int variable.

Luckily a long variable will be able to hold positive values up to 9,223,372,036,854,775,807. This is much larger than our “worst case” 9 × 9 × 9 × 9 × 9 × 9 × 9 × 9 × 9 × 9 × 9 × 9 × 9 = 2,541,865,828,329 value. We thus have to change our data type from int to long:

private static long getDigitProduct(final String digitWord) {
long product = 1;
  for (int i = 0; i < digitWord.length(); i++) {
    product *= getDigitValue(digitWord.charAt(i));
  }
  return product;
}

Assembling these pieces together leaves us with the following main(...) method:

public static void main(String[] args) {

  final String
      input = "73167176531330624919225119674426574742355349194934"
            + "96983520312774506326239578318016984801869478851843"
            + "85861560789112949495459501737958331952853208805511"
            + "12540698747158523863050715693290963295227443043557"
            + "66896648950445244523161731856403098711121722383113" ❶
            + "62229893423380308135336276614282806444486645238749"
            + "30358907296290491560440772390713810515859307960866"
            + "70172427121883998797908792274921901699720888093776"
            + "65727333001053367881220235421809751254540594752243"
            + "52584907711670556013604839586446706324415722155397"
            + "53697817977846174064955149290862569321978468622482"
            + "83972241375657056057490261407972968652414535100474"
            + "82166370484403199890008895243450658541227588666881"
            + "16427171479924442928230863465674813919123162824586"
            + "17866458359124566529476545682848912883142607690042"
            + "24219022671055626321111109370544217506941658960408"
            + "07198403850962455444362981230987879927244284909188"
            + "84580156166097919133875499200524063689912560717606"
            + "05886116467109405077541002256983155200055935729725"
            + "71636269561882670428252483600823257530420752963450";

  final int NUM_OF_DIGITS = 13;   // The intended number of adjacent digits

  long maximumDigitProduct = 0;
  String maxDigitString = null;
  for (int i = 0; i < input.length() - NUM_OF_DIGITS + 1; i++) {
    final String digitWord = input.substring(i, i + NUM_OF_DIGITS);
    final long productOfDigits = getDigitProduct(digitWord);
    if (maximumDigitProduct < productOfDigits) {
      maximumDigitProduct = productOfDigits;
      maxDigitString = digitWord;
    }
  }
  System.out.println("The substring '" + maxDigitString +
        "' yields the largest product value " + getDigitProduct(maxDigitString) + ".");
}

The largest product of 13 successive digits stems from the substring "5576689664895" ❶ starting with the last three digits in the fourth definition line of String input = ....

The substring '5576689664895' yields the largest product value 23514624000.

Execution yields:

a1 == a2: true ❶
a1.equals(a2): true
b1 == b2: false ❷
b1.equals(b2): true

System.out.println("TestA" == "TestA");

System.out.println("Hashcode a1 == " + System.identityHashCode(a1) +
                 ", Hashcode a2 == " + System.identityHashCode(a2));

Hashcode a1 == 366712642, Hashcode a2 == 366712642

System.out.println("Hashcode b1 == " + System.identityHashCode(b1) +
                 ", Hashcode b2 == " + System.identityHashCode(b2));

Hashcode b1 == 1829164700, Hashcode b2 == 2018699554

Having name = "An" + "ton" in place we get:

Content:Anton
Instances are equal

The Java compiler performs a clever optimization: The expression "An" + "ton" is being evaluated at compile time. Its value is identical to the string literal "Anton" and thus both variables name and reference will be initialized to a common String instance:

When starting from name = "An".concat("ton") the result is different:

Content:Anton
Instances are not equal

This time the Java compiler is unable to dynamically resolve the expression "An".concat("ton") at compile time. Instead the method concat(...)will be called at runtime resulting in a second String instance which by coincidence contains an identical value. Thus name and reference point to different objects: