set = Arrays.stream(second).boxed().collect(Collectors.toSet());
143 | return Arrays.stream(first)
144 | .filter(v -> !set.contains(v))
145 | .toArray();
146 | }
147 |
148 | /**
149 | * Filters out all values from an array for which the comparator function does not return true.
150 | *
151 | * @param first the first array
152 | * @param second the second array
153 | * @param comparator the comparator function
154 | * @return the resulting array
155 | */
156 | public static int[] differenceWith(int[] first, int[] second, IntBinaryOperator comparator) {
157 | return Arrays.stream(first)
158 | .filter(a ->
159 | Arrays.stream(second)
160 | .noneMatch(b -> comparator.applyAsInt(a, b) == 0)
161 | ).toArray();
162 | }
163 |
164 | /**
165 | * Returns all the distinct values of an array.
166 | *
167 | * @param elements ints
168 | * @return distinct values
169 | */
170 | public static int[] distinctValuesOfArray(int[] elements) {
171 | return Arrays.stream(elements).distinct().toArray();
172 | }
173 |
174 | /**
175 | * Removes elements in an array until the passed function returns true. Returns the remaining elements in the array.
176 | *
177 | * @param elements
178 | * @param condition
179 | * @return
180 | */
181 | public static int[] dropElements(int[] elements, IntPredicate condition) {
182 | while (elements.length > 0 && !condition.test(elements[0])) {
183 | elements = Arrays.copyOfRange(elements, 1, elements.length);
184 | }
185 | return elements;
186 | }
187 |
188 | /**
189 | * Returns a new array with n elements removed from the right
190 | *
191 | * @param elements
192 | * @param n number of elements to remove
193 | * @return array after removing n elements
194 | */
195 | public static int[] dropRight(int[] elements, int n) {
196 | if (n < 0) {
197 | throw new IllegalArgumentException("n is less than 0");
198 | }
199 | return n < elements.length
200 | ? Arrays.copyOfRange(elements, 0, elements.length - n)
201 | : new int[0];
202 | }
203 |
204 | /**
205 | * Returns every nth element in an array.
206 | *
207 | * @param elements
208 | * @param nth
209 | * @return
210 | */
211 | public static int[] everyNth(int[] elements, int nth) {
212 | return IntStream.range(0, elements.length)
213 | .filter(i -> i % nth == nth - 1)
214 | .map(i -> elements[i])
215 | .toArray();
216 | }
217 |
218 | /**
219 | * Filters out the non-unique values in an array.
220 | *
221 | * Use Array.stream().filter() for an array containing only the unique values.
222 | *
223 | * @param elements input array
224 | * @return unique values in the array
225 | */
226 | public static int[] filterNonUnique(int[] elements) {
227 | return Arrays.stream(elements)
228 | .filter(el -> indexOf(elements, el) == lastIndexOf(elements, el))
229 | .toArray();
230 | }
231 |
232 | /**
233 | * Find index of element in the array. Return -1 in case element does not exist.
234 | *
235 | * Uses IntStream.range().filter() to find index of the element in the array.
236 | *
237 | * @param elements input array
238 | * @param el element to find
239 | * @return index of the element
240 | */
241 | public static int indexOf(int[] elements, int el) {
242 | return IntStream.range(0, elements.length)
243 | .filter(idx -> elements[idx] == el)
244 | .findFirst()
245 | .orElse(-1);
246 | }
247 |
248 | /**
249 | * Find last index of element in the array. Return -1 in case element does not exist.
250 | *
251 | * Uses IntStream.iterate().limit().filter() to find index of the element in the array.
252 | *
253 | * @param elements input array
254 | * @param el element to find
255 | * @return index of the element
256 | */
257 | public static int lastIndexOf(int[] elements, int el) {
258 | return IntStream.iterate(elements.length - 1, i -> i - 1)
259 | .limit(elements.length)
260 | .filter(idx -> elements[idx] == el)
261 | .findFirst()
262 | .orElse(-1);
263 | }
264 |
265 | /**
266 | * Flattens an array.
267 | *
268 | * @param elements input array
269 | * @return flattened array
270 | */
271 | public static int[] flatten(Object[] elements) {
272 | return Arrays.stream(elements)
273 | .flatMapToInt(el -> el instanceof int[]
274 | ? Arrays.stream((int[]) el)
275 | : IntStream.of((int) el)
276 | ).toArray();
277 | }
278 |
279 | /**
280 | * Flattens an array up to the specified depth.
281 | *
282 | * @param elements input array
283 | * @param depth depth to which to flatten array
284 | * @return flattened array
285 | */
286 | public static Object[] flattenDepth(Object[] elements, int depth) {
287 | if (depth == 0) {
288 | return elements;
289 | }
290 | return Arrays.stream(elements)
291 | .flatMap(el -> el instanceof Object[]
292 | ? Arrays.stream(flattenDepth((Object[]) el, depth - 1))
293 | : Arrays.stream(new Object[]{el})
294 | ).toArray();
295 |
296 |
297 | }
298 |
299 | /**
300 | * Groups the elements of an array based on the given function.
301 | *
302 | * @param elements input array
303 | * @param func function
304 | * @param type parameter
305 | * @return grouped elements in a Map
306 | */
307 | public static Map> groupBy(T[] elements, Function func) {
308 | return Arrays.stream(elements).collect(Collectors.groupingBy(func));
309 | }
310 |
311 | /**
312 | * Returns all the elements of an array except the last one.
313 | * Use Arrays.copyOfRange() to return all except the last one
314 | *
315 | * @param elements
316 | * @param
317 | * @return
318 | */
319 | public static T[] initial(T[] elements) {
320 | return Arrays.copyOfRange(elements, 0, elements.length - 1);
321 | }
322 |
323 | /**
324 | * Initializes an array containing the numbers in the specified range where start and end are inclusive.
325 | *
326 | * @param end
327 | * @param start
328 | * @return
329 | */
330 | public static int[] initializeArrayWithRange(int end, int start) {
331 | return IntStream.rangeClosed(start, end).toArray();
332 | }
333 |
334 | public static int[] initializeArrayWithValues(int n, int value) {
335 | return IntStream.generate(() -> value).limit(n).toArray();
336 | }
337 |
338 | public static int[] intersection(int[] first, int[] second) {
339 | Set set = Arrays.stream(second).boxed().collect(Collectors.toSet());
340 | return Arrays.stream(first)
341 | .filter(set::contains)
342 | .toArray();
343 | }
344 |
345 | public static > int isSorted(T[] arr) {
346 | final int direction = arr[0].compareTo(arr[1]) < 0 ? 1 : -1;
347 | for (int i = 0; i < arr.length; i++) {
348 | T val = arr[i];
349 | if (i == arr.length - 1) return direction;
350 | else if ((val.compareTo(arr[i + 1]) * direction > 0)) return 0;
351 | }
352 | return direction;
353 | }
354 |
355 | public static String join(T[] arr, String separator, String end) {
356 | return IntStream.range(0, arr.length)
357 | .mapToObj(i -> new SimpleEntry<>(i, arr[i]))
358 | .reduce("", (acc, val) -> val.getKey() == arr.length - 2
359 | ? acc + val.getValue() + end
360 | : val.getKey() == arr.length - 1 ? acc + val.getValue() : acc + val.getValue() + separator, (fst, snd) -> fst);
361 | }
362 |
363 | public static String join(T[] arr, String separator) {
364 | return join(arr, separator, separator);
365 | }
366 |
367 | public static String join(T[] arr) {
368 | return join(arr, ",");
369 | }
370 |
371 | public static T nthElement(T[] arr, int n) {
372 | if (n > 0) {
373 | return Arrays.copyOfRange(arr, n, arr.length)[0];
374 | }
375 | return Arrays.copyOfRange(arr, arr.length + n, arr.length)[0];
376 | }
377 |
378 | public static Map pick(Map obj, T[] arr) {
379 | return Arrays.stream(arr)
380 | .filter(obj::containsKey)
381 | .collect(Collectors.toMap(k -> k, obj::get));
382 | }
383 |
384 | public static Map[] reducedFilter(Map[] data, String[] keys, Predicate> fn) {
385 | return Arrays.stream(data)
386 | .filter(fn)
387 | .map(el -> Arrays.stream(keys).filter(el::containsKey)
388 | .collect(Collectors.toMap(Function.identity(), el::get)))
389 | .toArray((IntFunction[]>) Map[]::new);
390 | }
391 |
392 | public static T sample(T[] arr) {
393 | return arr[(int) Math.floor(Math.random() * arr.length)];
394 | }
395 |
396 | public static T[] sampleSize(T[] input, int n) {
397 | T[] arr = Arrays.copyOf(input, input.length);
398 | int length = arr.length;
399 | int m = length;
400 | while (m > 0) {
401 | int i = (int) Math.floor(Math.random() * m--);
402 | T tmp = arr[i];
403 | arr[i] = arr[m];
404 | arr[m] = tmp;
405 | }
406 | return Arrays.copyOfRange(arr, 0, n > length ? length : n);
407 | }
408 |
409 | public static T[] shuffle(T[] input) {
410 | T[] arr = Arrays.copyOf(input, input.length);
411 | int length = arr.length;
412 | int m = length;
413 | while (m > 0) {
414 | int i = (int) Math.floor(Math.random() * m--);
415 | T tmp = arr[i];
416 | arr[i] = arr[m];
417 | arr[m] = tmp;
418 | }
419 | return arr;
420 | }
421 |
422 | public static T[] similarity(T[] first, T[] second) {
423 | return Arrays.stream(first)
424 | .filter(a -> Arrays.stream(second).anyMatch(b -> Objects.equals(a, b)))
425 | // Make a new array of first's runtime type, but empty content:
426 | .toArray(i -> (T[]) Arrays.copyOf(new Object[0], i, first.getClass()));
427 | }
428 |
429 | public static T[] emptyArray(Class clz) {
430 | return (T[]) Array.newInstance(clz, 0);
431 | }
432 |
433 |
434 | public static > int sortedIndex(T[] arr, T el) {
435 | boolean isDescending = arr[0].compareTo(arr[arr.length - 1]) > 0;
436 | return IntStream.range(0, arr.length)
437 | .filter(i -> isDescending ? el.compareTo(arr[i]) >= 0 : el.compareTo(arr[i]) <= 0)
438 | .findFirst()
439 | .orElse(arr.length);
440 | }
441 |
442 | public static T[] symmetricDifference(T[] first, T[] second) {
443 | Set sA = new HashSet<>(Arrays.asList(first));
444 | Set sB = new HashSet<>(Arrays.asList(second));
445 |
446 | return Stream.concat(
447 | Arrays.stream(first).filter(a -> !sB.contains(a)),
448 | Arrays.stream(second).filter(b -> !sA.contains(b))
449 | ).toArray(i -> (T[]) Arrays.copyOf(new Object[0], i, first.getClass()));
450 | }
451 |
452 | public static T[] tail(T[] arr) {
453 | return arr.length > 1
454 | ? Arrays.copyOfRange(arr, 1, arr.length)
455 | : arr;
456 | }
457 |
458 | public static T[] take(T[] arr, int n) {
459 | return Arrays.copyOfRange(arr, 0, n);
460 | }
461 |
462 | public static T[] takeRight(T[] arr, int n) {
463 | return Arrays.copyOfRange(arr, arr.length - n, arr.length);
464 | }
465 |
466 | public static T[] union(T[] first, T[] second) {
467 | Set set = new HashSet<>(Arrays.asList(first));
468 | set.addAll(Arrays.asList(second));
469 | return set.toArray((T[]) Arrays.copyOf(new Object[0], 0, first.getClass()));
470 | }
471 |
472 | public static T[] without(T[] arr, T... elements) {
473 | List excludeElements = Arrays.asList(elements);
474 | return Arrays.stream(arr)
475 | .filter(el -> !excludeElements.contains(el))
476 | .toArray(i -> (T[]) Arrays.copyOf(new Object[0], i, arr.getClass()));
477 | }
478 |
479 | public static List zip(Object[]... arrays) {
480 | OptionalInt max = Arrays.stream(arrays).mapToInt(arr -> arr.length).max();
481 | return IntStream.range(0, max.getAsInt())
482 | .mapToObj(i -> Arrays.stream(arrays)
483 | .map(arr -> i < arr.length ? arr[i] : null)
484 | .toArray())
485 | .collect(Collectors.toList());
486 | }
487 |
488 | public static Map zipObject(String[] props, Object[] values) {
489 | return IntStream.range(0, props.length)
490 | .mapToObj(i -> new SimpleEntry<>(props[i], i < values.length ? values[i] : null))
491 | .collect(
492 | HashMap::new, (m, v) -> m.put(v.getKey(), v.getValue()), HashMap::putAll);
493 | }
494 |
495 | public static double average(int[] arr) {
496 | return IntStream.of(arr)
497 | .average()
498 | .orElseThrow(() -> new IllegalArgumentException("Array is empty"));
499 | }
500 |
501 | public static List anagrams(String input) {
502 | if (input.length() <= 2) {
503 | return input.length() == 2
504 | ? Arrays.asList(input, input.substring(1) + input.substring(0, 1))
505 | : Collections.singletonList(input);
506 | }
507 | return IntStream.range(0, input.length())
508 | .mapToObj(i -> new SimpleEntry<>(i, input.substring(i, i + 1)))
509 | .flatMap(entry ->
510 | anagrams(input.substring(0, entry.getKey()) + input.substring(entry.getKey() + 1))
511 | .stream()
512 | .map(s -> entry.getValue() + s))
513 | .collect(Collectors.toList());
514 | }
515 |
516 | public static int byteSize(String input) {
517 | // Read the link below to learn more
518 | // https://stackoverflow.com/questions/16270994/difference-between-string-length-and-string-getbytes-length
519 | return input.getBytes().length;
520 | }
521 |
522 | public static String capitalize(String input, boolean lowerRest) {
523 | return input.substring(0, 1).toUpperCase() +
524 | (lowerRest
525 | ? input.substring(1, input.length()).toLowerCase()
526 | : input.substring(1, input.length()));
527 | }
528 |
529 | public static String capitalizeEveryWord(final String input) {
530 | return Pattern.compile("\\b(?=\\w)").splitAsStream(input)
531 | .map(w -> capitalize(w, false))
532 | .collect(Collectors.joining());
533 | }
534 |
535 | public static int countVowels(String input) {
536 | return input.replaceAll("[^aeiouAEIOU]", "").length();
537 | }
538 |
539 | public static String escapeRegExp(String input) {
540 | return Pattern.quote(input);
541 | }
542 |
543 | public static String fromCamelCase(String input, String separator) {
544 | return input
545 | .replaceAll("([a-z\\d])([A-Z])", "$1" + separator + "$2")
546 | .toLowerCase();
547 | }
548 |
549 | public static boolean isAbsoluteUrl(String url) {
550 | return Pattern.compile("^[a-z][a-z0-9+.-]*:").matcher(url).find();
551 | }
552 |
553 | public static boolean isLowerCase(String input) {
554 | return Objects.equals(input, input.toLowerCase());
555 | }
556 |
557 | public static boolean isUpperCase(String input) {
558 | return Objects.equals(input, input.toUpperCase());
559 | }
560 |
561 | public static String mask(String input, int num, String mask) {
562 | int length = input.length();
563 | return num > 0
564 | ?
565 | input.substring(0, length - num).replaceAll(".", mask)
566 | + input.substring(length - num)
567 | :
568 | input.substring(0, Math.negateExact(num))
569 | + input.substring(Math.negateExact(num), length).replaceAll(".", mask);
570 | }
571 |
572 | public static boolean isPalindrome(String input) {
573 | String s = input.toLowerCase().replaceAll("[\\W_]", "");
574 | return Objects.equals(
575 | s,
576 | new StringBuilder(s).reverse().toString()
577 | );
578 | }
579 |
580 | public static String reverseString(String input) {
581 | return new StringBuilder(input).reverse().toString();
582 | }
583 |
584 | public static String sortCharactersInString(String input) {
585 | return Arrays.stream(input.split("")).sorted().collect(Collectors.joining());
586 | }
587 |
588 | public static String[] splitLines(String input) {
589 | return input.split("\\r?\\n");
590 | }
591 |
592 | public static String toCamelCase(String input) {
593 | 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);
594 | List matchedParts = new ArrayList<>();
595 | while (matcher.find()) {
596 | matchedParts.add(matcher.group(0));
597 | }
598 | String s = matchedParts.stream()
599 | .map(x -> x.substring(0, 1).toUpperCase() + x.substring(1).toLowerCase())
600 | .collect(Collectors.joining());
601 | return s.substring(0, 1).toLowerCase() + s.substring(1);
602 | }
603 |
604 | public static String toKebabCase(String input) {
605 | 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);
606 | List matchedParts = new ArrayList<>();
607 | while (matcher.find()) {
608 | matchedParts.add(matcher.group(0));
609 | }
610 | return matchedParts.stream()
611 | .map(String::toLowerCase)
612 | .collect(Collectors.joining("-"));
613 | }
614 |
615 | public static List match(String input, String regex) {
616 | Matcher matcher = Pattern.compile(regex).matcher(input);
617 | List matchedParts = new ArrayList<>();
618 | while (matcher.find()) {
619 | matchedParts.add(matcher.group(0));
620 | }
621 | return matchedParts;
622 | }
623 |
624 | public static String toSnakeCase(String input) {
625 | 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);
626 | List matchedParts = new ArrayList<>();
627 | while (matcher.find()) {
628 | matchedParts.add(matcher.group(0));
629 | }
630 | return matchedParts.stream()
631 | .map(String::toLowerCase)
632 | .collect(Collectors.joining("_"));
633 | }
634 |
635 | public static String truncateString(String input, int num) {
636 | return input.length() > num
637 | ? input.substring(0, num > 3 ? num - 3 : num) + "..."
638 | : input;
639 | }
640 |
641 | public static String[] words(String input) {
642 | return Arrays.stream(input.split("[^a-zA-Z-]+"))
643 | .filter(s -> !s.isEmpty())
644 | .toArray(String[]::new);
645 | }
646 |
647 | //Read the link below for more information
648 | // https://stackoverflow.com/questions/309424/read-convert-an-inputstream-to-a-string
649 | public static String convertInputStreamToString(final InputStream in) throws IOException {
650 | ByteArrayOutputStream result = new ByteArrayOutputStream();
651 | byte[] buffer = new byte[1024];
652 | int length;
653 | while ((length = in.read(buffer)) != -1) {
654 | result.write(buffer, 0, length);
655 | }
656 | return result.toString(StandardCharsets.UTF_8.name());
657 | }
658 |
659 | public static int[] randomInts(int total, int start, int end) {
660 | return ThreadLocalRandom.current().ints(total, start, end).toArray();
661 | }
662 |
663 | public String readFileAsString(Path path) throws IOException {
664 | return new String(Files.readAllBytes(path));
665 | }
666 |
667 | public static String stackTraceAsString(final Throwable throwable) {
668 | final StringWriter sw = new StringWriter();
669 | throwable.printStackTrace(new PrintWriter(sw));
670 | return sw.toString();
671 | }
672 |
673 | public static T[] concat(T[] first, T[] second) {
674 | return Stream.concat(
675 | Stream.of(first),
676 | Stream.of(second)
677 | ).toArray(i -> (T[]) Arrays.copyOf(new Object[0], i, first.getClass()));
678 | }
679 |
680 | public static String getCurrentWorkingDirectoryPath() {
681 | return FileSystems.getDefault().getPath("").toAbsolutePath().toString();
682 | }
683 |
684 | public static boolean isNumeric(final String input) {
685 | if (input == null || input.isEmpty()) {
686 | return false;
687 | }
688 | return IntStream.range(0, input.length())
689 | .allMatch(i -> Character.isDigit(input.charAt(i)));
690 | }
691 |
692 | public static int findNextPositivePowerOfTwo(int value) {
693 | return 1 << (32 - Integer.numberOfLeadingZeros(value - 1));
694 | }
695 |
696 | public static boolean isEven(final int value) {
697 | return (value & 0b1) == 0;
698 | }
699 |
700 | public static boolean isPowerOfTwo(final int value) {
701 | return value > 0 && ((value & (~value + 1)) == value);
702 | }
703 |
704 | public static int generateRandomInt() {
705 | return ThreadLocalRandom.current().nextInt();
706 | }
707 |
708 | public static String tmpDirName() {
709 | String tmpDirName = System.getProperty("java.io.tmpdir");
710 | if (!tmpDirName.endsWith(File.separator)) {
711 | tmpDirName += File.separator;
712 | }
713 |
714 | return tmpDirName;
715 | }
716 |
717 | public static String osName() {
718 | return System.getProperty("os.name").toLowerCase();
719 | }
720 |
721 | public static boolean isDebuggerAttached() {
722 | final RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
723 | return runtimeMXBean.getInputArguments()
724 | .stream()
725 | .anyMatch(arg -> arg.contains("-agentlib:jdwp"));
726 |
727 | }
728 |
729 | /**
730 | * Input a line of numbers separated by space as integers
731 | * and return ArrayList of Integers.
732 | * eg. the String "1 2 3 4 5 6 7 8 9" is returned as an ArrayList of Integers.
733 | *
734 | * @param numbers range of numbers separated by space as a string
735 | * @return ArrayList of Integers
736 | */
737 |
738 | public static int[] stringToIntegers(String numbers) {
739 | return Arrays.stream(numbers.split(" ")).mapToInt(Integer::parseInt).toArray();
740 | }
741 |
742 | /* Class Utilities */
743 |
744 | public static List> getAllInterfaces(final Class cls) {
745 | return Stream.concat(
746 | Arrays.stream(cls.getInterfaces()).flatMap(intf ->
747 | Stream.concat(Stream.of(intf), getAllInterfaces(intf).stream())),
748 | cls.getSuperclass() == null ? Stream.empty() : getAllInterfaces(cls.getSuperclass()).stream()
749 | ).distinct().collect(Collectors.toList());
750 | }
751 |
752 | public static boolean isInnerClass(final Class cls) {
753 | return cls != null && cls.getEnclosingClass() != null;
754 | }
755 |
756 | public static > Map getEnumMap(final Class enumClass) {
757 | return Arrays.stream(enumClass.getEnumConstants())
758 | .collect(Collectors.toMap(Enum::name, Function.identity()));
759 | }
760 | }
761 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # 30 Seconds Of Java [](https://travis-ci.org/shekhargulati/little-java-functions)
2 |
3 | > Curated collection of useful little Java 8 functions that you can understand quickly.
4 |
5 | ## Table of Contents
6 |
7 | ### Array
8 |
9 |
10 | View contents
11 |
12 | * [`chunk`](#chunk)
13 | * [`countOccurrences`](#countoccurrences)
14 | * [`deepFlatten`](#deepflatten)
15 | * [`difference`](#difference)
16 | * [`differenceWith`](#differencewith)
17 | * [`distinctValuesOfArray`](#distinctvaluesofarray)
18 | * [`dropElements`](#dropelements)
19 | * [`dropRight`](#dropright)
20 | * [`everyNth`](#everynth)
21 | * [`filterNonUnique`](#filternonunique)
22 | * [`flatten`](#flatten)
23 | * [`flattenDepth`](#flattendepth)
24 | * [`groupBy`](#groupby)
25 | * [`head`](#head)
26 | * [`initial`](#initial)
27 | * [`initializeArrayWithRange`](#initializearraywithrange)
28 | * [`initializeArrayWithValues`](#initializearraywithvalues)
29 | * [`intersection`](#intersection)
30 | * [`isSorted`](#issorted)
31 | * [`join`](#join)
32 | * [`nthElement`](#nthelement)
33 | * [`pick`](#pick)
34 | * [`reducedFilter`](#reducedfilter)
35 | * [`remove`](#remove)
36 | * [`sample`](#sample)
37 | * [`sampleSize`](#samplesize)
38 | * [`shuffle`](#shuffle)
39 | * [`similarity`](#similarity)
40 | * [`sortedIndex`](#sortedindex)
41 | * [`symmetricDifference`](#symmetricdifference)
42 | * [`tail`](#tail)
43 | * [`take`](#take)
44 | * [`takeRight`](#takeright)
45 | * [`union`](#union)
46 | * [`without`](#without)
47 | * [`zip`](#zip)
48 | * [`zipObject`](#zipobject)
49 |
50 |
51 |
52 | ### Math
53 |
54 |
55 | View contents
56 |
57 | * [`average`](#average)
58 | * [`gcd`](#gcd)
59 | * [`lcm`](#lcm)
60 | * [`findNextPositivePowerOfTwo`](#findnextpositivepoweroftwo)
61 | * [`isEven`](#iseven)
62 | * [`isPowerOfTwo`](#ispoweroftwo)
63 | * [`generateRandomInt`](#generaterandomint)
64 |
65 |
66 |
67 | ### String
68 |
69 |
70 | View contents
71 |
72 | * [`anagrams`](#anagrams)
73 | * [`byteSize`](#bytesize)
74 | * [`capitalize`](#capitalize)
75 | * [`capitalizeEveryWord`](#capitalizeeveryword)
76 | * [`countVowels`](#countvowels)
77 | * [`escapeRegExp`](#escaperegexp)
78 | * [`fromCamelCase`](#fromcamelcase)
79 | * [`isAbsoluteURL`](#isabsoluteurl)
80 | * [`isLowerCase`](#islowercase)
81 | * [`isUpperCase`](#isuppercase)
82 | * [`isPalindrome`](#ispalindrome)
83 | * [`isNumeric`](#isnumeric)
84 | * [`mask`](#mask)
85 | * [`reverseString`](#reversestring)
86 | * [`sortCharactersInString`](#sortcharactersinstring)
87 | * [`splitLines`](#splitlines)
88 | * [`toCamelCase`](#tocamelcase)
89 | * [`toKebabCase`](#tokebabcase)
90 | * [`match`](#match)
91 | * [`toSnakeCase`](#tosnakecase)
92 | * [`truncateString`](#truncatestring)
93 | * [`words`](#words)
94 | * [`stringToIntegers`](#stringtointegers)
95 |
96 |
97 |
98 |
99 | ### IO
100 |
101 |
102 | View contents
103 |
104 | * [`convertInputStreamToString`](#convertinputstreamtostring)
105 | * [`readFileAsString`](#readfileasstring)
106 | * [`getCurrentWorkingDirectoryPath`](#getcurrentworkingdirectorypath)
107 | * [`tmpDirName`](#tmpdirname)
108 |
109 |
110 |
111 | ### Exception
112 |
113 |
114 | View contents
115 |
116 | * [`stackTraceAsString`](#stacktraceasstring)
117 |
118 |
119 |
120 | ### System
121 |
122 |
123 | View contents
124 |
125 | - [`osName`](#osname)
126 | - [`isDebuggerEnabled`](#isdebuggerenabled)
127 |
128 |
129 |
130 | ### Class
131 |
132 |
133 | View contents
134 |
135 | - [`getAllInterfaces`](#getallinterfaces)
136 | - [`IsInnerClass`](#isinnerclass)
137 |
138 |
139 |
140 | ### Enum
141 |
142 |
143 | View contents
144 |
145 | - [`getEnumMap`](#getenummap)
146 |
147 |
148 |
149 | ## Array
150 |
151 | ### chunk
152 |
153 | Chunks an array into smaller arrays of specified size.
154 |
155 | ```java
156 | public static int[][] chunk(int[] numbers, int size) {
157 | return IntStream.iterate(0, i -> i + size)
158 | .limit((long) Math.ceil((double) numbers.length / size))
159 | .mapToObj(cur -> Arrays.copyOfRange(numbers, cur, cur + size > numbers.length ? numbers.length : cur + size))
160 | .toArray(int[][]::new);
161 | }
162 | ```
163 |
164 | ### concat
165 |
166 | ```java
167 | public static T[] concat(T[] first, T[] second) {
168 | return Stream.concat(
169 | Stream.of(first),
170 | Stream.of(second)
171 | ).toArray(i -> (T[]) Arrays.copyOf(new Object[0], i, first.getClass()));
172 | }
173 | ```
174 |
175 | ### countOccurrences
176 |
177 | Counts the occurrences of a value in an array.
178 |
179 | Use Arrays.stream().filter().count() to count total number of values that equals the specified value.
180 |
181 | ```java
182 | public static long countOccurrences(int[] numbers, int value) {
183 | return Arrays.stream(numbers)
184 | .filter(number -> number == value)
185 | .count();
186 | }
187 | ```
188 |
189 | ### deepFlatten
190 |
191 | Deep flattens an array.
192 |
193 | Use recursion. Use Arrays.stream().flatMapToInt()
194 |
195 | ```java
196 | public static int[] deepFlatten(Object[] input) {
197 | return Arrays.stream(input)
198 | .flatMapToInt(o -> {
199 | if (o instanceof Object[]) {
200 | return Arrays.stream(deepFlatten((Object[]) o));
201 | }
202 | return IntStream.of((Integer) o);
203 | }).toArray();
204 | }
205 | ```
206 |
207 | ### difference
208 |
209 | Returns the difference between two arrays.
210 |
211 | Create a Set from b, then use Arrays.stream().filter() on a to only keep values not contained in b.
212 |
213 | ```java
214 | public static int[] difference(int[] first, int[] second) {
215 | Set set = Arrays.stream(second).boxed().collect(Collectors.toSet());
216 | return Arrays.stream(first)
217 | .filter(v -> !set.contains(v))
218 | .toArray();
219 | }
220 | ```
221 |
222 | ### differenceWith
223 |
224 | Filters out all values from an array for which the comparator function does not return true.
225 |
226 | The comparator for int is implemented using IntBinaryOperator function.
227 |
228 | Uses Arrays.stream().filter and Arrays.stream().noneMatch() to find the appropriate values.
229 |
230 | ```java
231 | public static int[] differenceWith(int[] first, int[] second, IntBinaryOperator comparator) {
232 | return Arrays.stream(first)
233 | .filter(a ->
234 | Arrays.stream(second)
235 | .noneMatch(b -> comparator.applyAsInt(a, b) == 0)
236 | ).toArray();
237 | }
238 | ```
239 |
240 | ### distinctValuesOfArray
241 |
242 | Returns all the distinct values of an array.
243 |
244 | Uses Arrays.stream().distinct() to discard all duplicated values.
245 |
246 | ```java
247 | public static int[] distinctValuesOfArray(int[] elements) {
248 | return Arrays.stream(elements).distinct().toArray();
249 | }
250 | ```
251 |
252 | ### dropElements
253 |
254 | Removes elements in an array until the passed function returns true. Returns the remaining elements in the array.
255 |
256 | Loop through the array, using Arrays.copyOfRange() to drop the first element of the array until the returned value from the function is true. Returns the remaining elements.
257 |
258 | ```java
259 | public static int[] dropElements(int[] elements, IntPredicate condition) {
260 | while (elements.length > 0 && !condition.test(elements[0])) {
261 | elements = Arrays.copyOfRange(elements, 1, elements.length);
262 | }
263 | return elements;
264 | }
265 | ```
266 |
267 | ### dropRight
268 |
269 | Returns a new array with n elements removed from the right.
270 |
271 | Check if n is shorter than the given array and use Array.copyOfRange() to slice it accordingly or return an empty array.
272 |
273 | ```java
274 | public static int[] dropRight(int[] elements, int n) {
275 | if (n < 0) {
276 | throw new IllegalArgumentException("n is less than 0");
277 | }
278 | return n < elements.length
279 | ? Arrays.copyOfRange(elements, 0, elements.length - n)
280 | : new int[0];
281 | }
282 | ```
283 |
284 | ### everyNth
285 |
286 | Returns every nth element in an array.
287 |
288 | Use IntStream.range().filter() to create a new array that contains every nth element of a given array.
289 |
290 | ```java
291 | public static int[] everyNth(int[] elements, int nth) {
292 | return IntStream.range(0, elements.length)
293 | .filter(i -> i % nth == nth - 1)
294 | .map(i -> elements[i])
295 | .toArray();
296 | }
297 | ```
298 |
299 | ### indexOf
300 |
301 | Find index of element in the array. Return -1 in case element does not exist.
302 |
303 | Uses IntStream.range().filter() to find index of the element in the array.
304 |
305 | ```java
306 | public static int indexOf(int[] elements, int el) {
307 | return IntStream.range(0, elements.length)
308 | .filter(idx -> elements[idx] == el)
309 | .findFirst()
310 | .orElse(-1);
311 | }
312 | ```
313 |
314 | ### lastIndexOf
315 |
316 | Find last index of element in the array. Return -1 in case element does not exist.
317 |
318 | Uses IntStream.iterate().limit().filter() to find index of the element in the array.
319 |
320 |
321 | ```java
322 | public static int lastIndexOf(int[] elements, int el) {
323 | return IntStream.iterate(elements.length - 1, i -> i - 1)
324 | .limit(elements.length)
325 | .filter(idx -> elements[idx] == el)
326 | .findFirst()
327 | .orElse(-1);
328 | }
329 | ```
330 |
331 | ### filterNonUnique
332 |
333 | Filters out the non-unique values in an array.
334 |
335 | Use Arrays.stream().filter() for an array containing only the unique values.
336 |
337 | ```java
338 | public static int[] filterNonUnique(int[] elements) {
339 | return Arrays.stream(elements)
340 | .filter(el -> indexOf(elements, el) == lastIndexOf(elements, el))
341 | .toArray();
342 | }
343 | ```
344 |
345 | ### flatten
346 |
347 | Flattens an array.
348 |
349 | Use Arrays.stream().flatMapToInt().toArray() to create a new array.
350 |
351 |
352 | ```java
353 | public static int[] flatten(Object[] elements) {
354 | return Arrays.stream(elements)
355 | .flatMapToInt(el -> el instanceof int[]
356 | ? Arrays.stream((int[]) el)
357 | : IntStream.of((int) el)
358 | ).toArray();
359 | }
360 | ```
361 |
362 | ### flattenDepth
363 |
364 | Flattens an array up to the specified depth.
365 |
366 | ```java
367 | public static Object[] flattenDepth(Object[] elements, int depth) {
368 | if (depth == 0) {
369 | return elements;
370 | }
371 | return Arrays.stream(elements)
372 | .flatMap(el -> el instanceof Object[]
373 | ? Arrays.stream(flattenDepth((Object[]) el, depth - 1))
374 | : Arrays.stream(new Object[]{el})
375 | ).toArray();
376 |
377 |
378 | }
379 | ```
380 |
381 | ### groupBy
382 |
383 | Groups the elements of an array based on the given function.
384 |
385 | Uses Arrays.stream().collect(Collectors.groupingBy()) to group based on the grouping function.
386 |
387 | ```java
388 | public static Map> groupBy(T[] elements, Function func) {
389 | return Arrays.stream(elements).collect(Collectors.groupingBy(func));
390 | }
391 | ```
392 |
393 | ### initial
394 |
395 | Returns all the elements of an array except the last one.
396 | Use Arrays.copyOfRange() to return all except the last one
397 |
398 | ```java
399 | public static T[] initial(T[] elements) {
400 | return Arrays.copyOfRange(elements, 0, elements.length - 1);
401 | }
402 | ```
403 |
404 | ### initializeArrayWithRange
405 |
406 | Initializes an array containing the numbers in the specified range where start and end are inclusive.
407 |
408 |
409 | ```java
410 | public static int[] initializeArrayWithRange(int end, int start) {
411 | return IntStream.rangeClosed(start, end).toArray();
412 | }
413 | ```
414 |
415 | ### initializeArrayWithValues
416 |
417 | Initializes and fills an array with the specified values.
418 |
419 | ```java
420 | public static int[] initializeArrayWithValues(int n, int value) {
421 | return IntStream.generate(() -> value).limit(n).toArray();
422 | }
423 | ```
424 |
425 | ### intersection
426 |
427 | Returns a list of elements that exist in both arrays.
428 |
429 | Create a Set from second, then use Arrays.stream().filter() on a to only keep values contained in b.
430 |
431 | ```java
432 | public static int[] intersection(int[] first, int[] second) {
433 | Set set = Arrays.stream(second).boxed().collect(Collectors.toSet());
434 | return Arrays.stream(first)
435 | .filter(set::contains)
436 | .toArray();
437 | }
438 | ```
439 |
440 | ### isSorted
441 |
442 | Returns `1` if the array is sorted in ascending order, `-1` if it is sorted in descending order or `0` if it is not sorted.
443 |
444 | Calculate the ordering `direction` for the first two elements.Use for loop to iterate over array items and compare them in pairs. Return `0` if the `direction` changes or the `direction` if the last element is reached.
445 |
446 | ```java
447 | public static > int isSorted(T[] arr) {
448 | final int direction = arr[0].compareTo(arr[1]) < 0 ? 1 : -1;
449 | for (int i = 0; i < arr.length; i++) {
450 | T val = arr[i];
451 | if (i == arr.length - 1) return direction;
452 | else if ((val.compareTo(arr[i + 1]) * direction > 0)) return 0;
453 | }
454 | return direction;
455 | }
456 | ```
457 |
458 | ### join
459 |
460 | Joins all elements of an array into a string and returns this string. Uses a separator and an end separator.
461 |
462 | Use IntStream.range to zip index with the array item. Then, use `Stream.reduce` to combine elements into a string.
463 |
464 | ```java
465 | public static String join(T[] arr, String separator, String end) {
466 | return IntStream.range(0, arr.length)
467 | .mapToObj(i -> new SimpleEntry<>(i, arr[i]))
468 | .reduce("", (acc, val) -> val.getKey() == arr.length - 2
469 | ? acc + val.getValue() + end
470 | : val.getKey() == arr.length - 1 ? acc + val.getValue() : acc + val.getValue() + separator, (fst, snd) -> fst);
471 | }
472 | ```
473 |
474 | ### nthElement
475 |
476 | Returns the nth element of an array.
477 |
478 | Use `Arrays.copyOfRange()` to get an array containing the nth element at the first place.
479 |
480 | ```Java
481 | public static T nthElement(T[] arr, int n) {
482 | if (n > 0) {
483 | return Arrays.copyOfRange(arr, n, arr.length)[0];
484 | }
485 | return Arrays.copyOfRange(arr, arr.length + n, arr.length)[0];
486 | }
487 | ```
488 |
489 | ### pick
490 |
491 | Picks the key-value pairs corresponding to the given keys from an object.
492 |
493 | Use `Arrays.stream` to filter all the keys that are present in the `arr`. Then, convert all the keys present into a Map using `Collectors.toMap`.
494 |
495 | ```java
496 | public static Map pick(Map obj, T[] arr) {
497 | return Arrays.stream(arr)
498 | .filter(obj::containsKey)
499 | .collect(Collectors.toMap(k -> k, obj::get));
500 | }
501 | ```
502 |
503 | ### reducedFilter
504 |
505 | Filter an array of objects based on a condition while also filtering out unspecified keys.
506 |
507 | Use `Arrays.stream().filter()` to filter the array based on the predicate `fn` so that it returns the objects for which the condition is true. For each filtered Map object, create a new Map with keys present in the `keys`. Finally, collect all the Map object into an array.
508 |
509 | ```java
510 | public static Map[] reducedFilter(Map[] data, String[] keys, Predicate> fn) {
511 | return Arrays.stream(data)
512 | .filter(fn)
513 | .map(el -> Arrays.stream(keys).filter(el::containsKey)
514 | .collect(Collectors.toMap(Function.identity(), el::get)))
515 | .toArray((IntFunction[]>) Map[]::new);
516 | }
517 | ```
518 |
519 | ### sample
520 |
521 | Returns a random element from an array.
522 |
523 | Use `Math.random()` to generate a random number, multiply it by `length` and round it of to the nearest whole number using `Math.floor()`. This method also works with strings.
524 |
525 | ```java
526 | public static T sample(T[] arr) {
527 | return arr[(int) Math.floor(Math.random() * arr.length)];
528 | }
529 | ```
530 |
531 | ### sampleSize
532 |
533 | Gets `n` random elements at unique keys from `array` up to the size of `array`.
534 |
535 | Shuffle the array using the [Fisher-Yates algorithm](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle). Use `Array.copyOfRange()` to get the first `n` elements.
536 |
537 | ```java
538 | public static T[] sampleSize(T[] input, int n) {
539 | T[] arr = Arrays.copyOf(input, input.length);
540 | int length = arr.length;
541 | int m = length;
542 | while (m > 0) {
543 | int i = (int) Math.floor(Math.random() * m--);
544 | T tmp = arr[i];
545 | arr[i] = arr[m];
546 | arr[m] = tmp;
547 | }
548 | return Arrays.copyOfRange(arr, 0, n > length ? length : n);
549 | }
550 | ```
551 |
552 | ### shuffle
553 |
554 | Randomizes the order of the values of an array, returning a new array.
555 |
556 | Uses the [Fisher-Yates algorithm](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle) to reorder the elements of the array.
557 |
558 | ```java
559 | public static T[] shuffle(T[] input) {
560 | T[] arr = Arrays.copyOf(input, input.length);
561 | int length = arr.length;
562 | int m = length;
563 | while (m > 0) {
564 | int i = (int) Math.floor(Math.random() * m--);
565 | T tmp = arr[i];
566 | arr[i] = arr[m];
567 | arr[m] = tmp;
568 | }
569 | return arr;
570 | }
571 | ```
572 |
573 | ### similarity
574 |
575 | Returns an array of elements that appear in both arrays.
576 |
577 | Use `Arrays.stream().filter()` to remove values that are not part of `second`, determined using `Arrays.stream().anyMatch()`.
578 |
579 | ```java
580 | public static T[] similarity(T[] first, T[] second) {
581 | return Arrays.stream(first)
582 | .filter(a -> Arrays.stream(second).anyMatch(b -> Objects.equals(a, b)))
583 | // Make a new array of first's runtime type, but empty content:
584 | .toArray(i -> (T[]) Arrays.copyOf(new Object[0], i, first.getClass()));
585 | }
586 | ```
587 |
588 | ### sortedIndex
589 |
590 | Returns the lowest index at which value should be inserted into array in order to maintain its sort order.
591 |
592 | Check if the array is sorted in descending order (loosely). Use `IntStream.range().filter()` to find the appropriate index where the element should be inserted.
593 |
594 | ```java
595 | public static > int sortedIndex(T[] arr, T el) {
596 | boolean isDescending = arr[0].compareTo(arr[arr.length - 1]) > 0;
597 | return IntStream.range(0, arr.length)
598 | .filter(i -> isDescending ? el.compareTo(arr[i]) >= 0 : el.compareTo(arr[i]) <= 0)
599 | .findFirst()
600 | .orElse(arr.length);
601 | }
602 | ```
603 |
604 | ### symmetricDifference
605 |
606 | Returns the symmetric difference between two arrays.
607 |
608 | Create a `Set` from each array, then use `Arrays.stream().filter()` on each of them to only keep values not contained in the other. Finally, concatenate both arrays and create a new array and return it.
609 |
610 | ```java
611 | public static T[] symmetricDifference(T[] first, T[] second) {
612 | Set sA = new HashSet<>(Arrays.asList(first));
613 | Set sB = new HashSet<>(Arrays.asList(second));
614 |
615 | return Stream.concat(
616 | Arrays.stream(first).filter(a -> !sB.contains(a)),
617 | Arrays.stream(second).filter(b -> !sA.contains(b))
618 | ).toArray(i -> (T[]) Arrays.copyOf(new Object[0], i, first.getClass()));
619 | }
620 | ```
621 |
622 | ### tail
623 |
624 | Returns all elements in an array except for the first one.
625 |
626 | Return `Arrays.copyOfRange(1)` if the array's `length` is more than `1`, otherwise, return the whole array.
627 |
628 | ```java
629 | public static T[] tail(T[] arr) {
630 | return arr.length > 1
631 | ? Arrays.copyOfRange(arr, 1, arr.length)
632 | : arr;
633 | }
634 | ```
635 |
636 | ### take
637 |
638 | Returns an array with n elements removed from the beginning.
639 |
640 | ```java
641 | public static T[] take(T[] arr, int n) {
642 | return Arrays.copyOfRange(arr, 0, n);
643 | }
644 | ```
645 |
646 | ### takeRight
647 |
648 | Returns an array with n elements removed from the end.
649 |
650 | Use `Arrays.copyOfRange()` to create a slice of the array with `n` elements taken from the end.
651 |
652 | ```java
653 | public static T[] takeRight(T[] arr, int n) {
654 | return Arrays.copyOfRange(arr, arr.length - n, arr.length);
655 | }
656 | ```
657 |
658 | ### union
659 |
660 | Returns every element that exists in any of the two arrays once.
661 |
662 | Create a `Set` with all values of `a` and `b` and convert to an array.
663 |
664 | ```Java
665 | public static T[] union(T[] first, T[] second) {
666 | Set set = new HashSet<>(Arrays.asList(first));
667 | set.addAll(Arrays.asList(second));
668 | return set.toArray((T[]) Arrays.copyOf(new Object[0], 0, first.getClass()));
669 | }
670 | ```
671 |
672 | ### without
673 |
674 | Filters out the elements of an array, that have one of the specified values.
675 |
676 | Use `Arrays.strean().filter()` to create an array excluding(using `!Arrays.asList(elements).contains()`) all given values.
677 |
678 | ```java
679 | public static T[] without(T[] arr, T... elements) {
680 | List excludeElements = Arrays.asList(elements);
681 | return Arrays.stream(arr)
682 | .filter(el -> !excludeElements.contains(el))
683 | .toArray(i -> (T[]) Arrays.copyOf(new Object[0], i, arr.getClass()));
684 | }
685 | ```
686 |
687 | ### zip
688 |
689 | Creates an array of elements, grouped based on the position in the original arrays.
690 |
691 | ```java
692 | public static List zip(Object[]... arrays) {
693 | OptionalInt max = Arrays.stream(arrays).mapToInt(arr -> arr.length).max();
694 | return IntStream.range(0, max.getAsInt())
695 | .mapToObj(i -> Arrays.stream(arrays)
696 | .map(arr -> i < arr.length ? arr[i] : null)
697 | .toArray())
698 | .collect(Collectors.toList());
699 | }
700 | ```
701 |
702 | ### zipObject
703 |
704 | Given an array of valid property identifiers and an array of values, return an object associating the properties to the values.
705 |
706 | ```java
707 | public static Map zipObject(String[] props, Object[] values) {
708 | return IntStream.range(0, props.length)
709 | .mapToObj(i -> new SimpleEntry<>(props[i], i < values.length ? values[i] : null))
710 | .collect(
711 | HashMap::new, (m, v) -> m.put(v.getKey(), v.getValue()), HashMap::putAll);
712 | }
713 | ```
714 |
715 | ## Maths
716 |
717 | ### average
718 |
719 | Returns the average of an of two or more numbers.
720 |
721 | ```java
722 | public static double average(int[] arr) {
723 | return IntStream.of(arr)
724 | .average()
725 | .orElseThrow(() -> new IllegalArgumentException("Array is empty"));
726 | }
727 | ```
728 |
729 | ### gcd
730 |
731 | Calculates the greatest common denominator (gcd) of an array of numbers.
732 |
733 | Use Arrays.stream().reduce() and the gcd formula (uses recursion) to calculate the greatest common denominator of an array of numbers.
734 |
735 | ```java
736 | public static OptionalInt gcd(int[] numbers) {
737 | return Arrays.stream(numbers)
738 | .reduce((a, b) -> gcd(a, b));
739 | }
740 |
741 | private static int gcd(int a, int b) {
742 | if (b == 0) {
743 | return a;
744 | }
745 | return gcd(b, a % b);
746 | }
747 | ```
748 |
749 | ### lcm
750 |
751 | Calculates the lowest common multiple (lcm) of an array of numbers.
752 |
753 | Use Arrays.stream().reduce() and the lcm formula (uses recursion) to calculate the lowest common multiple of an array of numbers.
754 |
755 | ```java
756 | public static OptionalInt lcm(int[] numbers) {
757 | IntBinaryOperator lcm = (x, y) -> (x * y) / gcd(x, y);
758 | return Arrays.stream(numbers)
759 | .reduce((a, b) -> lcm.applyAsInt(a, b));
760 | }
761 |
762 | private static int gcd(int a, int b) {
763 | if (b == 0) {
764 | return a;
765 | }
766 | return gcd(b, a % b);
767 | }
768 | ```
769 |
770 | ### findNextPositivePowerOfTwo
771 |
772 | Finds the next power of two greater than or equal to the value.
773 |
774 | This method uses left ship operator to shift 1 by the value on the right side. The right side is calculated using the `Integer.numberOfLeadingZeros` method.
775 |
776 | The `Integer.numberOfLeadingZeros` give the number of zeros leading the value. For example, calling `Integer.numberOfLeadingZeros(3)` would give value as 30. This is because 3 is represented in binary as `11`. As integer has 32 bits, so there are 30 bits with 0. The right side of the left shift operator becomes `32-30 = 2`. Left shifting 1 by 2 i.e. `001 << 2` would be `100`. `100` in decimal is equal to `4`.
777 |
778 | ```java
779 | public static int findNextPositivePowerOfTwo(int value) {
780 | return 1 << (32 - Integer.numberOfLeadingZeros(value - 1));
781 | }
782 | ```
783 |
784 | ### isEven
785 |
786 | Check if the number is even.
787 |
788 | This method uses bitwise & operator. The `0b1` is the binary representation of 1. Since, Java 7 you can write binary literals by prefixing them with either `0b` or `0B`. The & operator will return 0 when number is even. For example, `IsEven(4)` would result in `100` `&` `001`. The result of `&` will be `000`.
789 |
790 | ```java
791 | public static boolean isEven(final int value) {
792 | return (value & 0b1) == 0;
793 | }
794 | ```
795 |
796 | ### isPowerOfTwo
797 |
798 | Checks if a value is positive power of two.
799 |
800 | To understand how it works let's assume we made a call `IsPowerOfTwo(4)`.
801 |
802 | As value is greater than 0, so right side of the `&&` operator will be evaluated.
803 |
804 | The result of `(~value + 1)` is equal to value itself. `~100 + 001` => `011 + 001` => `100`. This is equal to value.
805 |
806 | The result of `(value & value)` is value. `100` & `100` => `100`.
807 |
808 | This will value the expression to true as value is equal to value.
809 |
810 | ```Java
811 | public static boolean isPowerOfTwo(final int value) {
812 | return value > 0 && ((value & (~value + 1)) == value);
813 | }
814 | ```
815 |
816 | ### generateRandomInt
817 |
818 | Generate a random integer between `Integer.MIN_VALUE` and `Integer.MAX_VALUE`.
819 |
820 | ```java
821 | public static int generateRandomInt() {
822 | return ThreadLocalRandom.current().nextInt();
823 | }
824 | ```
825 |
826 | ## String
827 |
828 | ### anagrams
829 |
830 | Generates all anagrams of a string (contains duplicates).
831 |
832 | ```java
833 | public static List anagrams(String input) {
834 | if (input.length() <= 2) {
835 | return input.length() == 2
836 | ? Arrays.asList(input, input.substring(1) + input.substring(0, 1))
837 | : Collections.singletonList(input);
838 | }
839 | return IntStream.range(0, input.length())
840 | .mapToObj(i -> new SimpleEntry<>(i, input.substring(i, i + 1)))
841 | .flatMap(entry ->
842 | anagrams(input.substring(0, entry.getKey()) + input.substring(entry.getKey() + 1))
843 | .stream()
844 | .map(s -> entry.getValue() + s))
845 | .collect(Collectors.toList());
846 | }
847 | ```
848 |
849 | ### byteSize
850 |
851 | Returns the length of a string in bytes.
852 |
853 | ```java
854 | public static int byteSize(String input) {
855 | return input.getBytes().length;
856 | }
857 | ```
858 |
859 | ### capitalize
860 |
861 | Capitalizes the first letter of a string.
862 |
863 | ```Java
864 | public static String capitalize(String input, boolean lowerRest) {
865 | return input.substring(0, 1).toUpperCase() +
866 | (lowerRest
867 | ? input.substring(1, input.length()).toLowerCase()
868 | : input.substring(1, input.length()));
869 | }
870 | ```
871 |
872 | ### capitalizeEveryWord
873 |
874 | Capitalizes the first letter of every word in a string.
875 |
876 | ```java
877 | public static String capitalizeEveryWord(final String input) {
878 | return Pattern.compile("\\b(?=\\w)").splitAsStream(input)
879 | .map(w -> capitalize(w, false))
880 | .collect(Collectors.joining());
881 | }
882 | ```
883 |
884 | ### countVowels
885 |
886 | Retuns `number` of vowels in provided string.
887 |
888 | ```java
889 | public static int countVowels(String input) {
890 | return input.replaceAll("[^aeiouAEIOU]", "").length();
891 | }
892 | ```
893 |
894 | ### escapeRegExp
895 |
896 | Escapes a string to use in a regular expression.
897 |
898 | ```java
899 | public static String escapeRegExp(String input) {
900 | return Pattern.quote(input);
901 | }
902 | ```
903 |
904 | ### fromCamelCase
905 |
906 | Converts a string from camelcase.
907 |
908 | ```java
909 | public static String fromCamelCase(String input, String separator) {
910 | return input
911 | .replaceAll("([a-z\\d])([A-Z])", "$1" + separator + "$2")
912 | .toLowerCase();
913 | }
914 | ```
915 |
916 | ### isAbsoluteUrl
917 |
918 | Returns `true` if the given string is an absolute URL, `false` otherwise.
919 |
920 | ```java
921 | public static boolean isAbsoluteUrl(String url) {
922 | return Pattern.compile("^[a-z][a-z0-9+.-]*:").matcher(url).find();
923 | }
924 | ```
925 |
926 | ### isLowerCase
927 |
928 | Checks if a string is lower case.
929 |
930 | ```java
931 | public static boolean isLowerCase(String input) {
932 | return Objects.equals(input, input.toLowerCase());
933 | }
934 | ```
935 |
936 | ### isUpperCase
937 |
938 | Checks if a string is upper case.
939 |
940 | ```java
941 | public static boolean isUpperCase(String input) {
942 | return Objects.equals(input, input.toUpperCase());
943 | }
944 | ```
945 |
946 | ### isPalindrome
947 |
948 | Checks if a string is palindrome.
949 |
950 | ```java
951 | public static boolean isPalindrome(String input) {
952 | String s = input.toLowerCase().replaceAll("[\\W_]", "");
953 | return Objects.equals(
954 | s,
955 | new StringBuilder(s).reverse().toString()
956 | );
957 | }
958 | ```
959 |
960 | ### isNumeric
961 |
962 | Checks if a string is numeric.
963 |
964 | ```java
965 | public static boolean isNumeric(final String input) {
966 | return IntStream.range(0, input.length())
967 | .allMatch(i -> Character.isDigit(input.charAt(i)));
968 | }
969 | ```
970 |
971 | ### mask
972 |
973 | Replaces all but the last `num` of characters with the specified mask character.
974 |
975 | ```Java
976 | public static String mask(String input, int num, String mask) {
977 | int length = input.length();
978 | return num > 0
979 | ?
980 | input.substring(0, length - num).replaceAll(".", mask)
981 | + input.substring(length - num)
982 | :
983 | input.substring(0, Math.negateExact(num))
984 | + input.substring(Math.negateExact(num), length).replaceAll(".", mask);
985 | }
986 | ```
987 |
988 | ### reverseString
989 |
990 | Reverses a string.
991 |
992 | ```java
993 | public static String reverseString(String input) {
994 | return new StringBuilder(input).reverse().toString();
995 | }
996 | ```
997 |
998 | ### sortCharactersInString
999 |
1000 | Alphabetically sorts the characters in a string.
1001 |
1002 | ```java
1003 | public static String sortCharactersInString(String input) {
1004 | return Arrays.stream(input.split("")).sorted().collect(Collectors.joining());
1005 | }
1006 | ```
1007 |
1008 | ### splitLines
1009 |
1010 | Splits a multiline string into an array of lines.
1011 |
1012 | ```java
1013 | public static String[] splitLines(String input) {
1014 | return input.split("\\r?\\n");
1015 | }
1016 | ```
1017 |
1018 | ### toCamelCase
1019 |
1020 | Converts a string to camelcase.
1021 |
1022 | ```java
1023 | public static String toCamelCase(String input) {
1024 | 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);
1025 | List matchedParts = new ArrayList<>();
1026 | while (matcher.find()) {
1027 | matchedParts.add(matcher.group(0));
1028 | }
1029 | String s = matchedParts.stream()
1030 | .map(x -> x.substring(0, 1).toUpperCase() + x.substring(1).toLowerCase())
1031 | .collect(Collectors.joining());
1032 | return s.substring(0, 1).toLowerCase() + s.substring(1);
1033 | }
1034 |
1035 | ```
1036 |
1037 | ### toKebabCase
1038 |
1039 | Converts a string to kebab case.
1040 |
1041 | ```java
1042 | public static String toKebabCase(String input) {
1043 | 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);
1044 | List matchedParts = new ArrayList<>();
1045 | while (matcher.find()) {
1046 | matchedParts.add(matcher.group(0));
1047 | }
1048 | return matchedParts.stream()
1049 | .map(String::toLowerCase)
1050 | .collect(Collectors.joining("-"));
1051 | }
1052 | ```
1053 |
1054 | ### match
1055 |
1056 | ```java
1057 | public static List match(String input, String regex) {
1058 | Matcher matcher = Pattern.compile(regex).matcher(input);
1059 | List matchedParts = new ArrayList<>();
1060 | while (matcher.find()) {
1061 | matchedParts.add(matcher.group(0));
1062 | }
1063 | return matchedParts;
1064 | }
1065 |
1066 | ```
1067 |
1068 | ### toSnakeCase
1069 |
1070 | Converts a string to snake case.
1071 |
1072 | ```java
1073 | public static String toSnakeCase(String input) {
1074 | 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);
1075 | List matchedParts = new ArrayList<>();
1076 | while (matcher.find()) {
1077 | matchedParts.add(matcher.group(0));
1078 | }
1079 | return matchedParts.stream()
1080 | .map(String::toLowerCase)
1081 | .collect(Collectors.joining("_"));
1082 | }
1083 | ```
1084 |
1085 | ### truncateString
1086 |
1087 | Truncates a string up to a specified length.
1088 |
1089 | ```java
1090 | public static String truncateString(String input, int num) {
1091 | return input.length() > num
1092 | ? input.substring(0, num > 3 ? num - 3 : num) + "..."
1093 | : input;
1094 | }
1095 | ```
1096 |
1097 | ### words
1098 |
1099 | Converts a given string into an array of words.
1100 |
1101 | ```Java
1102 | public static String[] words(String input) {
1103 | return Arrays.stream(input.split("[^a-zA-Z-]+"))
1104 | .filter(s -> !s.isEmpty())
1105 | .toArray(String[]::new);
1106 | }
1107 | ```
1108 |
1109 | ### stringToIntegers
1110 |
1111 | Converts a String of numbers separated by space to an array of ints.
1112 |
1113 | ```Java
1114 | public static int[] stringToIntegers(String numbers) {
1115 | return Arrays.stream(numbers.split(" ")).mapToInt(Integer::parseInt).toArray();
1116 | }
1117 | ```
1118 |
1119 |
1120 | ## IO
1121 |
1122 | ### convertInputStreamToString
1123 |
1124 | Converts InputStream to a String.
1125 |
1126 | ```java
1127 | public static String convertInputStreamToString(final InputStream in) throws IOException {
1128 | ByteArrayOutputStream result = new ByteArrayOutputStream();
1129 | byte[] buffer = new byte[1024];
1130 | int length;
1131 | while ((length = in.read(buffer)) != -1) {
1132 | result.write(buffer, 0, length);
1133 | }
1134 | return result.toString(StandardCharsets.UTF_8.name());
1135 | }
1136 | ```
1137 |
1138 | ### readFileAsString
1139 |
1140 | Reads content of a file to a String
1141 |
1142 | ```java
1143 | public String readFileAsString(Path path) throws IOException {
1144 | return new String(Files.readAllBytes(path));
1145 | }
1146 | ```
1147 |
1148 | ### getCurrentWorkingDirectoryPath
1149 |
1150 | ```java
1151 | public static String getCurrentWorkingDirectoryPath() {
1152 | return FileSystems.getDefault().getPath("").toAbsolutePath().toString();
1153 | }
1154 | ```
1155 |
1156 | ### tmpDirName
1157 |
1158 | Returns the value of `java.io.tmpdir` system property. It appends separator if not present at the end.
1159 |
1160 | ```java
1161 | public static String tmpDirName() {
1162 | String tmpDirName = System.getProperty("java.io.tmpdir");
1163 | if (!tmpDirName.endsWith(File.separator)) {
1164 | tmpDirName += File.separator;
1165 | }
1166 |
1167 | return tmpDirName;
1168 | }
1169 | ```
1170 |
1171 | ## Exception
1172 |
1173 | ### stackTraceAsString
1174 |
1175 | Converts exception stack trace to a String.
1176 |
1177 | ```java
1178 | public static String stackTraceAsString(final Throwable throwable) {
1179 | final StringWriter sw = new StringWriter();
1180 | throwable.printStackTrace(new PrintWriter(sw));
1181 | return sw.toString();
1182 | }
1183 | ```
1184 | ## System
1185 |
1186 | ### osName
1187 |
1188 | Gets the name of the operating system as a lower case String.
1189 |
1190 | ```java
1191 | public static String osName() {
1192 | return System.getProperty("os.name").toLowerCase();
1193 | }
1194 | ```
1195 |
1196 | ### isDebuggerEnabled
1197 |
1198 | Checks if debugger is attached to the JVM.
1199 |
1200 | ```java
1201 | public static boolean isDebuggerAttached() {
1202 | final RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
1203 | return runtimeMXBean.getInputArguments()
1204 | .stream()
1205 | .anyMatch(arg -> arg.contains("-agentlib:jdwp"));
1206 |
1207 | }
1208 | ```
1209 |
1210 | ## Class
1211 |
1212 | ### getAllInterfaces
1213 |
1214 | This methods returns all the interfaces implemented by the given class and its superclasses.
1215 |
1216 | This method works by concatenating two streams. The first stream is recursively built by creating a stream with the interface and all the interfaces implemented by the the interface. The second stream does the same for the super classes. The result is the concatenation of the two streams after removing the duplicates.
1217 |
1218 | ```java
1219 | public static List> getAllInterfaces(Class cls) {
1220 | return Stream.concat(
1221 | Arrays.stream(cls.getInterfaces()).flatMap(intf ->
1222 | Stream.concat(Stream.of(intf), getAllInterfaces(intf).stream())),
1223 | cls.getSuperclass() == null ? Stream.empty() : getAllInterfaces(cls.getSuperclass()).stream()
1224 | ).distinct().collect(Collectors.toList());
1225 | }
1226 | ```
1227 |
1228 | ### isInnerClass
1229 |
1230 | This method checks if the specified class is an inner class or static nested class
1231 |
1232 | ```Java
1233 | public static boolean isInnerClass(final Class cls) {
1234 | return cls != null && cls.getEnclosingClass() != null;
1235 | }
1236 | ```
1237 |
1238 | ## Enum
1239 |
1240 | ### getEnumMap
1241 |
1242 | Converts to enum to Map where key is the name and value is Enum itself.
1243 |
1244 | ```java
1245 | public static > Map getEnumMap(final Class enumClass) {
1246 | return Arrays.stream(enumClass.getEnumConstants())
1247 | .collect(Collectors.toMap(Enum::name, Function.identity()));
1248 | }
1249 | ```
1250 |
1251 | ## In News
1252 |
1253 | 1. Jetbrains Java Annotated Monthly covered little-java-functions in their [January newsletter](https://blog.jetbrains.com/idea/2018/01/java-annotated-monthly-january-2018/).
1254 | 2. JavaChannel podcast covered little-java-functions in their [episode 11](https://javachannel.org/posts/javachannels-interesting-links-podcast-episode-11/).
1255 | 3. little-java-functions was Github trending repository on 8th January 2018.
1256 |
1257 | ## Thanks
1258 |
1259 | This project started as a Java fork of [30-seconds-of-code](https://github.com/Chalarangelo/30-seconds-of-code). Thanks to the project collaborators for the effort.
1260 |
--------------------------------------------------------------------------------