30 seconds of java
1.0.0
Collection organisée de petites fonctions Java 8 utiles que vous pouvez comprendre rapidement.
chunkcountOccurrencesdeepFlattendifferencedifferenceWithdistinctValuesOfArraydropElementsdropRighteveryNthfilterNonUniqueflattenflattenDepthgroupByheadinitialinitializeArrayWithRangeinitializeArrayWithValuesintersectionisSortedjoinnthElementpickreducedFilterremovesamplesampleSizeshufflesimilaritysortedIndexsymmetricDifferencetailtaketakeRightunionwithoutzipzipObjectaveragegcdlcmfindNextPositivePowerOfTwoisEvenisPowerOfTwogenerateRandomIntanagramsbyteSizecapitalizecapitalizeEveryWordcountVowelsescapeRegExpfromCamelCaseisAbsoluteURLisLowerCaseisUpperCaseisPalindromeisNumericmaskreverseStringsortCharactersInStringsplitLinestoCamelCasetoKebabCasematchtoSnakeCasetruncateStringwordsstringToIntegersconvertInputStreamToStringreadFileAsStringgetCurrentWorkingDirectoryPathtmpDirNamestackTraceAsStringosNameisDebuggerEnabledgetAllInterfacesIsInnerClassgetEnumMapChuns un tableau en tableaux plus petits de taille spécifié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 ()));
}Compte les occurrences d'une valeur dans un tableau.
Utilisez Arrays.Stream (). Filter (). Count () pour compter le nombre total de valeurs qui équivaut à la valeur spécifiée.
public static long countOccurrences ( int [] numbers , int value ) {
return Arrays . stream ( numbers )
. filter ( number -> number == value )
. count ();
}Deep flamboyant un tableau.
Utilisez la récursivité. Utilisez des Arrays.Stream (). FlatMaptRoint ()
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 ();
}Renvoie la différence entre deux tableaux.
Créez un ensemble à partir de B, puis utilisez Arrays.Stream (). Filter () sur A pour conserver uniquement les valeurs non contenues dans 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 ();
}Filtre toutes les valeurs d'un tableau pour lequel la fonction de comparaison ne renvoie pas vrai.
Le comparateur pour INT est implémenté à l'aide de la fonction instbinaryOperator.
Utilise arrays.stream (). Filtre et arrays.stream (). Nonmatch () pour trouver les valeurs appropriées.
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 ();
}Renvoie toutes les valeurs distinctes d'un tableau.
Utilise des arrays.stream (). Distinct () pour éliminer toutes les valeurs dupliquées.
public static int [] distinctValuesOfArray ( int [] elements ) {
return Arrays . stream ( elements ). distinct (). toArray ();
}Supprime les éléments dans un tableau jusqu'à ce que la fonction passée renvoie vrai. Renvoie les éléments restants dans le tableau.
Boucle dans le tableau, en utilisant des arrays.copyofrange () pour supprimer le premier élément du tableau jusqu'à ce que la valeur renvoyée de la fonction soit vraie. Renvoie les éléments restants.
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 ;
}Renvoie un nouveau tableau avec N éléments supprimés de la droite.
Vérifiez si N est plus court que le tableau donné et utilisez un array.copyofrange () pour le trancher en conséquence ou renvoyez un tableau vide.
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 ];
}Renvoie chaque nième élément d'un tableau.
Utilisez IntStream.Range (). Filter () pour créer un nouveau tableau qui contient chaque nième élément d'un tableau donné.
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 ();
}Trouvez l'index de l'élément dans le tableau. Retour -1 dans le cas où l'élément n'existe pas.
Utilise IntStream.Range (). Filter () pour trouver l'index de l'élément dans le tableau.
public static int indexOf ( int [] elements , int el ) {
return IntStream . range ( 0 , elements . length )
. filter ( idx -> elements [ idx ] == el )
. findFirst ()
. orElse (- 1 );
}Trouvez le dernier index de l'élément dans le tableau. Retour -1 dans le cas où l'élément n'existe pas.
Utilise IntStream.iterate (). Limit (). Filter () pour trouver l'index de l'élément dans le tableau.
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 );
}Filtre les valeurs non uniques dans un tableau.
Utilisez Arrays.Stream (). Filter () pour un tableau contenant uniquement les valeurs uniques.
public static int [] filterNonUnique ( int [] elements ) {
return Arrays . stream ( elements )
. filter ( el -> indexOf ( elements , el ) == lastIndexOf ( elements , el ))
. toArray ();
}Aplatit un tableau.
Utilisez Arrays.Stream (). FlatMaptRoint (). ToArray () pour créer un nouveau tableau.
public static int [] flatten ( Object [] elements ) {
return Arrays . stream ( elements )
. flatMapToInt ( el -> el instanceof int []
? Arrays . stream (( int []) el )
: IntStream . of (( int ) el )
). toArray ();
}Appliquant un tableau jusqu'à la profondeur spécifiée.
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 ();
}Groupe les éléments d'un tableau basé sur la fonction donnée.
Utilise Arrays.Stream (). Collect (collectionors.groupingBy ()) en groupe en fonction de la fonction de regroupement.
public static < T , R > Map < R , List < T >> groupBy ( T [] elements , Function < T , R > func ) {
return Arrays . stream ( elements ). collect ( Collectors . groupingBy ( func ));
}Renvoie tous les éléments d'un tableau sauf le dernier. Utilisez des tableaux.copyofrange () pour retourner tout sauf le dernier
public static < T > T [] initial ( T [] elements ) {
return Arrays . copyOfRange ( elements , 0 , elements . length - 1 );
}Initialise un tableau contenant les nombres dans la plage spécifiée où le démarrage et la fin sont inclusifs.
public static int [] initializeArrayWithRange ( int end , int start ) {
return IntStream . rangeClosed ( start , end ). toArray ();
}Initialise et remplit un tableau avec les valeurs spécifiées.
public static int [] initializeArrayWithValues ( int n , int value ) {
return IntStream . generate (() -> value ). limit ( n ). toArray ();
}Renvoie une liste d'éléments qui existent dans les deux tableaux.
Créez un ensemble à partir de seconde, puis utilisez des arrays.stream (). Filter () sur A pour conserver uniquement les valeurs contenues dans 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 ();
} Renvoie 1 Si le tableau est trié par ordre croissant, -1 s'il est trié en ordre décroissant ou 0 s'il n'est pas trié.
Calculez la direction de commande pour les deux premiers éléments. Utilisez la boucle pour itérer sur les éléments du tableau et comparez-les par paires. Retour 0 Si la direction change ou la direction si le dernier élément est atteint.
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 ;
}Rejoint tous les éléments d'un tableau dans une chaîne et renvoie cette chaîne. Utilise un séparateur et un séparateur final.
Utilisez INTSTREAM.Range à l'index à zip avec l'élément de tableau. Ensuite, utilisez Stream.reduce pour combiner des éléments dans une chaîne.
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 );
}Renvoie le nième élément d'un tableau.
Utilisez Arrays.copyOfRange() pour obtenir un tableau contenant le nième élément à la première place.
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 ];
}Choisissez les paires de valeurs clés correspondant aux clés données d'un objet.
Utilisez Arrays.stream pour filtrer toutes les clés présentes dans l' arr . Ensuite, convertissez toutes les touches présentes en une carte en utilisant 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 ));
}Filtrez un tableau d'objets en fonction d'une condition tout en filtrant également les clés non spécifiées.
Utilisez Arrays.stream().filter() pour filtrer le tableau en fonction du prédicat fn afin qu'il renvoie les objets pour lesquels la condition est vraie. Pour chaque objet de carte filtrée, créez une nouvelle carte avec des touches présentes dans les keys . Enfin, collectez tous les objets de carte dans un tableau.
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 );
}Renvoie un élément aléatoire d'un tableau.
Utilisez Math.random() pour générer un nombre aléatoire, multipliez-le par length et tournez-le du nombre entier le plus proche à l'aide de Math.floor() . Cette méthode fonctionne également avec les chaînes.
public static < T > T sample ( T [] arr ) {
return arr [( int ) Math . floor ( Math . random () * arr . length )];
} Obtient n éléments aléatoires à des clés uniques du array jusqu'à la taille du array .
Mercer le tableau à l'aide de l'algorithme Fisher-Yates. Utilisez Array.copyOfRange() pour obtenir les n premier éléments.
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 );
}Randomise l'ordre des valeurs d'un tableau, renvoyant un nouveau tableau.
Utilise l'algorithme Fisher-Yates pour réorganiser les éléments du tableau.
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 ;
}Renvoie un tableau d'éléments qui apparaissent dans les deux tableaux.
Utilisez Arrays.stream().filter() pour supprimer des valeurs qui ne font pas partie de second , déterminées à l'aide de 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 ()));
}Renvoie l'index le plus bas auquel la valeur doit être insérée dans le tableau afin de maintenir son ordre de tri.
Vérifiez si le tableau est trié par ordre décroissant (librement). Utilisez IntStream.range().filter() pour trouver l'index approprié où l'élément doit être inséré.
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 );
}Renvoie la différence symétrique entre deux tableaux.
Créez un Set à partir de chaque tableau, puis utilisez Arrays.stream().filter() sur chacun d'eux pour conserver uniquement les valeurs non contenues dans l'autre. Enfin, concaténez les deux tableaux et créez un nouveau tableau et renvoyez-le.
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 ()));
}Renvoie tous les éléments dans un tableau, sauf pour le premier.
Return Arrays.copyOfRange(1) Si la length du tableau est supérieure à 1 , sinon, renvoyez l'ensemble du tableau.
public static < T > T [] tail ( T [] arr ) {
return arr . length > 1
? Arrays . copyOfRange ( arr , 1 , arr . length )
: arr ;
}Renvoie un tableau avec N éléments supprimés depuis le début.
public static < T > T [] take ( T [] arr , int n ) {
return Arrays . copyOfRange ( arr , 0 , n );
}Renvoie un tableau avec N éléments supprimés de la fin.
Utilisez Arrays.copyOfRange() pour créer une tranche du tableau avec n éléments pris à la fin.
public static < T > T [] takeRight ( T [] arr , int n ) {
return Arrays . copyOfRange ( arr , arr . length - n , arr . length );
}Renvoie chaque élément qui existe dans l'un des deux tableaux une fois.
Créez un Set avec toutes les valeurs de a et b et convertissez en un tableau.
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 ()));
}Filtre les éléments d'un tableau, qui ont l'une des valeurs spécifiées.
Utilisez Arrays.strean().filter() pour créer un tableau excluant (utilisant !Arrays.asList(elements).contains() ) toutes les valeurs données.
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 ()));
}Crée un tableau d'éléments, regroupés en fonction de la position dans les tableaux d'origine.
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 ());
}Étant donné un tableau d'identificateurs de propriétés valides et un tableau de valeurs, renvoyez un objet associant les propriétés aux valeurs.
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 );
}Renvoie la moyenne de deux ou plusieurs nombres.
public static double average ( int [] arr ) {
return IntStream . of ( arr )
. average ()
. orElseThrow (() -> new IllegalArgumentException ( "Array is empty" ));
}Calcule le plus grand dénominateur commun (GCD) d'un tableau de nombres.
Utilisez des Arrays.Stream (). Reduce () et la formule GCD (utilise une récursivité) pour calculer le plus grand dénominateur commun d'un tableau de nombres.
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 );
}Calcule le multiple commun (LCM) le plus bas (LCM) d'un tableau de nombres.
Utilisez des Arrays.Stream (). Reduce () et la formule LCM (utilise une récursivité) pour calculer le multiple commun le plus bas d'un tableau de nombres.
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 );
}Trouve la puissance suivante de deux supérieures ou égales à la valeur.
Cette méthode utilise l'opérateur de navire gauche pour déplacer 1 par la valeur du côté droit. Le côté droit est calculé à l'aide de la méthode Integer.numberOfLeadingZeros .
L' Integer.numberOfLeadingZeros donne le nombre de zéros menant la valeur. Par exemple, appeler Integer.numberOfLeadingZeros(3) donnerait de la valeur à 30. En effet, 3 est représenté en binaire comme 11 . Comme entier a 32 bits, il y a donc 30 bits avec 0. Le côté droit de l'opérateur de changement de gauche devient 32-30 = 2 . Le déplacement gauche 1 par 2, c'est-à-dire 001 << 2 serait 100 . 100 en décimal est égal à 4 .
public static int findNextPositivePowerOfTwo ( int value ) {
return 1 << ( 32 - Integer . numberOfLeadingZeros ( value - 1 ));
}Vérifiez si le numéro est uniforme.
Cette méthode utilise Bitwise et l'opérateur. Le 0b1 est la représentation binaire de 1. Puisque, Java 7, vous pouvez écrire des littéraux binaires en les préfixant avec 0b ou 0B . L'opérateur & va retourner 0 lorsque le numéro est égal. Par exemple, IsEven(4) se traduirait en 100 & 001 . Le résultat de & sera 000 .
public static boolean isEven ( final int value ) {
return ( value & 0b1) == 0 ;
}Vérifie si une valeur est une puissance positive de deux.
Pour comprendre comment cela fonctionne, supposons que nous ayons passé un appel IsPowerOfTwo(4) .
Car la valeur est supérieure à 0, donc le côté droit de l'opérateur && sera évalué.
Le résultat de (~value + 1) est égal à la valeur elle-même. ~100 + 001 => 011 + 001 => 100 . Ceci est égal à la valeur.
Le résultat de (value & value) est de la valeur. 100 et 100 => 100 .
Cela valorisera l'expression à la vraie valeur que la valeur est égale à la valeur.
public static boolean isPowerOfTwo ( final int value ) {
return value > 0 && (( value & (~ value + 1 )) == value );
} Générez un entier aléatoire entre Integer.MIN_VALUE et Integer.MAX_VALUE .
public static int generateRandomInt () {
return ThreadLocalRandom . current (). nextInt ();
}Génère toutes les anagrammes d'une chaîne (contient des doublons).
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 ());
}Renvoie la longueur d'une chaîne en octets.
public static int byteSize ( String input ) {
return input . getBytes (). length ;
}Capitalise la première lettre d'une chaîne.
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 ()));
}Capitalise la première lettre de chaque mot d'une chaîne.
public static String capitalizeEveryWord ( final String input ) {
return Pattern . compile ( " \ b(?= \ w)" ). splitAsStream ( input )
. map ( w -> capitalize ( w , false ))
. collect ( Collectors . joining ());
} Retourne number de voyelles dans la chaîne fournie.
public static int countVowels ( String input ) {
return input . replaceAll ( "[^aeiouAEIOU]" , "" ). length ();
}Échappe à une chaîne à utiliser dans une expression régulière.
public static String escapeRegExp ( String input ) {
return Pattern . quote ( input );
}Convertit une chaîne de camelcase.
public static String fromCamelCase ( String input , String separator ) {
return input
. replaceAll ( "([a-z \ d])([A-Z])" , "$1" + separator + "$2" )
. toLowerCase ();
} Renvoie true si la chaîne donnée est une URL absolue, false autrement.
public static boolean isAbsoluteUrl ( String url ) {
return Pattern . compile ( "^[a-z][a-z0-9+.-]*:" ). matcher ( url ). find ();
}Vérifie si une chaîne est minuscule.
public static boolean isLowerCase ( String input ) {
return Objects . equals ( input , input . toLowerCase ());
}Vérifie si une chaîne est en majuscules.
public static boolean isUpperCase ( String input ) {
return Objects . equals ( input , input . toUpperCase ());
}Vérifie si une chaîne est palindrome.
public static boolean isPalindrome ( String input ) {
String s = input . toLowerCase (). replaceAll ( "[ \ W_]" , "" );
return Objects . equals (
s ,
new StringBuilder ( s ). reverse (). toString ()
);
}Vérifie si une chaîne est numérique.
public static boolean isNumeric ( final String input ) {
return IntStream . range ( 0 , input . length ())
. allMatch ( i -> Character . isDigit ( input . charAt ( i )));
} Remplace tous sauf le dernier num de caractères par le caractère de masque spécifié.
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 );
}Inverse une chaîne.
public static String reverseString ( String input ) {
return new StringBuilder ( input ). reverse (). toString ();
}Trie par ordre alphabétique les caractères dans une chaîne.
public static String sortCharactersInString ( String input ) {
return Arrays . stream ( input . split ( "" )). sorted (). collect ( Collectors . joining ());
}Fruit une chaîne multiline dans un tableau de lignes.
public static String [] splitLines ( String input ) {
return input . split ( " \ r? \ n" );
}Convertit une chaîne en 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 );
}Convertit une chaîne en cas de 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 ;
}Convertit une chaîne en cas de serpent.
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 ( "_" ));
}Tronque une chaîne jusqu'à une longueur spécifiée.
public static String truncateString ( String input , int num ) {
return input . length () > num
? input . substring ( 0 , num > 3 ? num - 3 : num ) + "..."
: input ;
}Convertit une chaîne donnée en un tableau de mots.
public static String [] words ( String input ) {
return Arrays . stream ( input . split ( "[^a-zA-Z-]+" ))
. filter ( s -> ! s . isEmpty ())
. toArray ( String []:: new );
}Convertit une chaîne de nombres séparés par l'espace en un tableau d'INTS.
public static int [] stringToIntegers ( String numbers ) {
return Arrays . stream ( numbers . split ( " " )). mapToInt ( Integer :: parseInt ). toArray ();
}Convertit InputStream en une chaîne.
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 ());
}Lit le contenu d'un fichier dans une chaîne
public String readFileAsString ( Path path ) throws IOException {
return new String ( Files . readAllBytes ( path ));
} public static String getCurrentWorkingDirectoryPath () {
return FileSystems . getDefault (). getPath ( "" ). toAbsolutePath (). toString ();
} Renvoie la valeur de la propriété système java.io.tmpdir . Il ajoute le séparateur s'il n'est pas présent à la fin.
public static String tmpDirName () {
String tmpDirName = System . getProperty ( "java.io.tmpdir" );
if (! tmpDirName . endsWith ( File . separator )) {
tmpDirName += File . separator ;
}
return tmpDirName ;
}Convertit la trace de pile d'exception en une chaîne.
public static String stackTraceAsString ( final Throwable throwable ) {
final StringWriter sw = new StringWriter ();
throwable . printStackTrace ( new PrintWriter ( sw ));
return sw . toString ();
}Obtient le nom du système d'exploitation en tant que chaîne en minuscules.
public static String osName () {
return System . getProperty ( "os.name" ). toLowerCase ();
}Vérifie si le débogueur est attaché au JVM.
public static boolean isDebuggerAttached () {
final RuntimeMXBean runtimeMXBean = ManagementFactory . getRuntimeMXBean ();
return runtimeMXBean . getInputArguments ()
. stream ()
. anyMatch ( arg -> arg . contains ( "-agentlib:jdwp" ));
}Ces méthodes renvoient toutes les interfaces implémentées par la classe donnée et ses superclasses.
Cette méthode fonctionne en concaténant deux flux. Le premier flux est construit récursivement en créant un flux avec l'interface et toutes les interfaces implémentées par l'interface. Le deuxième flux fait de même pour les super classes. Le résultat est la concaténation des deux flux après avoir retiré les doublons.
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 ());
}Cette méthode vérifie si la classe spécifiée est une classe intérieure ou une classe imbriquée statique
public static boolean isInnerClass ( final Class <?> cls ) {
return cls != null && cls . getEnclosingClass () != null ;
}Se convertit en énumération en map où la clé est le nom et la valeur est en énumération elle-même.
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 ()));
}Ce projet a commencé comme une fourche Java de 30 secondes de code. Merci aux collaborateurs du projet pour l'effort.
