{"id":13511835,"url":"https://github.com/hellokaton/30-seconds-of-java8","last_synced_at":"2025-05-15T09:05:22.270Z","repository":{"id":39375378,"uuid":"119536655","full_name":"hellokaton/30-seconds-of-java8","owner":"hellokaton","description":"☕ 30 seconds to collect useful Java 8 snippet.","archived":false,"fork":false,"pushed_at":"2024-12-03T02:50:31.000Z","size":49,"stargazers_count":2399,"open_issues_count":0,"forks_count":426,"subscribers_count":68,"default_branch":"master","last_synced_at":"2025-05-15T09:05:08.854Z","etag":null,"topics":["code-snippets","java8","java8-study"],"latest_commit_sha":null,"homepage":"","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"cc0-1.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/hellokaton.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2018-01-30T13:02:27.000Z","updated_at":"2025-05-11T03:04:04.000Z","dependencies_parsed_at":"2022-07-07T18:21:00.444Z","dependency_job_id":"8aac3de4-a03c-44b4-81c3-873fa9399949","html_url":"https://github.com/hellokaton/30-seconds-of-java8","commit_stats":null,"previous_names":["biezhi/30-seconds-of-java8"],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hellokaton%2F30-seconds-of-java8","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hellokaton%2F30-seconds-of-java8/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hellokaton%2F30-seconds-of-java8/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hellokaton%2F30-seconds-of-java8/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/hellokaton","download_url":"https://codeload.github.com/hellokaton/30-seconds-of-java8/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":254310513,"owners_count":22049468,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["code-snippets","java8","java8-study"],"created_at":"2024-08-01T03:01:13.123Z","updated_at":"2025-05-15T09:05:22.213Z","avatar_url":"https://github.com/hellokaton.png","language":"Java","readme":"# 30 seconds of java8\n\n[![License](https://img.shields.io/badge/license-CC0--1.0-blue.svg)](https://github.com/biezhi/30-seconds-of-java8/blob/master/LICENSE) \n[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](http://makeapullrequest.com) \n[![Travis Build](https://travis-ci.org/biezhi/30-seconds-of-java8.svg?branch=master)](https://travis-ci.org/biezhi/30-seconds-of-java8)\n[![@biezhi on zhihu](https://img.shields.io/badge/zhihu-%40biezhi-red.svg)](https://www.zhihu.com/people/biezhi)\n[![](https://img.shields.io/github/followers/biezhi.svg?style=social\u0026label=Follow%20Me)](https://github.com/biezhi)\n\n\u003e 你可以在30秒或更短时间内收集有用的Java8代码片段。\n\n- 使用 \u003ckbd\u003eCtrl\u003c/kbd\u003e + \u003ckbd\u003eF\u003c/kbd\u003e 或者 \u003ckbd\u003ecommand\u003c/kbd\u003e + \u003ckbd\u003eF\u003c/kbd\u003e 来查找代码片段。\n- 代码片段基于 Java8，如果你还不熟悉可以在[这里](https://zhuanlan.zhihu.com/java8)学习。\n- 代码片段翻译自 [little-java-functions](https://github.com/shekhargulati/little-java-functions)\n\n## 目录\n\n### 📚 Array (数组相关)\n\n\u003cdetails\u003e\n\u003csummary\u003e详细信息\u003c/summary\u003e\n\n* [`chunk`](#chunk)\n* [`countOccurrences`](#countoccurrences)\n* [`deepFlatten`](#deepflatten)\n* [`difference`](#difference)\n* [`differenceWith`](#differencewith)\n* [`distinctValuesOfArray`](#distinctvaluesofarray)\n* [`dropElements`](#dropelements)\n* [`dropRight`](#dropright)\n* [`everyNth`](#everynth)\n* [`filterNonUnique`](#filternonunique)\n* [`flatten`](#flatten)\n* [`flattenDepth`](#flattendepth)\n* [`groupBy`](#groupby)\n* [`head`](#head)\n* [`initial`](#initial)\n* [`initializeArrayWithRange`](#initializearraywithrange)\n* [`initializeArrayWithValues`](#initializearraywithvalues)\n* [`intersection`](#intersection)\n* [`isSorted`](#issorted)\n* [`join`](#join)\n* [`nthElement`](#nthelement)\n* [`pick`](#pick)\n* [`reducedFilter`](#reducedfilter)\n* [`remove`](#remove)\n* [`sample`](#sample)\n* [`sampleSize`](#samplesize)\n* [`shuffle`](#shuffle)\n* [`similarity`](#similarity)\n* [`sortedIndex`](#sortedindex)\n* [`symmetricDifference`](#symmetricdifference)\n* [`tail`](#tail)\n* [`take`](#take)\n* [`takeRight`](#takeright)\n* [`union`](#union)\n* [`without`](#without)\n* [`zip`](#zip)\n* [`zipObject`](#zipobject)\n\n\u003c/details\u003e\n\n### ➗ Math (数学相关)\n\n\u003cdetails\u003e\n\u003csummary\u003e详细信息\u003c/summary\u003e\n\n* [`average`](#average)\n* [`gcd`](#gcd)\n* [`lcm`](#lcm)\n* [`findNextPositivePowerOfTwo`](#findnextpositivepoweroftwo)\n* [`isEven`](#iseven)\n* [`isPowerOfTwo`](#ispoweroftwo)\n* [`generateRandomInt`](#generaterandomint)\n\n\u003c/details\u003e\n\n### 📜 String (字符串相关)\n\n\u003cdetails\u003e\n\u003csummary\u003e详细信息\u003c/summary\u003e\n\n* [`anagrams`](#anagrams)\n* [`byteSize`](#bytesize)\n* [`capitalize`](#capitalize)\n* [`capitalizeEveryWord`](#capitalizeeveryword)\n* [`countVowels`](#countvowels)\n* [`escapeRegExp`](#escaperegexp)\n* [`fromCamelCase`](#fromcamelcase)\n* [`isAbsoluteURL`](#isabsoluteurl)\n* [`isLowerCase`](#islowercase)\n* [`isUpperCase`](#isuppercase)\n* [`isPalindrome`](#ispalindrome)\n* [`isNumeric`](#isnumeric)\n* [`mask`](#mask)\n* [`reverseString`](#reversestring)\n* [`sortCharactersInString`](#sortcharactersinstring)\n* [`splitLines`](#splitlines)\n* [`toCamelCase`](#tocamelcase)\n* [`toKebabCase`](#tokebabcase)\n* [`match`](#match)\n* [`toSnakeCase`](#tosnakecase)\n* [`truncateString`](#truncatestring)\n* [`words`](#words)\n* [`stringToIntegers`](#stringtointegers)\n\n\u003c/details\u003e\n\n### ⭕️ IO (IO流相关)\n\n\u003cdetails\u003e\n\u003csummary\u003e详细信息\u003c/summary\u003e\n\n* [`convertInputStreamToString`](#convertinputstreamtostring)\n* [`readFileAsString`](#readfileasstring)\n* [`getCurrentWorkingDirectoryPath`](#getcurrentworkingdirectorypath)\n* [`tmpDirName`](#tmpdirname)\n\n\u003c/details\u003e\n\n### ❌ Exception (异常相关)\n\n\u003cdetails\u003e\n\u003csummary\u003e详细信息\u003c/summary\u003e\n\n* [`stackTraceAsString`](#stacktraceasstring)\n\n\u003c/details\u003e\n\n### 🖥 System (系统相关)\n\n\u003cdetails\u003e\n\u003csummary\u003e详细信息\u003c/summary\u003e\n\n- [`osName`](#osname)\n- [`isDebuggerEnabled`](#isdebuggerenabled)\n\n\u003c/details\u003e\n\n### 💡 Class (类相关)\n\n\u003cdetails\u003e\n\u003csummary\u003e详细信息\u003c/summary\u003e\n\n- [`getAllInterfaces`](#getallinterfaces)\n- [`IsInnerClass`](#isinnerclass)\n\n\u003c/details\u003e\n\n### 💎 Enum (枚举相关)\n\n\u003cdetails\u003e\n\u003csummary\u003e详细信息\u003c/summary\u003e\n\n- [`getEnumMap`](#getenummap)\n\n\u003c/details\u003e\n\n## Array\n\n### chunk\n\n将数组分割成特定大小的小数组。\n\n```java\npublic static int[][] chunk(int[] numbers, int size) {\n    return IntStream.iterate(0, i -\u003e i + size)\n            .limit((long) Math.ceil((double) numbers.length / size))\n            .mapToObj(cur -\u003e Arrays.copyOfRange(numbers, cur, cur + size \u003e numbers.length ? numbers.length : cur + size))\n            .toArray(int[][]::new);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### concat\n\n```java\npublic static \u003cT\u003e T[] concat(T[] first, T[] second) {\n    return Stream.concat(\n            Stream.of(first),\n            Stream.of(second)\n    ).toArray(i -\u003e (T[]) Arrays.copyOf(new Object[0], i, first.getClass()));\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### countOccurrences\n\n计算数组中某个值出现的次数。\n\n使用 `Arrays.stream().filter().count()` 计算等于指定值的值的总数。\n\n```java\npublic static long countOccurrences(int[] numbers, int value) {\n    return Arrays.stream(numbers)\n            .filter(number -\u003e number == value)\n            .count();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### deepFlatten\n\n数组扁平化。\n\n使用递归实现，`Arrays.stream().flatMapToInt()`\n\n```java\npublic static int[] deepFlatten(Object[] input) {\n    return Arrays.stream(input)\n            .flatMapToInt(o -\u003e {\n                if (o instanceof Object[]) {\n                    return Arrays.stream(deepFlatten((Object[]) o));\n                }\n                return IntStream.of((Integer) o);\n            }).toArray();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### difference\n\n返回两个数组之间的差异。\n\n从 b 中创建一个集合，然后在 a 上使用 `Arrays.stream().filter()` 只保留 b 中不包含的值。\n\n```java\npublic static int[] difference(int[] first, int[] second) {\n    Set\u003cInteger\u003e set = Arrays.stream(second).boxed().collect(Collectors.toSet());\n    return Arrays.stream(first)\n            .filter(v -\u003e !set.contains(v))\n            .toArray();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### differenceWith\n\n从比较器函数不返回true的数组中筛选出所有值。\n\nint的比较器是使用IntbinaryPerator函数来实现的。\n\n使用 `Arrays.stream().filter()` 和 `Arrays.stream().noneMatch()` 查找相应的值。\n\n```java\npublic static int[] differenceWith(int[] first, int[] second, IntBinaryOperator comparator) {\n    return Arrays.stream(first)\n            .filter(a -\u003e\n                    Arrays.stream(second)\n                            .noneMatch(b -\u003e comparator.applyAsInt(a, b) == 0)\n            ).toArray();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### distinctValuesOfArray\n\n返回数组的所有不同值。 \n\n使用 `Arrays.stream().distinct()` 去除所有重复的值。\n\n```java\npublic static int[] distinctValuesOfArray(int[] elements) {\n    return Arrays.stream(elements).distinct().toArray();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### dropElements\n\n移除数组中的元素，直到传递的函数返回true为止。返回数组中的其余元素。 \n\n使用数组循环遍历数组，将数组的第一个元素删除，直到函数返回的值为真为止。返回其余的元素。\n\n```java\npublic static int[] dropElements(int[] elements, IntPredicate condition) {\n    while (elements.length \u003e 0 \u0026\u0026 !condition.test(elements[0])) {\n        elements = Arrays.copyOfRange(elements, 1, elements.length);\n    }\n    return elements;\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### dropRight\n\n返回一个新数组，从右边移除n个元素。 \n\n检查n是否短于给定的数组，并使用 `Array.copyOfRange()` 以便对其进行相应的切片或返回一个空数组。\n\n```java\npublic static int[] dropRight(int[] elements, int n) {\n    if (n \u003c 0) {\n        throw new IllegalArgumentException(\"n is less than 0\");\n    }\n    return n \u003c elements.length\n            ? Arrays.copyOfRange(elements, 0, elements.length - n)\n            : new int[0];\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### everyNth\n\n返回数组中的每个第n个元素。 \n\n使用 `IntStream.range().filter()` 创建一个新数组，该数组包含给定数组的每个第n个元素。\n\n```java\npublic static int[] everyNth(int[] elements, int nth) {\n     return IntStream.range(0, elements.length)\n             .filter(i -\u003e i % nth == nth - 1)\n             .map(i -\u003e elements[i])\n             .toArray();\n }\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### indexOf\n\n查找数组中元素的索引，在不存在元素的情况下返回-1。 \n\n使用 `IntStream.range().filter()` 查找数组中元素的索引。\n\n```java\npublic static int indexOf(int[] elements, int el) {\n    return IntStream.range(0, elements.length)\n            .filter(idx -\u003e elements[idx] == el)\n            .findFirst()\n            .orElse(-1);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### lastIndexOf\n\n查找数组中元素的最后索引，在不存在元素的情况下返回-1。 \n\n使用 `IntStream.iterate().limit().filter()` 查找数组中元素的索引。\n\n```java\npublic static int lastIndexOf(int[] elements, int el) {\n    return IntStream.iterate(elements.length - 1, i -\u003e i - 1)\n            .limit(elements.length)\n            .filter(idx -\u003e elements[idx] == el)\n            .findFirst()\n            .orElse(-1);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### filterNonUnique\n\n筛选出数组中的非唯一值。 \n\n对只包含唯一值的数组使用 `Arrays.stream().filter()`。\n\n```java\npublic static int[] filterNonUnique(int[] elements) {\n    return Arrays.stream(elements)\n            .filter(el -\u003e indexOf(elements, el) != lastIndexOf(elements, el))\n            .distinct()\n            .toArray();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### flatten\n\n使数组扁平。\n\n使用 `Arrays.stream().flatMapToInt().toArray()` 创建一个新数组。\n\n```java\npublic static int[] flatten(Object[] elements) {\n    return Arrays.stream(elements)\n            .flatMapToInt(el -\u003e el instanceof int[]\n                    ? Arrays.stream((int[]) el)\n                    : IntStream.of((int) el)\n            ).toArray();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### flattenDepth\n\n将数组压平到指定的深度。\n\n```java\npublic static Object[] flattenDepth(Object[] elements, int depth) {\n    if (depth == 0) {\n        return elements;\n    }\n    return Arrays.stream(elements)\n            .flatMap(el -\u003e el instanceof Object[]\n                    ? Arrays.stream(flattenDepth((Object[]) el, depth - 1))\n                    : Arrays.stream(new Object[]{el})\n            ).toArray();\n\n\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### groupBy\n\n根据给定函数对数组元素进行分组。\n\n使用 `Arrays.stream().collect(Collectors.groupingBy())` 分组。\n\n```java\npublic static \u003cT, R\u003e Map\u003cR, List\u003cT\u003e\u003e groupBy(T[] elements, Function\u003cT, R\u003e func) {\n    return Arrays.stream(elements).collect(Collectors.groupingBy(func));\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### initial\n\n返回数组中除去最后一个的所有元素。\n\n使用 `Arrays.copyOfRange()` 返回除最后一个之外的所有元素。\n\n```java\npublic static \u003cT\u003e T[] initial(T[] elements) {\n    return Arrays.copyOfRange(elements, 0, elements.length - 1);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### initializeArrayWithRange\n\n初始化一个数组，该数组包含在指定范围内的数字，传入 `start` 和 `end`。\n\n```java\npublic static int[] initializeArrayWithRange(int end, int start) {\n    return IntStream.rangeClosed(start, end).toArray();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### initializeArrayWithValues\n\n使用指定的值初始化并填充数组。\n\n```java\npublic static int[] initializeArrayWithValues(int n, int value) {\n    return IntStream.generate(() -\u003e value).limit(n).toArray();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### intersection\n\n返回两个数组中存在的元素列表。 \n\n从第二步创建一个集合，然后在 a 上使用 `Arrays.stream().filter()` 来保存包含在 b 中的值。\n\n```java\npublic static int[] intersection(int[] first, int[] second) {\n    Set\u003cInteger\u003e set = Arrays.stream(second).boxed().collect(Collectors.toSet());\n    return Arrays.stream(first)\n            .filter(set::contains)\n            .toArray();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### isSorted\n\n如果数组按升序排序，则返回 `1`，如果数组按降序排序，返回 `-1`，如果没有排序，则返回 `0`。\n\n计算前两个元素的排序 `direction`。使用for循环对数组进行迭代，并对它们进行成对比较。如果 `direction` 发生变化，则返回 `0`，\n如果到达最后一个元素，则返回 `direction`。\n\n```java\npublic static \u003cT extends Comparable\u003c? super T\u003e\u003e int isSorted(T[] arr) {\n    final int direction = arr[0].compareTo(arr[1]) \u003c 0 ? 1 : -1;\n    for (int i = 0; i \u003c arr.length; i++) {\n        T val = arr[i];\n        if (i == arr.length - 1) return direction;\n        else if ((val.compareTo(arr[i + 1]) * direction \u003e 0)) return 0;\n    }\n    return direction;\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### join\n\n将数组的所有元素连接到字符串中，并返回此字符串。\n\n使用 `IntStream.range` 创建一个指定索引的数组。然后，使用 `Stream.reduce` 将元素组合成字符串。\n\n```java\npublic static \u003cT\u003e String join(T[] arr, String separator, String end) {\n    return IntStream.range(0, arr.length)\n            .mapToObj(i -\u003e new SimpleEntry\u003c\u003e(i, arr[i]))\n            .reduce(\"\", (acc, val) -\u003e val.getKey() == arr.length - 2\n                    ? acc + val.getValue() + end\n                    : val.getKey() == arr.length - 1 ? acc + val.getValue() : acc + val.getValue() + separator, (fst, snd) -\u003e fst);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### nthElement\n\n返回数组的第n个元素。\n\nUse `Arrays.copyOfRange()` 优先得到包含第n个元素的数组。 \n\n```Java\npublic static \u003cT\u003e T nthElement(T[] arr, int n) {\n    if (n \u003e 0) {\n        return Arrays.copyOfRange(arr, n, arr.length)[0];\n    }\n    return Arrays.copyOfRange(arr, arr.length + n, arr.length)[0];\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### pick\n\n从对象中选择与给定键对应的键值对。\n\n使用 `Arrays.stream` 过滤 `arr` 中存在的所有键。然后，使用 `Collectors.toMap` 将所有的key转换为Map。\n\n```java\npublic static \u003cT, R\u003e Map\u003cT, R\u003e pick(Map\u003cT, R\u003e obj, T[] arr) {\n    return Arrays.stream(arr)\n            .filter(obj::containsKey)\n            .collect(Collectors.toMap(k -\u003e k, obj::get));\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### reducedFilter\n\n根据条件筛选对象数组，同时筛选出未指定的键。\n\n使用 `Arrays.stream().filter()` 根据谓词 `fn` 过滤数组，以便返回条件为真的对象。\n对于每个过滤的Map对象，创建一个新的Map，其中包含 `keys` 中的键。最后，将Map对象收集到一个数组中。\n\n```java\npublic static Map\u003cString, Object\u003e[] reducedFilter(Map\u003cString, Object\u003e[] data, String[] keys, Predicate\u003cMap\u003cString, Object\u003e\u003e fn) {\n    return Arrays.stream(data)\n            .filter(fn)\n            .map(el -\u003e Arrays.stream(keys).filter(el::containsKey)\n                    .collect(Collectors.toMap(Function.identity(), el::get)))\n            .toArray((IntFunction\u003cMap\u003cString, Object\u003e[]\u003e) Map[]::new);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### sample\n\n从数组中返回一个随机元素。\n\n使用 `Math.Randoman()` 生成一个随机数，然后将它乘以数组的 `length`，然后使用 `Math.floor()` 获得一个最近的整数，该方法也适用于字符串。\n\n```java\npublic static \u003cT\u003e T sample(T[] arr) {\n    return arr[(int) Math.floor(Math.random() * arr.length)];\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### sampleSize\n\n从 `array` 到 `array` 大小的唯一键获取 `n` 个随机元素。\n\n根据[Fisher-Yates算法](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle)，使用 `Array.copyOfRange()` 获得优先的 `n` 个元素。\n\n```java\npublic static \u003cT\u003e T[] sampleSize(T[] input, int n) {\n    T[] arr = Arrays.copyOf(input, input.length);\n    int length = arr.length;\n    int m = length;\n    while (m \u003e 0) {\n        int i = (int) Math.floor(Math.random() * m--);\n        T tmp = arr[i];\n        arr[i] = arr[m];\n        arr[m] = tmp;\n    }\n    return Arrays.copyOfRange(arr, 0, n \u003e length ? length : n);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### shuffle\n\n将数组值的顺序随机化，返回一个新数组。\n\n根据 [Fisher-Yates 算法](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle) 重新排序数组的元素。\n\n```java\npublic static \u003cT\u003e T[] shuffle(T[] input) {\n    T[] arr = Arrays.copyOf(input, input.length);\n    int length = arr.length;\n    int m = length;\n    while (m \u003e 0) {\n        int i = (int) Math.floor(Math.random() * m--);\n        T tmp = arr[i];\n        arr[i] = arr[m];\n        arr[m] = tmp;\n    }\n    return arr;\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### similarity\n\n返回出现在两个数组中的元素数组。\n\n使用 `Arrays.stream().filter()` 移除，然后使用 `Arrays.stream().anyMatch()` 匹配 `second` 部分的值。\n\n```java\npublic static \u003cT\u003e T[] similarity(T[] first, T[] second) {\n    return Arrays.stream(first)\n            .filter(a -\u003e Arrays.stream(second).anyMatch(b -\u003e Objects.equals(a, b)))\n            // Make a new array of first's runtime type, but empty content:\n            .toArray(i -\u003e (T[]) Arrays.copyOf(new Object[0], i, first.getClass()));\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### sortedIndex\n\n返回值应该插入到数组中的最低索引，以保持其排序顺序。\n\n检查数组是否按降序（松散地）排序。 使用 `IntStream.range().filter()` 来找到元素应该被插入的合适的索引。\n\n```java\npublic static \u003cT extends Comparable\u003c? super T\u003e\u003e int sortedIndex(T[] arr, T el) {\n    boolean isDescending = arr[0].compareTo(arr[arr.length - 1]) \u003e 0;\n    return IntStream.range(0, arr.length)\n            .filter(i -\u003e isDescending ? el.compareTo(arr[i]) \u003e= 0 : el.compareTo(arr[i]) \u003c= 0)\n            .findFirst()\n            .orElse(arr.length);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### symmetricDifference\n\n返回两个数组之间的对称差异。\n\n从每个数组中创建一个 `Set`，然后使用 `Arrays.stream().filter()` 来保持其他值不包含的值。最后，连接两个数组并创建一个新数组并返回。\n\n```java\npublic static \u003cT\u003e T[] symmetricDifference(T[] first, T[] second) {\n    Set\u003cT\u003e sA = new HashSet\u003c\u003e(Arrays.asList(first));\n    Set\u003cT\u003e sB = new HashSet\u003c\u003e(Arrays.asList(second));\n\n    return Stream.concat(\n            Arrays.stream(first).filter(a -\u003e !sB.contains(a)),\n            Arrays.stream(second).filter(b -\u003e !sA.contains(b))\n    ).toArray(i -\u003e (T[]) Arrays.copyOf(new Object[0], i, first.getClass()));\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### tail\n\n返回数组中除第一个元素外的所有元素。\n\n如果数组的长度大于1，则返回 `Arrays.copyOfRange(1)`，否则返回整个数组。\n\n```java\npublic static \u003cT\u003e T[] tail(T[] arr) {\n    return arr.length \u003e 1\n            ? Arrays.copyOfRange(arr, 1, arr.length)\n            : arr;\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### take\n\n返回一个从开头删除n个元素的数组。\n\n```java\npublic static \u003cT\u003e T[] take(T[] arr, int n) {\n    return Arrays.copyOfRange(arr, 0, n);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### takeRight\n\n返回从末尾移除n个元素的数组。\n\n使用 `Arrays.copyOfRange()` 用从末尾取来的 `N` 个元素来创建一个数组。\n\n```java\npublic static \u003cT\u003e T[] takeRight(T[] arr, int n) {\n    return Arrays.copyOfRange(arr, arr.length - n, arr.length);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### union\n\n返回两个数组中任何一个中存在的每个元素一次。\n\n使用 `a` 和 `b` 的所有值创建一个 `Set`，并将其转换为数组。\n\n```Java\npublic static \u003cT\u003e T[] union(T[] first, T[] second) {\n    Set\u003cT\u003e set = new HashSet\u003c\u003e(Arrays.asList(first));\n    set.addAll(Arrays.asList(second));\n    return set.toArray((T[]) Arrays.copyOf(new Object[0], 0, first.getClass()));\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### without\n\n筛选出具有指定值之一的数组的元素。\n\n使用 `Arrays.strean().filter()` 创建一个数组，排除(使用 `!Arrays.asList(elements).contains()`)所有命中的值。\n\n```java\npublic static \u003cT\u003e T[] without(T[] arr, T... elements) {\n    List\u003cT\u003e excludeElements = Arrays.asList(elements);\n    return Arrays.stream(arr)\n            .filter(el -\u003e !excludeElements.contains(el))\n            .toArray(i -\u003e (T[]) Arrays.copyOf(new Object[0], i, arr.getClass()));\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### zip\n\n根据原始数组中的位置创建元素数组。\n\n```java\npublic static List\u003cObject[]\u003e zip(Object[]... arrays) {\n    OptionalInt max = Arrays.stream(arrays).mapToInt(arr -\u003e arr.length).max();\n    return IntStream.range(0, max.getAsInt())\n            .mapToObj(i -\u003e Arrays.stream(arrays)\n                    .map(arr -\u003e i \u003c arr.length ? arr[i] : null)\n                    .toArray())\n            .collect(Collectors.toList());\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### zipObject\n\n给定有效的属性标识符数组和值数组，返回将属性与值关联的对象。\n\n```java\npublic static Map\u003cString, Object\u003e zipObject(String[] props, Object[] values) {\n    return IntStream.range(0, props.length)\n            .mapToObj(i -\u003e new SimpleEntry\u003c\u003e(props[i], i \u003c values.length ? values[i] : null))\n            .collect(\n                    HashMap::new, (m, v) -\u003e m.put(v.getKey(), v.getValue()), HashMap::putAll);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n## Maths\n\n### average\n\n返回两个或两个以上数字的平均值。\n\n```java\npublic static double average(int[] arr) {\n    return IntStream.of(arr)\n            .average()\n            .orElseThrow(() -\u003e new IllegalArgumentException(\"Array is empty\"));\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### gcd\n\n计算一系列数字的最大公约数(gcd)。\n\n使用 `Arrays.stream().reduce()` 和 GCD（使用递归公式）计算一组数字的最大公约数。\n\n```java\npublic static OptionalInt gcd(int[] numbers) {\n    return Arrays.stream(numbers)\n            .reduce((a, b) -\u003e gcd(a, b));\n}\n\nprivate static int gcd(int a, int b) {\n    if (b == 0) {\n        return a;\n    }\n    return gcd(b, a % b);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### lcm\n\n计算数字数组的最低公共倍数(LCM)。\n\n使用 `Arrays.stream().reduce()` 和 LCM公式(使用递归)来计算数字数组的最低公共倍数。\n\n```java\npublic static OptionalInt lcm(int[] numbers) {\n    IntBinaryOperator lcm = (x, y) -\u003e (x * y) / gcd(x, y);\n    return Arrays.stream(numbers)\n            .reduce((a, b) -\u003e lcm.applyAsInt(a, b));\n}\n\nprivate static int gcd(int a, int b) {\n    if (b == 0) {\n        return a;\n    }\n    return gcd(b, a % b);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### findNextPositivePowerOfTwo\n\n查找大于或等于该值的下一个幂。\n\n该方法使用左移运算符将1与右侧的值位移。右侧使用 `Integer.numberOfLeadingZeros`方法。\n`001 \u003c\u003c 2` would be `100`. `100` in decimal is equal to `4`.\n\n`Integer.numberOfLeadingZeros` 给出了数值前导零的数目。例如，调用 `Integer.numberOfLeadingZeros(3)` 将赋值为30。\n这是因为3在二进制中表示为 `11`。由于整数有32位，所以有30位有0位。左移运算符的右边变为 `32-30 = 2`。\n左移1，即 `001 \u003c\u003c 2` 将是 `100`，十进制中的 `100` 等于 `4`。\n\n```java\npublic static int findNextPositivePowerOfTwo(int value) {\n    return 1 \u003c\u003c (32 - Integer.numberOfLeadingZeros(value - 1));\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### isEven\n\n检查数字是否是偶数。\n\n这个方法使用按位运算符，`0b1` 是1的二进制表示。\n因为Java 7可以通过用 `0b` 或 `0B` 作为前缀来编写二进制文字。\n数字为偶数时，`＆` 运算符将返回0。 例如，`IsEven(4)` 会导致 `100` `\u0026` `001`，`＆` 的结果将是 `000`。\n\n```java\npublic static boolean isEven(final int value) {\n    return (value \u0026 0b1) == 0;\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### isPowerOfTwo\n\n检查一个值是2的正幂。\n\n为了理解它是如何工作的，让我们假设我们调用了 `IsPowerOfTwo(4)`。\n\n当值大于0时，将评估 `\u0026\u0026` 运算符的右侧。\n\n`(~value + 1)` 的结果等于值本身，`~100 + 001` =\u003e `011 + 001` =\u003e `100`。\n\n`(value \u0026 value)` 的结果是value，`100` \u0026 `100` =\u003e `100`.。\n\n当值等于值时，这将把值表达为真值。\n\n```Java\npublic static boolean isPowerOfTwo(final int value) {\n    return value \u003e 0 \u0026\u0026 ((value \u0026 (~value + 1)) == value);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### generateRandomInt\n\n生成一个介于 `Integer.MIN_VALUE` 和 `Integer.MAX_VALUE` 之间的随机数。\n\n```java\npublic static int generateRandomInt() {\n    return ThreadLocalRandom.current().nextInt();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n## String\n\n### anagrams\n\n生成一个字符串的所有字符（包含重复）。\n\n```java\npublic static List\u003cString\u003e anagrams(String input) {\n    if (input.length() \u003c= 2) {\n        return input.length() == 2\n                ? Arrays.asList(input, input.substring(1) + input.substring(0, 1))\n                : Collections.singletonList(input);\n    }\n    return IntStream.range(0, input.length())\n            .mapToObj(i -\u003e new SimpleEntry\u003c\u003e(i, input.substring(i, i + 1)))\n            .flatMap(entry -\u003e\n                    anagrams(input.substring(0, entry.getKey()) + input.substring(entry.getKey() + 1))\n                            .stream()\n                            .map(s -\u003e entry.getValue() + s))\n            .collect(Collectors.toList());\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### byteSize\n\n以字节为单位返回字符串的长度。\n\n```java\npublic static int byteSize(String input) {\n    return input.getBytes().length;\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### capitalize\n\n将字符串首字母大写。\n\n```Java\npublic static String capitalize(String input, boolean lowerRest) {\n    return input.substring(0, 1).toUpperCase() +\n            (lowerRest\n                    ? input.substring(1, input.length()).toLowerCase()\n                    : input.substring(1, input.length()));\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### capitalizeEveryWord\n\n将字符串中每个单词的首字母大写。\n\n```java\npublic static String capitalizeEveryWord(final String input) {\n    return Pattern.compile(\"\\\\b(?=\\\\w)\").splitAsStream(input)\n            .map(w -\u003e capitalize(w, false))\n            .collect(Collectors.joining());\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### countVowels\n\n在提供的字符串中返回元音的个数。\n\n```java\npublic static int countVowels(String input) {\n    return input.replaceAll(\"[^aeiouAEIOU]\", \"\").length();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### escapeRegExp\n\n转义要在正则表达式中使用的字符串。\n\n```java\npublic static String escapeRegExp(String input) {\n    return Pattern.quote(input);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### fromCamelCase\n\n从驼峰式转换字符串。\n\n```java\npublic static String fromCamelCase(String input, String separator) {\n    return input\n            .replaceAll(\"([a-z\\\\d])([A-Z])\", \"$1\" + separator + \"$2\")\n            .toLowerCase();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### isAbsoluteUrl\n\n如果给定的字符串是绝对URL，则返回 `true`，否则返回 `false`。\n\n```java\npublic static boolean isAbsoluteUrl(String url) {\n    return Pattern.compile(\"^[a-z][a-z0-9+.-]*:\").matcher(url).find();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### isLowerCase\n\n检查字符串是否为小写。\n\n```java\npublic static boolean isLowerCase(String input) {\n    return Objects.equals(input, input.toLowerCase());\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### isUpperCase\n\n检查字符串是否为大写。\n\n```java\npublic static boolean isUpperCase(String input) {\n    return Objects.equals(input, input.toUpperCase());\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### isPalindrome\n\n判断一个字符串是否回文。\n\n```java\npublic static boolean isPalindrome(String input) {\n    String s = input.toLowerCase().replaceAll(\"[\\\\W_]\", \"\");\n    return Objects.equals(\n            s,\n            new StringBuilder(s).reverse().toString()\n    );\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### isNumeric\n\n检查字符串是否为数字。\n\n```java\npublic static boolean isNumeric(final String input) {\n    return IntStream.range(0, input.length())\n            .allMatch(i -\u003e Character.isDigit(input.charAt(i)));\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### mask\n\n用指定的掩码字符替换除最后 `num` 个字符以外的所有字符。\n\n```Java\npublic static String mask(String input, int num, String mask) {\n    int length = input.length();\n    return num \u003e 0\n            ?\n            input.substring(0, length - num).replaceAll(\".\", mask)\n                    + input.substring(length - num)\n            :\n            input.substring(0, Math.negateExact(num))\n                    + input.substring(Math.negateExact(num), length).replaceAll(\".\", mask);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### reverseString\n\n反转字符串。\n\n```java\npublic static String reverseString(String input) {\n    return new StringBuilder(input).reverse().toString();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### sortCharactersInString\n\n按字母顺序排列字符串中的字符。\n\n```java\npublic static String sortCharactersInString(String input) {\n    return Arrays.stream(input.split(\"\")).sorted().collect(Collectors.joining());\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### splitLines\n\n将多行字符串拆分为行数组。\n\n```java\npublic static String[] splitLines(String input) {\n    return input.split(\"\\\\r?\\\\n\");\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### toCamelCase\n\n转换一个字符串为驼峰式。\n\n```java\npublic static String toCamelCase(String input) {\n    Matcher matcher = Pattern.compile(\"[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\\\\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+\").matcher(input);\n    List\u003cString\u003e matchedParts = new ArrayList\u003c\u003e();\n    while (matcher.find()) {\n        matchedParts.add(matcher.group(0));\n    }\n    String s = matchedParts.stream()\n            .map(x -\u003e x.substring(0, 1).toUpperCase() + x.substring(1).toLowerCase())\n            .collect(Collectors.joining());\n    return s.substring(0, 1).toLowerCase() + s.substring(1);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### toKebabCase\n\n将字符串转换为kebab大小写。\n\n```java\npublic static String toKebabCase(String input) {\n    Matcher matcher = Pattern.compile(\"[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\\\\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+\").matcher(input);\n    List\u003cString\u003e matchedParts = new ArrayList\u003c\u003e();\n    while (matcher.find()) {\n        matchedParts.add(matcher.group(0));\n    }\n    return matchedParts.stream()\n            .map(String::toLowerCase)\n            .collect(Collectors.joining(\"-\"));\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### match\n\n正则匹配。\n\n```java\npublic static List\u003cString\u003e match(String input, String regex) {\n    Matcher matcher = Pattern.compile(regex).matcher(input);\n    List\u003cString\u003e matchedParts = new ArrayList\u003c\u003e();\n    while (matcher.find()) {\n        matchedParts.add(matcher.group(0));\n    }\n    return matchedParts;\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### toSnakeCase\n\n将字符串转换为蛇形小写，如 `Im_Biezhi`。\n\n```java\npublic static String toSnakeCase(String input) {\n    Matcher matcher = Pattern.compile(\"[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\\\\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+\").matcher(input);\n    List\u003cString\u003e matchedParts = new ArrayList\u003c\u003e();\n    while (matcher.find()) {\n        matchedParts.add(matcher.group(0));\n    }\n    return matchedParts.stream()\n            .map(String::toLowerCase)\n            .collect(Collectors.joining(\"_\"));\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### truncateString\n\n将字符串截断到指定的长度。\n\n```java\npublic static String truncateString(String input, int num) {\n    return input.length() \u003e num\n            ? input.substring(0, num \u003e 3 ? num - 3 : num) + \"...\"\n            : input;\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### words\n\n将给定的字符串转换为单词数组。\n\n```Java\npublic static String[] words(String input) {\n    return Arrays.stream(input.split(\"[^a-zA-Z-]+\"))\n            .filter(s -\u003e !s.isEmpty())\n            .toArray(String[]::new);\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### stringToIntegers\n\n将由空格分隔的数字字符串转换为 int 数组。\n\n```Java\npublic static int[] stringToIntegers(String numbers) {\n        return Arrays.stream(numbers.split(\" \")).mapToInt(Integer::parseInt).toArray();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n## IO\n\n### convertInputStreamToString\n\n将InputStream转换为字符串。\n\n```java\npublic static String convertInputStreamToString(final InputStream in) throws IOException {\n    ByteArrayOutputStream result = new ByteArrayOutputStream();\n    byte[] buffer = new byte[1024];\n    int length;\n    while ((length = in.read(buffer)) != -1) {\n        result.write(buffer, 0, length);\n    }\n    return result.toString(StandardCharsets.UTF_8.name());\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### readFileAsString\n\n将文件内容读入字符串。\n\n```java\npublic String readFileAsString(Path path) throws IOException {\n    return new String(Files.readAllBytes(path));\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### getCurrentWorkingDirectoryPath\n\n获取当前工作目录。\n\n```java\npublic static String getCurrentWorkingDirectoryPath() {\n    return FileSystems.getDefault().getPath(\"\").toAbsolutePath().toString();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### tmpDirName\n\n返回 `java.io.tmpdir` 系统属性的值。如果末尾没有分隔符，则追加分隔符。\n\n```java\npublic static String tmpDirName() {\n    String tmpDirName = System.getProperty(\"java.io.tmpdir\");\n    if (!tmpDirName.endsWith(File.separator)) {\n        tmpDirName += File.separator;\n    }\n\n    return tmpDirName;\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n## Exception\n\n### stackTraceAsString\n\n将异常堆栈跟踪转换为字符串。\n\n```java\npublic static String stackTraceAsString(final Throwable throwable) {\n    final StringWriter sw = new StringWriter();\n    throwable.printStackTrace(new PrintWriter(sw));\n    return sw.toString();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n## System\n\n### osName\n\n以小写字符串的形式获取操作系统的名称。\n\n```java\npublic static String osName() {\n    return System.getProperty(\"os.name\").toLowerCase();\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### isDebuggerEnabled\n\n检查JVM是否为debug模式。\n\n```java\npublic static boolean isDebuggerAttached() {\n    final RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();\n    return runtimeMXBean.getInputArguments()\n            .stream()\n            .anyMatch(arg -\u003e arg.contains(\"-agentlib:jdwp\"));\n\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n## Class\n\n### getAllInterfaces\n\n此方法返回由给定类及其超类实现的所有接口。\n\n该方法通过连接两个Stream来工作。第一个Stream是通过创建带有接口的流和接口实现的所有接口来递归构建的。\n第二个Stream对超类也是如此。其结果是删除重复项后将两个Stream连接起来。\n\n```java\npublic static List\u003cClass\u003c?\u003e\u003e getAllInterfaces(Class\u003c?\u003e cls) {\n    return Stream.concat(\n            Arrays.stream(cls.getInterfaces()).flatMap(intf -\u003e\n                    Stream.concat(Stream.of(intf), getAllInterfaces(intf).stream())),\n            cls.getSuperclass() == null ? Stream.empty() : getAllInterfaces(cls.getSuperclass()).stream()\n    ).distinct().collect(Collectors.toList());\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n### isInnerClass\n\n此方法检查指定的类是内部类还是静态嵌套类。\n\n```Java\npublic static boolean isInnerClass(final Class\u003c?\u003e cls) {\n    return cls != null \u0026\u0026 cls.getEnclosingClass() != null;\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n\n## Enum\n\n### getEnumMap\n\n将枚举转换为 Map，其中 key 是枚举名，value 是枚举本身。\n\n```java\npublic static \u003cE extends Enum\u003cE\u003e\u003e Map\u003cString, E\u003e getEnumMap(final Class\u003cE\u003e enumClass) {\n    return Arrays.stream(enumClass.getEnumConstants())\n            .collect(Collectors.toMap(Enum::name, Function.identity()));\n}\n```\n\n\u003cbr\u003e[⬆ 回到顶部](#目录)\n","funding_links":[],"categories":["Java"],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhellokaton%2F30-seconds-of-java8","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fhellokaton%2F30-seconds-of-java8","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhellokaton%2F30-seconds-of-java8/lists"}