org.apache.commons.lang3.CharSet.getInstance java code examples

/**
 * Implementation of delete and keep
 *
 * @param str String to modify characters within
 * @param set String[] set of characters to modify
 * @param expect whether to evaluate on match, or non-match
 * @return the modified String, not null
 */
private static String modify(final String str, final String[] set, final boolean expect) {
  final CharSet chars = CharSet.getInstance(set);
  final StringBuilder buffer = new StringBuilder(str.length());
  final char[] chrs = str.toCharArray();
  for (final char chr : chrs) {
    if (chars.contains(chr) == expect) {
      buffer.append(chr);
    }
  }
  return buffer.toString();
}

  return false;
final CharSet chars = CharSet.getInstance(set);
for (final char c : str.toCharArray()) {
  if (chars.contains(c)) {

  return 0;
final CharSet chars = CharSet.getInstance(set);
int count = 0;
for (final char c : str.toCharArray()) {

  return str;
final CharSet chars = CharSet.getInstance(set);
final StringBuilder buffer = new StringBuilder(str.length());
final char[] chrs = str.toCharArray();

@Test
public void testGetInstance() {
  assertSame(CharSet.EMPTY, CharSet.getInstance( (String) null));
  assertSame(CharSet.EMPTY, CharSet.getInstance(""));
  assertSame(CharSet.ASCII_ALPHA, CharSet.getInstance("a-zA-Z"));
  assertSame(CharSet.ASCII_ALPHA, CharSet.getInstance("A-Za-z"));
  assertSame(CharSet.ASCII_ALPHA_LOWER, CharSet.getInstance("a-z"));
  assertSame(CharSet.ASCII_ALPHA_UPPER, CharSet.getInstance("A-Z"));
  assertSame(CharSet.ASCII_NUMERIC, CharSet.getInstance("0-9"));
}

@Test
public void testGetInstance_Stringarray() {
  assertNull(CharSet.getInstance((String[]) null));
  assertEquals("[]", CharSet.getInstance(new String[0]).toString());
  assertEquals("[]", CharSet.getInstance(new String[] {null}).toString());
  assertEquals("[a-e]", CharSet.getInstance(new String[] {"a-e"}).toString());
}

  @Test
  public void testJavadocExamples() throws Exception {
    assertFalse(CharSet.getInstance("^a-c").contains('a'));
    assertTrue(CharSet.getInstance("^a-c").contains('d'));
    assertTrue(CharSet.getInstance("^^a-c").contains('a'));
    assertFalse(CharSet.getInstance("^^a-c").contains('^'));
    assertTrue(CharSet.getInstance("^a-cd-f").contains('d'));
    assertTrue(CharSet.getInstance("a-c^").contains('^'));
    assertTrue(CharSet.getInstance("^", "a-c").contains('^'));
  }
}

@Test
public void testSerialization() {
  CharSet set = CharSet.getInstance("a");
  assertEquals(set, SerializationUtils.clone(set));
  set = CharSet.getInstance("a-e");
  assertEquals(set, SerializationUtils.clone(set));
  set = CharSet.getInstance("be-f^a-z");
  assertEquals(set, SerializationUtils.clone(set));
}

@Test
public void testHashCode() {
  final CharSet abc = CharSet.getInstance("abc");
  final CharSet abc2 = CharSet.getInstance("abc");
  final CharSet atoc = CharSet.getInstance("a-c");
  final CharSet atoc2 = CharSet.getInstance("a-c");
  final CharSet notatoc = CharSet.getInstance("^a-c");
  final CharSet notatoc2 = CharSet.getInstance("^a-c");
  assertEquals(abc.hashCode(), abc.hashCode());
  assertEquals(abc.hashCode(), abc2.hashCode());
  assertEquals(atoc.hashCode(), atoc.hashCode());
  assertEquals(atoc.hashCode(), atoc2.hashCode());
  assertEquals(notatoc.hashCode(), notatoc.hashCode());
  assertEquals(notatoc.hashCode(), notatoc2.hashCode());
}

set = CharSet.getInstance("-");
array = set.getCharRanges();
assertEquals(1, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
set = CharSet.getInstance("--");
array = set.getCharRanges();
assertEquals(1, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
set = CharSet.getInstance("---");
array = set.getCharRanges();
assertEquals(1, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
set = CharSet.getInstance("----");
array = set.getCharRanges();
assertEquals(1, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('-')));
set = CharSet.getInstance("-a");
array = set.getCharRanges();
assertEquals(2, array.length);
set = CharSet.getInstance("a-");
array = set.getCharRanges();
assertEquals(2, array.length);
set = CharSet.getInstance("a--");

CharRange[] array;
set = CharSet.getInstance("abc");
array = set.getCharRanges();
assertEquals(3, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('c')));
set = CharSet.getInstance("a-ce-f");
array = set.getCharRanges();
assertEquals(2, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.isIn('e', 'f')));
set = CharSet.getInstance("ae-f");
array = set.getCharRanges();
assertEquals(2, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.isIn('e', 'f')));
set = CharSet.getInstance("e-fa");
array = set.getCharRanges();
assertEquals(2, array.length);
set = CharSet.getInstance("ae-fm-pz");
array = set.getCharRanges();
assertEquals(4, array.length);

CharSet set;
CharRange[] array;
set = CharSet.getInstance("^");
array = set.getCharRanges();
assertEquals(1, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('^'))); // "^"
set = CharSet.getInstance("^^");
array = set.getCharRanges();
assertEquals(1, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^"
set = CharSet.getInstance("^^^");
array = set.getCharRanges();
assertEquals(2, array.length);
set = CharSet.getInstance("^^^^");
array = set.getCharRanges();
assertEquals(1, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.isNot('^'))); // "^^" x2
set = CharSet.getInstance("a^");
array = set.getCharRanges();
assertEquals(2, array.length);
set = CharSet.getInstance("^a-");
array = set.getCharRanges();
assertEquals(2, array.length);

@Test
public void testEquals_Object() {
  final CharSet abc = CharSet.getInstance("abc");
  final CharSet abc2 = CharSet.getInstance("abc");
  final CharSet atoc = CharSet.getInstance("a-c");
  final CharSet atoc2 = CharSet.getInstance("a-c");
  final CharSet notatoc = CharSet.getInstance("^a-c");
  final CharSet notatoc2 = CharSet.getInstance("^a-c");
  assertFalse(abc.equals(null));
  assertTrue(abc.equals(abc));
  assertTrue(abc.equals(abc2));
  assertFalse(abc.equals(atoc));
  assertFalse(abc.equals(notatoc));
  assertFalse(atoc.equals(abc));
  assertTrue(atoc.equals(atoc));
  assertTrue(atoc.equals(atoc2));
  assertFalse(atoc.equals(notatoc));
  assertFalse(notatoc.equals(abc));
  assertFalse(notatoc.equals(atoc));
  assertTrue(notatoc.equals(notatoc));
  assertTrue(notatoc.equals(notatoc2));
}

CharRange[] array;
set = CharSet.getInstance("^abc");
array = set.getCharRanges();
assertEquals(3, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('c')));
set = CharSet.getInstance("b^ac");
array = set.getCharRanges();
assertEquals(3, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('c')));
set = CharSet.getInstance("db^ac");
array = set.getCharRanges();
assertEquals(4, array.length);
assertTrue(ArrayUtils.contains(array, CharRange.is('c')));
set = CharSet.getInstance("^b^a");
array = set.getCharRanges();
assertEquals(2, array.length);
set = CharSet.getInstance("b^a-c^z");
array = set.getCharRanges();
assertEquals(3, array.length);

CharRange[] array;
set = CharSet.getInstance((String) null);
array = set.getCharRanges();
assertEquals("[]", set.toString());
assertEquals(0, array.length);
set = CharSet.getInstance("");
array = set.getCharRanges();
assertEquals("[]", set.toString());
assertEquals(0, array.length);
set = CharSet.getInstance("a");
array = set.getCharRanges();
assertEquals("[a]", set.toString());
set = CharSet.getInstance("^a");
array = set.getCharRanges();
assertEquals("[^a]", set.toString());
set = CharSet.getInstance("a-e");
array = set.getCharRanges();
assertEquals("[a-e]", set.toString());
set = CharSet.getInstance("^a-e");
array = set.getCharRanges();
assertEquals("[^a-e]", set.toString());

CharRange[] array = null;
set = CharSet.getInstance("a-^c");
array = set.getCharRanges();
assertTrue(ArrayUtils.contains(array, CharRange.isIn('a', '^'))); // "a-^"
assertTrue(set.contains('c'));
set = CharSet.getInstance("^a-^c");
array = set.getCharRanges();
assertTrue(ArrayUtils.contains(array, CharRange.isNotIn('a', '^'))); // "^a-^"
assertFalse(set.contains('_')); // between ^ and a
set = CharSet.getInstance("a- ^-- "); //contains everything
array = set.getCharRanges();
assertTrue(ArrayUtils.contains(array, CharRange.isIn('a', ' '))); // "a- "
assertTrue(set.contains('A'));
set = CharSet.getInstance("^-b");
array = set.getCharRanges();
assertTrue(ArrayUtils.contains(array, CharRange.isIn('^','b'))); // "^-b"
set = CharSet.getInstance("b-^");
array = set.getCharRanges();
assertTrue(ArrayUtils.contains(array, CharRange.isIn('^','b'))); // "b-^"

