30 seconds of java
1.0.0
Koleksi fungsi java 8 kecil yang berguna yang dapat Anda pahami dengan cepat.
chunkcountOccurrencesdeepFlattendifferencedifferenceWithdistinctValuesOfArraydropElementsdropRighteveryNthfilterNonUniqueflattenflattenDepthgroupByheadinitialinitializeArrayWithRangeinitializeArrayWithValuesintersectionisSortedjoinnthElementpickreducedFilterremovesamplesampleSizeshufflesimilaritysortedIndexsymmetricDifferencetailtaketakeRightunionwithoutzipzipObjectaveragegcdlcmfindNextPositivePowerOfTwoisEvenisPowerOfTwogenerateRandomIntanagramsbyteSizecapitalizecapitalizeEveryWordcountVowelsescapeRegExpfromCamelCaseisAbsoluteURLisLowerCaseisUpperCaseisPalindromeisNumericmaskreverseStringsortCharactersInStringsplitLinestoCamelCasetoKebabCasematchtoSnakeCasetruncateStringwordsstringToIntegersconvertInputStreamToStringreadFileAsStringgetCurrentWorkingDirectoryPathtmpDirNamestackTraceAsStringosNameisDebuggerEnabledgetAllInterfacesIsInnerClassgetEnumMapPotongan array ke array yang lebih kecil dengan ukuran tertentu.
public static int [][] chunk ( int [] numbers , int size ) {
return IntStream . iterate ( 0 , i -> i + size )
. limit (( long ) Math . ceil (( double ) numbers . length / size ))
. mapToObj ( cur -> Arrays . copyOfRange ( numbers , cur , cur + size > numbers . length ? numbers . length : cur + size ))
. toArray ( int [][]:: new );
} public static < T > 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 ()));
}Menghitung kejadian nilai dalam suatu array.
Gunakan arrays.stream (). Filter (). Count () untuk menghitung jumlah total nilai yang sama dengan nilai yang ditentukan.
public static long countOccurrences ( int [] numbers , int value ) {
return Arrays . stream ( numbers )
. filter ( number -> number == value )
. count ();
}Mendalam meratakan array.
Gunakan rekursi. Gunakan 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 ();
}Mengembalikan perbedaan antara dua array.
Buat satu set dari B, lalu gunakan arrays.stream (). Filter () pada A untuk hanya menjaga nilai tidak terkandung dalam 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 ();
}Menyaring semua nilai dari array yang fungsi pembanding tidak mengembalikan true.
Pembanding untuk INT diimplementasikan menggunakan fungsi Intbinaryoperator.
Menggunakan arrays.stream (). Filter dan arrays.stream (). Nonematch () untuk menemukan nilai yang sesuai.
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 ();
}Mengembalikan semua nilai yang berbeda dari suatu array.
Menggunakan arrays.stream (). Distance () untuk membuang semua nilai duplikat.
public static int [] distinctValuesOfArray ( int [] elements ) {
return Arrays . stream ( elements ). distinct (). toArray ();
}Menghapus elemen dalam array sampai fungsi yang dilewati mengembalikan true. Mengembalikan elemen yang tersisa di array.
Loop melalui array, menggunakan arrays.copyofrange () untuk menjatuhkan elemen pertama dari array sampai nilai yang dikembalikan dari fungsi benar. Mengembalikan elemen yang tersisa.
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 ;
}Mengembalikan array baru dengan N elemen yang dihapus dari kanan.
Periksa apakah N lebih pendek dari array yang diberikan dan gunakan array.copyofrange () untuk mengirisnya atau mengembalikan array kosong.
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 ];
}Mengembalikan setiap elemen ke -n dalam array.
Gunakan intstream.range (). Filter () untuk membuat array baru yang berisi setiap elemen ke -n dari array yang diberikan.
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 ();
}Temukan indeks elemen dalam array. Return -1 Dalam hal elemen tidak ada.
Menggunakan intstream.range (). Filter () untuk menemukan indeks elemen dalam array.
public static int indexOf ( int [] elements , int el ) {
return IntStream . range ( 0 , elements . length )
. filter ( idx -> elements [ idx ] == el )
. findFirst ()
. orElse (- 1 );
}Temukan indeks elemen terakhir dalam array. Return -1 Dalam hal elemen tidak ada.
Menggunakan intstream.iterate (). Limit (). Filter () untuk menemukan indeks elemen dalam array.
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 );
}Menyaring nilai-nilai non-unik dalam suatu array.
Gunakan arrays.stream (). Filter () untuk array yang hanya berisi nilai unik.
public static int [] filterNonUnique ( int [] elements ) {
return Arrays . stream ( elements )
. filter ( el -> indexOf ( elements , el ) == lastIndexOf ( elements , el ))
. toArray ();
}Meratakan array.
Gunakan arrays.stream (). Flatmaptoint (). Toarray () untuk membuat array baru.
public static int [] flatten ( Object [] elements ) {
return Arrays . stream ( elements )
. flatMapToInt ( el -> el instanceof int []
? Arrays . stream (( int []) el )
: IntStream . of (( int ) el )
). toArray ();
}Meratakan array hingga kedalaman yang ditentukan.
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 ();
}Mengelompokkan elemen -elemen array berdasarkan fungsi yang diberikan.
Menggunakan arrays.stream (). Collect (collector.groupingby ()) untuk dikelompokkan berdasarkan fungsi pengelompokan.
public static < T , R > Map < R , List < T >> groupBy ( T [] elements , Function < T , R > func ) {
return Arrays . stream ( elements ). collect ( Collectors . groupingBy ( func ));
}Mengembalikan semua elemen array kecuali yang terakhir. Gunakan arrays.copyofrange () untuk mengembalikan semua kecuali yang terakhir
public static < T > T [] initial ( T [] elements ) {
return Arrays . copyOfRange ( elements , 0 , elements . length - 1 );
}Menginisialisasi array yang berisi angka -angka dalam kisaran yang ditentukan di mana start dan end inklusif.
public static int [] initializeArrayWithRange ( int end , int start ) {
return IntStream . rangeClosed ( start , end ). toArray ();
}Menginisialisasi dan mengisi array dengan nilai yang ditentukan.
public static int [] initializeArrayWithValues ( int n , int value ) {
return IntStream . generate (() -> value ). limit ( n ). toArray ();
}Mengembalikan daftar elemen yang ada di kedua array.
Buat set dari kedua, lalu gunakan arrays.stream (). Filter () pada A untuk hanya menjaga nilai yang terkandung dalam 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 ();
} Pengembalian 1 Jika array diurutkan dalam urutan naik, -1 jika diurutkan dalam urutan menurun atau 0 jika tidak diurutkan.
Hitung direction pemesanan untuk dua elemen pertama. Gunakan untuk Loop untuk mengulangi item array dan membandingkannya berpasangan. Kembalikan 0 jika direction berubah atau direction jika elemen terakhir tercapai.
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 ;
}Bergabung dengan semua elemen array ke dalam string dan mengembalikan string ini. Menggunakan pemisah dan pemisah akhir.
Gunakan intstream.range ke indeks zip dengan item array. Kemudian, gunakan Stream.reduce untuk menggabungkan elemen menjadi string.
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 );
}Mengembalikan elemen ke -n dari suatu array.
Gunakan Arrays.copyOfRange() untuk mendapatkan array yang berisi elemen ke -n di tempat pertama.
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 ];
}Memilih pasangan nilai kunci yang sesuai dengan kunci yang diberikan dari suatu objek.
Gunakan Arrays.stream untuk memfilter semua tombol yang ada di arr . Kemudian, konversi semua kunci yang ada menjadi peta menggunakan Collectors.toMap .
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 ));
}Saring array objek berdasarkan kondisi sementara juga menyaring tombol yang tidak ditentukan.
Gunakan Arrays.stream().filter() untuk memfilter array berdasarkan predikat fn sehingga mengembalikan objek yang kondisinya benar. Untuk setiap objek peta yang difilter, buat peta baru dengan kunci yang ada di keys . Akhirnya, kumpulkan semua objek peta ke dalam array.
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 );
}Mengembalikan elemen acak dari array.
Gunakan Math.random() untuk menghasilkan angka acak, kalikan dengan length dan bundarnya ke seluruh bilangan terdekat menggunakan Math.floor() . Metode ini juga berfungsi dengan string.
public static < T > T sample ( T [] arr ) {
return arr [( int ) Math . floor ( Math . random () * arr . length )];
} Mendapat n elemen acak pada kunci unik dari array hingga ukuran array .
Ambil array menggunakan algoritma fisher-yates. Gunakan Array.copyOfRange() untuk mendapatkan elemen n pertama.
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 );
}Mengacak urutan nilai array, mengembalikan array baru.
Menggunakan algoritma Fisher-Yates untuk menyusun ulang elemen array.
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 ;
}Mengembalikan berbagai elemen yang muncul di kedua array.
Gunakan Arrays.stream().filter() untuk menghapus nilai yang bukan bagian dari second , ditentukan menggunakan Arrays.stream().anyMatch() .
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 ()));
}Mengembalikan indeks terendah di mana nilai harus dimasukkan ke dalam array untuk mempertahankan urutan pengurutannya.
Periksa apakah array diurutkan dalam urutan menurun (secara longgar). Gunakan IntStream.range().filter() untuk menemukan indeks yang sesuai di mana elemen harus dimasukkan.
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 );
}Mengembalikan perbedaan simetris antara dua array.
Buat satu Set dari setiap array, lalu gunakan Arrays.stream().filter() pada masing -masing untuk hanya menjaga nilai tidak terkandung di yang lain. Akhirnya, menggabungkan kedua array dan membuat array baru dan mengembalikannya.
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 ()));
}Mengembalikan semua elemen dalam array kecuali yang pertama.
Return Arrays.copyOfRange(1) Jika length array lebih dari 1 , jika tidak, kembalikan seluruh array.
public static < T > T [] tail ( T [] arr ) {
return arr . length > 1
? Arrays . copyOfRange ( arr , 1 , arr . length )
: arr ;
}Mengembalikan array dengan N elemen yang dihapus dari awal.
public static < T > T [] take ( T [] arr , int n ) {
return Arrays . copyOfRange ( arr , 0 , n );
}Mengembalikan array dengan N elemen yang dihapus dari ujung.
Gunakan Arrays.copyOfRange() untuk membuat sepotong array dengan elemen n yang diambil dari akhir.
public static < T > T [] takeRight ( T [] arr , int n ) {
return Arrays . copyOfRange ( arr , arr . length - n , arr . length );
}Mengembalikan setiap elemen yang ada di salah satu dari dua array sekali.
Buat Set dengan semua nilai a dan b dan konversi ke array.
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 ()));
}Menyaring elemen -elemen array, yang memiliki salah satu nilai yang ditentukan.
Gunakan Arrays.strean().filter() untuk membuat array tidak termasuk (menggunakan !Arrays.asList(elements).contains() ) semua nilai yang diberikan.
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 ()));
}Membuat serangkaian elemen, dikelompokkan berdasarkan posisi dalam array asli.
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 ());
}Diberikan serangkaian pengidentifikasi properti yang valid dan array nilai, kembalikan objek yang mengaitkan properti dengan nilai.
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 );
}Mengembalikan rata -rata dari dua angka atau lebih.
public static double average ( int [] arr ) {
return IntStream . of ( arr )
. average ()
. orElseThrow (() -> new IllegalArgumentException ( "Array is empty" ));
}Menghitung denominator umum terbesar (GCD) dari berbagai angka.
Gunakan arrays.stream (). Reduksi () dan rumus GCD (menggunakan rekursi) untuk menghitung denominator umum terbesar dari array angka.
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 );
}Menghitung multiple umum terendah (LCM) dari array angka.
Gunakan arrays.stream (). Reduksi () dan rumus LCM (menggunakan rekursi) untuk menghitung kelipatan umum terendah dari array angka.
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 );
}Menemukan kekuatan berikutnya dari dua lebih dari atau sama dengan nilainya.
Metode ini menggunakan operator kapal kiri untuk menggeser 1 dengan nilai di sisi kanan. Sisi kanan dihitung menggunakan metode Integer.numberOfLeadingZeros .
Integer.numberOfLeadingZeros memberikan jumlah nol yang memimpin nilai. Misalnya, panggilan Integer.numberOfLeadingZeros(3) akan memberikan nilai sebagai 30. Ini karena 3 diwakili dalam biner sebagai 11 . Karena bilangan bulat memiliki 32 bit, jadi ada 30 bit dengan 0. Sisi kanan operator shift kiri menjadi 32-30 = 2 . Kiri bergeser 1 dengan 2 yaitu 001 << 2 akan menjadi 100 . 100 dalam desimal sama dengan 4 .
public static int findNextPositivePowerOfTwo ( int value ) {
return 1 << ( 32 - Integer . numberOfLeadingZeros ( value - 1 ));
}Periksa apakah nomornya rata.
Metode ini menggunakan Bitwise & Operator. 0b1 adalah representasi biner dari 1. Karena, Java 7 Anda dapat menulis literal biner dengan mengawali mereka dengan 0b atau 0B . The & Operator akan mengembalikan 0 saat angka bahkan. Misalnya, IsEven(4) akan menghasilkan 100 & 001 . Hasil & akan menjadi 000 .
public static boolean isEven ( final int value ) {
return ( value & 0b1) == 0 ;
}Memeriksa apakah nilai adalah kekuatan positif dua.
Untuk memahami cara kerjanya, mari kita asumsikan kami membuat panggilan IsPowerOfTwo(4) .
Karena nilai lebih besar dari 0, maka sisi kanan operator && akan dievaluasi.
Hasil (~value + 1) sama dengan nilai itu sendiri. ~100 + 001 => 011 + 001 => 100 . Ini sama dengan nilai.
Hasil (value & value) adalah nilai. 100 & 100 => 100 .
Ini akan menghargai ekspresi ke true karena nilai sama dengan nilai.
public static boolean isPowerOfTwo ( final int value ) {
return value > 0 && (( value & (~ value + 1 )) == value );
} Menghasilkan bilangan bulat acak antara Integer.MIN_VALUE dan Integer.MAX_VALUE .
public static int generateRandomInt () {
return ThreadLocalRandom . current (). nextInt ();
}Menghasilkan semua anagram dari suatu string (berisi duplikat).
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 ());
}Mengembalikan panjang string dalam byte.
public static int byteSize ( String input ) {
return input . getBytes (). length ;
}Memanfaatkan huruf pertama dari suatu string.
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 ()));
}Memanfaatkan huruf pertama dari setiap kata dalam sebuah string.
public static String capitalizeEveryWord ( final String input ) {
return Pattern . compile ( " \ b(?= \ w)" ). splitAsStream ( input )
. map ( w -> capitalize ( w , false ))
. collect ( Collectors . joining ());
} Retuns number vokal di string yang disediakan.
public static int countVowels ( String input ) {
return input . replaceAll ( "[^aeiouAEIOU]" , "" ). length ();
}Lolos dari string untuk digunakan dalam ekspresi reguler.
public static String escapeRegExp ( String input ) {
return Pattern . quote ( input );
}Konversi string dari Camelcase.
public static String fromCamelCase ( String input , String separator ) {
return input
. replaceAll ( "([a-z \ d])([A-Z])" , "$1" + separator + "$2" )
. toLowerCase ();
} Mengembalikan true jika string yang diberikan adalah URL absolut, false sebaliknya.
public static boolean isAbsoluteUrl ( String url ) {
return Pattern . compile ( "^[a-z][a-z0-9+.-]*:" ). matcher ( url ). find ();
}Memeriksa apakah string adalah huruf kecil.
public static boolean isLowerCase ( String input ) {
return Objects . equals ( input , input . toLowerCase ());
}Periksa apakah string adalah huruf besar.
public static boolean isUpperCase ( String input ) {
return Objects . equals ( input , input . toUpperCase ());
}Memeriksa apakah string adalah palindrome.
public static boolean isPalindrome ( String input ) {
String s = input . toLowerCase (). replaceAll ( "[ \ W_]" , "" );
return Objects . equals (
s ,
new StringBuilder ( s ). reverse (). toString ()
);
}Memeriksa apakah string adalah numerik.
public static boolean isNumeric ( final String input ) {
return IntStream . range ( 0 , input . length ())
. allMatch ( i -> Character . isDigit ( input . charAt ( i )));
} Menggantikan semua kecuali num karakter terakhir dengan karakter topeng yang ditentukan.
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 );
}Membalikkan string.
public static String reverseString ( String input ) {
return new StringBuilder ( input ). reverse (). toString ();
}Secara abjad mengurutkan karakter dalam string.
public static String sortCharactersInString ( String input ) {
return Arrays . stream ( input . split ( "" )). sorted (). collect ( Collectors . joining ());
}Membagi string multiline menjadi array garis.
public static String [] splitLines ( String input ) {
return input . split ( " \ r? \ n" );
}Mengubah string ke Camelcase.
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 );
}Konversi string ke kasus 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 ( "-" ));
} 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 ;
}Mengonversi casing string ke ular.
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 ( "_" ));
}Memotong string hingga panjang yang ditentukan.
public static String truncateString ( String input , int num ) {
return input . length () > num
? input . substring ( 0 , num > 3 ? num - 3 : num ) + "..."
: input ;
}Mengubah string yang diberikan menjadi berbagai kata.
public static String [] words ( String input ) {
return Arrays . stream ( input . split ( "[^a-zA-Z-]+" ))
. filter ( s -> ! s . isEmpty ())
. toArray ( String []:: new );
}Konversi serangkaian angka yang dipisahkan oleh ruang menjadi array ints.
public static int [] stringToIntegers ( String numbers ) {
return Arrays . stream ( numbers . split ( " " )). mapToInt ( Integer :: parseInt ). toArray ();
}Konversi inputstream ke string.
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 ());
}Membaca konten file ke string
public String readFileAsString ( Path path ) throws IOException {
return new String ( Files . readAllBytes ( path ));
} public static String getCurrentWorkingDirectoryPath () {
return FileSystems . getDefault (). getPath ( "" ). toAbsolutePath (). toString ();
} Mengembalikan nilai properti sistem java.io.tmpdir . Ini menambahkan pemisah jika tidak ada di akhir.
public static String tmpDirName () {
String tmpDirName = System . getProperty ( "java.io.tmpdir" );
if (! tmpDirName . endsWith ( File . separator )) {
tmpDirName += File . separator ;
}
return tmpDirName ;
}Konversi Pengecualian Stack Trace ke String.
public static String stackTraceAsString ( final Throwable throwable ) {
final StringWriter sw = new StringWriter ();
throwable . printStackTrace ( new PrintWriter ( sw ));
return sw . toString ();
}Mendapatkan nama sistem operasi sebagai string case kecil.
public static String osName () {
return System . getProperty ( "os.name" ). toLowerCase ();
}Periksa apakah debugger dilampirkan ke JVM.
public static boolean isDebuggerAttached () {
final RuntimeMXBean runtimeMXBean = ManagementFactory . getRuntimeMXBean ();
return runtimeMXBean . getInputArguments ()
. stream ()
. anyMatch ( arg -> arg . contains ( "-agentlib:jdwp" ));
}Metode ini mengembalikan semua antarmuka yang diimplementasikan oleh kelas yang diberikan dan superclassesnya.
Metode ini berfungsi dengan menggabungkan dua aliran. Aliran pertama dibangun secara rekursif dengan membuat aliran dengan antarmuka dan semua antarmuka yang diimplementasikan oleh antarmuka. Aliran kedua melakukan hal yang sama untuk kelas super. Hasilnya adalah gabungan dari dua aliran setelah menghapus duplikat.
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 ());
}Metode ini memeriksa apakah kelas yang ditentukan adalah kelas dalam atau kelas bersarang statis
public static boolean isInnerClass ( final Class <?> cls ) {
return cls != null && cls . getEnclosingClass () != null ;
}Konversi ke enum ke peta di mana kunci adalah nama dan nilainya enum itu sendiri.
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 ()));
}Proyek ini dimulai sebagai garpu Java dari kode 30 detik. Terima kasih kepada kolaborator proyek atas upaya ini.
