Package Torello.Java

Class StrTokIndexOf


  • public class StrTokIndexOf
    extends java.lang.Object
    StrTokIndexOf - Documentation.

    The purpose of this class is to help find the location of Token-Matches inside of an input source-String. Normally, checking for an occurrence of a substring inside of a Java String is as easy as calling the method String.contains(substring).

    Problems can crop up, however, when working with String's whose contents have derived from HTML Attributes. For instance, when working with the HTML Element Attribute 'CLASS=...', simply making a call to String.contains(cssClassName) to find if it is a member of 'cssClassName' would return many incorrect results due to the fact that the cssClassName - if occurring within the list of CSS Classes - is only considered a match if that class-name is bounded on both sides by white-space or the start (or end) of the CSS 'CLASS' Attribute-Value. This StrTokIndexOf is nearly identical to the class with the similarly chosen name StrIndexOf; but differs in that the matches it finds are only considered matches when the sub-string the logic is searching is found, by itself, like a separate word in the String being searched.

    The following examples will hopefully make more clear what a Token-Match actually is:

    Example:
     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    int pos = StrTokIndexOf.first("This is a warm, sunny afternoon in August.", "war");
    // 'pos' would evaluate to -1, because 'war' was not found as a token.  HOWEVER...
    
    int pos = StrIndexOf.first("This is a warm, sunny afternoon in August.", "war");
    // 'pos' would evaluate to 10, because the word 'warm' begins with 'war' and the
    // first letter of 'warm' is located at string-index 10.
    
    TagNode tn          = new TagNode("<DIV CLASS='PersonalPics' ID='Photos-10'>");
    String  cssClass    = "Pics";
    
    boolean found       = StrTokIndexOf.first(tn.AV("class"), cssClass) != -1;
    // 'found' would evaluate to FALSE, because though 'PersonalPics' contains the substring
    // 'Pics', it is not an actually CSS Class String match.  The concept of "Token-Match" is 
    // identical to how CSS Parsers look for Class String's
    
    // NOTE:
    boolean found       = StrIndexOf.first(tn.AV("class"), cssClass) != -1;
    // 'found' would evaluate to TRUE, because 'Pics' is a substring of 'PersonalPics'
    // but this would be a mistake since, as a CSS class, this token is not really one of the
    // CSS Classes contained by the HTML divider element.
    

    StrTokIndexOf =>

    1. StrTok: Token-Matches are substring matches which are found inside a supplied 'srcStr'. These matches must be both fully contained within 'srcStr', and have "match locations" (String-index position in 'srcStr' where the token matches) that are bounded / 'surrounded' by either white-space (space-character '#32', '\n', '\r', etc ) or by characters that pass a user supplied Character-Predicate test().
    2. IndexOf: Each of the methods in this class shall return an integer, or int[] array of indices into the input String 'srcStr' where match-locations were found.

    Methods Available

    Method Explanation
    first (...) This will retrieve an integer-pointer that points to the first String-Token match found within the input String-parameter 'srcStr'.
    nth (...) This will retrieve an integer-pointer that points to the nth String-Token match found within the input String-parameter 'srcStr'.
    last (...) This will retrieve an integer-pointer that points to the last String-Token match found within the input String-parameter 'srcStr'.
    nthFromEnd (...) This will retrieve an integer-pointer that points to the nth-from-last String-Token match found within the input String-parameter 'srcStr'.
    all (...) This will retrieve an integer-pointer to every String-Token match found within the input String-parameter 'srcStr'.

    Method Parameters

    Parameter Explanation
    String srcStr This parameter is mandatory for every method here. It is the source String that is being searched. Every method is designed to iterate through the characters in this String, searching for matches of String or char parameter 'token'.
    int nth This represents the 'nth' match of a comparison for-loop. When the method-signature used includes the parameter 'nth' , the first n-1 matches that are found - will be skipped, and the 'nth' match is, instead, returned.

    EXCEPTIONS: An NException shall throw if the value of parameter 'nth' is zero, negative, or larger than the size of the input html-Vector.
    int sPos, int ePos When these parameters are present, only substring's that are found between these specified String indices will be considered when returning results from StrTokIndexOf.

    NOTE: In every situation where the parameters int sPos, int ePos are used, parameter 'ePos' will accept a negative value, but parameter 'sPos' will not. When 'ePos' is passed a negative-value, the internal LV ('Loop Variable Counter') will have its public final int end field set to the length of the 'srcStr' parameter String.

    EXCEPTIONS: An IndexOutOfBoundsException will be thrown if:

    • If sPos is negative, or if sPos is greater-than or equal-to the size of 'srcStr'
    • If ePos is zero, or greater than the size 'srcStr'.
    • If sPos is a larger integer than ePos
    String token This is the testing-substring that is this class' search goal. When this String is identified as a substring of the input-parameter String 'srcStr', a potential match has been found. In order for potential matches to be returned as results, they are subsequently tested for surrounding white-space (or the additional 'extraDelimiterTest'). The requirements for a potential match to be returned as a Token Match are as follows:

    1. The location of 'token' in 'srcStr' must be bounded by white-space, or be located at the very beginning or ending of the 'srcStr'.
    2. If an extraDelimiterTest has been provided, the location of 'token' in 'srcStr' may also be bounded by characters that are a match with the Character-Predicate 'test(char)' method.
    3. And, of course, the 'token' must be a substring of 'srcStr'
    char token This parameter is used indentically to parameter String token. However, rather than searching for sub-string matches, the search-loops are looking for copies of character 'token'. All the rules listed in the previous parameter entry (above) apply to this parameter too.
    Predicate<Character> extraDelimiterTest When this parameter is present in the method-signature parameter-list, the decision of whether a Token-Match is to be included in the search result-set can be made less restrictive. Usually, a match must be delimited by white-space; meaning that the characters directly before and after the match location in 'srcStr' must be white-space, or the String terminus (Regex: '^' and '$').

    However, when this parameter is part of a method signature, the method body in this class that implements this search will also permit a token-match location to be bounded by characters that pass this Character-Predicate's Predicate.test(char) method.

    For instance, if (Character c) -> ",.!?()".contains("" + c) were passed to this parameter, then: commas, periods, exclamation-points, question-marks, and parenthesis would all be allowed directly before or immediately after the token-match location of the 'token' parameter inside String 'srcStr'.

    Return Values:

    1. int represents a position index of String parameter 'srcStr'.
    2. A return value of -1 implies no matches were found.
    3. int[] A list of position indices where token-matches were found.
    4. A zero-length int[] array means no matches were found in 'srcStr'. Zero-length arrays are returned from any method where the possibility existed for multiple-matches being provided as a result-set. Null will not be returned.


    Static (Functional) API: The methods in this class are all (100%) defined with the Java Key-Word / Key-Concept 'static'. Furthermore, there is no way to obtain an instance of this class, because there are no public (nor private) constructors. Java's Spring-Boot, MVC feature is *not* utilized because it flies directly in the face of the light-weight data-classes philosophy. This has many advantages over the rather ornate Component Annotations (@Component, @Service, @AutoWired, etc... 'Java Beans') syntax:

    • The methods here use the key-word 'static' which means (by implication) that there is no internal-state. Without any 'internal state' there is no need for constructors in the first place! (This is often the complaint by MVC Programmers).
    • A 'Static' (Functional-Programming) API expects to use fewer data-classes, and light-weight data-classes, making it easier to understand and to program.
    • The Vectorized HTML data-model allows more user-control over HTML parse, search, update & scrape. Also, memory management, memory leakage, and the Java Garbage Collector ought to be intelligible through the 'reuse' of the standard JDK class Vector for storing HTML Web-Page data.

    The power that object-oriented programming extends to a user is (mostly) limited to data-representation. Thinking of "Services" as "Objects" (Spring-MVC, 'Java Beans') is somewhat 'over-applying' the Object Oriented Programming Model. Like most classes in the Java-HTML JAR Library, this class backtracks to a more C-Styled Functional Programming Model (no Objects) - by re-using (quite profusely) the key-word static with all of its methods, and by sticking to Java's well-understood class Vector

    Internal-State: A user may click on this class' source code (see link below) to view any and all internally defined fields class. A cursory inspection of the code would prove that this class has precisely zero internally defined global fields (Spaghetti). All variables used by the methods in this class are local fields only, and therefore this class ought to be though of as 'state-less'.



    • Method Summary

      All Methods Static Methods Concrete Methods 
      Modifier and Type Method
      static int[] all​(String srcStr, char c)
      static int[] all​(String srcStr, char c, Predicate<Character> extraDelimiterTest)
      static int[] all​(String srcStr, int sPos, int ePos, char c)
      static int[] all​(String srcStr, int sPos, int ePos, char c, Predicate<Character> extraDelimiterTest)
      static int[] all​(String srcStr, int sPos, int ePos, String token)
      static int[] all​(String srcStr, int sPos, int ePos, String token, Predicate<Character> extraDelimiterTest)
      static int[] all​(String srcStr, String token)
      static int[] all​(String srcStr, String token, Predicate<Character> extraDelimiterTest)
      static int[] all_CI​(String srcStr, char c)
      static int[] all_CI​(String srcStr, char c, Predicate<Character> extraDelimiterTest)
      static int[] all_CI​(String srcStr, int sPos, int ePos, char c)
      static int[] all_CI​(String srcStr, int sPos, int ePos, char c, Predicate<Character> extraDelimiterTest)
      static int[] all_CI​(String srcStr, int sPos, int ePos, String token)
      static int[] all_CI​(String srcStr, int sPos, int ePos, String token, Predicate<Character> extraDelimiterTest)
      static int[] all_CI​(String srcStr, String token)
      static int[] all_CI​(String srcStr, String token, Predicate<Character> extraDelimiterTest)
      static int first​(String srcStr, char c)
      static int first​(String srcStr, char c, Predicate<Character> extraDelimiterTest)
      static int first​(String srcStr, int sPos, int ePos, char c)
      static int first​(String srcStr, int sPos, int ePos, char c, Predicate<Character> extraDelimiterTest)
      static int first​(String srcStr, int sPos, int ePos, String token)
      static int first​(String srcStr, int sPos, int ePos, String token, Predicate<Character> extraDelimiterTest)
      static int first​(String srcStr, String token)
      static int first​(String srcStr, String token, Predicate<Character> extraDelimiterTest)
      static int first_CI​(String srcStr, char c)
      static int first_CI​(String srcStr, char c, Predicate<Character> extraDelimiterTest)
      static int first_CI​(String srcStr, int sPos, int ePos, char c)
      static int first_CI​(String srcStr, int sPos, int ePos, char c, Predicate<Character> extraDelimiterTest)
      static int first_CI​(String srcStr, int sPos, int ePos, String token)
      static int first_CI​(String srcStr, int sPos, int ePos, String token, Predicate<Character> extraDelimiterTest)
      static int first_CI​(String srcStr, String token)
      static int first_CI​(String srcStr, String token, Predicate<Character> extraDelimiterTest)
      static int last​(String srcStr, char c)
      static int last​(String srcStr, char c, Predicate<Character> extraDelimiterTest)
      static int last​(String srcStr, int sPos, int ePos, char c)
      static int last​(String srcStr, int sPos, int ePos, char c, Predicate<Character> extraDelimiterTest)
      static int last​(String srcStr, int sPos, int ePos, String token)
      static int last​(String srcStr, int sPos, int ePos, String token, Predicate<Character> extraDelimiterTest)
      static int last​(String srcStr, String token)
      static int last​(String srcStr, String token, Predicate<Character> extraDelimiterTest)
      static int last_CI​(String srcStr, char c)
      static int last_CI​(String srcStr, char c, Predicate<Character> extraDelimiterTest)
      static int last_CI​(String srcStr, int sPos, int ePos, char c)
      static int last_CI​(String srcStr, int sPos, int ePos, char c, Predicate<Character> extraDelimiterTest)
      static int last_CI​(String srcStr, int sPos, int ePos, String token)
      static int last_CI​(String srcStr, int sPos, int ePos, String token, Predicate<Character> extraDelimiterTest)
      static int last_CI​(String srcStr, String token)
      static int last_CI​(String srcStr, String token, Predicate<Character> extraDelimiterTest)
      static int left​(String srcStr, int fromIndex, char c)
      static int left​(String srcStr, int fromIndex, char c, Predicate<Character> extraDelimiterTest)
      static int left​(String srcStr, int fromIndex, String token)
      static int left​(String srcStr, int fromIndex, String token, Predicate<Character> extraDelimiterTest)
      static int left_CI​(String srcStr, int fromIndex, char c)
      static int left_CI​(String srcStr, int fromIndex, char c, Predicate<Character> extraDelimiterTest)
      static int left_CI​(String srcStr, int fromIndex, String token)
      static int left_CI​(String srcStr, int fromIndex, String token, Predicate<Character> extraDelimiterTest)
      static int nth​(String srcStr, int n, char c)
      static int nth​(String srcStr, int n, char c, Predicate<Character> extraDelimiterTest)
      static int nth​(String srcStr, int sPos, int ePos, int n, char c)
      static int nth​(String srcStr, int sPos, int ePos, int n, char c, Predicate<Character> extraDelimiterTest)
      static int nth​(String srcStr, int sPos, int ePos, int n, String token)
      static int nth​(String srcStr, int sPos, int ePos, int n, String token, Predicate<Character> extraDelimiterTest)
      static int nth​(String srcStr, int n, String token)
      static int nth​(String srcStr, int n, String token, Predicate<Character> extraDelimiterTest)
      static int nth_CI​(String srcStr, int n, char c)
      static int nth_CI​(String srcStr, int n, char c, Predicate<Character> extraDelimiterTest)
      static int nth_CI​(String srcStr, int sPos, int ePos, int n, char c)
      static int nth_CI​(String srcStr, int sPos, int ePos, int n, char c, Predicate<Character> extraDelimiterTest)
      static int nth_CI​(String srcStr, int sPos, int ePos, int n, String token)
      static int nth_CI​(String srcStr, int sPos, int ePos, int n, String token, Predicate<Character> extraDelimiterTest)
      static int nth_CI​(String srcStr, int n, String token)
      static int nth_CI​(String srcStr, int n, String token, Predicate<Character> extraDelimiterTest)
      static int nthFromEnd​(String srcStr, int n, char c)
      static int nthFromEnd​(String srcStr, int n, char c, Predicate<Character> extraDelimiterTest)
      static int nthFromEnd​(String srcStr, int sPos, int ePos, int n, char c)
      static int nthFromEnd​(String srcStr, int sPos, int ePos, int n, char c, Predicate<Character> extraDelimiterTest)
      static int nthFromEnd​(String srcStr, int sPos, int ePos, int n, String token)
      static int nthFromEnd​(String srcStr, int sPos, int ePos, int n, String token, Predicate<Character> extraDelimiterTest)
      static int nthFromEnd​(String srcStr, int n, String token)
      static int nthFromEnd​(String srcStr, int n, String token, Predicate<Character> extraDelimiterTest)
      static int nthFromEnd_CI​(String srcStr, int n, char c)
      static int nthFromEnd_CI​(String srcStr, int n, char c, Predicate<Character> extraDelimiterTest)
      static int nthFromEnd_CI​(String srcStr, int sPos, int ePos, int n, char c)
      static int nthFromEnd_CI​(String srcStr, int sPos, int ePos, int n, char c, Predicate<Character> extraDelimiterTest)
      static int nthFromEnd_CI​(String srcStr, int sPos, int ePos, int n, String token)
      static int nthFromEnd_CI​(String srcStr, int sPos, int ePos, int n, String token, Predicate<Character> extraDelimiterTest)
      static int nthFromEnd_CI​(String srcStr, int n, String token)
      static int nthFromEnd_CI​(String srcStr, int n, String token, Predicate<Character> extraDelimiterTest)
      static int nthLeft​(String srcStr, int fromIndex, int n, char c)
      static int nthLeft​(String srcStr, int fromIndex, int n, char c, Predicate<Character> extraDelimiterTest)
      static int nthLeft​(String srcStr, int fromIndex, int n, String token)
      static int nthLeft​(String srcStr, int fromIndex, int n, String token, Predicate<Character> extraDelimiterTest)
      static int nthLeft_CI​(String srcStr, int fromIndex, int n, char c)
      static int nthLeft_CI​(String srcStr, int fromIndex, int n, char c, Predicate<Character> extraDelimiterTest)
      static int nthLeft_CI​(String srcStr, int fromIndex, int n, String token)
      static int nthLeft_CI​(String srcStr, int fromIndex, int n, String token, Predicate<Character> extraDelimiterTest)
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Method Detail

      • all_CI

        public static int[] all_CI​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for all token-matches of char-parameter 'c' in 'srcStr', and return an integer-array of index-locations into 'srcStr' indicating where matches have occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an integer-array of String-index pointers will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        An integer-pointer array of java.lang.String-indices where matches were found.

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
         LV                  l = new LV(srcStr, sPos, ePos);
         IntStream.Builder   b = IntStream.builder();
        
         c = Character.toLowerCase(c);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 b.accept(i);
        
         return b.build().toArray();
        
      • all_CI

        public static int[] all_CI​(java.lang.String srcStr,
                                   int sPos,
                                   int ePos,
                                   char c)
        Search for all token-matches of char-parameter 'c' in 'srcStr', and return an integer-array of index-locations into 'srcStr' indicating where matches have occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an integer-array of String-index pointers will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        An integer-pointer array of java.lang.String-indices where matches were found.

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         LV                  l = new LV(srcStr, sPos, ePos);
         IntStream.Builder   b = IntStream.builder();
        
         c = Character.toLowerCase(c);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 b.accept(i);
        
         return b.build().toArray();
        
      • all_CI

        public static int[] all_CI​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for all token-matches of String-parameter 'token' in 'srcStr', and return an integer-array of index-locations into 'srcStr' indicating where matches have occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an integer-array of String-index pointers will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        An integer-pointer array of java.lang.String-indices where matches were found.

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         LV                  l          = new LV(srcStr, sPos, ePos, token.length());
         IntStream.Builder   b          = IntStream.builder();
         int                 tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 b.accept(i);
        
         return b.build().toArray();
        
      • all_CI

        public static int[] all_CI​(java.lang.String srcStr,
                                   int sPos,
                                   int ePos,
                                   java.lang.String token)
        Search for all token-matches of String-parameter 'token' in 'srcStr', and return an integer-array of index-locations into 'srcStr' indicating where matches have occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an integer-array of String-index pointers will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        An integer-pointer array of java.lang.String-indices where matches were found.

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         LV                  l          = new LV(srcStr, sPos, ePos, token.length());
         IntStream.Builder   b          = IntStream.builder();
         int                 tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 b.accept(i);
        
         return b.build().toArray();
        
      • all_CI

        public static int[] all_CI​
                    (java.lang.String srcStr,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for all token-matches of char-parameter 'c' in 'srcStr', and return an integer-array of index-locations into 'srcStr' indicating where matches have occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an integer-array of String-index pointers will be returned.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        An integer-pointer array of java.lang.String-indices where matches were found.

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
         LV                  l = new LV(srcStr, 0, -1);
         IntStream.Builder   b = IntStream.builder();
        
         c = Character.toLowerCase(c);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 b.accept(i);
        
         return b.build().toArray();
        
      • all_CI

        public static int[] all_CI​(java.lang.String srcStr,
                                   char c)
        Search for all token-matches of char-parameter 'c' in 'srcStr', and return an integer-array of index-locations into 'srcStr' indicating where matches have occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an integer-array of String-index pointers will be returned.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        An integer-pointer array of java.lang.String-indices where matches were found.

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         LV                  l = new LV(srcStr, 0, -1);
         IntStream.Builder   b = IntStream.builder();
        
         c = Character.toLowerCase(c);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 b.accept(i);
        
         return b.build().toArray();
        
      • all_CI

        public static int[] all_CI​
                    (java.lang.String srcStr,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for all token-matches of String-parameter 'token' in 'srcStr', and return an integer-array of index-locations into 'srcStr' indicating where matches have occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an integer-array of String-index pointers will be returned.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        An integer-pointer array of java.lang.String-indices where matches were found.

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         LV                  l          = new LV(srcStr, 0, -1, token.length());
         IntStream.Builder   b          = IntStream.builder();
         int                 tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 b.accept(i);
        
         return b.build().toArray();
        
      • all_CI

        public static int[] all_CI​(java.lang.String srcStr,
                                   java.lang.String token)
        Search for all token-matches of String-parameter 'token' in 'srcStr', and return an integer-array of index-locations into 'srcStr' indicating where matches have occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an integer-array of String-index pointers will be returned.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        An integer-pointer array of java.lang.String-indices where matches were found.

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         LV                  l          = new LV(srcStr, 0, -1, token.length());
         IntStream.Builder   b          = IntStream.builder();
         int                 tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 b.accept(i);
        
         return b.build().toArray();
        
      • all

        public static int[] all​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for all token-matches of char-parameter 'c' in 'srcStr', and return an integer-array of index-locations into 'srcStr' indicating where matches have occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an integer-array of String-index pointers will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        An integer-pointer array of java.lang.String-indices where matches were found.

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         LV                  l = new LV(srcStr, sPos, ePos);
         IntStream.Builder   b = IntStream.builder();
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 b.accept(i);
        
         return b.build().toArray();
        
      • all

        public static int[] all​(java.lang.String srcStr,
                                int sPos,
                                int ePos,
                                char c)
        Search for all token-matches of char-parameter 'c' in 'srcStr', and return an integer-array of index-locations into 'srcStr' indicating where matches have occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an integer-array of String-index pointers will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        An integer-pointer array of java.lang.String-indices where matches were found.

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
         LV                  l = new LV(srcStr, sPos, ePos);
         IntStream.Builder   b = IntStream.builder();
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 b.accept(i);
        
         return b.build().toArray();
        
      • all

        public static int[] all​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for all token-matches of String-parameter 'token' in 'srcStr', and return an integer-array of index-locations into 'srcStr' indicating where matches have occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an integer-array of String-index pointers will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        An integer-pointer array of java.lang.String-indices where matches were found.

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         LV                  l          = new LV(srcStr, sPos, ePos, token.length());
         IntStream.Builder   b          = IntStream.builder();
         int                 tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 b.accept(i);
        
         return b.build().toArray();
        
      • all

        public static int[] all​(java.lang.String srcStr,
                                int sPos,
                                int ePos,
                                java.lang.String token)
        Search for all token-matches of String-parameter 'token' in 'srcStr', and return an integer-array of index-locations into 'srcStr' indicating where matches have occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an integer-array of String-index pointers will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        An integer-pointer array of java.lang.String-indices where matches were found.

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         LV                  l          = new LV(srcStr, sPos, ePos, token.length());
         IntStream.Builder   b          = IntStream.builder();
         int                 tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 b.accept(i);
        
         return b.build().toArray();
        
      • all

        public static int[] all​
                    (java.lang.String srcStr,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for all token-matches of char-parameter 'c' in 'srcStr', and return an integer-array of index-locations into 'srcStr' indicating where matches have occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an integer-array of String-index pointers will be returned.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        An integer-pointer array of java.lang.String-indices where matches were found.

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         LV                  l = new LV(srcStr, 0, -1);
         IntStream.Builder   b = IntStream.builder();
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 b.accept(i);
        
         return b.build().toArray();
        
      • all

        public static int[] all​(java.lang.String srcStr,
                                char c)
        Search for all token-matches of char-parameter 'c' in 'srcStr', and return an integer-array of index-locations into 'srcStr' indicating where matches have occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an integer-array of String-index pointers will be returned.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        An integer-pointer array of java.lang.String-indices where matches were found.

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
         LV                  l = new LV(srcStr, 0, -1);
         IntStream.Builder   b = IntStream.builder();
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 b.accept(i);
        
         return b.build().toArray();
        
      • all

        public static int[] all​
                    (java.lang.String srcStr,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for all token-matches of String-parameter 'token' in 'srcStr', and return an integer-array of index-locations into 'srcStr' indicating where matches have occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an integer-array of String-index pointers will be returned.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        An integer-pointer array of java.lang.String-indices where matches were found.

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         LV                  l          = new LV(srcStr, 0, -1, token.length());
         IntStream.Builder   b          = IntStream.builder();
         int                 tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 b.accept(i);
        
         return b.build().toArray();
        
      • all

        public static int[] all​(java.lang.String srcStr,
                                java.lang.String token)
        Search for all token-matches of String-parameter 'token' in 'srcStr', and return an integer-array of index-locations into 'srcStr' indicating where matches have occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an integer-array of String-index pointers will be returned.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        An integer-pointer array of java.lang.String-indices where matches were found.

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         LV                  l          = new LV(srcStr, 0, -1, token.length());
         IntStream.Builder   b          = IntStream.builder();
         int                 tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 b.accept(i);
        
         return b.build().toArray();
        
      • first_CI

        public static int first_CI​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the first token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         LV l = new LV(srcStr, sPos, ePos);
        
         c = Character.toLowerCase(c);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • first_CI

        public static int first_CI​(java.lang.String srcStr,
                                   int sPos,
                                   int ePos,
                                   char c)
        Search for the first token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         LV l = new LV(srcStr, sPos, ePos);
        
         c = Character.toLowerCase(c);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • first_CI

        public static int first_CI​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the first token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         LV  l          = new LV(srcStr, sPos, ePos, token.length());
         int tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • first_CI

        public static int first_CI​(java.lang.String srcStr,
                                   int sPos,
                                   int ePos,
                                   java.lang.String token)
        Search for the first token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
         LV  l          = new LV(srcStr, sPos, ePos, token.length());
         int tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • first_CI

        public static int first_CI​
                    (java.lang.String srcStr,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the first token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         LV l = new LV(srcStr, 0, -1);
        
         c = Character.toLowerCase(c);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • first_CI

        public static int first_CI​(java.lang.String srcStr,
                                   char c)
        Search for the first token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         LV l = new LV(srcStr, 0, -1);
        
         c = Character.toLowerCase(c);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • first_CI

        public static int first_CI​
                    (java.lang.String srcStr,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the first token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         LV  l          = new LV(srcStr, 0, -1, token.length());
         int tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • first_CI

        public static int first_CI​(java.lang.String srcStr,
                                   java.lang.String token)
        Search for the first token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
         LV  l          = new LV(srcStr, 0, -1, token.length());
         int tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • first

        public static int first​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the first token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         LV l = new LV(srcStr, sPos, ePos);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • first

        public static int first​(java.lang.String srcStr,
                                int sPos,
                                int ePos,
                                char c)
        Search for the first token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
         LV l = new LV(srcStr, sPos, ePos);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • first

        public static int first​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the first token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         LV  l          = new LV(srcStr, sPos, ePos, token.length());
         int tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • first

        public static int first​(java.lang.String srcStr,
                                int sPos,
                                int ePos,
                                java.lang.String token)
        Search for the first token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
         LV  l          = new LV(srcStr, sPos, ePos, token.length());
         int tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • first

        public static int first​
                    (java.lang.String srcStr,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the first token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         LV l = new LV(srcStr, 0, -1);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • first

        public static int first​(java.lang.String srcStr,
                                char c)
        Search for the first token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
         LV l = new LV(srcStr, 0, -1);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • first

        public static int first​
                    (java.lang.String srcStr,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the first token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         LV  l          = new LV(srcStr, 0, -1, token.length());
         int tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • first

        public static int first​(java.lang.String srcStr,
                                java.lang.String token)
        Search for the first token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
         LV  l          = new LV(srcStr, 0, -1, token.length());
         int tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • last_CI

        public static int last_CI​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the last token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the last identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         LV l = new LV(srcStr, sPos, ePos);
        
         c = Character.toLowerCase(c);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • last_CI

        public static int last_CI​(java.lang.String srcStr,
                                  int sPos,
                                  int ePos,
                                  char c)
        Search for the last token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the last identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         LV l = new LV(srcStr, sPos, ePos);
        
         c = Character.toLowerCase(c);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • last_CI

        public static int last_CI​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the last token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the last identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         LV  l          = new LV(srcStr, sPos, ePos, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • last_CI

        public static int last_CI​(java.lang.String srcStr,
                                  int sPos,
                                  int ePos,
                                  java.lang.String token)
        Search for the last token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the last identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
         LV  l          = new LV(srcStr, sPos, ePos, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • last_CI

        public static int last_CI​
                    (java.lang.String srcStr,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the last token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the last identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         LV l = new LV(srcStr, 0, -1);
        
         c = Character.toLowerCase(c);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • last_CI

        public static int last_CI​(java.lang.String srcStr,
                                  char c)
        Search for the last token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the last identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         LV l = new LV(srcStr, 0, -1);
        
         c = Character.toLowerCase(c);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • last_CI

        public static int last_CI​
                    (java.lang.String srcStr,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the last token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the last identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         LV  l          = new LV(srcStr, 0, -1, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • last_CI

        public static int last_CI​(java.lang.String srcStr,
                                  java.lang.String token)
        Search for the last token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the last identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
         LV  l          = new LV(srcStr, 0, -1, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • last

        public static int last​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the last token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the last identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         LV l = new LV(srcStr, sPos, ePos);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • last

        public static int last​(java.lang.String srcStr,
                               int sPos,
                               int ePos,
                               char c)
        Search for the last token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the last identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
         LV l = new LV(srcStr, sPos, ePos);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • last

        public static int last​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the last token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the last identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         LV  l          = new LV(srcStr, sPos, ePos, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • last

        public static int last​(java.lang.String srcStr,
                               int sPos,
                               int ePos,
                               java.lang.String token)
        Search for the last token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the last identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
         LV  l          = new LV(srcStr, sPos, ePos, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • last

        public static int last​
                    (java.lang.String srcStr,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the last token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the last identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         LV l = new LV(srcStr, 0, -1);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • last

        public static int last​(java.lang.String srcStr,
                               char c)
        Search for the last token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the last identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
         LV l = new LV(srcStr, 0, -1);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • last

        public static int last​
                    (java.lang.String srcStr,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the last token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the last identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         LV  l          = new LV(srcStr, 0, -1, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • last

        public static int last​(java.lang.String srcStr,
                               java.lang.String token)
        Search for the last token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the last identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
         LV  l          = new LV(srcStr, 0, -1, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • nth_CI

        public static int nth_CI​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     int n,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, sPos, ePos);
        
         c = Character.toLowerCase(c);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nth_CI

        public static int nth_CI​(java.lang.String srcStr,
                                 int sPos,
                                 int ePos,
                                 int n,
                                 char c)
        Search for the nth token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, sPos, ePos);
        
         c = Character.toLowerCase(c);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nth_CI

        public static int nth_CI​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     int n,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, sPos, ePos, token.length());
         int tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nth_CI

        public static int nth_CI​(java.lang.String srcStr,
                                 int sPos,
                                 int ePos,
                                 int n,
                                 java.lang.String token)
        Search for the nth token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, sPos, ePos, token.length());
         int tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nth_CI

        public static int nth_CI​
                    (java.lang.String srcStr,
                     int n,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, 0, -1);
        
         c = Character.toLowerCase(c);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nth_CI

        public static int nth_CI​(java.lang.String srcStr,
                                 int n,
                                 char c)
        Search for the nth token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, 0, -1);
        
         c = Character.toLowerCase(c);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nth_CI

        public static int nth_CI​
                    (java.lang.String srcStr,
                     int n,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, 0, -1, token.length());
         int tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nth_CI

        public static int nth_CI​(java.lang.String srcStr,
                                 int n,
                                 java.lang.String token)
        Search for the nth token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, 0, -1, token.length());
         int tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nth

        public static int nth​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     int n,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, sPos, ePos);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nth

        public static int nth​(java.lang.String srcStr,
                              int sPos,
                              int ePos,
                              int n,
                              char c)
        Search for the nth token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, sPos, ePos);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nth

        public static int nth​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     int n,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, sPos, ePos, token.length());
         int tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nth

        public static int nth​(java.lang.String srcStr,
                              int sPos,
                              int ePos,
                              int n,
                              java.lang.String token)
        Search for the nth token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, sPos, ePos, token.length());
         int tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nth

        public static int nth​
                    (java.lang.String srcStr,
                     int n,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, 0, -1);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nth

        public static int nth​(java.lang.String srcStr,
                              int n,
                              char c)
        Search for the nth token-match of char-parameter 'c' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-Character match in 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, 0, -1);
        
         for (int i=l.start; i < l.end; i++)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nth

        public static int nth​
                    (java.lang.String srcStr,
                     int n,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, 0, -1, token.length());
         int tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nth

        public static int nth​(java.lang.String srcStr,
                              int n,
                              java.lang.String token)
        Search for the nth token-match of String-parameter 'token' in 'srcStr', and return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-String match in 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, 0, -1, token.length());
         int tokenLen   = token.length();
        
         for (int i=l.start; i < l.end; i++)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthFromEnd_CI

        public static int nthFromEnd_CI​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     int n,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of char-parameter 'c' but start the search with the last character of the String and work left. Return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr', counting left from the end of 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, sPos, ePos);
        
         c = Character.toLowerCase(c);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthFromEnd_CI

        public static int nthFromEnd_CI​(java.lang.String srcStr,
                                        int sPos,
                                        int ePos,
                                        int n,
                                        char c)
        Search for the nth token-match of char-parameter 'c' but start the search with the last character of the String and work left. Return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr', counting left from the end of 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, sPos, ePos);
        
         c = Character.toLowerCase(c);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthFromEnd_CI

        public static int nthFromEnd_CI​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     int n,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of String-parameter 'token' but start the search with the last character of the String and work left. Return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr', counting left from the end of 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, sPos, ePos, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthFromEnd_CI

        public static int nthFromEnd_CI​(java.lang.String srcStr,
                                        int sPos,
                                        int ePos,
                                        int n,
                                        java.lang.String token)
        Search for the nth token-match of String-parameter 'token' but start the search with the last character of the String and work left. Return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr', counting left from the end of 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, sPos, ePos, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthFromEnd_CI

        public static int nthFromEnd_CI​
                    (java.lang.String srcStr,
                     int n,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of char-parameter 'c' but start the search with the last character of the String and work left. Return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr', counting left from the end of 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, 0, -1);
        
         c = Character.toLowerCase(c);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthFromEnd_CI

        public static int nthFromEnd_CI​(java.lang.String srcStr,
                                        int n,
                                        char c)
        Search for the nth token-match of char-parameter 'c' but start the search with the last character of the String and work left. Return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr', counting left from the end of 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, 0, -1);
        
         c = Character.toLowerCase(c);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthFromEnd_CI

        public static int nthFromEnd_CI​
                    (java.lang.String srcStr,
                     int n,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of String-parameter 'token' but start the search with the last character of the String and work left. Return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr', counting left from the end of 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, 0, -1, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthFromEnd_CI

        public static int nthFromEnd_CI​(java.lang.String srcStr,
                                        int n,
                                        java.lang.String token)
        Search for the nth token-match of String-parameter 'token' but start the search with the last character of the String and work left. Return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr', counting left from the end of 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, 0, -1, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthFromEnd

        public static int nthFromEnd​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     int n,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of char-parameter 'c' but start the search with the last character of the String and work left. Return the integer index-location into 'srcStr' where the match occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr', counting left from the end of 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, sPos, ePos);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthFromEnd

        public static int nthFromEnd​(java.lang.String srcStr,
                                     int sPos,
                                     int ePos,
                                     int n,
                                     char c)
        Search for the nth token-match of char-parameter 'c' but start the search with the last character of the String and work left. Return the integer index-location into 'srcStr' where the match occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr', counting left from the end of 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, sPos, ePos);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthFromEnd

        public static int nthFromEnd​
                    (java.lang.String srcStr,
                     int sPos,
                     int ePos,
                     int n,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of String-parameter 'token' but start the search with the last character of the String and work left. Return the integer index-location into 'srcStr' where the match occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr', counting left from the end of 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, sPos, ePos, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthFromEnd

        public static int nthFromEnd​(java.lang.String srcStr,
                                     int sPos,
                                     int ePos,
                                     int n,
                                     java.lang.String token)
        Search for the nth token-match of String-parameter 'token' but start the search with the last character of the String and work left. Return the integer index-location into 'srcStr' where the match occured.

        This method allows sub-sections, or 'partial-sections', of the java.lang.String to be checked. This is done via the int 'sPos' and the int 'ePos' parameters. These are indices into the 'srcStr' input-parameter.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        sPos - This is the integer-index String-location which limits the left-most position to search in 'srcStr'. This value is 'inclusive,' meaning that if the character at this index (in 'srcStr') is part of a match, it shall be factored into the return results. Note that if this value is negative, or larger than the length of 'srcStr', an exception will be thrown.
        ePos - This is the integer-index String-location which limits the right-most position to search in 'srcStr'. This value is 'exclusive,' meaning that if the character at this location is part of match, it will not be calculated into the results. If this value is larger than the length of input-parameter 'srcStr', an exception will throw.

        NOTE: Passing a negative value to this parameter, 'ePos', will cause its to be reset to the integer-value: srcStr.length()
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr', counting left from the end of 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        java.lang.StringIndexOutOfBoundsException - This exception shall be thrown if any of the following are true:

        • If 'sPos' is negative, or if sPos is greater-than-or-equal-to the length of the String
        • If 'ePos' is zero, or greater than the length of the String
        • If the value of 'sPos' is a larger integer than 'ePos'. If ePos was negative, it is first reset to String.length(), before this check is done.
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, sPos, ePos, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthFromEnd

        public static int nthFromEnd​
                    (java.lang.String srcStr,
                     int n,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of char-parameter 'c' but start the search with the last character of the String and work left. Return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr', counting left from the end of 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, 0, -1);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthFromEnd

        public static int nthFromEnd​(java.lang.String srcStr,
                                     int n,
                                     char c)
        Search for the nth token-match of char-parameter 'c' but start the search with the last character of the String and work left. Return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr', counting left from the end of 'srcStr'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, 0, -1);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthFromEnd

        public static int nthFromEnd​
                    (java.lang.String srcStr,
                     int n,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of String-parameter 'token' but start the search with the last character of the String and work left. Return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr', counting left from the end of 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, 0, -1, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthFromEnd

        public static int nthFromEnd​(java.lang.String srcStr,
                                     int n,
                                     java.lang.String token)
        Search for the nth token-match of String-parameter 'token' but start the search with the last character of the String and work left. Return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr', counting left from the end of 'srcStr'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, 0, -1, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • left_CI

        public static int left_CI​
                    (java.lang.String srcStr,
                     int fromIndex,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the first token-match of char-parameter 'c' searching left beginning at 'srcStr' position 'fromIndex'. Return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        fromIndex - This is the right-most index-position in 'srcStr' (*INCLUSIVE*) from where the search shall start.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr', performing the search in the left direction, beginning at String-index 'fromIndex'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         LV l = new LV(srcStr, 0, fromIndex);
        
         c = Character.toLowerCase(c);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • left_CI

        public static int left_CI​(java.lang.String srcStr,
                                  int fromIndex,
                                  char c)
        Search for the first token-match of char-parameter 'c' searching left beginning at 'srcStr' position 'fromIndex'. Return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        fromIndex - This is the right-most index-position in 'srcStr' (*INCLUSIVE*) from where the search shall start.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr', performing the search in the left direction, beginning at String-index 'fromIndex'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         LV l = new LV(srcStr, 0, fromIndex);
        
         c = Character.toLowerCase(c);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • left_CI

        public static int left_CI​
                    (java.lang.String srcStr,
                     int fromIndex,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the first token-match of String-parameter 'token' searching left beginning at 'srcStr' position 'fromIndex'. Return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        fromIndex - This is the right-most index-position in 'srcStr' (*INCLUSIVE*) from where the search shall start.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr', performing the search in the left direction, beginning at String-index 'fromIndex'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         LV  l          = new LV(srcStr, 0, fromIndex, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • left_CI

        public static int left_CI​(java.lang.String srcStr,
                                  int fromIndex,
                                  java.lang.String token)
        Search for the first token-match of String-parameter 'token' searching left beginning at 'srcStr' position 'fromIndex'. Return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        fromIndex - This is the right-most index-position in 'srcStr' (*INCLUSIVE*) from where the search shall start.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr', performing the search in the left direction, beginning at String-index 'fromIndex'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
         LV  l          = new LV(srcStr, 0, fromIndex, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • left

        public static int left​
                    (java.lang.String srcStr,
                     int fromIndex,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the first token-match of char-parameter 'c' searching left beginning at 'srcStr' position 'fromIndex'. Return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        fromIndex - This is the right-most index-position in 'srcStr' (*INCLUSIVE*) from where the search shall start.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr', performing the search in the left direction, beginning at String-index 'fromIndex'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         LV l = new LV(srcStr, 0, fromIndex);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • left

        public static int left​(java.lang.String srcStr,
                               int fromIndex,
                               char c)
        Search for the first token-match of char-parameter 'c' searching left beginning at 'srcStr' position 'fromIndex'. Return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        fromIndex - This is the right-most index-position in 'srcStr' (*INCLUSIVE*) from where the search shall start.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-Character match in 'srcStr', performing the search in the left direction, beginning at String-index 'fromIndex'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
         LV l = new LV(srcStr, 0, fromIndex);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 return i;
        
         return -1;
        
      • left

        public static int left​
                    (java.lang.String srcStr,
                     int fromIndex,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the first token-match of String-parameter 'token' searching left beginning at 'srcStr' position 'fromIndex'. Return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        fromIndex - This is the right-most index-position in 'srcStr' (*INCLUSIVE*) from where the search shall start.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr', performing the search in the left direction, beginning at String-index 'fromIndex'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         LV  l          = new LV(srcStr, 0, fromIndex, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • left

        public static int left​(java.lang.String srcStr,
                               int fromIndex,
                               java.lang.String token)
        Search for the first token-match of String-parameter 'token' searching left beginning at 'srcStr' position 'fromIndex'. Return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        fromIndex - This is the right-most index-position in 'srcStr' (*INCLUSIVE*) from where the search shall start.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the first identified TOKEN-String match in 'srcStr', performing the search in the left direction, beginning at String-index 'fromIndex'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
         LV  l          = new LV(srcStr, 0, fromIndex, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 return i;
        
         return -1;
        
      • nthLeft_CI

        public static int nthLeft_CI​
                    (java.lang.String srcStr,
                     int fromIndex,
                     int n,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of char-parameter 'c' in 'srcStr', but begin the search at index-position 'fromIndex' and work left. Return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        fromIndex - This is the right-most index-position in 'srcStr' (*INCLUSIVE*) from where the search shall start.
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-Character match in 'srcStr', performing the search in the left direction, beginning at String-index 'fromIndex'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
        18
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, 0, fromIndex);
        
         c = Character.toLowerCase(c);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthLeft_CI

        public static int nthLeft_CI​(java.lang.String srcStr,
                                     int fromIndex,
                                     int n,
                                     char c)
        Search for the nth token-match of char-parameter 'c' in 'srcStr', but begin the search at index-position 'fromIndex' and work left. Return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        fromIndex - This is the right-most index-position in 'srcStr' (*INCLUSIVE*) from where the search shall start.
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-Character match in 'srcStr', performing the search in the left direction, beginning at String-index 'fromIndex'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, 0, fromIndex);
        
         c = Character.toLowerCase(c);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == Character.toLowerCase(srcStr.charAt(i)))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthLeft_CI

        public static int nthLeft_CI​
                    (java.lang.String srcStr,
                     int fromIndex,
                     int n,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of String-parameter 'token' in 'srcStr', but begin the search at index-position 'fromIndex' and work left. Return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        fromIndex - This is the right-most index-position in 'srcStr' (*INCLUSIVE*) from where the search shall start.
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-String match in 'srcStr', performing the search in the left direction, beginning at String-index 'fromIndex'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, 0, fromIndex, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthLeft_CI

        public static int nthLeft_CI​(java.lang.String srcStr,
                                     int fromIndex,
                                     int n,
                                     java.lang.String token)
        Search for the nth token-match of String-parameter 'token' in 'srcStr', but begin the search at index-position 'fromIndex' and work left. Return the integer index-location into 'srcStr' where the match occured.

        'CI' NOTE: This method is identical to the one by the same name without the letters 'CI' appended. Here, 'CI' is an acronym for "Case Insensitive", and the difference implied is that all comparisons done by this method will ignore case.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        fromIndex - This is the right-most index-position in 'srcStr' (*INCLUSIVE*) from where the search shall start.
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-String match in 'srcStr', performing the search in the left direction, beginning at String-index 'fromIndex'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, 0, fromIndex, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(true, i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthLeft

        public static int nthLeft​
                    (java.lang.String srcStr,
                     int fromIndex,
                     int n,
                     char c,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of char-parameter 'c' in 'srcStr', but begin the search at index-position 'fromIndex' and work left. Return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        fromIndex - This is the right-most index-position in 'srcStr' (*INCLUSIVE*) from where the search shall start.
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input char 'c' parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-Character match in 'srcStr', performing the search in the left direction, beginning at String-index 'fromIndex'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, 0, fromIndex);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthLeft

        public static int nthLeft​(java.lang.String srcStr,
                                  int fromIndex,
                                  int n,
                                  char c)
        Search for the nth token-match of char-parameter 'c' in 'srcStr', but begin the search at index-position 'fromIndex' and work left. Return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        fromIndex - This is the right-most index-position in 'srcStr' (*INCLUSIVE*) from where the search shall start.
        n - This is the number of matches to skip when searching for char-parameter 'c' before returning an answer.
        c - This is the character that will be 'searched-for' in input-parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-Character match in 'srcStr', performing the search in the left direction, beginning at String-index 'fromIndex'

        NOTE: The concept of a char-TOKEN match will be defined as nearly identical to a regular 'contains-character' match, with the added requirement that BOTH the character directly preceding the matching-char AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
         NException.check(n, srcStr);
        
         LV l = new LV(srcStr, 0, fromIndex);
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    (c == srcStr.charAt(i))
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i+1) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i+1)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthLeft

        public static int nthLeft​
                    (java.lang.String srcStr,
                     int fromIndex,
                     int n,
                     java.lang.String token,
                     java.util.function.Predicate<java.lang.Character> extraDelimiterTest)
        
        Search for the nth token-match of String-parameter 'token' in 'srcStr', but begin the search at index-position 'fromIndex' and work left. Return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        fromIndex - This is the right-most index-position in 'srcStr' (*INCLUSIVE*) from where the search shall start.
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        extraDelimiterTest - When this method makes token comparisons using the input String-token parameter, if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match before considering the match as a token-match. This Predicate<Character> test allows the programmer to identify characters in addition to white-space that identify the match as a token match.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-String match in 'srcStr', performing the search in the left direction, beginning at String-index 'fromIndex'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Any character that matches the user-provided Predicate<Character> 'extraDelimiterTest'
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
        16
        17
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, 0, fromIndex, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1))
                     ||   extraDelimiterTest.test(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen))
                     ||   extraDelimiterTest.test(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;
        
      • nthLeft

        public static int nthLeft​(java.lang.String srcStr,
                                  int fromIndex,
                                  int n,
                                  java.lang.String token)
        Search for the nth token-match of String-parameter 'token' in 'srcStr', but begin the search at index-position 'fromIndex' and work left. Return the integer index-location into 'srcStr' where the match occured.
        Parameters:
        srcStr - This may be any java.lang.String. Its contents will be searched for the specified token-matches, and an an index-pointer (an integer) will be returned.
        fromIndex - This is the right-most index-position in 'srcStr' (*INCLUSIVE*) from where the search shall start.
        n - This is the number of matches to skip when searching for String-parameter 'token' before returning an answer.
        token - This is the sub-string that will be 'searched-for' in input parameter String 'srcStr'.
        Returns:
        The 'srcStr' String-index of the nth identified TOKEN-String match in 'srcStr', performing the search in the left direction, beginning at String-index 'fromIndex'

        NOTE: The concept of a TOKEN match will be defined as nearly identical to a sub-string match, with the added requirement that BOTH the character directly preceding the sub-string match AND the character immediately following it may only equal one of these values:

        white-space (matching '\s')
        String-start (matching '^')
        String-terminus (matching '$')
        Throws:
        NException - If the value of 'n' is negative, or greater than srcStr.length(), this exception shall throw.
        Code:
        Exact Method Body:
         1
         2
         3
         4
         5
         6
         7
         8
         9
        10
        11
        12
        13
        14
        15
         NException.check(n, srcStr);
        
         LV  l          = new LV(srcStr, 0, fromIndex, token.length());
         int tokenLen   = token.length();
        
         for (int i=(l.end-1); i >= l.start; i--)
             if (    srcStr.regionMatches(i, token, 0, tokenLen)
                 &&  (    (i==0)
                     ||   Character.isWhitespace(srcStr.charAt(i-1)))
                 &&  (    ((i + tokenLen) == srcStr.length())
                     ||   Character.isWhitespace(srcStr.charAt(i + tokenLen)))
             )
                 if (--n == 0) return i;
        
         return -1;