Why does the `java.util.UUID` class seem to repeat its validation when parsing an input string?

The UUID specifications, RFC 9562 & RFC 4122, both define a canonical textual representation of 128 bits as groups of hexadecimal digits delimited by HYPHEN-PLUS character, 8-4-4-4-12, like this:

7f1943d2-f582-11f0-8de9-0242ac120002

When I examine the source code of the OpenJDK implementation, I see the parsing method fromString calls a subroutine, fromString1. That subroutine seems to repeat the logic of the first method:

Check for length. Check for hyphens. Parse the bits to produce two long integer values.

First method, doing the parsing:

// https://github.com/openjdk/jdk/blob/master/src/java.base/share/classes/java/util/UUID.java public static UUID fromString(String name) { if (name.length() == 36) { char ch1 = name.charAt(8); char ch2 = name.charAt(13); char ch3 = name.charAt(18); char ch4 = name.charAt(23); if (ch1 == '-' && ch2 == '-' && ch3 == '-' && ch4 == '-') { long msb1 = parse4Nibbles(name, 0); long msb2 = parse4Nibbles(name, 4); long msb3 = parse4Nibbles(name, 9); long msb4 = parse4Nibbles(name, 14); long lsb1 = parse4Nibbles(name, 19); long lsb2 = parse4Nibbles(name, 24); long lsb3 = parse4Nibbles(name, 28); long lsb4 = parse4Nibbles(name, 32); if ((msb1 | msb2 | msb3 | msb4 | lsb1 | lsb2 | lsb3 | lsb4) >= 0) { return new UUID( msb1 << 48 | msb2 << 32 | msb3 << 16 | msb4, lsb1 << 48 | lsb2 << 32 | lsb3 << 16 | lsb4); } } } return fromString1(name); }

… and the subroutine:

// https://github.com/openjdk/jdk/blob/master/src/java.base/share/classes/java/util/UUID.java private static UUID fromString1(String name) { int len = name.length(); if (len > 36) { throw new IllegalArgumentException("UUID string too large"); } int dash1 = name.indexOf('-'); int dash2 = name.indexOf('-', dash1 + 1); int dash3 = name.indexOf('-', dash2 + 1); int dash4 = name.indexOf('-', dash3 + 1); int dash5 = name.indexOf('-', dash4 + 1); // For any valid input, dash1 through dash4 will be positive and dash5 // negative, but it's enough to check dash4 and dash5: // - if dash1 is -1, dash4 will be -1 // - if dash1 is positive but dash2 is -1, dash4 will be -1 // - if dash1 and dash2 is positive, dash3 will be -1, dash4 will be // positive, but so will dash5 if (dash4 < 0 || dash5 >= 0) { throw new IllegalArgumentException("Invalid UUID string: " + name); } long mostSigBits = Long.parseLong(name, 0, dash1, 16) & 0xffffffffL; mostSigBits <<= 16; mostSigBits |= Long.parseLong(name, dash1 + 1, dash2, 16) & 0xffffL; mostSigBits <<= 16; mostSigBits |= Long.parseLong(name, dash2 + 1, dash3, 16) & 0xffffL; long leastSigBits = Long.parseLong(name, dash3 + 1, dash4, 16) & 0xffffL; leastSigBits <<= 48; leastSigBits |= Long.parseLong(name, dash4 + 1, len, 16) & 0xffffffffffffL; return new UUID(mostSigBits, leastSigBits); }

What exactly does the second method accomplish that the first one did not already cover?