内容简介:30 秒收集有用的 Java 8 代码片段
30 seconds of java8
你可以在30秒或更短时间内收集有用的 Java 8代码片段。
- 使用 Ctrl + F 或者 command + F 来查找代码片段。
- 代码片段基于 Java8,如果你还不熟悉可以在 这里 学习。
- 代码片段翻译自 little-java-functions
目录
:books:
Array (数组相关)
-
chunk
-
countOccurrences
-
deepFlatten
-
difference
-
differenceWith
-
distinctValuesOfArray
-
dropElements
-
dropRight
-
everyNth
-
filterNonUnique
-
flatten
-
flattenDepth
-
groupBy
-
head
-
initial
-
initializeArrayWithRange
-
initializeArrayWithValues
-
intersection
-
isSorted
-
join
-
nthElement
-
pick
-
reducedFilter
-
remove
-
sample
-
sampleSize
-
shuffle
-
similarity
-
sortedIndex
-
symmetricDifference
-
tail
-
take
-
takeRight
-
union
-
without
-
zip
-
zipObject
:heavy_division_sign:
Math (数学相关)
-
average
-
gcd
-
lcm
-
findNextPositivePowerOfTwo
-
isEven
-
isPowerOfTwo
-
generateRandomInt
:scroll:
String (字符串相关)
-
anagrams
-
byteSize
-
capitalize
-
capitalizeEveryWord
-
countVowels
-
escapeRegExp
-
fromCamelCase
-
isAbsoluteURL
-
isLowerCase
-
isUpperCase
-
isPalindrome
-
isNumeric
-
mask
-
reverseString
-
sortCharactersInString
-
splitLines
-
toCamelCase
-
toKebabCase
-
match
-
toSnakeCase
-
truncateString
-
words
-
stringToIntegers
:o:️
IO (IO流相关)
-
convertInputStreamToString
-
readFileAsString
-
getCurrentWorkingDirectoryPath
-
tmpDirName
:x:
Exception (异常相关)
-
stackTraceAsString
System (系统相关)
-
osName
-
isDebuggerEnabled
:bulb:
Class (类相关)
-
getAllInterfaces
-
IsInnerClass
:gem:
Enum (枚举相关)
-
getEnumMap
Array
chunk
将数组分割成特定大小的小数组。
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); }
⬆ 回到顶部
concat
public static <T> 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())); }
⬆ 回到顶部
countOccurrences
计算数组中某个值出现的次数。
使用 Arrays.stream().filter().count()
计算等于指定值的值的总数。
public static long countOccurrences(int[] numbers, int value) { return Arrays.stream(numbers) .filter(number -> number == value) .count(); }
⬆ 回到顶部
deepFlatten
数组扁平化。
使用递归实现, 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(); }
⬆ 回到顶部
difference
返回两个数组之间的差异。
从 b 中创建一个集合,然后在 a 上使用 Arrays.stream().filter()
只保留 b 中不包含的值。
public static int[] difference(int[] first, int[] second) { Set<Integer> set = Arrays.stream(second).boxed().collect(Collectors.toSet()); return Arrays.stream(first) .filter(v -> !set.contains(v)) .toArray(); }
⬆ 回到顶部
differenceWith
从比较器函数不返回true的数组中筛选出所有值。
int的比较器是使用IntbinaryPerator函数来实现的。
使用 Arrays.stream().filter()
和 Arrays.stream().noneMatch()
查找相应的值。
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(); }
⬆ 回到顶部
distinctValuesOfArray
返回数组的所有不同值。
使用 Arrays.stream().distinct()
去除所有重复的值。
public static int[] distinctValuesOfArray(int[] elements) { return Arrays.stream(elements).distinct().toArray(); }
⬆ 回到顶部
dropElements
移除数组中的元素,直到传递的函数返回true为止。返回数组中的其余元素。
使用数组循环遍历数组,将数组的第一个元素删除,直到函数返回的值为真为止。返回其余的元素。
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; }
⬆ 回到顶部
dropRight
返回一个新数组,从右边移除n个元素。
检查n是否短于给定的数组,并使用 Array.copyOfRange()
以便对其进行相应的切片或返回一个空数组。
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]; }
⬆ 回到顶部
everyNth
返回数组中的每个第n个元素。
使用 IntStream.range().filter()
创建一个新数组,该数组包含给定数组的每个第n个元素。
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(); }
⬆ 回到顶部
indexOf
查找数组中元素的索引,在不存在元素的情况下返回-1。
使用 IntStream.range().filter()
查找数组中元素的索引。
public static int indexOf(int[] elements, int el) { return IntStream.range(0, elements.length) .filter(idx -> elements[idx] == el) .findFirst() .orElse(-1); }
⬆ 回到顶部
lastIndexOf
查找数组中元素的最后索引,在不存在元素的情况下返回-1。
使用 IntStream.iterate().limit().filter()
查找数组中元素的索引。
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); }
⬆ 回到顶部
filterNonUnique
筛选出数组中的非唯一值。
对只包含唯一值的数组使用 Arrays.stream().filter()
。
public static int[] filterNonUnique(int[] elements) { return Arrays.stream(elements) .filter(el -> indexOf(elements, el) == lastIndexOf(elements, el)) .toArray(); }
⬆ 回到顶部
flatten
使数组扁平。
使用 Arrays.stream().flatMapToInt().toArray()
创建一个新数组。
public static int[] flatten(Object[] elements) { return Arrays.stream(elements) .flatMapToInt(el -> el instanceof int[] ? Arrays.stream((int[]) el) : IntStream.of((int) el) ).toArray(); }
⬆ 回到顶部
flattenDepth
将数组压平到指定的深度。
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(); }
⬆ 回到顶部
groupBy
根据给定函数对数组元素进行分组。
使用 Arrays.stream().collect(Collectors.groupingBy())
分组。
public static <T, R> Map<R, List<T>> groupBy(T[] elements, Function<T, R> func) { return Arrays.stream(elements).collect(Collectors.groupingBy(func)); }
⬆ 回到顶部
initial
返回数组中除去最后一个的所有元素。
使用 Arrays.copyOfRange()
返回除最后一个之外的所有元素。
public static <T> T[] initial(T[] elements) { return Arrays.copyOfRange(elements, 0, elements.length - 1); }
⬆ 回到顶部
initializeArrayWithRange
初始化一个数组,该数组包含在指定范围内的数字,传入 start
和 end
。
public static int[] initializeArrayWithRange(int end, int start) { return IntStream.rangeClosed(start, end).toArray(); }
⬆ 回到顶部
initializeArrayWithValues
使用指定的值初始化并填充数组。
public static int[] initializeArrayWithValues(int n, int value) { return IntStream.generate(() -> value).limit(n).toArray(); }
⬆ 回到顶部
intersection
返回两个数组中存在的元素列表。
从第二步创建一个集合,然后在 a 上使用 Arrays.stream().filter()
来保存包含在 b 中的值。
public static int[] intersection(int[] first, int[] second) { Set<Integer> set = Arrays.stream(second).boxed().collect(Collectors.toSet()); return Arrays.stream(first) .filter(set::contains) .toArray(); }
⬆ 回到顶部
isSorted
如果数组按升序排序,则返回 1
,如果数组按降序排序,返回 -1
,如果没有排序,则返回 0
。
计算前两个元素的排序 direction
。使用for循环对数组进行迭代,并对它们进行成对比较。如果 direction
发生变化,则返回 0
, 如果到达最后一个元素,则返回 direction
。
public static <T extends Comparable<? super T>> 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; }
⬆ 回到顶部
join
将数组的所有元素连接到字符串中,并返回此字符串。
使用 IntStream.range
创建一个指定索引的数组。然后,使用 Stream.reduce
将元素组合成字符串。
public static <T> 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); }
⬆ 回到顶部
nthElement
返回数组的第n个元素。
Use Arrays.copyOfRange()
优先得到包含第n个元素的数组。
public static <T> 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]; }
⬆ 回到顶部
pick
从对象中选择与给定键对应的键值对。
使用 Arrays.stream
过滤 arr
中存在的所有键。然后,使用 Collectors.toMap
将所有的key转换为Map。
public static <T, R> Map<T, R> pick(Map<T, R> obj, T[] arr) { return Arrays.stream(arr) .filter(obj::containsKey) .collect(Collectors.toMap(k -> k, obj::get)); }
⬆ 回到顶部
reducedFilter
根据条件筛选对象数组,同时筛选出未指定的键。
使用 Arrays.stream().filter()
根据谓词 fn
过滤数组,以便返回条件为真的对象。 对于每个过滤的Map对象,创建一个新的Map,其中包含 keys
中的键。最后,将Map对象收集到一个数组中。
public static Map<String, Object>[] reducedFilter(Map<String, Object>[] data, String[] keys, Predicate<Map<String, Object>> 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<String, Object>[]>) Map[]::new); }
⬆ 回到顶部
sample
从数组中返回一个随机元素。
使用 Math.Randoman()
生成一个随机数,然后将它乘以数组的 length
,然后使用 Math.floor()
获得一个最近的整数,该方法也适用于字符串。
public static <T> T sample(T[] arr) { return arr[(int) Math.floor(Math.random() * arr.length)]; }
⬆ 回到顶部
sampleSize
从 array
到 array
大小的唯一键获取 n
个随机元素。
根据 Fisher-Yates算法
,使用 Array.copyOfRange()
获得优先的 n
个元素。
public static <T> 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); }
⬆ 回到顶部
shuffle
将数组值的顺序随机化,返回一个新数组。
根据 Fisher-Yates 算法 重新 排序 数组的元素。
public static <T> 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; }
⬆ 回到顶部
similarity
返回出现在两个数组中的元素数组。
使用 Arrays.stream().filter()
移除,然后使用 Arrays.stream().anyMatch()
匹配 second
部分的值。
public static <T> 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())); }
⬆ 回到顶部
sortedIndex
返回值应该插入到数组中的最低索引,以保持其排序顺序。
检查数组是否按降序(松散地)排序。 使用 IntStream.range().filter()
来找到元素应该被插入的合适的索引。
public static <T extends Comparable<? super T>> 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); }
⬆ 回到顶部
symmetricDifference
返回两个数组之间的对称差异。
从每个数组中创建一个 Set
,然后使用 Arrays.stream().filter()
来保持其他值不包含的值。最后,连接两个数组并创建一个新数组并返回。
public static <T> T[] symmetricDifference(T[] first, T[] second) { Set<T> sA = new HashSet<>(Arrays.asList(first)); Set<T> 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())); }
⬆ 回到顶部
tail
返回数组中除第一个元素外的所有元素。
如果数组的长度大于1,则返回 Arrays.copyOfRange(1)
,否则返回整个数组。
public static <T> T[] tail(T[] arr) { return arr.length > 1 ? Arrays.copyOfRange(arr, 1, arr.length) : arr; }
⬆ 回到顶部
take
返回一个从开头删除n个元素的数组。
public static <T> T[] take(T[] arr, int n) { return Arrays.copyOfRange(arr, 0, n); }
⬆ 回到顶部
takeRight
返回从末尾移除n个元素的数组。
使用 Arrays.copyOfRange()
用从末尾取来的 N
个元素来创建一个数组。
public static <T> T[] takeRight(T[] arr, int n) { return Arrays.copyOfRange(arr, arr.length - n, arr.length); }
⬆ 回到顶部
union
返回两个数组中任何一个中存在的每个元素一次。
使用 a
和 b
的所有值创建一个 Set
,并将其转换为数组。
public static <T> T[] union(T[] first, T[] second) { Set<T> set = new HashSet<>(Arrays.asList(first)); set.addAll(Arrays.asList(second)); return set.toArray((T[]) Arrays.copyOf(new Object[0], 0, first.getClass())); }
⬆ 回到顶部
without
筛选出具有指定值之一的数组的元素。
使用 Arrays.strean().filter()
创建一个数组,排除(使用 !Arrays.asList(elements).contains()
)所有命中的值。
public static <T> T[] without(T[] arr, T... elements) { List<T> excludeElements = Arrays.asList(elements); return Arrays.stream(arr) .filter(el -> !excludeElements.contains(el)) .toArray(i -> (T[]) Arrays.copyOf(new Object[0], i, arr.getClass())); }
⬆ 回到顶部
zip
根据原始数组中的位置创建元素数组。
public static List<Object[]> 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()); }
⬆ 回到顶部
zipObject
给定有效的属性标识符数组和值数组,返回将属性与值关联的对象。
public static Map<String, Object> 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); }
⬆ 回到顶部
Maths
average
返回两个或两个以上数字的平均值。
public static double average(int[] arr) { return IntStream.of(arr) .average() .orElseThrow(() -> new IllegalArgumentException("Array is empty")); }
⬆ 回到顶部
gcd
计算一系列数字的最大公约数(gcd)。
使用 Arrays.stream().reduce()
和 GCD(使用递归公式)计算一组数字的最大公约数。
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); }
⬆ 回到顶部
lcm
计算数字数组的最低公共倍数(LCM)。
使用 Arrays.stream().reduce()
和 LCM公式(使用递归)来计算数字数组的最低公共倍数。
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); }
⬆ 回到顶部
findNextPositivePowerOfTwo
查找大于或等于该值的下一个幂。
该方法使用左移运算符将1与右侧的值位移。右侧使用 Integer.numberOfLeadingZeros
方法。 001 << 2
would be 100
. 100
in decimal is equal to 4
.
Integer.numberOfLeadingZeros
给出了数值前导零的数目。例如,调用 Integer.numberOfLeadingZeros(3)
将赋值为30。 这是因为3在二进制中表示为 11
。由于整数有32位,所以有30位有0位。左移运算符的右边变为 32-30 = 2
。 左移1,即 001 << 2
将是 100
,十进制中的 100
等于 4
。
public static int findNextPositivePowerOfTwo(int value) { return 1 << (32 - Integer.numberOfLeadingZeros(value - 1)); }
⬆ 回到顶部
isEven
检查数字是否是偶数。
这个方法使用按位运算符, 0b1
是1的二进制表示。 因为Java 7可以通过用 0b
或 0B
作为前缀来编写二进制文字。 数字为偶数时, &
运算符将返回0。 例如, IsEven(4)
会导致 100
&
001
, &
的结果将是 000
。
public static boolean isEven(final int value) { return (value & 0b1) == 0; }
⬆ 回到顶部
isPowerOfTwo
检查一个值是2的正幂。
为了理解它是如何工作的,让我们假设我们调用了 IsPowerOfTwo(4)
。
当值大于0时,将评估 &&
运算符的右侧。
(~value + 1)
的结果等于值本身, ~100 + 001
=> 011 + 001
=> 100
。
(value & value)
的结果是value, 100
& 100
=> 100
.。
当值等于值时,这将把值表达为真值。
public static boolean isPowerOfTwo(final int value) { return value > 0 && ((value & (~value + 1)) == value); }
⬆ 回到顶部
generateRandomInt
生成一个介于 Integer.MIN_VALUE
和 Integer.MAX_VALUE
之间的随机数。
public static int generateRandomInt() { return ThreadLocalRandom.current().nextInt(); }
⬆ 回到顶部
String
anagrams
生成一个字符串的所有字符(包含重复)。
public static List<String> 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()); }
⬆ 回到顶部
byteSize
以字节为单位返回字符串的长度。
public static int byteSize(String input) { return input.getBytes().length; }
⬆ 回到顶部
capitalize
将字符串首字母大写。
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())); }
⬆ 回到顶部
capitalizeEveryWord
将字符串中每个单词的首字母大写。
public static String capitalizeEveryWord(final String input) { return Pattern.compile("\\b(?=\\w)").splitAsStream(input) .map(w -> capitalize(w, false)) .collect(Collectors.joining()); }
⬆ 回到顶部
countVowels
在提供的字符串中返回元音的个数。
public static int countVowels(String input) { return input.replaceAll("[^aeiouAEIOU]", "").length(); }
⬆ 回到顶部
escapeRegExp
转义要在正则表达式中使用的字符串。
public static String escapeRegExp(String input) { return Pattern.quote(input); }
⬆ 回到顶部
fromCamelCase
从驼峰式转换字符串。
public static String fromCamelCase(String input, String separator) { return input .replaceAll("([a-z\\d])([A-Z])", "$1" + separator + "$2") .toLowerCase(); }
⬆ 回到顶部
isAbsoluteUrl
如果给定的字符串是绝对URL,则返回 true
,否则返回 false
。
public static boolean isAbsoluteUrl(String url) { return Pattern.compile("^[a-z][a-z0-9+.-]*:").matcher(url).find(); }
⬆ 回到顶部
isLowerCase
检查字符串是否为小写。
public static boolean isLowerCase(String input) { return Objects.equals(input, input.toLowerCase()); }
⬆ 回到顶部
isUpperCase
检查字符串是否为大写。
public static boolean isUpperCase(String input) { return Objects.equals(input, input.toUpperCase()); }
⬆ 回到顶部
isPalindrome
判断一个字符串是否回文。
public static boolean isPalindrome(String input) { String s = input.toLowerCase().replaceAll("[\\W_]", ""); return Objects.equals( s, new StringBuilder(s).reverse().toString() ); }
⬆ 回到顶部
isNumeric
检查字符串是否为数字。
public static boolean isNumeric(final String input) { return IntStream.range(0, input.length()) .allMatch(i -> Character.isDigit(input.charAt(i))); }
⬆ 回到顶部
mask
用指定的掩码字符替换除最后 num
个字符以外的所有字符。
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); }
⬆ 回到顶部
reverseString
反转字符串。
public static String reverseString(String input) { return new StringBuilder(input).reverse().toString(); }
⬆ 回到顶部
sortCharactersInString
按字母顺序排列字符串中的字符。
public static String sortCharactersInString(String input) { return Arrays.stream(input.split("")).sorted().collect(Collectors.joining()); }
⬆ 回到顶部
splitLines
将多行字符串拆分为行数组。
public static String[] splitLines(String input) { return input.split("\\r?\\n"); }
⬆ 回到顶部
toCamelCase
转换一个字符串为驼峰式。
public static String toCamelCase(String input) { 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); List<String> 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); }
⬆ 回到顶部
toKebabCase
将字符串转换为kebab大小写。
public static String toKebabCase(String input) { 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); List<String> matchedParts = new ArrayList<>(); while (matcher.find()) { matchedParts.add(matcher.group(0)); } return matchedParts.stream() .map(String::toLowerCase) .collect(Collectors.joining("-")); }
⬆ 回到顶部
match
正则匹配。
public static List<String> match(String input, String regex) { Matcher matcher = Pattern.compile(regex).matcher(input); List<String> matchedParts = new ArrayList<>(); while (matcher.find()) { matchedParts.add(matcher.group(0)); } return matchedParts; }
⬆ 回到顶部
toSnakeCase
将字符串转换为蛇形小写,如 Im_Biezhi
。
public static String toSnakeCase(String input) { 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); List<String> matchedParts = new ArrayList<>(); while (matcher.find()) { matchedParts.add(matcher.group(0)); } return matchedParts.stream() .map(String::toLowerCase) .collect(Collectors.joining("_")); }
⬆ 回到顶部
truncateString
将字符串截断到指定的长度。
public static String truncateString(String input, int num) { return input.length() > num ? input.substring(0, num > 3 ? num - 3 : num) + "..." : input; }
⬆ 回到顶部
words
将给定的字符串转换为单词数组。
public static String[] words(String input) { return Arrays.stream(input.split("[^a-zA-Z-]+")) .filter(s -> !s.isEmpty()) .toArray(String[]::new); }
⬆ 回到顶部
stringToIntegers
将由空格分隔的数字字符串转换为 int 数组。
public static int[] stringToIntegers(String numbers) { return Arrays.stream(numbers.split(" ")).mapToInt(Integer::parseInt).toArray(); }
⬆ 回到顶部
IO
convertInputStreamToString
将InputStream转换为字符串。
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()); }
⬆ 回到顶部
readFileAsString
将文件内容读入字符串。
public String readFileAsString(Path path) throws IOException { return new String(Files.readAllBytes(path)); }
⬆ 回到顶部
getCurrentWorkingDirectoryPath
获取当前工作目录。
public static String getCurrentWorkingDirectoryPath() { return FileSystems.getDefault().getPath("").toAbsolutePath().toString(); }
⬆ 回到顶部
tmpDirName
返回 java.io.tmpdir
系统属性的值。如果末尾没有分隔符,则追加分隔符。
public static String tmpDirName() { String tmpDirName = System.getProperty("java.io.tmpdir"); if (!tmpDirName.endsWith(File.separator)) { tmpDirName += File.separator; } return tmpDirName; }
⬆ 回到顶部
Exception
stackTraceAsString
将异常堆栈跟踪转换为字符串。
public static String stackTraceAsString(final Throwable throwable) { final StringWriter sw = new StringWriter(); throwable.printStackTrace(new PrintWriter(sw)); return sw.toString(); }
⬆ 回到顶部
System
osName
以小写字符串的形式获取操作系统的名称。
public static String osName() { return System.getProperty("os.name").toLowerCase(); }
⬆ 回到顶部
isDebuggerEnabled
检查JVM是否为debug模式。
public static boolean isDebuggerAttached() { final RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean(); return runtimeMXBean.getInputArguments() .stream() .anyMatch(arg -> arg.contains("-agentlib:jdwp")); }
⬆ 回到顶部
Class
getAllInterfaces
此方法返回由给定类及其超类实现的所有接口。
该方法通过连接两个Stream来工作。第一个Stream是通过创建带有接口的流和接口实现的所有接口来递归构建的。 第二个Stream对超类也是如此。其结果是删除重复项后将两个Stream连接起来。
public static List<Class<?>> 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()); }
⬆ 回到顶部
isInnerClass
此方法检查指定的类是内部类还是静态嵌套类。
public static boolean isInnerClass(final Class<?> cls) { return cls != null && cls.getEnclosingClass() != null; }
⬆ 回到顶部
Enum
getEnumMap
将枚举转换为 Map,其中 key 是枚举名,value 是枚举本身。
public static <E extends Enum<E>> Map<String, E> getEnumMap(final Class<E> enumClass) { return Arrays.stream(enumClass.getEnumConstants()) .collect(Collectors.toMap(Enum::name, Function.identity())); }
⬆ 回到顶部
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持 码农网
猜你喜欢:本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们。
精通Android游戏开发
[美] Vladimir Silva / 王恒、苏金国 等 / 人民邮电出版社 / 2011-2 / 45.00元
作为引领移动技术潮流的软件平台,Android发布了NDK以支持Java和C的混合开发,使PC游戏可以在Android平台上焕发更多魅力。 本书是为那些在Android游戏开发工作中寻求突破的人准备的。书中不仅通过Space Blaster和Asteroids这两个炫酷 的街机游戏深入介绍了如何从头构建纯Java游戏,更详细展示了如何将PC上的3D经典游戏Doom和Wolfenstein 3......一起来看看 《精通Android游戏开发》 这本书的介绍吧!