摘要：使用計(jì)算等于指定值的值的總數(shù)。檢查是否短于給定的數(shù)組，并使用以便對(duì)其進(jìn)行相應(yīng)的切片或返回一個(gè)空數(shù)組。使用和使用遞歸公式計(jì)算一組數(shù)字的最大公約數(shù)。該方法使用左移運(yùn)算符將與右側(cè)的值位移。異常相關(guān)將異常堆棧跟蹤轉(zhuǎn)換為字符串。

本文來(lái)自于我的慕課網(wǎng)手記：非常實(shí)用的 Java 8 代碼片段，轉(zhuǎn)載請(qǐng)保留鏈接 ;)

將數(shù)組分割成特定大小的小數(shù)組。

public static int[][] chunk(int[] numbers, int size) {
    return IntStream.iterate(0, i -> i + size)
            .limit((long) Math.ceil((double) numbers.length / size))
            .mapToObj(cur -> Arrays.copyOfRange(numbers, cur, cur + size > numbers.length ? numbers.length : cur + size))
            .toArray(int[][]::new);
}

public static  T[] concat(T[] first, T[] second) {
    return Stream.concat(
            Stream.of(first),
            Stream.of(second)
    ).toArray(i -> (T[]) Arrays.copyOf(new Object[0], i, first.getClass()));
}

計(jì)算數(shù)組中某個(gè)值出現(xiàn)的次數(shù)。

使用 Arrays.stream().filter().count() 計(jì)算等于指定值的值的總數(shù)。

public static long countOccurrences(int[] numbers, int value) {
    return Arrays.stream(numbers)
            .filter(number -> number == value)
            .count();
}

數(shù)組扁平化。

使用遞歸實(shí)現(xiàn)，Arrays.stream().flatMapToInt()

public static int[] deepFlatten(Object[] input) {
    return Arrays.stream(input)
            .flatMapToInt(o -> {
                if (o instanceof Object[]) {
                    return Arrays.stream(deepFlatten((Object[]) o));
                }
                return IntStream.of((Integer) o);
            }).toArray();
}

返回兩個(gè)數(shù)組之間的差異。

從 b 中創(chuàng)建一個(gè)集合，然后在 a 上使用 Arrays.stream().filter() 只保留 b 中不包含的值。

public static int[] difference(int[] first, int[] second) {
    Set set = Arrays.stream(second).boxed().collect(Collectors.toSet());
    return Arrays.stream(first)
            .filter(v -> !set.contains(v))
            .toArray();
}

從比較器函數(shù)不返回true的數(shù)組中篩選出所有值。

int的比較器是使用IntbinaryPerator函數(shù)來(lái)實(shí)現(xiàn)的。

使用 Arrays.stream().filter() 和 Arrays.stream().noneMatch() 查找相應(yīng)的值。

public static int[] differenceWith(int[] first, int[] second, IntBinaryOperator comparator) {
    return Arrays.stream(first)
            .filter(a ->
                    Arrays.stream(second)
                            .noneMatch(b -> comparator.applyAsInt(a, b) == 0)
            ).toArray();
}

返回?cái)?shù)組的所有不同值。

使用 Arrays.stream().distinct() 去除所有重復(fù)的值。

public static int[] distinctValuesOfArray(int[] elements) {
    return Arrays.stream(elements).distinct().toArray();
}

移除數(shù)組中的元素，直到傳遞的函數(shù)返回true為止。返回?cái)?shù)組中的其余元素。

使用數(shù)組循環(huán)遍歷數(shù)組，將數(shù)組的第一個(gè)元素刪除，直到函數(shù)返回的值為真為止。返回其余的元素。

public static int[] dropElements(int[] elements, IntPredicate condition) {
    while (elements.length > 0 && !condition.test(elements[0])) {
        elements = Arrays.copyOfRange(elements, 1, elements.length);
    }
    return elements;
}

