|
Eclipse JDT 2.1 |
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object | +--org.eclipse.jdt.core.compiler.CharOperation
This class is a collection of helper methods to manipulate char arrays.
Field Summary | |
static char[] |
NO_CHAR
Constant for an empty char array |
static char[][] |
NO_CHAR_CHAR
Constant for an empty char array with two dimensions. |
Constructor Summary | |
CharOperation()
|
Method Summary | |
static char[] |
append(char[] array,
char suffix)
Answers a new array with appending the suffix character at the end of the array. |
static char[] |
append(char[] target,
int index,
char[] array,
int start,
int end)
Append the given subarray to the target array starting at the given index in the target array. |
static char[][] |
arrayConcat(char[][] first,
char[] second)
Answers a new array adding the second array at the end of first array. |
static char[][] |
arrayConcat(char[][] first,
char[][] second)
Answers the concatenation of the two arrays. |
static int |
compareWith(char[] array,
char[] prefix)
Compare the contents of the two arrays array and prefix and answers: zero if the array starts with the prefix contents the difference between the first two characters that are not equal one if array length is lower than the prefix length and that the prefix starts with the array contents. For example: |
static char[] |
concat(char[] first,
char[] second)
Answers the concatenation of the two arrays. |
static char[] |
concat(char[] first,
char[] second,
char separator)
Answers the concatenation of the two arrays inserting the separator character between the two arrays. |
static char[] |
concat(char[] first,
char[] second,
char[] third)
Answers the concatenation of the three arrays. |
static char[] |
concat(char[] first,
char sep1,
char[] second,
char sep2,
char[] third)
Answers the concatenation of the three arrays inserting the sep1 character between the two arrays and sep2 between the last two. |
static char[] |
concat(char prefix,
char[] array,
char suffix)
Answers a new array with prepending the prefix character and appending the suffix character at the end of the array. |
static char[] |
concatWith(char[][] array,
char separator)
Answers the concatenation of the given array parts using the given separator between each part. |
static char[] |
concatWith(char[][] array,
char[] name,
char separator)
Answers the concatenation of the given array parts using the given separator between each part and appending the given name at the end. |
static char[] |
concatWith(char[] name,
char[][] array,
char separator)
Answers the concatenation of the given array parts using the given separator between each part and appending the given name at the end. |
static boolean |
contains(char character,
char[] array)
Answers true if the array contains an occurrence of character, false otherwise. |
static boolean |
contains(char character,
char[][] array)
Answers true if the array contains an occurrence of character, false otherwise. |
static char[][] |
deepCopy(char[][] toCopy)
Answers a deep copy of the toCopy array. |
static boolean |
endsWith(char[] array,
char[] toBeFound)
Return true if array ends with the sequence of characters contained in toBeFound, otherwise false. |
static boolean |
equals(char[][] first,
char[][] second)
Answers true if the two arrays are identical character by character, otherwise false. |
static boolean |
equals(char[][] first,
char[][] second,
boolean isCaseSensitive)
If isCaseSensite is true, answers true if the two arrays are identical character by character, otherwise false. |
static boolean |
equals(char[] first,
char[] second)
Answers true if the two arrays are identical character by character, otherwise false. |
static boolean |
equals(char[] first,
char[] second,
boolean isCaseSensitive)
If isCaseSensite is true, answers true if the two arrays are identical character by character, otherwise false. |
static boolean |
fragmentEquals(char[] fragment,
char[] name,
int startIndex,
boolean isCaseSensitive)
If isCaseSensite is true, the equality is case sensitive, otherwise it is case insensitive. |
static int |
hashCode(char[] array)
Answers a hashcode for the array |
static int |
indexOf(char toBeFound,
char[] array)
Answers the first index in the array for which the corresponding character is equal to toBeFound. |
static int |
indexOf(char toBeFound,
char[] array,
int start)
Answers the first index in the array for which the corresponding character is equal to toBeFound starting the search at index start. |
static boolean |
isWhitespace(char c)
Answers true if c is a whitespace according to the JLS (\u000a, \u000c, \u000d, \u0009), otherwise false. |
static int |
lastIndexOf(char toBeFound,
char[] array)
Answers the last index in the array for which the corresponding character is equal to toBeFound starting from the end of the array. |
static int |
lastIndexOf(char toBeFound,
char[] array,
int startIndex)
Answers the last index in the array for which the corresponding character is equal to toBeFound stopping at the index startIndex. |
static int |
lastIndexOf(char toBeFound,
char[] array,
int startIndex,
int endIndex)
Answers the last index in the array for which the corresponding character is equal to toBeFound starting from endIndex to startIndex. |
static char[] |
lastSegment(char[] array,
char separator)
Answers the last portion of a name given a separator. |
static boolean |
match(char[] pattern,
char[] name,
boolean isCaseSensitive)
Answers true if the pattern matches the given name, false otherwise. |
static boolean |
match(char[] pattern,
int patternStart,
int patternEnd,
char[] name,
int nameStart,
int nameEnd,
boolean isCaseSensitive)
Answers true if the a sub-pattern matches the subpart of the given name, false otherwise. |
static int |
occurencesOf(char toBeFound,
char[] array)
Answers the number of occurrences of the given character in the given array, 0 if any. |
static int |
occurencesOf(char toBeFound,
char[] array,
int start)
Answers the number of occurrences of the given character in the given array starting at the given index, 0 if any. |
static boolean |
pathMatch(char[] pattern,
char[] filepath,
boolean isCaseSensitive,
char pathSeparator)
Answers true if the pattern matches the filepath using the pathSepatator, false otherwise. |
static boolean |
prefixEquals(char[] prefix,
char[] name)
Answers true if the given name starts with the given prefix, false otherwise. |
static boolean |
prefixEquals(char[] prefix,
char[] name,
boolean isCaseSensitive)
Answers true if the given name starts with the given prefix, false otherwise. |
static char[] |
replace(char[] array,
char[] toBeReplaced,
char[] replacementChars)
Answers a new array of characters with substitutions. |
static void |
replace(char[] array,
char toBeReplaced,
char replacementChar)
Replace all occurrence of the character to be replaced with the remplacement character in the given array. |
static char[][] |
splitAndTrimOn(char divider,
char[] array)
Return a new array which is the split of the given array using the given divider and triming each subarray to remove whitespaces equals to ' '. |
static char[][] |
splitOn(char divider,
char[] array)
Return a new array which is the split of the given array using the given divider. |
static char[][] |
splitOn(char divider,
char[] array,
int start,
int end)
Return a new array which is the split of the given array using the given divider. |
static char[][] |
subarray(char[][] array,
int start,
int end)
Answers a new array which is a copy of the given array starting at the given start and ending at the given end. |
static char[] |
subarray(char[] array,
int start,
int end)
Answers a new array which is a copy of the given array starting at the given start and ending at the given end. |
static char[] |
toLowerCase(char[] chars)
Answers the result of a char[] conversion to lowercase. |
static String |
toString(char[][] array)
Answers a string which is the concatenation of the given array using the '.' as a separator. |
static char[] |
trim(char[] chars)
Answers a new array removing leading and trailing spaces (' '). |
Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
public static final char[] NO_CHAR
public static final char[][] NO_CHAR_CHAR
Constructor Detail |
public CharOperation()
Method Detail |
public static final char[] append(char[] array, char suffix)
array = { 'a', 'b' } suffix = 'c' => result = { 'a', 'b' , 'c' }
array = null suffix = 'c' => result = { 'c' }
array
- the array that is concanated with the suffix charactersuffix
- the suffix character
public static final char[] append(char[] target, int index, char[] array, int start, int end)
target = { 'a', 'b', '0' } index = 2 array = { 'c', 'd' } start = 0 end = 1 => result = { 'a', 'b' , 'c' }
target = { 'a', 'b' } index = 2 array = { 'c', 'd' } start = 0 end = 1 => result = { 'a', 'b' , 'c', '0', '0' , '0' } (new array)
target = { 'a', 'b', 'c' } index = 1 array = { 'c', 'd', 'e', 'f' } start = 1 end = 4 => result = { 'a', 'd' , 'e', 'f', '0', '0', '0', '0' } (new array)
target
- the given targetindex
- the given indexarray
- the given arraystart
- the given start indexend
- the given end index
NullPointerException
- if the target array is nullpublic static final char[][] arrayConcat(char[][] first, char[][] second)
first = null second = null => result = null
first = { { ' a' } } second = null => result = { { ' a' } }
first = null second = { { ' a' } } => result = { { ' a' } }
first = { { ' b' } } second = { { ' a' } } => result = { { ' b' }, { ' a' } }
first
- the first array to concatenatesecond
- the second array to concatenate
public static final char[][] arrayConcat(char[][] first, char[] second)
first = null second = { 'a' } => result = { { ' a' } }
first = { { ' a' } } second = null => result = { { ' a' } }
first = { { ' a' } } second = { ' b' } => result = { { ' a' } , { ' b' } }
first
- the first array to concatenatesecond
- the array to add at the end of the first array
public static final int compareWith(char[] array, char[] prefix)
array = null prefix = null => result = NullPointerException
array = { 'a', 'b', 'c', 'd', 'e' } prefix = { 'a', 'b', 'c'} => result = 0
array = { 'a', 'b', 'c', 'd', 'e' } prefix = { 'a', 'B', 'c'} => result = 32
array = { 'd', 'b', 'c', 'd', 'e' } prefix = { 'a', 'b', 'c'} => result = 3
array = { 'a', 'b', 'c', 'd', 'e' } prefix = { 'd', 'b', 'c'} => result = -3
array = { 'a', 'a', 'c', 'd', 'e' } prefix = { 'a', 'e', 'c'} => result = -4
array
- the given arrayprefix
- the given prefix
NullPointerException
- if either array or prefix is nullpublic static final char[] concat(char[] first, char[] second)
first = null second = { 'a' } => result = { ' a' }
first = { ' a' } second = null => result = { ' a' }
first = { ' a' } second = { ' b' } => result = { ' a' , ' b' }
first
- the first array to concatenatesecond
- the second array to concatenate
public static final char[] concat(char[] first, char[] second, char[] third)
first = null second = { 'a' } third = { 'b' } => result = { ' a', 'b' }
first = { 'a' } second = null third = { 'b' } => result = { ' a', 'b' }
first = { 'a' } second = { 'b' } third = null => result = { ' a', 'b' }
first = null second = null third = null => result = null
first = { 'a' } second = { 'b' } third = { 'c' } => result = { 'a', 'b', 'c' }
first
- the first array to concatenatesecond
- the second array to concatenatethird
- the third array to concatenate
public static final char[] concat(char[] first, char[] second, char separator)
first = null second = { 'a' } separator = '/' => result = { ' a' }
first = { ' a' } second = null separator = '/' => result = { ' a' }
first = { ' a' } second = { ' b' } separator = '/' => result = { ' a' , '/', 'b' }
first
- the first array to concatenatesecond
- the second array to concatenateseparator
- the character to insert
public static final char[] concat(char[] first, char sep1, char[] second, char sep2, char[] third)
first = null second = { 'a' } separator = '/' => result = { ' a' }
first = { ' a' } second = null separator = '/' => result = { ' a' }
first = { ' a' } second = { ' b' } separator = '/' => result = { ' a' , '/', 'b' }
first
- the first array to concatenatesecond
- the second array to concatenate
public static final char[] concat(char prefix, char[] array, char suffix)
prefix = 'a' array = { 'b' } suffix = 'c' => result = { 'a', 'b' , 'c' }
prefix = 'a' array = null suffix = 'c' => result = { 'a', 'c' }
prefix
- the prefix characterarray
- the array that is concanated with the prefix and suffix characterssuffix
- the suffix character
public static final char[] concatWith(char[] name, char[][] array, char separator)
name = { 'c' } array = { { 'a' }, { 'b' } } separator = '.' => result = { 'a', '.', 'b' , '.', 'c' }
name = null array = { { 'a' }, { 'b' } } separator = '.' => result = { 'a', '.', 'b' }
name = { ' c' } array = null separator = '.' => result = { 'c' }
name
- the given namearray
- the given arrayseparator
- the given separator
public static final char[] concatWith(char[][] array, char[] name, char separator)
name = { 'c' } array = { { 'a' }, { 'b' } } separator = '.' => result = { 'a', '.', 'b' , '.', 'c' }
name = null array = { { 'a' }, { 'b' } } separator = '.' => result = { 'a', '.', 'b' }
name = { ' c' } array = null separator = '.' => result = { 'c' }
array
- the given arrayname
- the given nameseparator
- the given separator
public static final char[] concatWith(char[][] array, char separator)
array = { { 'a' }, { 'b' } } separator = '.' => result = { 'a', '.', 'b' }
array = null separator = '.' => result = { }
array
- the given arrayseparator
- the given separator
public static final boolean contains(char character, char[][] array)
character = 'c' array = { { ' a' }, { ' b' } } result => false
character = 'a' array = { { ' a' }, { ' b' } } result => true
character
- the character to searcharray
- the array in which the search is done
NullPointerException
- if array is null.public static final boolean contains(char character, char[] array)
character = 'c' array = { ' b' } result => false
character = 'a' array = { ' a' , ' b' } result => true
character
- the character to searcharray
- the array in which the search is done
NullPointerException
- if array is null.public static final char[][] deepCopy(char[][] toCopy)
toCopy
- the array to copy
public static final boolean endsWith(char[] array, char[] toBeFound)
array = { 'a', 'b', 'c', 'd' } toBeFound = { 'b', 'c' } result => false
array = { 'a', 'b', 'c' } toBeFound = { 'b', 'c' } result => true
array
- the array to checktoBeFound
- the array to find
NullPointerException
- if array is null or toBeFound is nullpublic static final boolean equals(char[][] first, char[][] second)
first = null second = null result => true
first = { { } } second = null result => false
first = { { 'a' } } second = { { 'a' } } result => true
first = { { 'A' } } second = { { 'a' } } result => false
first
- the first arraysecond
- the second array
public static final boolean equals(char[][] first, char[][] second, boolean isCaseSensitive)
first = null second = null isCaseSensitive = true result => true
first = { { } } second = null isCaseSensitive = true result => false
first = { { 'A' } } second = { { 'a' } } isCaseSensitive = true result => false
first = { { 'A' } } second = { { 'a' } } isCaseSensitive = false result => true
first
- the first arraysecond
- the second arrayisCaseSensitive
- check whether or not the equality should be case sensitive
public static final boolean equals(char[] first, char[] second)
first = null second = null result => true
first = { } second = null result => false
first = { 'a' } second = { 'a' } result => true
first = { 'a' } second = { 'A' } result => false
first
- the first arraysecond
- the second array
public static final boolean equals(char[] first, char[] second, boolean isCaseSensitive)
first = null second = null isCaseSensitive = true result => true
first = { } second = null isCaseSensitive = true result => false
first = { 'A' } second = { 'a' } isCaseSensitive = true result => false
first = { 'A' } second = { 'a' } isCaseSensitive = false result => true
first
- the first arraysecond
- the second arrayisCaseSensitive
- check whether or not the equality should be case sensitive
public static final boolean fragmentEquals(char[] fragment, char[] name, int startIndex, boolean isCaseSensitive)
fragment = { 'b', 'c' , 'd' } name = { 'a', 'b', 'c' , 'd' } startIndex = 1 isCaseSensitive = true result => true
fragment = { 'b', 'c' , 'd' } name = { 'a', 'b', 'C' , 'd' } startIndex = 1 isCaseSensitive = true result => false
fragment = { 'b', 'c' , 'd' } name = { 'a', 'b', 'C' , 'd' } startIndex = 0 isCaseSensitive = false result => false
fragment = { 'b', 'c' , 'd' } name = { 'a', 'b'} startIndex = 0 isCaseSensitive = true result => false
fragment
- the fragment to checkstartIndex
- the starting indexisCaseSensitive
- check whether or not the equality should be case sensitive
NullPointerException
- if fragment or name is null.public static final int hashCode(char[] array)
array
- the array for which a hashcode is required
NullPointerException
- if array is nullpublic static boolean isWhitespace(char c)
c = ' ' result => true
c = '\u3000' result => false
c
- the character to check
public static final int indexOf(char toBeFound, char[] array)
toBeFound = 'c' array = { ' a', 'b', 'c', 'd' } result => 2
toBeFound = 'e' array = { ' a', 'b', 'c', 'd' } result => -1
toBeFound
- the character to searcharray
- the array to be searched
NullPointerException
- if array is nullpublic static final int indexOf(char toBeFound, char[] array, int start)
toBeFound = 'c' array = { ' a', 'b', 'c', 'd' } start = 2 result => 2
toBeFound = 'c' array = { ' a', 'b', 'c', 'd' } start = 3 result => -1
toBeFound = 'e' array = { ' a', 'b', 'c', 'd' } start = 1 result => -1
toBeFound
- the character to searcharray
- the array to be searchedstart
- the starting index
NullPointerException
- if array is null
ArrayIndexOutOfBoundsException
- if start is lower than 0public static final int lastIndexOf(char toBeFound, char[] array)
toBeFound = 'c' array = { ' a', 'b', 'c', 'd' , 'c', 'e' } result => 4
toBeFound = 'e' array = { ' a', 'b', 'c', 'd' } result => -1
toBeFound
- the character to searcharray
- the array to be searched
NullPointerException
- if array is nullpublic static final int lastIndexOf(char toBeFound, char[] array, int startIndex)
toBeFound = 'c' array = { ' a', 'b', 'c', 'd' } startIndex = 2 result => 2
toBeFound = 'c' array = { ' a', 'b', 'c', 'd', 'e' } startIndex = 3 result => -1
toBeFound = 'e' array = { ' a', 'b', 'c', 'd' } startIndex = 0 result => -1
toBeFound
- the character to searcharray
- the array to be searchedstartIndex
- the stopping index
NullPointerException
- if array is null
ArrayIndexOutOfBoundsException
- if startIndex is lower than 0public static final int lastIndexOf(char toBeFound, char[] array, int startIndex, int endIndex)
toBeFound = 'c' array = { ' a', 'b', 'c', 'd' } startIndex = 2 endIndex = 2 result => 2
toBeFound = 'c' array = { ' a', 'b', 'c', 'd', 'e' } startIndex = 3 endIndex = 4 result => -1
toBeFound = 'e' array = { ' a', 'b', 'c', 'd' } startIndex = 0 endIndex = 3 result => -1
toBeFound
- the character to searcharray
- the array to be searchedstartIndex
- the stopping indexendIndex
- the starting index
NullPointerException
- if array is null
ArrayIndexOutOfBoundsException
- if endIndex is greater or equals to array length or starting is lower than 0public static final char[] lastSegment(char[] array, char separator)
lastSegment("java.lang.Object".toCharArray(),'.') --> Object
array
- the arrayseparator
- the given separator
NullPointerException
- if array is nullpublic static final boolean match(char[] pattern, char[] name, boolean isCaseSensitive)
pattern = { '?', 'b', '*' } name = { 'a', 'b', 'c' , 'd' } isCaseSensitive = true result => true
pattern = { '?', 'b', '?' } name = { 'a', 'b', 'c' , 'd' } isCaseSensitive = true result => false
pattern = { 'b', '*' } name = { 'a', 'b', 'c' , 'd' } isCaseSensitive = true result => false
pattern
- the given patternname
- the given nameisCaseSensitive
- flag to know whether or not the matching should be case sensitive
public static final boolean match(char[] pattern, int patternStart, int patternEnd, char[] name, int nameStart, int nameEnd, boolean isCaseSensitive)
pattern = { '?', 'b', '*' } patternStart = 1 patternEnd = 3 name = { 'a', 'b', 'c' , 'd' } nameStart = 1 nameEnd = 4 isCaseSensitive = true result => true
pattern = { '?', 'b', '*' } patternStart = 1 patternEnd = 2 name = { 'a', 'b', 'c' , 'd' } nameStart = 1 nameEnd = 2 isCaseSensitive = true result => false
pattern
- the given patternpatternStart
- the given pattern startpatternEnd
- the given pattern endname
- the given namenameStart
- the given name startnameEnd
- the given name endisCaseSensitive
- flag to know if the matching should be case sensitive
public static final boolean pathMatch(char[] pattern, char[] filepath, boolean isCaseSensitive, char pathSeparator)
pattern
- the given patternfilepath
- the given pathisCaseSensitive
- to find out whether or not the matching should be case sensitivepathSeparator
- the given path separator
public static final int occurencesOf(char toBeFound, char[] array)
toBeFound = 'b' array = { 'a' , 'b', 'b', 'a', 'b', 'a' } result => 3
toBeFound = 'c' array = { 'a' , 'b', 'b', 'a', 'b', 'a' } result => 0
toBeFound
- the given characterarray
- the given array
NullPointerException
- if array is nullpublic static final int occurencesOf(char toBeFound, char[] array, int start)
toBeFound = 'b' array = { 'a' , 'b', 'b', 'a', 'b', 'a' } start = 2 result => 2
toBeFound = 'c' array = { 'a' , 'b', 'b', 'a', 'b', 'a' } start = 0 result => 0
toBeFound
- the given characterarray
- the given array
NullPointerException
- if array is null
ArrayIndexOutOfBoundsException
- if start is lower than 0public static final boolean prefixEquals(char[] prefix, char[] name)
prefix = { 'a' , 'b' } name = { 'a' , 'b', 'b', 'a', 'b', 'a' } result => true
prefix = { 'a' , 'c' } name = { 'a' , 'b', 'b', 'a', 'b', 'a' } result => false
prefix
- the given prefixname
- the given name
NullPointerException
- if the given name is null or if the given prefix is nullpublic static final boolean prefixEquals(char[] prefix, char[] name, boolean isCaseSensitive)
prefix = { 'a' , 'B' } name = { 'a' , 'b', 'b', 'a', 'b', 'a' } isCaseSensitive = false result => true
prefix = { 'a' , 'B' } name = { 'a' , 'b', 'b', 'a', 'b', 'a' } isCaseSensitive = true result => false
prefix
- the given prefixname
- the given nameisCaseSensitive
- to find out whether or not the comparison should be case sensitive
NullPointerException
- if the given name is null or if the given prefix is nullpublic static final void replace(char[] array, char toBeReplaced, char replacementChar)
array = { 'a' , 'b', 'b', 'a', 'b', 'a' } toBeReplaced = 'b' replacementChar = 'a' result => No returned value, but array is now equals to { 'a' , 'a', 'a', 'a', 'a', 'a' }
array = { 'a' , 'b', 'b', 'a', 'b', 'a' } toBeReplaced = 'c' replacementChar = 'a' result => No returned value, but array is now equals to { 'a' , 'b', 'b', 'a', 'b', 'a' }
array
- the given arraytoBeReplaced
- the character to be replacedreplacementChar
- the replacement character
NullPointerException
- if the given array is nullpublic static final char[] replace(char[] array, char[] toBeReplaced, char[] replacementChars)
array = { 'a' , 'b', 'b', 'a', 'b', 'a' } toBeReplaced = { 'b' } replacementChar = { 'a', 'a' } result => { 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a' }
array = { 'a' , 'b', 'b', 'a', 'b', 'a' } toBeReplaced = { 'c' } replacementChar = { 'a' } result => { 'a' , 'b', 'b', 'a', 'b', 'a' }
toBeReplaced
- characters to be replaced
NullPointerException
- if the given array is nullpublic static final char[][] splitAndTrimOn(char divider, char[] array)
divider = 'b' array = { 'a' , 'b', 'b', 'a', 'b', 'a' } result => { { 'a' }, { }, { 'a' }, { 'a' } }
divider = 'c' array = { 'a' , 'b', 'b', 'a', 'b', 'a' } result => { { 'a', 'b', 'b', 'a', 'b', 'a' } }
divider = 'b' array = { 'a' , ' ', 'b', 'b', 'a', 'b', 'a' } result => { { 'a' }, { }, { 'a' }, { 'a' } }
divider = 'c' array = { ' ', ' ', 'a' , 'b', 'b', 'a', 'b', 'a', ' ' } result => { { 'a', 'b', 'b', 'a', 'b', 'a' } }
divider
- the given dividerarray
- the given array
public static final char[][] splitOn(char divider, char[] array)
divider = 'b' array = { 'a' , 'b', 'b', 'a', 'b', 'a' } result => { { 'a' }, { }, { 'a' }, { 'a' } }
divider = 'c' array = { 'a' , 'b', 'b', 'a', 'b', 'a' } result => { { 'a', 'b', 'b', 'a', 'b', 'a' } }
divider = 'c' array = { ' ', ' ', 'a' , 'b', 'b', 'a', 'b', 'a', ' ' } result => { { ' ', 'a', 'b', 'b', 'a', 'b', 'a', ' ' } }
divider
- the given dividerarray
- the given array
public static final char[][] splitOn(char divider, char[] array, int start, int end)
divider = 'b' array = { 'a' , 'b', 'b', 'a', 'b', 'a' } start = 2 end = 5 result => { { }, { }, { 'a' } }
divider
- the given dividerarray
- the given arraystart
- the given starting indexend
- the given ending index
ArrayIndexOutOfBoundsException
- if start is lower than 0 or end is greater than the array lengthpublic static final char[][] subarray(char[][] array, int start, int end)
array = { { 'a' } , { 'b' } } start = 0 end = 1 result => { { 'a' } }
array = { { 'a' } , { 'b' } } start = 0 end = -1 result => { { 'a' }, { 'b' } }
array
- the given arraystart
- the given starting indexend
- the given ending index
NullPointerException
- if the given array is nullpublic static final char[] subarray(char[] array, int start, int end)
array = { 'a' , 'b' } start = 0 end = 1 result => { 'a' }
array = { 'a', 'b' } start = 0 end = -1 result => { 'a' , 'b' }
array
- the given arraystart
- the given starting indexend
- the given ending index
NullPointerException
- if the given array is nullpublic static final char[] toLowerCase(char[] chars)
chars = { 'a' , 'b' } result => { 'a' , 'b' }
array = { 'A', 'b' } result => { 'a' , 'b' }
chars
- the chars to convert
public static final char[] trim(char[] chars)
chars = { ' ', 'a' , 'b', ' ', ' ' } result => { 'a' , 'b' }
array = { 'A', 'b' } result => { 'A' , 'b' }
chars
- the given array
public static final String toString(char[][] array)
array = { { 'a' } , { 'b' } } result => "a.b"
array = { { ' ', 'a' } , { 'b' } } result => " a.b"
|
Eclipse JDT 2.1 |
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |