How to use

chars

method

in

java.lang.String

private static int computeWidth(String text) {
 return text.chars()
  .mapToObj(i -> (char) i)
  .mapToInt(c -> {
   Integer length = CHAR_LENGTH.get(c);
   checkState(length != null, "Invalid character '%s'", c);
   return length;
  })
  .sum();
}

private static boolean validateName(String name)
{
  return name.chars().noneMatch(c -> c == '<' || c == '>' || c == ',');
}

private static boolean validateName(String name)
{
  return name.chars().noneMatch(c -> c == '<' || c == '>' || c == ',');
}

public static String launder(String input) {
  Preconditions.checkNotNull(input);
  final StringBuilder sb = new StringBuilder();
  input.chars().forEach(c -> sb.append((char) Integer.valueOf(c).intValue()));
  return sb.toString();
}

private void printSepLine(StringBuilder sb, String title) {
  title.chars().forEach((c) -> {
    if (c == '|') {
      sb.append('+');
    } else {
      sb.append('-');
    }
  });
  sb.append('\n');
}

/**
 * Counts the number of occurrences of each character in the string
 *
 * @param input The input string
 * @return A map containing the number of occurrences of each character in the string
 */
public static Map<Character, Long> charsCount(String input) {
  if (isNullOrEmpty(input)) {
    return Collections.emptyMap();
  }
  return input.chars().mapToObj(c -> (char) c).collect(groupingBy(identity(), counting()));
}

private boolean isProbablyType(String name) {
 Symbol typeSymbol = FindIdentifiers.findIdent(name, state, KindSelector.TYP);
 return typeSymbol instanceof TypeSymbol
   || name.chars().filter(c -> c == '.').count() >= 3
   || name.contains("#");
}

@Benchmark
public long java8() {
  // Using Java8
  return testString.chars().filter(ch -> ch =='.').count();
}

@Benchmark
public long java8() {
  // Using Java8
  return testString.chars().filter(ch -> ch =='.').count();
}

/**
 * Add a single object into the script context.
 *
 * @param key the name in the context this object is to stored under.
 * @param bean the object to be stored in the script context.
 */
public void addBean(String key, Object bean) {
  if (!key.isEmpty() && Character.isJavaIdentifierStart(key.charAt(0))
      && key.chars().skip(1).allMatch(Character::isJavaIdentifierPart)) {
    beans.put(key, bean);
  }
}

private static boolean isErrorUriValid(String errorUri) {
  return errorUri == null ||
      errorUri.chars().allMatch(c ->
          c == 0x21 ||
          withinTheRangeOf(c, 0x23, 0x5B) ||
          withinTheRangeOf(c, 0x5D, 0x7E));
}

private String randomizeCase(String s) {
 return s.chars()
  .map(c -> random.nextBoolean() ? Character.toUpperCase(c) : Character.toLowerCase(c))
  .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
  .toString();
}

private static boolean validateScope(String scope) {
  return scope == null ||
      scope.chars().allMatch(c ->
          withinTheRangeOf(c, 0x21, 0x21) ||
          withinTheRangeOf(c, 0x23, 0x5B) ||
          withinTheRangeOf(c, 0x5D, 0x7E));
}

private static boolean isScopeValid(String scope) {
  return scope == null ||
      scope.chars().allMatch(c ->
          withinTheRangeOf(c, 0x20, 0x21) ||
          withinTheRangeOf(c, 0x23, 0x5B) ||
          withinTheRangeOf(c, 0x5D, 0x7E));
}

private static boolean isDescriptionValid(String description) {
  return description == null ||
      description.chars().allMatch(c ->
          withinTheRangeOf(c, 0x20, 0x21) ||
          withinTheRangeOf(c, 0x23, 0x5B) ||
          withinTheRangeOf(c, 0x5D, 0x7E));
}

private static boolean isErrorCodeValid(String errorCode) {
  return errorCode.chars().allMatch(c ->
          withinTheRangeOf(c, 0x20, 0x21) ||
          withinTheRangeOf(c, 0x23, 0x5B) ||
          withinTheRangeOf(c, 0x5D, 0x7E));
}

