30 seconds of java
1.0.0
Kuratierte Sammlung nützlicher kleiner Java 8 -Funktionen, die Sie schnell verstehen können.
chunkcountOccurrencesdeepFlattendifferencedifferenceWithdistinctValuesOfArraydropElementsdropRighteveryNthfilterNonUniqueflattenflattenDepthgroupByheadinitialinitializeArrayWithRangeinitializeArrayWithValuesintersectionisSortedjoinnthElementpickreducedFilterremovesamplesampleSizeshufflesimilaritysortedIndexsymmetricDifferencetailtaketakeRightunionwithoutzipzipObjectaveragegcdlcmfindNextPositivePowerOfTwoisEvenisPowerOfTwogenerateRandomIntanagramsbyteSizecapitalizecapitalizeEveryWordcountVowelsescapeRegExpfromCamelCaseisAbsoluteURLisLowerCaseisUpperCaseisPalindromeisNumericmaskreverseStringsortCharactersInStringsplitLinestoCamelCasetoKebabCasematchtoSnakeCasetruncateStringwordsstringToIntegersconvertInputStreamToStringreadFileAsStringgetCurrentWorkingDirectoryPathtmpDirNamestackTraceAsStringosNameisDebuggerEnabledgetAllInterfacesIsInnerClassgetEnumMapSteckt ein Array in kleinere Arrays der angegebenen Größe.
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 ()));
}Zählt das Ereignis eines Wertes in einem Array.
Verwenden Sie Arrays.stream (). Filter (). Count (), um die Gesamtzahl der Werte zu zählen, die dem angegebenen Wert entsprechen.
public static long countOccurrences ( int [] numbers , int value ) {
return Arrays . stream ( numbers )
. filter ( number -> number == value )
. count ();
}Deep flacht ein Array.
Verwenden Sie Rekursion. Verwenden Sie 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 ();
}Gibt den Unterschied zwischen zwei Arrays zurück.
Erstellen Sie einen Satz aus B und verwenden Sie dann Arrays.stream () filter () auf a, um nur die Werte nicht in b enthalten zu halten.
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 ();
}Filtert alle Werte aus einem Array, für das die Komparatorfunktion nicht true zurückgibt.
Der Komparator für INT wird mithilfe der IntBinaryoperator -Funktion implementiert.
Verwendet Arrays.Stream (). Filter und Arrays.Stream (). Nonematch (), um die entsprechenden Werte zu finden.
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 ();
}Gibt alle unterschiedlichen Werte eines Arrays zurück.
Verwendet Arrays.
public static int [] distinctValuesOfArray ( int [] elements ) {
return Arrays . stream ( elements ). distinct (). toArray ();
}Entfernt Elemente in einem Array, bis die übergebene Funktion wahr zurückgibt. Gibt die verbleibenden Elemente im Array zurück.
Schleifen Sie durch das Array mit Arrays. Gibt die verbleibenden Elemente zurück.
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 ;
}Gibt ein neues Array mit N -Elementen zurück, die von rechts entfernt wurden.
Überprüfen Sie, ob n kürzer als das angegebene Array ist, und verwenden Sie Array.CopyofRange (), um es entsprechend zu schneiden oder ein leeres Array zurückzugeben.
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 ];
}Gibt jedes nte Element in einem Array zurück.
Verwenden Sie intstream.range (). Filter (), um ein neues Array zu erstellen, das jedes nte Element eines bestimmten Arrays enthält.
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 ();
}Finden Sie Index des Elements im Array. Rückgabe -1 falls Element nicht existiert.
Verwendet intstream.range (). Filter (), um den Index des Elements im Array zu finden.
public static int indexOf ( int [] elements , int el ) {
return IntStream . range ( 0 , elements . length )
. filter ( idx -> elements [ idx ] == el )
. findFirst ()
. orElse (- 1 );
}Finden Sie den letzten Elementindex im Array. Rückgabe -1 falls Element nicht existiert.
Verwendet IntStream.Eterate (). Limit (). Filter (), um den Index des Elements im Array zu finden.
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 );
}Filtert die nicht eindeutigen Werte in einem Array.
Verwenden Sie Arrays.stream (). Filter () für ein Array, das nur die eindeutigen Werte enthält.
public static int [] filterNonUnique ( int [] elements ) {
return Arrays . stream ( elements )
. filter ( el -> indexOf ( elements , el ) == lastIndexOf ( elements , el ))
. toArray ();
}Flach ein Array.
Verwenden Sie Arrays.
public static int [] flatten ( Object [] elements ) {
return Arrays . stream ( elements )
. flatMapToInt ( el -> el instanceof int []
? Arrays . stream (( int []) el )
: IntStream . of (( int ) el )
). toArray ();
}Flacht ein Array bis zur angegebenen Tiefe.
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 ();
}Gruppiert die Elemente eines Arrays basierend auf der angegebenen Funktion.
Verwendet Arrays.Stream (). Sammeln (sammel.groupingby ()), um basierend auf der Gruppierungsfunktion zu gruppieren.
public static < T , R > Map < R , List < T >> groupBy ( T [] elements , Function < T , R > func ) {
return Arrays . stream ( elements ). collect ( Collectors . groupingBy ( func ));
}Gibt alle Elemente eines Arrays außer dem letzten zurück. Verwenden Sie Arrays.copyofrange (), um alle außer dem letzten zurückzugeben
public static < T > T [] initial ( T [] elements ) {
return Arrays . copyOfRange ( elements , 0 , elements . length - 1 );
}Initialisiert ein Array, das die Zahlen im angegebenen Bereich enthält, in dem Start und Ende inklusive sind.
public static int [] initializeArrayWithRange ( int end , int start ) {
return IntStream . rangeClosed ( start , end ). toArray ();
}Initialisiert und füllt ein Array mit den angegebenen Werten.
public static int [] initializeArrayWithValues ( int n , int value ) {
return IntStream . generate (() -> value ). limit ( n ). toArray ();
}Gibt eine Liste von Elementen zurück, die in beiden Arrays existieren.
Erstellen Sie einen Satz aus der zweiten und verwenden Sie dann Arrays.stream (). Filter () auf a, um nur die in b enthaltenen Werte zu halten.
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 ();
} Gibt 1 zurück, wenn das Array in aufsteigender Reihenfolge sortiert ist, -1 , wenn es in absteigender Reihenfolge sortiert ist oder 0 , wenn es nicht sortiert ist.
Berechnen Sie die direction für die ersten beiden Elemente. Verwenden Sie für die Schleife, um Array -Elemente zu iterieren, und vergleichen Sie sie paarweise. Geben Sie 0 zurück, wenn sich die direction ändert oder die direction , wenn das letzte Element erreicht ist.
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 ;
}Verbindet alle Elemente eines Arrays in eine Zeichenfolge und gibt diese Zeichenfolge zurück. Verwendet ein Trennzeichen und ein Endabscheider.
Verwenden Sie mit dem Array -Element intstream.Range, um den Reißverschluss index. Verwenden Sie dann Stream.reduce , um Elemente zu einer Schnur zu kombinieren.
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 );
}Gibt das nte Element eines Arrays zurück.
Verwenden Sie Arrays.copyOfRange() .
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 ];
}Wählt die Schlüsselwertpaare aus, die den angegebenen Schlüssel aus einem Objekt entsprechen.
Verwenden Sie Arrays.stream , um alle im arr vorhandenen Schlüssel zu filtern. Konvertieren Sie dann alle vorhandenen Schlüssel mit Collectors.toMap in eine Karte.
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 ));
}Filtern Sie eine Anordnung von Objekten basierend auf einer Bedingung und filtern Sie gleichzeitig nicht spezifizierte Schlüssel.
Verwenden fn Arrays.stream().filter() Erstellen Sie für jedes gefilterte Kartenobjekt eine neue Karte mit Tasten in den keys . Sammeln Sie zum Schluss das gesamte Kartenobjekt in ein 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 );
}Gibt ein zufälliges Element aus einem Array zurück.
Verwenden Sie Math.random() , um eine Zufallszahl zu generieren, sie mit length zu multiplizieren und mit Math.floor() auf die nächste ganze Zahl zu runden. Diese Methode funktioniert auch mit Saiten.
public static < T > T sample ( T [] arr ) {
return arr [( int ) Math . floor ( Math . random () * arr . length )];
} Erholt sich n Elemente bei einzigartigen Schlüssel von array bis zur Größe des array .
Mischen Sie das Array mit dem Fisher-Yates-Algorithmus. Verwenden Sie Array.copyOfRange() um die ersten n -Elemente zu erhalten.
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 );
}Randomisiert die Reihenfolge der Werte eines Arrays und gibt ein neues Array zurück.
Verwendet den Fisher-Yates-Algorithmus, um die Elemente des Arrays neu zu ordnen.
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 ;
}Gibt eine Reihe von Elementen zurück, die in beiden Arrays erscheinen.
Verwenden Sie Arrays.stream().filter() um Werte zu entfernen, die nicht Teil von second sind, und unter Verwendung von Arrays.stream().anyMatch() bestimmt.
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 ()));
}Gibt den niedrigsten Index zurück, bei dem der Wert in ein Array eingefügt werden sollte, um seine Sortierreihenfolge beizubehalten.
Überprüfen Sie, ob das Array (lose) in absteigender Reihenfolge sortiert ist. Verwenden Sie IntStream.range().filter() um den entsprechenden Index zu finden, in dem das Element eingefügt werden soll.
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 );
}Gibt den symmetrischen Unterschied zwischen zwei Arrays zurück.
Erstellen Sie einen Set aus jedem Array und verwenden Sie dann Arrays.stream().filter() Schließlich verkettet beide Arrays, erstellen Sie ein neues Array und geben Sie es zurück.
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 ()));
}Gibt alle Elemente in einem Array mit Ausnahme des ersten zurück.
Return Arrays.copyOfRange(1) Wenn die length des Arrays mehr als 1 beträgt, geben Sie ansonsten das gesamte Array zurück.
public static < T > T [] tail ( T [] arr ) {
return arr . length > 1
? Arrays . copyOfRange ( arr , 1 , arr . length )
: arr ;
}Gibt ein Array mit N -Elementen zurück, die von Anfang an entfernt wurden.
public static < T > T [] take ( T [] arr , int n ) {
return Arrays . copyOfRange ( arr , 0 , n );
}Gibt ein Array mit N -Elementen zurück, die vom Ende entfernt wurden.
n Sie Arrays.copyOfRange()
public static < T > T [] takeRight ( T [] arr , int n ) {
return Arrays . copyOfRange ( arr , arr . length - n , arr . length );
}Gibt jedes Element zurück, das einmal in einem der beiden Arrays existiert.
Erstellen Sie einen Set mit allen Werten von a und b und konvertieren Sie sie in ein 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 ()));
}Filtert die Elemente eines Arrays, die einen der angegebenen Werte haben.
Verwenden Sie Arrays.strean().filter() , um ein Array mit Ausschluss (mit !Arrays.asList(elements).contains() alle angegebenen Werte.
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 ()));
}Erstellt eine Reihe von Elementen, die basierend auf der Position in den ursprünglichen Arrays gruppiert sind.
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 ());
}Geben Sie bei einem Array gültiger Eigenschaftsbekennungsmittel und einer Reihe von Werten ein Objekt zurück, das die Eigenschaften mit den Werten assoziiert.
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 );
}Gibt den Durchschnitt von zwei oder mehr Zahlen zurück.
public static double average ( int [] arr ) {
return IntStream . of ( arr )
. average ()
. orElseThrow (() -> new IllegalArgumentException ( "Array is empty" ));
}Berechnet den größten gemeinsamen Nenner (GCD) einer Reihe von Zahlen.
Verwenden Sie Arrays.
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 );
}Berechnet das niedrigste gemeinsame Multiple (LCM) eines Arrays von Zahlen.
Verwenden Sie Arrays.
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 );
}Findet die nächste Kraft von zwei größer oder gleich dem Wert.
Diese Methode verwendet den linken Schiffsbetreiber, um 1 um den Wert auf der rechten Seite zu verschieben. Die rechte Seite wird mit der Integer.numberOfLeadingZeros -Methode berechnet.
Die Integer.numberOfLeadingZeros geben die Anzahl der Nullen an, die den Wert anführen. Zum Beispiel würde das Aufrufen von Integer.numberOfLeadingZeros(3) 11 Da die Ganzzahl 32 Bit hat, gibt es 30 Bit mit 0. Die rechte Seite des linken Schaltoperators wird zu 32-30 = 2 . Linkswechsel 1 mal 2 dh 001 << 2 wäre 100 . 100 im Dezimalwert entspricht 4 .
public static int findNextPositivePowerOfTwo ( int value ) {
return 1 << ( 32 - Integer . numberOfLeadingZeros ( value - 1 ));
}Überprüfen Sie, ob die Nummer gerade ist.
Diese Methode verwendet Bitwise & Operator. Der 0b1 ist die binäre Darstellung von 1. Da Java 7 Binärliterale schreiben können, indem Sie sie entweder mit 0b oder 0B vorfixieren. Der & Operator gibt 0 zurück, wenn die Nummer gerade ist. Zum Beispiel würde IsEven(4) 100 & 001 führen. Das Ergebnis von & wird 000 sein.
public static boolean isEven ( final int value ) {
return ( value & 0b1) == 0 ;
}Überprüft, ob ein Wert eine positive Leistung von zwei ist.
Um zu verstehen, wie es funktioniert, gehen wir davon aus, dass wir einen Anruf IsPowerOfTwo(4) getätigt haben.
Da der Wert größer als 0 ist, wird die rechte Seite des && Operators bewertet.
Das Ergebnis von (~value + 1) ist gleich dem Wert selbst. ~100 + 001 => 011 + 001 => 100 . Dies ist gleich Wert.
Das Ergebnis von (value & value) ist Wert. 100 & 100 => 100 .
Dies bewertet den Ausdruck auf True, da Wert gleich dem Wert ist.
public static boolean isPowerOfTwo ( final int value ) {
return value > 0 && (( value & (~ value + 1 )) == value );
} Generieren Sie eine zufällige Ganzzahl zwischen Integer.MIN_VALUE und Integer.MAX_VALUE .
public static int generateRandomInt () {
return ThreadLocalRandom . current (). nextInt ();
}Generiert alle Anagramme einer Zeichenfolge (enthält Duplikate).
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 ());
}Gibt die Länge einer Saite in Bytes zurück.
public static int byteSize ( String input ) {
return input . getBytes (). length ;
}Kapitalisiert den ersten Buchstaben einer Zeichenfolge.
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 ()));
}Kapitalisiert den ersten Buchstaben jedes Wortes in einer Zeichenfolge.
public static String capitalizeEveryWord ( final String input ) {
return Pattern . compile ( " \ b(?= \ w)" ). splitAsStream ( input )
. map ( w -> capitalize ( w , false ))
. collect ( Collectors . joining ());
} RETUNGEN number der Vokale in der vorgesehenen Zeichenfolge.
public static int countVowels ( String input ) {
return input . replaceAll ( "[^aeiouAEIOU]" , "" ). length ();
}Entkommt einer String, die in einem regulären Ausdruck verwendet werden kann.
public static String escapeRegExp ( String input ) {
return Pattern . quote ( input );
}Konvertiert eine Saite aus dem Kamelase.
public static String fromCamelCase ( String input , String separator ) {
return input
. replaceAll ( "([a-z \ d])([A-Z])" , "$1" + separator + "$2" )
. toLowerCase ();
} Gibt true zurück, wenn die angegebene Zeichenfolge eine absolute URL ist, sonst false .
public static boolean isAbsoluteUrl ( String url ) {
return Pattern . compile ( "^[a-z][a-z0-9+.-]*:" ). matcher ( url ). find ();
}Überprüft, ob eine Zeichenfolge niedriger ist.
public static boolean isLowerCase ( String input ) {
return Objects . equals ( input , input . toLowerCase ());
}Überprüft, ob eine Zeichenfolge oberes Gehäuse ist.
public static boolean isUpperCase ( String input ) {
return Objects . equals ( input , input . toUpperCase ());
}Überprüft, ob eine Saite Palindrome ist.
public static boolean isPalindrome ( String input ) {
String s = input . toLowerCase (). replaceAll ( "[ \ W_]" , "" );
return Objects . equals (
s ,
new StringBuilder ( s ). reverse (). toString ()
);
}Überprüft, ob eine Zeichenfolge numerisch ist.
public static boolean isNumeric ( final String input ) {
return IntStream . range ( 0 , input . length ())
. allMatch ( i -> Character . isDigit ( input . charAt ( i )));
} Ersetzt alle bis auf die letzte num von Zeichen durch das angegebene Maskenzeichen.
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 );
}Kehrt eine Zeichenfolge um.
public static String reverseString ( String input ) {
return new StringBuilder ( input ). reverse (). toString ();
}Alphabetisch sortiert die Zeichen in einer Zeichenfolge.
public static String sortCharactersInString ( String input ) {
return Arrays . stream ( input . split ( "" )). sorted (). collect ( Collectors . joining ());
}Teilt eine Multilin -Schnur in eine Reihe von Linien auf.
public static String [] splitLines ( String input ) {
return input . split ( " \ r? \ n" );
}Konvertiert eine Saite in Kamelcase.
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 );
}Konvertiert eine Zeichenfolge in Kebab -Fall.
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 ;
}Konvertiert eine Zeichenfolge in Schlangenkoffer.
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 ( "_" ));
}Schneiden Sie eine Zeichenfolge auf eine bestimmte Länge ab.
public static String truncateString ( String input , int num ) {
return input . length () > num
? input . substring ( 0 , num > 3 ? num - 3 : num ) + "..."
: input ;
}Konvertiert eine bestimmte Zeichenfolge in eine Reihe von Wörtern.
public static String [] words ( String input ) {
return Arrays . stream ( input . split ( "[^a-zA-Z-]+" ))
. filter ( s -> ! s . isEmpty ())
. toArray ( String []:: new );
}Konvertiert eine Reihe von Zahlen, die durch den Raum in ein Array von INTs getrennt sind.
public static int [] stringToIntegers ( String numbers ) {
return Arrays . stream ( numbers . split ( " " )). mapToInt ( Integer :: parseInt ). toArray ();
}Konvertiert InputStream in eine Zeichenfolge.
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 ());
}Liest Inhalte einer Datei zu einer Zeichenfolge
public String readFileAsString ( Path path ) throws IOException {
return new String ( Files . readAllBytes ( path ));
} public static String getCurrentWorkingDirectoryPath () {
return FileSystems . getDefault (). getPath ( "" ). toAbsolutePath (). toString ();
} Gibt den Wert von java.io.tmpdir System -Eigenschaft zurück. Es findet das Trennzeichen an, wenn es am Ende nicht vorhanden ist.
public static String tmpDirName () {
String tmpDirName = System . getProperty ( "java.io.tmpdir" );
if (! tmpDirName . endsWith ( File . separator )) {
tmpDirName += File . separator ;
}
return tmpDirName ;
}Konvertiert die Ausnahmestapelverfolgung in eine Schnur.
public static String stackTraceAsString ( final Throwable throwable ) {
final StringWriter sw = new StringWriter ();
throwable . printStackTrace ( new PrintWriter ( sw ));
return sw . toString ();
}Ruft den Namen des Betriebssystems als niedrigere Fallzeichenfolge ab.
public static String osName () {
return System . getProperty ( "os.name" ). toLowerCase ();
}Überprüft, ob Debugger an die JVM angeschlossen ist.
public static boolean isDebuggerAttached () {
final RuntimeMXBean runtimeMXBean = ManagementFactory . getRuntimeMXBean ();
return runtimeMXBean . getInputArguments ()
. stream ()
. anyMatch ( arg -> arg . contains ( "-agentlib:jdwp" ));
}Diese Methoden geben alle von der angegebenen Klasse und ihren Superklassen implementierten Schnittstellen zurück.
Diese Methode funktioniert durch Verkettung von zwei Streams. Der erste Stream wird rekursiv erstellt, indem ein Stream mit der Schnittstelle und allen von der Schnittstelle implementierten Schnittstellen erstellt wird. Der zweite Stream macht dasselbe für die Superklassen. Das Ergebnis ist die Verkettung der beiden Ströme nach Entfernen der Duplikate.
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 ());
}Diese Methode prüft, ob die angegebene Klasse eine innere oder statische verschachtelte Klasse ist
public static boolean isInnerClass ( final Class <?> cls ) {
return cls != null && cls . getEnclosingClass () != null ;
}Konvertiten in Enum, um zu kartieren, wo der Schlüssel der Name ist und der Wert ist enum selbst.
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 ()));
}Dieses Projekt begann als Java-Gabel von 30 Sekunden lang Code. Vielen Dank an die Projektkollaborateure für die Bemühungen.