返回一個(gè)新數(shù)組，從右邊移除n個(gè)元素。

檢查n是否短于給定的數(shù)組，并使用 Array.copyOfRange() 以便對(duì)其進(jìn)行相應(yīng)的切片或返回一個(gè)空數(shù)組。

public static int[] dropRight(int[] elements, int n) {
    if (n < 0) {
        throw new IllegalArgumentException("n is less than 0");
    }
    return n < elements.length
            ? Arrays.copyOfRange(elements, 0, elements.length - n)
            : new int[0];
}

返回?cái)?shù)組中的每個(gè)第n個(gè)元素。

使用 IntStream.range().filter() 創(chuàng)建一個(gè)新數(shù)組，該數(shù)組包含給定數(shù)組的每個(gè)第n個(gè)元素。

public static int[] everyNth(int[] elements, int nth) {
     return IntStream.range(0, elements.length)
             .filter(i -> i % nth == nth - 1)
             .map(i -> elements[i])
             .toArray();
 }

查找數(shù)組中元素的索引，在不存在元素的情況下返回-1。

使用 IntStream.range().filter() 查找數(shù)組中元素的索引。

public static int indexOf(int[] elements, int el) {
    return IntStream.range(0, elements.length)
            .filter(idx -> elements[idx] == el)
            .findFirst()
            .orElse(-1);
}

查找數(shù)組中元素的最后索引，在不存在元素的情況下返回-1。

使用 IntStream.iterate().limit().filter() 查找數(shù)組中元素的索引。

public static int lastIndexOf(int[] elements, int el) {
    return IntStream.iterate(elements.length - 1, i -> i - 1)
            .limit(elements.length)
            .filter(idx -> elements[idx] == el)
            .findFirst()
            .orElse(-1);
}

篩選出數(shù)組中的非唯一值。

對(duì)只包含唯一值的數(shù)組使用 Arrays.stream().filter()。

public static int[] filterNonUnique(int[] elements) {
    return Arrays.stream(elements)
            .filter(el -> indexOf(elements, el) == lastIndexOf(elements, el))
            .toArray();
}

使數(shù)組扁平。

使用 Arrays.stream().flatMapToInt().toArray() 創(chuàng)建一個(gè)新數(shù)組。

public static int[] flatten(Object[] elements) {
    return Arrays.stream(elements)
            .flatMapToInt(el -> el instanceof int[]
                    ? Arrays.stream((int[]) el)
                    : IntStream.of((int) el)
            ).toArray();
}

將數(shù)組壓平到指定的深度。

public static Object[] flattenDepth(Object[] elements, int depth) {
    if (depth == 0) {
        return elements;
    }
    return Arrays.stream(elements)
            .flatMap(el -> el instanceof Object[]
                    ? Arrays.stream(flattenDepth((Object[]) el, depth - 1))
                    : Arrays.stream(new Object[]{el})
            ).toArray();


}

根據(jù)給定函數(shù)對(duì)數(shù)組元素進(jìn)行分組。

使用 Arrays.stream().collect(Collectors.groupingBy()) 分組。

public static  Map> groupBy(T[] elements, Function func) {
    return Arrays.stream(elements).collect(Collectors.groupingBy(func));
}

返回?cái)?shù)組中除去最后一個(gè)的所有元素。

使用 Arrays.copyOfRange() 返回除最后一個(gè)之外的所有元素。

public static  T[] initial(T[] elements) {
    return Arrays.copyOfRange(elements, 0, elements.length - 1);
}

初始化一個(gè)數(shù)組，該數(shù)組包含在指定范圍內(nèi)的數(shù)字，傳入 start 和 end。

public static int[] initializeArrayWithRange(int end, int start) {
    return IntStream.rangeClosed(start, end).toArray();
}

使用指定的值初始化并填充數(shù)組。

public static int[] initializeArrayWithValues(int n, int value) {
    return IntStream.generate(() -> value).limit(n).toArray();
}

返回兩個(gè)數(shù)組中存在的元素列表。

從第二步創(chuàng)建一個(gè)集合，然后在 a 上使用 Arrays.stream().filter() 來(lái)保存包含在 b 中的值。

public static int[] intersection(int[] first, int[] second) {
    Set set = Arrays.stream(second).boxed().collect(Collectors.toSet());
    return Arrays.stream(first)
            .filter(set::contains)
            .toArray();
}

如果數(shù)組按升序排序，則返回 1，如果數(shù)組按降序排序，返回 -1，如果沒(méi)有排序，則返回 0。

計(jì)算前兩個(gè)元素的排序 direction。使用for循環(huán)對(duì)數(shù)組進(jìn)行迭代，并對(duì)它們進(jìn)行成對(duì)比較。如果 direction 發(fā)生變化，則返回 0，
如果到達(dá)最后一個(gè)元素，則返回 direction。

public static > int isSorted(T[] arr) {
    final int direction = arr[0].compareTo(arr[1]) < 0 ? 1 : -1;
    for (int i = 0; i < arr.length; i++) {
        T val = arr[i];
        if (i == arr.length - 1) return direction;
        else if ((val.compareTo(arr[i + 1]) * direction > 0)) return 0;
    }
    return direction;
}

將數(shù)組的所有元素連接到字符串中，并返回此字符串。

使用 IntStream.range 創(chuàng)建一個(gè)指定索引的數(shù)組。然后，使用 Stream.reduce 將元素組合成字符串。

public static  String join(T[] arr, String separator, String end) {
    return IntStream.range(0, arr.length)
            .mapToObj(i -> new SimpleEntry<>(i, arr[i]))
            .reduce("", (acc, val) -> val.getKey() == arr.length - 2
                    ? acc + val.getValue() + end
                    : val.getKey() == arr.length - 1 ? acc + val.getValue() : acc + val.getValue() + separator, (fst, snd) -> fst);
}

返回?cái)?shù)組的第n個(gè)元素。

Use Arrays.copyOfRange() 優(yōu)先得到包含第n個(gè)元素的數(shù)組。

public static  T nthElement(T[] arr, int n) {
    if (n > 0) {
        return Arrays.copyOfRange(arr, n, arr.length)[0];
    }
    return Arrays.copyOfRange(arr, arr.length + n, arr.length)[0];
}

從對(duì)象中選擇與給定鍵對(duì)應(yīng)的鍵值對(duì)。

使用 Arrays.stream 過(guò)濾 arr 中存在的所有鍵。然后，使用 Collectors.toMap 將所有的key轉(zhuǎn)換為Map。

public static  Map pick(Map obj, T[] arr) {
    return Arrays.stream(arr)
            .filter(obj::containsKey)
            .collect(Collectors.toMap(k -> k, obj::get));
}

根據(jù)條件篩選對(duì)象數(shù)組，同時(shí)篩選出未指定的鍵。

使用 Arrays.stream().filter() 根據(jù)謂詞 fn 過(guò)濾數(shù)組，以便返回條件為真的對(duì)象。
對(duì)于每個(gè)過(guò)濾的Map對(duì)象，創(chuàng)建一個(gè)新的Map，其中包含 keys 中的鍵。最后，將Map對(duì)象收集到一個(gè)數(shù)組中。

public static Map[] reducedFilter(Map[] data, String[] keys, Predicate> fn) {
    return Arrays.stream(data)
            .filter(fn)
            .map(el -> Arrays.stream(keys).filter(el::containsKey)
                    .collect(Collectors.toMap(Function.identity(), el::get)))
            .toArray((IntFunction[]>) Map[]::new);
}

從數(shù)組中返回一個(gè)隨機(jī)元素。

使用 Math.Randoman() 生成一個(gè)隨機(jī)數(shù)，然后將它乘以數(shù)組的 length，然后使用 Math.floor() 獲得一個(gè)最近的整數(shù)，該方法也適用于字符串。

public static  T sample(T[] arr) {
    return arr[(int) Math.floor(Math.random() * arr.length)];
}

從 array 到 array 大小的唯一鍵獲取 n 個(gè)隨機(jī)元素。

根據(jù)Fisher-Yates算法，使用 Array.copyOfRange() 獲得優(yōu)先的 n 個(gè)元素。

public static  T[] sampleSize(T[] input, int n) {
    T[] arr = Arrays.copyOf(input, input.length);
    int length = arr.length;
    int m = length;
    while (m > 0) {
        int i = (int) Math.floor(Math.random() * m--);
        T tmp = arr[i];
        arr[i] = arr[m];
        arr[m] = tmp;
    }
    return Arrays.copyOfRange(arr, 0, n > length ? length : n);
}

將數(shù)組值的順序隨機(jī)化，返回一個(gè)新數(shù)組。

根據(jù) Fisher-Yates 算法 重新排序數(shù)組的元素。

public static  T[] shuffle(T[] input) {
    T[] arr = Arrays.copyOf(input, input.length);
    int length = arr.length;
    int m = length;
    while (m > 0) {
        int i = (int) Math.floor(Math.random() * m--);
        T tmp = arr[i];
        arr[i] = arr[m];
        arr[m] = tmp;
    }
    return arr;
}

返回出現(xiàn)在兩個(gè)數(shù)組中的元素?cái)?shù)組。

使用 Arrays.stream().filter() 移除，然后使用 Arrays.stream().anyMatch() 匹配 second 部分的值。

public static  T[] similarity(T[] first, T[] second) {
    return Arrays.stream(first)
            .filter(a -> Arrays.stream(second).anyMatch(b -> Objects.equals(a, b)))
            // Make a new array of first"s runtime type, but empty content:
            .toArray(i -> (T[]) Arrays.copyOf(new Object[0], i, first.getClass()));
}

返回值應(yīng)該插入到數(shù)組中的最低索引，以保持其排序順序。

檢查數(shù)組是否按降序（松散地）排序。 使用 IntStream.range().filter() 來(lái)找到元素應(yīng)該被插入的合適的索引。

public static > int sortedIndex(T[] arr, T el) {
    boolean isDescending = arr[0].compareTo(arr[arr.length - 1]) > 0;
    return IntStream.range(0, arr.length)
            .filter(i -> isDescending ? el.compareTo(arr[i]) >= 0 : el.compareTo(arr[i]) <= 0)
            .findFirst()
            .orElse(arr.length);
}

返回兩個(gè)數(shù)組之間的對(duì)稱(chēng)差異。

從每個(gè)數(shù)組中創(chuàng)建一個(gè) Set，然后使用 Arrays.stream().filter() 來(lái)保持其他值不包含的值。最后，連接兩個(gè)數(shù)組并創(chuàng)建一個(gè)新數(shù)組并返回。

public static  T[] symmetricDifference(T[] first, T[] second) {
    Set sA = new HashSet<>(Arrays.asList(first));
    Set sB = new HashSet<>(Arrays.asList(second));

    return Stream.concat(
            Arrays.stream(first).filter(a -> !sB.contains(a)),
            Arrays.stream(second).filter(b -> !sA.contains(b))
    ).toArray(i -> (T[]) Arrays.copyOf(new Object[0], i, first.getClass()));
}

返回?cái)?shù)組中除第一個(gè)元素外的所有元素。

如果數(shù)組的長(zhǎng)度大于1，則返回 Arrays.copyOfRange(1)，否則返回整個(gè)數(shù)組。

public static  T[] tail(T[] arr) {
    return arr.length > 1
            ? Arrays.copyOfRange(arr, 1, arr.length)
            : arr;
}

返回一個(gè)從開(kāi)頭刪除n個(gè)元素的數(shù)組。

public static  T[] take(T[] arr, int n) {
    return Arrays.copyOfRange(arr, 0, n);
}

返回從末尾移除n個(gè)元素的數(shù)組。

使用 Arrays.copyOfRange() 用從末尾取來(lái)的 N 個(gè)元素來(lái)創(chuàng)建一個(gè)數(shù)組。

public static  T[] takeRight(T[] arr, int n) {
    return Arrays.copyOfRange(arr, arr.length - n, arr.length);
}

返回兩個(gè)數(shù)組中任何一個(gè)中存在的每個(gè)元素一次。

使用 a 和 b 的所有值創(chuàng)建一個(gè) Set，并將其轉(zhuǎn)換為數(shù)組。

public static  T[] union(T[] first, T[] second) {
    Set set = new HashSet<>(Arrays.asList(first));
    set.addAll(Arrays.asList(second));
    return set.toArray((T[]) Arrays.copyOf(new Object[0], 0, first.getClass()));
}

篩選出具有指定值之一的數(shù)組的元素。

使用 Arrays.strean().filter() 創(chuàng)建一個(gè)數(shù)組，排除(使用 !Arrays.asList(elements).contains())所有命中的值。

public static  T[] without(T[] arr, T... elements) {
    List excludeElements = Arrays.asList(elements);
    return Arrays.stream(arr)
            .filter(el -> !excludeElements.contains(el))
            .toArray(i -> (T[]) Arrays.copyOf(new Object[0], i, arr.getClass()));
}

根據(jù)原始數(shù)組中的位置創(chuàng)建元素?cái)?shù)組。

public static List zip(Object[]... arrays) {
    OptionalInt max = Arrays.stream(arrays).mapToInt(arr -> arr.length).max();
    return IntStream.range(0, max.getAsInt())
            .mapToObj(i -> Arrays.stream(arrays)
                    .map(arr -> i < arr.length ? arr[i] : null)
                    .toArray())
            .collect(Collectors.toList());
}

給定有效的屬性標(biāo)識(shí)符數(shù)組和值數(shù)組，返回將屬性與值關(guān)聯(lián)的對(duì)象。

public static Map zipObject(String[] props, Object[] values) {
    return IntStream.range(0, props.length)
            .mapToObj(i -> new SimpleEntry<>(props[i], i < values.length ? values[i] : null))
            .collect(
                    HashMap::new, (m, v) -> m.put(v.getKey(), v.getValue()), HashMap::putAll);
}

返回兩個(gè)或兩個(gè)以上數(shù)字的平均值。

public static double average(int[] arr) {
    return IntStream.of(arr)
            .average()
            .orElseThrow(() -> new IllegalArgumentException("Array is empty"));
}

計(jì)算一系列數(shù)字的最大公約數(shù)(gcd)。

使用 Arrays.stream().reduce() 和 GCD（使用遞歸公式）計(jì)算一組數(shù)字的最大公約數(shù)。

public static OptionalInt gcd(int[] numbers) {
    return Arrays.stream(numbers)
            .reduce((a, b) -> gcd(a, b));
}

private static int gcd(int a, int b) {
    if (b == 0) {
        return a;
    }
    return gcd(b, a % b);
}

計(jì)算數(shù)字?jǐn)?shù)組的最低公共倍數(shù)(LCM)。

使用 Arrays.stream().reduce() 和 LCM公式(使用遞歸)來(lái)計(jì)算數(shù)字?jǐn)?shù)組的最低公共倍數(shù)。

public static OptionalInt lcm(int[] numbers) {
    IntBinaryOperator lcm = (x, y) -> (x * y) / gcd(x, y);
    return Arrays.stream(numbers)
            .reduce((a, b) -> lcm.applyAsInt(a, b));
}

private static int gcd(int a, int b) {
    if (b == 0) {
        return a;
    }
    return gcd(b, a % b);
}

查找大于或等于該值的下一個(gè)冪。