@Test
public void nextAlphaNumericString()
{
  Set<Integer> seenDigits = "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789".chars().boxed()
      .collect( Collectors.toSet() );
  for ( int i = 0; i < ITERATIONS; i++ )
  {
    TextValue textValue = randomValues.nextAlphaNumericTextValue( 10, 20 );
    String asString = textValue.stringValue();
    for ( int j = 0; j < asString.length(); j++ )
    {
      int ch = asString.charAt( j );
      assertTrue( "Not a character nor letter: " + ch,
          Character.isAlphabetic( ch ) || Character.isDigit( ch ) );
      seenDigits.remove( ch );
    }
  }
  assertThat( seenDigits, empty() );
}

public void testFlatteningToImmutableListMultimap() {
 Collector<String, ?, ImmutableListMultimap<Character, Character>> collector =
   ImmutableListMultimap.flatteningToImmutableListMultimap(
     str -> str.charAt(0), str -> str.substring(1).chars().mapToObj(c -> (char) c));
 BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence =
   Equivalence.equals()
     .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet()))
     .and(Equivalence.equals());
 ImmutableListMultimap<Character, Character> empty = ImmutableListMultimap.of();
 ImmutableListMultimap<Character, Character> filled =
   ImmutableListMultimap.<Character, Character>builder()
     .putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a'))
     .putAll('a', Arrays.asList('p', 'p', 'l', 'e'))
     .putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't'))
     .putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's'))
     .putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y'))
     .build();
 CollectorTester.of(collector, equivalence)
   .expectCollects(empty)
   .expectCollects(filled, "banana", "apple", "carrot", "asparagus", "cherry");
}

public void testFlatteningToImmutableSetMultimap() {
 Collector<String, ?, ImmutableSetMultimap<Character, Character>> collector =
   ImmutableSetMultimap.flatteningToImmutableSetMultimap(
     str -> str.charAt(0), str -> str.substring(1).chars().mapToObj(c -> (char) c));
 BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence =
   Equivalence.equals()
     .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet()))
     .and(Equivalence.equals());
 ImmutableSetMultimap<Character, Character> empty = ImmutableSetMultimap.of();
 ImmutableSetMultimap<Character, Character> filled =
   ImmutableSetMultimap.<Character, Character>builder()
     .putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a'))
     .putAll('a', Arrays.asList('p', 'p', 'l', 'e'))
     .putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't'))
     .putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's'))
     .putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y'))
     .build();
 CollectorTester.of(collector, equivalence)
   .expectCollects(empty)
   .expectCollects(filled, "banana", "apple", "carrot", "asparagus", "cherry");
}

public void testFlatteningToMultimap() {
 Collector<String, ?, ListMultimap<Character, Character>> collector =
   Multimaps.flatteningToMultimap(
     str -> str.charAt(0),
     str -> str.substring(1).chars().mapToObj(c -> (char) c),
     MultimapBuilder.linkedHashKeys().arrayListValues()::build);
 BiPredicate<Multimap<?, ?>, Multimap<?, ?>> equivalence =
   Equivalence.equals()
     .onResultOf((Multimap<?, ?> mm) -> ImmutableList.copyOf(mm.asMap().entrySet()))
     .and(Equivalence.equals());
 ListMultimap<Character, Character> empty =
   MultimapBuilder.linkedHashKeys().arrayListValues().build();
 ListMultimap<Character, Character> filled =
   MultimapBuilder.linkedHashKeys().arrayListValues().build();
 filled.putAll('b', Arrays.asList('a', 'n', 'a', 'n', 'a'));
 filled.putAll('a', Arrays.asList('p', 'p', 'l', 'e'));
 filled.putAll('c', Arrays.asList('a', 'r', 'r', 'o', 't'));
 filled.putAll('a', Arrays.asList('s', 'p', 'a', 'r', 'a', 'g', 'u', 's'));
 filled.putAll('c', Arrays.asList('h', 'e', 'r', 'r', 'y'));
 CollectorTester.of(collector, equivalence)
   .expectCollects(empty)
   .expectCollects(filled, "banana", "apple", "carrot", "asparagus", "cherry");
}