30 seconds of java
1.0.0
Colección curada de pequeñas funciones útiles de Java 8 que puede entender rápidamente.
chunkcountOccurrencesdeepFlattendifferencedifferenceWithdistinctValuesOfArraydropElementsdropRighteveryNthfilterNonUniqueflattenflattenDepthgroupByheadinitialinitializeArrayWithRangeinitializeArrayWithValuesintersectionisSortedjoinnthElementpickreducedFilterremovesamplesampleSizeshufflesimilaritysortedIndexsymmetricDifferencetailtaketakeRightunionwithoutzipzipObjectaveragegcdlcmfindNextPositivePowerOfTwoisEvenisPowerOfTwogenerateRandomIntanagramsbyteSizecapitalizecapitalizeEveryWordcountVowelsescapeRegExpfromCamelCaseisAbsoluteURLisLowerCaseisUpperCaseisPalindromeisNumericmaskreverseStringsortCharactersInStringsplitLinestoCamelCasetoKebabCasematchtoSnakeCasetruncateStringwordsstringToIntegersconvertInputStreamToStringreadFileAsStringgetCurrentWorkingDirectoryPathtmpDirNamestackTraceAsStringosNameisDebuggerEnabledgetAllInterfacesIsInnerClassgetEnumMapFragmica una matriz en matrices más pequeñas de tamaño especificado.
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 ()));
}Cuenta las ocurrencias de un valor en una matriz.
Use Arrays.stream (). Filter (). Count () para contar el número total de valores que es igual al valor especificado.
public static long countOccurrences ( int [] numbers , int value ) {
return Arrays . stream ( numbers )
. filter ( number -> number == value )
. count ();
}Deep aplana una matriz.
Usar recursión. Use 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 ();
}Devuelve la diferencia entre dos matrices.
Cree un conjunto desde B, luego use Arrays.stream (). Filter () en A para mantener solo los valores no contenidos en 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 ();
}Filma todos los valores de una matriz para la cual la función del comparador no devuelve verdadero.
El comparador para INT se implementa utilizando la función IntbinaryOperator.
Usa arrays.stream (). Filtro y arrays.stream (). Nonematch () para encontrar los valores apropiados.
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 ();
}Devuelve todos los valores distintos de una matriz.
Usa arrays.stream (). Distinto () para descartar todos los valores duplicados.
public static int [] distinctValuesOfArray ( int [] elements ) {
return Arrays . stream ( elements ). distinct (). toArray ();
}Elimina elementos en una matriz hasta que la función pasada devuelve verdaderas. Devuelve los elementos restantes en la matriz.
Reunir a través de la matriz, usando Arrays.CopyOfRange () para soltar el primer elemento de la matriz hasta que el valor devuelto de la función sea verdadero. Devuelve los elementos restantes.
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 ;
}Devuelve una nueva matriz con n elementos eliminados de la derecha.
Compruebe si N es más corto que la matriz dada y use Array.CopyOfRange () para cortarlo en consecuencia o devolver una matriz vacía.
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 ];
}Devuelve cada enésimo elemento en una matriz.
Use intstream.range (). Filter () para crear una nueva matriz que contenga cada enésimo elemento de una matriz dada.
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 ();
}Encuentre el índice de elemento en la matriz. Retorno -1 en caso de que el elemento no exista.
Usa intstream.range (). Filtre () para encontrar el índice del elemento en la matriz.
public static int indexOf ( int [] elements , int el ) {
return IntStream . range ( 0 , elements . length )
. filter ( idx -> elements [ idx ] == el )
. findFirst ()
. orElse (- 1 );
}Encuentre el último índice de elemento en la matriz. Retorno -1 en caso de que el elemento no exista.
Usa intstream.iterate (). Limit (). Filter () para encontrar el índice del elemento en la matriz.
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 );
}Filma los valores no únicos en una matriz.
Use Arrays.stream (). Filter () para una matriz que contiene solo los valores únicos.
public static int [] filterNonUnique ( int [] elements ) {
return Arrays . stream ( elements )
. filter ( el -> indexOf ( elements , el ) == lastIndexOf ( elements , el ))
. toArray ();
}Aplana una matriz.
Use Arrays.stream (). FlatMapToint (). ToArray () para crear una nueva matriz.
public static int [] flatten ( Object [] elements ) {
return Arrays . stream ( elements )
. flatMapToInt ( el -> el instanceof int []
? Arrays . stream (( int []) el )
: IntStream . of (( int ) el )
). toArray ();
}Aplana una matriz hasta la profundidad especificada.
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 ();
}Agrupe los elementos de una matriz basada en la función dada.
Usa arrays.stream (). Coleccionar (coleccionista.groupingBy ()) para agrupar en función de la función de agrupación.
public static < T , R > Map < R , List < T >> groupBy ( T [] elements , Function < T , R > func ) {
return Arrays . stream ( elements ). collect ( Collectors . groupingBy ( func ));
}Devuelve todos los elementos de una matriz, excepto el último. Use Arrays.CopyOfRange () para devolver todo excepto el último
public static < T > T [] initial ( T [] elements ) {
return Arrays . copyOfRange ( elements , 0 , elements . length - 1 );
}Inicializa una matriz que contiene los números en el rango especificado donde el inicio y el final son inclusivos.
public static int [] initializeArrayWithRange ( int end , int start ) {
return IntStream . rangeClosed ( start , end ). toArray ();
}Inicializa y llena una matriz con los valores especificados.
public static int [] initializeArrayWithValues ( int n , int value ) {
return IntStream . generate (() -> value ). limit ( n ). toArray ();
}Devuelve una lista de elementos que existen en ambas matrices.
Cree un conjunto desde el segundo, luego use Arrays.stream (). Filter () en A para mantener solo los valores contenidos en 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 ();
} Devuelve 1 si la matriz se clasifica en orden ascendente, -1 si se clasifica en orden descendente o 0 si no se clasifica.
Calcule la direction de pedido para los dos primeros elementos. Use el bucle para iterar sobre los elementos de la matriz y compararlos en pares. Regrese 0 si la direction cambia o la direction si se alcanza el último elemento.
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 ;
}Se une a todos los elementos de una matriz en una cadena y devuelve esta cadena. Utiliza un separador y un separador final.
Use Intstream.Range to Zip Index con el elemento de matriz. Luego, use Stream.reduce para combinar elementos en una cadena.
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 );
}Devuelve el enésimo elemento de una matriz.
Use Arrays.copyOfRange() para obtener una matriz que contiene el enésimo elemento en primer lugar.
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 ];
}Elige los pares de valor clave correspondientes a las teclas dadas de un objeto.
Use Arrays.stream para filtrar todas las teclas que están presentes en el arr . Luego, convierta todas las teclas presentes en un mapa usando 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 ));
}Filtre una matriz de objetos basados en una condición al tiempo que filtra las teclas no especificadas.
Use Arrays.stream().filter() para filtrar la matriz en función del predicado fn para que devuelva los objetos para los cuales la condición es verdadera. Para cada objeto de mapa filtrado, cree un nuevo mapa con teclas presentes en las keys . Finalmente, recopile todo el objeto de mapa en una matriz.
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 );
}Devuelve un elemento aleatorio de una matriz.
Use Math.random() para generar un número aleatorio, multiplíquelo por length y redondee al número entero más cercano usando Math.floor() . Este método también funciona con cadenas.
public static < T > T sample ( T [] arr ) {
return arr [( int ) Math . floor ( Math . random () * arr . length )];
} Obtiene n elementos aleatorios en claves únicas desde array hasta el tamaño de array .
Arrastra la matriz usando el algoritmo Fisher-Yates. Use Array.copyOfRange() para obtener los primeros n elementos.
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 );
}Aleatoriza el orden de los valores de una matriz, devolviendo una nueva matriz.
Utiliza el algoritmo Fisher-Yates para reordenar los elementos de la matriz.
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 ;
}Devuelve una variedad de elementos que aparecen en ambas matrices.
Use Arrays.stream().filter() para eliminar los valores que no son parte del second , determinados usando 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 ()));
}Devuelve el índice más bajo en el que se debe insertar el valor en la matriz para mantener su orden de clasificación.
Compruebe si la matriz se clasifica en orden descendente (libremente). Use IntStream.range().filter() para encontrar el índice apropiado donde se debe insertar el elemento.
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 );
}Devuelve la diferencia simétrica entre dos matrices.
Cree un Set desde cada matriz, luego use Arrays.stream().filter() en cada uno de ellos para mantener solo los valores no contenidos en el otro. Finalmente, concatene ambas matrices y cree una nueva matriz y devuélvala.
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 ()));
}Devuelve todos los elementos en una matriz, excepto el primero.
Arrays.copyOfRange(1) Si la length de la matriz es más de 1 , de lo contrario, devuelva toda la matriz.
public static < T > T [] tail ( T [] arr ) {
return arr . length > 1
? Arrays . copyOfRange ( arr , 1 , arr . length )
: arr ;
}Devuelve una matriz con n elementos eliminados del principio.
public static < T > T [] take ( T [] arr , int n ) {
return Arrays . copyOfRange ( arr , 0 , n );
}Devuelve una matriz con n elementos eliminados del final.
Use Arrays.copyOfRange() para crear una porción de la matriz con n elementos tomados desde el final.
public static < T > T [] takeRight ( T [] arr , int n ) {
return Arrays . copyOfRange ( arr , arr . length - n , arr . length );
}Devuelve cada elemento que existe en cualquiera de las dos matrices una vez.
Cree un Set con todos los valores de a y b y convierta a una matriz.
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 ()));
}Filma los elementos de una matriz, que tienen uno de los valores especificados.
Use Arrays.strean().filter() para crear una matriz excluyendo (usando !Arrays.asList(elements).contains() ) Todos los valores dados.
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 ()));
}Crea una variedad de elementos, agrupados en función de la posición en las matrices originales.
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 ());
}Dada una matriz de identificadores de propiedades válidos y una matriz de valores, devuelva un objeto que asocie las propiedades a los valores.
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 );
}Devuelve el promedio de un de dos o más números.
public static double average ( int [] arr ) {
return IntStream . of ( arr )
. average ()
. orElseThrow (() -> new IllegalArgumentException ( "Array is empty" ));
}Calcula el mayor denominador común (GCD) de una matriz de números.
Use Arrays.stream (). Reduce () y la fórmula GCD (usa recursión) para calcular el mayor denominador común de una matriz de números.
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 );
}Calcula el múltiplo común (LCM) más bajo de una matriz de números.
Use Arrays.stream (). Reduce () y la fórmula LCM (usa recursión) para calcular el múltiplo común más bajo de una matriz de números.
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 );
}Encuentra el siguiente poder de dos mayor o igual al valor.
Este método utiliza el operador del barco izquierdo para cambiar 1 por el valor en el lado derecho. El lado derecho se calcula utilizando el Integer.numberOfLeadingZeros Método.
El Integer.numberOfLeadingZeros da el número de ceros que lidera el valor. Por ejemplo, llamar Integer.numberOfLeadingZeros(3) daría valor como 30. Esto se debe a que 3 se representa en binario como 11 . Como el número entero tiene 32 bits, así hay 30 bits con 0. El lado derecho del operador de cambio izquierdo se convierte en 32-30 = 2 . Cambio de izquierda 1 por 2 IE 001 << 2 sería 100 . 100 en decimal es igual a 4 .
public static int findNextPositivePowerOfTwo ( int value ) {
return 1 << ( 32 - Integer . numberOfLeadingZeros ( value - 1 ));
}Compruebe si el número es uniforme.
Este método usa bitwise & operador. El 0b1 es la representación binaria de 1. Dado que Java 7 puedes escribir literales binarios prefiándolos con 0b o 0B . El y el operador devolverán 0 cuando el número sea par. Por ejemplo, IsEven(4) daría como resultado 100 & 001 . El resultado de & Will será 000 .
public static boolean isEven ( final int value ) {
return ( value & 0b1) == 0 ;
}Comprueba si un valor es un poder positivo de dos.
Para comprender cómo funciona, supongamos que hicimos una llamada IsPowerOfTwo(4) .
Ya que el valor es mayor que 0, se evaluará el lado derecho del operador && .
El resultado de (~value + 1) es igual al valor mismo. ~100 + 001 => 011 + 001 => 100 . Esto es igual al valor.
El resultado de (value & value) es valor. 100 & 100 => 100 .
Esto valorará la expresión a verdadero como valor es igual al valor.
public static boolean isPowerOfTwo ( final int value ) {
return value > 0 && (( value & (~ value + 1 )) == value );
} Genere un entero aleatorio entre Integer.MIN_VALUE y Integer.MAX_VALUE .
public static int generateRandomInt () {
return ThreadLocalRandom . current (). nextInt ();
}Genera todos los anagramas de una cadena (contiene duplicados).
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 ());
}Devuelve la longitud de una cadena en bytes.
public static int byteSize ( String input ) {
return input . getBytes (). length ;
}Capitaliza la primera letra de una cadena.
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 ()));
}Capitaliza la primera letra de cada palabra en una cadena.
public static String capitalizeEveryWord ( final String input ) {
return Pattern . compile ( " \ b(?= \ w)" ). splitAsStream ( input )
. map ( w -> capitalize ( w , false ))
. collect ( Collectors . joining ());
} Reabastece number de vocales en la cadena proporcionada.
public static int countVowels ( String input ) {
return input . replaceAll ( "[^aeiouAEIOU]" , "" ). length ();
}Escapa de una cadena para usar en una expresión regular.
public static String escapeRegExp ( String input ) {
return Pattern . quote ( input );
}Convierte una cuerda de CamelCase.
public static String fromCamelCase ( String input , String separator ) {
return input
. replaceAll ( "([a-z \ d])([A-Z])" , "$1" + separator + "$2" )
. toLowerCase ();
} Devuelve true si la cadena dada es una URL absoluta, false de lo contrario.
public static boolean isAbsoluteUrl ( String url ) {
return Pattern . compile ( "^[a-z][a-z0-9+.-]*:" ). matcher ( url ). find ();
}Comprueba si una cadena es minúscula.
public static boolean isLowerCase ( String input ) {
return Objects . equals ( input , input . toLowerCase ());
}Comprueba si una cadena es la caja superior.
public static boolean isUpperCase ( String input ) {
return Objects . equals ( input , input . toUpperCase ());
}Comprueba si una cadena es Palindrome.
public static boolean isPalindrome ( String input ) {
String s = input . toLowerCase (). replaceAll ( "[ \ W_]" , "" );
return Objects . equals (
s ,
new StringBuilder ( s ). reverse (). toString ()
);
}Comprueba si una cadena es numérica.
public static boolean isNumeric ( final String input ) {
return IntStream . range ( 0 , input . length ())
. allMatch ( i -> Character . isDigit ( input . charAt ( i )));
} Reemplaza todos menos el último num de caracteres con el carácter de máscara especificado.
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 );
}Invierte una cadena.
public static String reverseString ( String input ) {
return new StringBuilder ( input ). reverse (). toString ();
}Alfabéticamente clasifica los caracteres en una cadena.
public static String sortCharactersInString ( String input ) {
return Arrays . stream ( input . split ( "" )). sorted (). collect ( Collectors . joining ());
}Divide una cadena multilínea en una matriz de líneas.
public static String [] splitLines ( String input ) {
return input . split ( " \ r? \ n" );
}Convierte una cuerda 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 );
}Convierte una cadena en el caso 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 ;
}Convierte una cadena en caso de serpiente.
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 ( "_" ));
}Trunca una cadena hasta una longitud especificada.
public static String truncateString ( String input , int num ) {
return input . length () > num
? input . substring ( 0 , num > 3 ? num - 3 : num ) + "..."
: input ;
}Convierte una cadena dada en una matriz de palabras.
public static String [] words ( String input ) {
return Arrays . stream ( input . split ( "[^a-zA-Z-]+" ))
. filter ( s -> ! s . isEmpty ())
. toArray ( String []:: new );
}Convierte una cadena de números separados por espacio en una matriz de INTS.
public static int [] stringToIntegers ( String numbers ) {
return Arrays . stream ( numbers . split ( " " )). mapToInt ( Integer :: parseInt ). toArray ();
}Convierte InputStream en una cadena.
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 ());
}Lee contenido de un archivo a una cadena
public String readFileAsString ( Path path ) throws IOException {
return new String ( Files . readAllBytes ( path ));
} public static String getCurrentWorkingDirectoryPath () {
return FileSystems . getDefault (). getPath ( "" ). toAbsolutePath (). toString ();
} Devuelve el valor de la propiedad del sistema java.io.tmpdir . Agrega separador si no está presente al final.
public static String tmpDirName () {
String tmpDirName = System . getProperty ( "java.io.tmpdir" );
if (! tmpDirName . endsWith ( File . separator )) {
tmpDirName += File . separator ;
}
return tmpDirName ;
}Convierte el rastro de la pila de excepciones en una cadena.
public static String stackTraceAsString ( final Throwable throwable ) {
final StringWriter sw = new StringWriter ();
throwable . printStackTrace ( new PrintWriter ( sw ));
return sw . toString ();
}Obtiene el nombre del sistema operativo como una cadena minúscula.
public static String osName () {
return System . getProperty ( "os.name" ). toLowerCase ();
}Comprueba si el depurador se adjunta al JVM.
public static boolean isDebuggerAttached () {
final RuntimeMXBean runtimeMXBean = ManagementFactory . getRuntimeMXBean ();
return runtimeMXBean . getInputArguments ()
. stream ()
. anyMatch ( arg -> arg . contains ( "-agentlib:jdwp" ));
}Estos métodos devuelven todas las interfaces implementadas por la clase dada y sus superclase.
Este método funciona concatenando dos transmisiones. La primera secuencia se crea recursivamente creando una transmisión con la interfaz y todas las interfaces implementadas por la interfaz. La segunda transmisión hace lo mismo para las súper clases. El resultado es la concatenación de las dos corrientes después de eliminar los duplicados.
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 ());
}Este método verifica si la clase especificada es una clase interna o una clase anidada estática
public static boolean isInnerClass ( final Class <?> cls ) {
return cls != null && cls . getEnclosingClass () != null ;
}Convierte a Enum para mapear donde la tecla es el nombre y el valor es enumero en sí.
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 ()));
}Este proyecto comenzó como una bifurcación Java de 30 segundos de código. Gracias a los colaboradores del proyecto por el esfuerzo.