該方法使用左移運(yùn)算符將1與右側(cè)的值位移。右側(cè)使用 Integer.numberOfLeadingZeros方法。
001 << 2 would be 100. 100 in decimal is equal to 4.

Integer.numberOfLeadingZeros 給出了數(shù)值前導(dǎo)零的數(shù)目。例如，調(diào)用 Integer.numberOfLeadingZeros(3) 將賦值為30。
這是因?yàn)?在二進(jìn)制中表示為 11。由于整數(shù)有32位，所以有30位有0位。左移運(yùn)算符的右邊變?yōu)?32-30 = 2。
左移1，即 001 << 2 將是 100，十進(jìn)制中的 100 等于 4。

public static int findNextPositivePowerOfTwo(int value) {
    return 1 << (32 - Integer.numberOfLeadingZeros(value - 1));
}

檢查數(shù)字是否是偶數(shù)。

這個(gè)方法使用按位運(yùn)算符，0b1 是1的二進(jìn)制表示。
因?yàn)镴ava 7可以通過(guò)用 0b 或 0B 作為前綴來(lái)編寫(xiě)二進(jìn)制文字。
數(shù)字為偶數(shù)時(shí)，＆ 運(yùn)算符將返回0。 例如，IsEven(4) 會(huì)導(dǎo)致 100 & 001，＆ 的結(jié)果將是 000。

public static boolean isEven(final int value) {
    return (value & 0b1) == 0;
}

檢查一個(gè)值是2的正冪。

為了理解它是如何工作的，讓我們假設(shè)我們調(diào)用了 IsPowerOfTwo(4)。

當(dāng)值大于0時(shí)，將評(píng)估 && 運(yùn)算符的右側(cè)。

(~value + 1) 的結(jié)果等于值本身，~100 + 001 => 011 + 001 => 100。

(value & value) 的結(jié)果是value，100 & 100 => 100.。

當(dāng)值等于值時(shí)，這將把值表達(dá)為真值。

public static boolean isPowerOfTwo(final int value) {
    return value > 0 && ((value & (~value + 1)) == value);
}

生成一個(gè)介于 Integer.MIN_VALUE 和 Integer.MAX_VALUE 之間的隨機(jī)數(shù)。

public static int generateRandomInt() {
    return ThreadLocalRandom.current().nextInt();
}

生成一個(gè)字符串的所有字符（包含重復(fù)）。

public static List anagrams(String input) {
    if (input.length() <= 2) {
        return input.length() == 2
                ? Arrays.asList(input, input.substring(1) + input.substring(0, 1))
                : Collections.singletonList(input);
    }
    return IntStream.range(0, input.length())
            .mapToObj(i -> new SimpleEntry<>(i, input.substring(i, i + 1)))
            .flatMap(entry ->
                    anagrams(input.substring(0, entry.getKey()) + input.substring(entry.getKey() + 1))
                            .stream()
                            .map(s -> entry.getValue() + s))
            .collect(Collectors.toList());
}

以字節(jié)為單位返回字符串的長(zhǎng)度。

public static int byteSize(String input) {
    return input.getBytes().length;
}

將字符串首字母大寫(xiě)。

public static String capitalize(String input, boolean lowerRest) {
    return input.substring(0, 1).toUpperCase() +
            (lowerRest
                    ? input.substring(1, input.length()).toLowerCase()
                    : input.substring(1, input.length()));
}

將字符串中每個(gè)單詞的首字母大寫(xiě)。

public static String capitalizeEveryWord(final String input) {
    return Pattern.compile("(?=w)").splitAsStream(input)
            .map(w -> capitalize(w, false))
            .collect(Collectors.joining());
}

在提供的字符串中返回元音的個(gè)數(shù)。

public static int countVowels(String input) {
    return input.replaceAll("[^aeiouAEIOU]", "").length();
}

轉(zhuǎn)義要在正則表達(dá)式中使用的字符串。

