StringUtils.java

package io.github.chermehdi.lib.string;


import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;

public class StringUtils {

  public static <E> String join(List<E> collection, String delimiter) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < collection.size(); i++) {
      if (i > 0) {
        sb.append(delimiter);
      }
      sb.append(collection.get(i));
    }
    return sb.toString().trim();
  }

  public static <E> String join(List<E> collection) {
    return join(collection, " ");
  }


  public static int countMatching(String s, Predicate<Character> p) {
    return countMatching(s.toCharArray(), p);
  }

  public static int countMatching(char[] s, Predicate<Character> p) {
    return countMatching(s, 0, s.length - 1, p);
  }

  public static int countMatching(char[] s, int start, int finish, Predicate<Character> p) {
    int ret = 0;
    for (int i = start; i <= finish; ++i) {
      if (p.test(s[i])) {
        ++ret;
      }
    }
    return ret;
  }

  public static int[] prefixFunction(char[] s) {
    int[] p = new int[s.length];
    int k = 0;
    for (int i = 1; i < s.length; i++) {
      while (k > 0 && s[k] != s[i]) {
        k = p[k - 1];
      }
      if (s[i] == s[k]) {
        ++k;
      }
      p[i] = k;
    }
    return p;
  }

  public static boolean contains(String text, String pat) {
    int[] p = prefixFunction(pat);
    int k = 0;
    for (int i = 0; i < text.length(); i++) {
      while (k > 0 && text.charAt(i) != pat.charAt(k)) {
        k = p[k - 1];
      }
      if (text.charAt(i) == pat.charAt(k)) {
        ++k;
      }
      if (k == pat.length()) {
        return true;
      }
    }
    return false;
  }

  public static List<Integer> getIndexes(String text, String pat) {
    List<Integer> arr = new ArrayList<>();
    int[] p = prefixFunction(pat);
    int k = 0;
    for (int i = 0; i < text.length(); i++) {
      while (k > 0 && text.charAt(i) != pat.charAt(k)) {
        k = p[k - 1];
      }
      if (text.charAt(i) == pat.charAt(k)) {
        ++k;
      }
      if (k == pat.length()) {
        arr.add((i + 1 - pat.length()));
        k = p[k - 1];
      }
    }
    return arr;
  }


  public static int count(String text, String pat) {
    int[] p = prefixFunction(pat);
    int k = 0;
    int ans = 0;
    for (int i = 0; i < text.length(); i++) {
      while (k > 0 && text.charAt(i) != pat.charAt(k)) {
        k = p[k - 1];
      }
      if (text.charAt(i) == pat.charAt(k)) {
        ++k;
      }
      if (k == pat.length()) {
        ++ans;
        k = p[k - 1];
      }
    }
    return ans;
  }

  public static int[] prefixFunction(String s) {
    return prefixFunction(s.toCharArray());
  }

  public static String reverse(String s) {
    return new StringBuilder(s).reverse().toString();
  }

  public static String pad(String cur, char with, int len) {
    StringBuilder ret = new StringBuilder(cur);
    for (int i = cur.length(); i < len; i++) {
      ret.insert(0, with);
    }
    return ret.toString();
  }

  public static char[] offsetByOne(char[] temp) {
    return offsetBy(temp, 1);
  }

  public static char[] offsetBy(char[] temp, int offset) {
    char[] res = new char[temp.length + offset];
    for (int i = offset, pt = 0; pt < temp.length; ++i) {
      res[i] = temp[pt++];
    }
    return res;
  }

  public static boolean isPalindrome(String cur) {
    return isPalindrome(cur.toCharArray());
  }

  public static boolean isPalindrome(char[] s) {
    if (s.length <= 1) {
      return true;
    }
    for (int i = 0; i < s.length / 2; ++i) {
      if (s[i] != s[s.length - i - 1]) {
        return false;
      }
    }
    return true;
  }

  public static int indexOf(String s, char value) {
    for (int i = 0; i < s.length(); ++i) {
      if (s.charAt(i) == value) {
        return i;
      }
    }
    return -1;
  }

  public static int firstIndexMatching(char[] val, Predicate<Character> test) {
    for (int i = 0; i < val.length; ++i) {
      if (test.test(val[i])) {
        return i;
      }
    }
    return -1;
  }

  public static int firstIndexMatching(String val, Predicate<Character> test) {
    for (int i = 0; i < val.length(); ++i) {
      if (test.test(val.charAt(i))) {
        return i;
      }
    }
    return -1;
  }

  public static int[] mapToInt(String val, Function<Character, Integer> transformer) {
    int[] ret = new int[val.length()];
    for (int i = 0; i < ret.length; ++i) {
      ret[i] = transformer.apply(val.charAt(i));
    }
    return ret;
  }

  public static long[] mapToLong(String val, Function<Character, Long> transformer) {
    long[] ret = new long[val.length()];
    for (int i = 0; i < ret.length; ++i) {
      ret[i] = transformer.apply(val.charAt(i));
    }
    return ret;
  }
}