@Test
public void testContains_Char() {
  final CharSet btod = CharSet.getInstance("b-d");
  final CharSet dtob = CharSet.getInstance("d-b");
  final CharSet bcd = CharSet.getInstance("bcd");
  final CharSet bd = CharSet.getInstance("bd");
  final CharSet notbtod = CharSet.getInstance("^b-d");

/**
 * @param resultBuilder
 *            , the builder for result strings.
 * @param resultArray
 *            , the byte array to hold results.
 * @param pattern
 *            , the string that is used to construct the charset for trimming.
 */
public StringTrimmer(UTF8StringBuilder resultBuilder, GrowableArray resultArray, String pattern) {
  this.resultBuilder = resultBuilder;
  this.resultArray = resultArray;
  if (pattern != null) {
    charSet = CharSet.getInstance(pattern);
  }
}

/**
 * Implementation of delete and keep
 *
 * @param str String to modify characters within
 * @param set String[] set of characters to modify
 * @param expect whether to evaluate on match, or non-match
 * @return the modified String, not null
 */
private static String modify(final String str, final String[] set, final boolean expect) {
  final CharSet chars = CharSet.getInstance(set);
  final StringBuilder buffer = new StringBuilder(str.length());
  final char[] chrs = str.toCharArray();
  for (final char chr : chrs) {
    if (chars.contains(chr) == expect) {
      buffer.append(chr);
    }
  }
  return buffer.toString();
}

/**
 * Builds the charset from a pattern string.
 *
 * @param patternPtr
 *            , a pattern string.
 */
public void build(UTF8StringPointable patternPtr) {
  final boolean newPattern = charSet == null || lastPatternPtr.compareTo(patternPtr) != 0;
  if (newPattern) {
    StringEvaluatorUtils.copyResetUTF8Pointable(patternPtr, lastPatternStorage, lastPatternPtr);
    charSet = CharSet.getInstance(patternPtr.toString());
  }
}

Javadoc

Factory method to create a new CharSet using a special syntax.

null or empty string ("") - set containing no characters
Single character, such as "a" - set containing just that character
Multi character, such as "a-e" - set containing characters from one character to the other
Negated, such as "^a" or "^a-e" - set containing all characters except those defined
Combinations, such as "abe-g" - set containing all the characters from the individual sets

The matching order is:

Negated multi character range, such as "^a-e"
Ordinary multi character range, such as "a-e"
Negated single character, such as "^a"
Ordinary single character, such as "a"

Matching works left to right. Once a match is found the search starts again from the next character.

If the same range is defined twice using the same syntax, only one range will be kept. Thus, "a-ca-c" creates only one range of "a-c".

If the start and end of a range are in the wrong order, they are reversed. Thus "a-e" is the same as "e-a". As a result, "a-ee-a" would create only one range, as the "a-e" and "e-a" are the same.

The set of characters represented is the union of the specified ranges.

There are two ways to add a literal negation character ( ^):

As the last character in a string, e.g. CharSet.getInstance("a-z^")
As a separate element, e.g. CharSet.getInstance("^","a-z")

Examples using the negation character:

 
CharSet.getInstance("^a-c").contains('a') = false 
CharSet.getInstance("^a-c").contains('d') = true 
CharSet.getInstance("^^a-c").contains('a') = true // (only '^' is negated) 
CharSet.getInstance("^^a-c").contains('^') = false 
CharSet.getInstance("^a-cd-f").contains('d') = true 
CharSet.getInstance("a-c^").contains('^') = true 
CharSet.getInstance("^", "a-c").contains('^') = true

All CharSet objects returned by this method will be immutable.

Popular methods of CharSet

contains
Does the CharSet contain the specified character ch.
<init>
Constructs a new CharSet using the set syntax. Each string is merged in with the set.
add
Add a set definition string to the CharSet.
equals
Compares two CharSet objects, returning true if they represent exactly the same set of characters de
getCharRanges
Gets the internal set as an array of CharRange objects.
hashCode
Gets a hash code compatible with the equals method.
toString
Gets a string representation of the set.

Popular in Java

Updating database using SQL prepared statement
onCreateOptionsMenu (Activity)
getSharedPreferences (Context)
setContentView (Activity)
Pointer (com.sun.jna)
An abstraction for a native pointer data type. A Pointer instance represents, on the Java side, a na
FileNotFoundException (java.io)
Thrown when a file specified by a program cannot be found.
PrintWriter (java.io)
Wraps either an existing OutputStream or an existing Writerand provides convenience methods for prin
BigDecimal (java.math)
An immutable arbitrary-precision signed decimal.A value is represented by an arbitrary-precision "un
IOUtils (org.apache.commons.io)
General IO stream manipulation utilities. This class provides static utility methods for input/outpu
Loader (org.hibernate.loader)
Abstract superclass of object loading (and querying) strategies. This class implements useful common
CodeWhisperer alternatives

How to use getInstancemethodin org.apache.commons.lang3.CharSet

Best Java code snippets using org.apache.commons.lang3.CharSet.getInstance (Showing top 20 results out of 315)

How to use
getInstance
method
in
org.apache.commons.lang3.CharSet