public static String escapeRegExp(String input) {
    return Pattern.quote(input);
}

從駝峰式轉(zhuǎn)換字符串。

public static String fromCamelCase(String input, String separator) {
    return input
            .replaceAll("([a-zd])([A-Z])", "$1" + separator + "$2")
            .toLowerCase();
}

如果給定的字符串是絕對(duì)URL，則返回 true，否則返回 false。

public static boolean isAbsoluteUrl(String url) {
    return Pattern.compile("^[a-z][a-z0-9+.-]*:").matcher(url).find();
}

檢查字符串是否為小寫(xiě)。

public static boolean isLowerCase(String input) {
    return Objects.equals(input, input.toLowerCase());
}

檢查字符串是否為大寫(xiě)。

public static boolean isUpperCase(String input) {
    return Objects.equals(input, input.toUpperCase());
}

判斷一個(gè)字符串是否回文。

public static boolean isPalindrome(String input) {
    String s = input.toLowerCase().replaceAll("[W_]", "");
    return Objects.equals(
            s,
            new StringBuilder(s).reverse().toString()
    );
}

檢查字符串是否為數(shù)字。

public static boolean isNumeric(final String input) {
    return IntStream.range(0, input.length())
            .allMatch(i -> Character.isDigit(input.charAt(i)));
}

用指定的掩碼字符替換除最后 num 個(gè)字符以外的所有字符。

public static String mask(String input, int num, String mask) {
    int length = input.length();
    return num > 0
            ?
            input.substring(0, length - num).replaceAll(".", mask)
                    + input.substring(length - num)
            :
            input.substring(0, Math.negateExact(num))
                    + input.substring(Math.negateExact(num), length).replaceAll(".", mask);
}

反轉(zhuǎn)字符串。

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

按字母順序排列字符串中的字符。

public static String sortCharactersInString(String input) {
    return Arrays.stream(input.split("")).sorted().collect(Collectors.joining());
}

將多行字符串拆分為行數(shù)組。

public static String[] splitLines(String input) {
    return input.split("
?
");
}

轉(zhuǎn)換一個(gè)字符串為駝峰式。

public static String toCamelCase(String input) {
    Matcher matcher = Pattern.compile("[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+").matcher(input);
    List matchedParts = new ArrayList<>();
    while (matcher.find()) {
        matchedParts.add(matcher.group(0));
    }
    String s = matchedParts.stream()
            .map(x -> x.substring(0, 1).toUpperCase() + x.substring(1).toLowerCase())
            .collect(Collectors.joining());
    return s.substring(0, 1).toLowerCase() + s.substring(1);
}

將字符串轉(zhuǎn)換為kebab大小寫(xiě)。

public static String toKebabCase(String input) {
    Matcher matcher = Pattern.compile("[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+").matcher(input);
    List matchedParts = new ArrayList<>();
    while (matcher.find()) {
        matchedParts.add(matcher.group(0));
    }
    return matchedParts.stream()
            .map(String::toLowerCase)
            .collect(Collectors.joining("-"));
}

正則匹配。

public static List match(String input, String regex) {
    Matcher matcher = Pattern.compile(regex).matcher(input);
    List matchedParts = new ArrayList<>();
    while (matcher.find()) {
        matchedParts.add(matcher.group(0));
    }
    return matchedParts;
}

將字符串轉(zhuǎn)換為蛇形小寫(xiě)，如 Im_Biezhi。

public static String toSnakeCase(String input) {
    Matcher matcher = Pattern.compile("[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+").matcher(input);
    List matchedParts = new ArrayList<>();
    while (matcher.find()) {
        matchedParts.add(matcher.group(0));
    }
    return matchedParts.stream()
            .map(String::toLowerCase)
            .collect(Collectors.joining("_"));
}

將字符串截?cái)嗟街付ǖ拈L(zhǎng)度。

public static String truncateString(String input, int num) {
    return input.length() > num
            ? input.substring(0, num > 3 ? num - 3 : num) + "..."
            : input;
}

將給定的字符串轉(zhuǎn)換為單詞數(shù)組。

public static String[] words(String input) {
    return Arrays.stream(input.split("[^a-zA-Z-]+"))
            .filter(s -> !s.isEmpty())
            .toArray(String[]::new);
}

將由空格分隔的數(shù)字字符串轉(zhuǎn)換為 int 數(shù)組。

public static int[] stringToIntegers(String numbers) {
        return Arrays.stream(numbers.split(" ")).mapToInt(Integer::parseInt).toArray();
}

將InputStream轉(zhuǎn)換為字符串。

public static String convertInputStreamToString(final InputStream in) throws IOException {
    ByteArrayOutputStream result = new ByteArrayOutputStream();
    byte[] buffer = new byte[1024];
    int length;
    while ((length = in.read(buffer)) != -1) {
        result.write(buffer, 0, length);
    }
    return result.toString(StandardCharsets.UTF_8.name());
}

將文件內(nèi)容讀入字符串。

public String readFileAsString(Path path) throws IOException {
    return new String(Files.readAllBytes(path));
}

獲取當(dāng)前工作目錄。

public static String getCurrentWorkingDirectoryPath() {
    return FileSystems.getDefault().getPath("").toAbsolutePath().toString();
}

返回 java.io.tmpdir 系統(tǒng)屬性的值。如果末尾沒(méi)有分隔符，則追加分隔符。

public static String tmpDirName() {
    String tmpDirName = System.getProperty("java.io.tmpdir");
    if (!tmpDirName.endsWith(File.separator)) {
        tmpDirName += File.separator;
    }

    return tmpDirName;
}

將異常堆棧跟蹤轉(zhuǎn)換為字符串。

public static String stackTraceAsString(final Throwable throwable) {
    final StringWriter sw = new StringWriter();
    throwable.printStackTrace(new PrintWriter(sw));
    return sw.toString();
}

以小寫(xiě)字符串的形式獲取操作系統(tǒng)的名稱(chēng)。

public static String osName() {
    return System.getProperty("os.name").toLowerCase();
}

檢查JVM是否為debug模式。

public static boolean isDebuggerAttached() {
    final RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
    return runtimeMXBean.getInputArguments()
            .stream()
            .anyMatch(arg -> arg.contains("-agentlib:jdwp"));

}

此方法返回由給定類(lèi)及其超類(lèi)實(shí)現(xiàn)的所有接口。

該方法通過(guò)連接兩個(gè)Stream來(lái)工作。第一個(gè)Stream是通過(guò)創(chuàng)建帶有接口的流和接口實(shí)現(xiàn)的所有接口來(lái)遞歸構(gòu)建的。
第二個(gè)Stream對(duì)超類(lèi)也是如此。其結(jié)果是刪除重復(fù)項(xiàng)后將兩個(gè)Stream連接起來(lái)。

public static List> getAllInterfaces(Class cls) {
    return Stream.concat(
            Arrays.stream(cls.getInterfaces()).flatMap(intf ->
                    Stream.concat(Stream.of(intf), getAllInterfaces(intf).stream())),
            cls.getSuperclass() == null ? Stream.empty() : getAllInterfaces(cls.getSuperclass()).stream()
    ).distinct().collect(Collectors.toList());
}

此方法檢查指定的類(lèi)是內(nèi)部類(lèi)還是靜態(tài)嵌套類(lèi)。

public static boolean isInnerClass(final Class cls) {
    return cls != null && cls.getEnclosingClass() != null;
}

將枚舉轉(zhuǎn)換為 Map，其中 key 是枚舉名，value 是枚舉本身。

public static > Map getEnumMap(final Class enumClass) {
    return Arrays.stream(enumClass.getEnumConstants())
            .collect(Collectors.toMap(Enum::name, Function.identity()));
}