30 seconds of java
1.0.0
迅速に理解できる便利なLittle Java 8機能のキュレーションコレクション。
chunkcountOccurrencesdeepFlattendifferencedifferenceWithdistinctValuesOfArraydropElementsdropRighteveryNthfilterNonUniqueflattenflattenDepthgroupByheadinitialinitializeArrayWithRangeinitializeArrayWithValuesintersectionisSortedjoinnthElementpickreducedFilterremovesamplesampleSizeshufflesimilaritysortedIndexsymmetricDifferencetailtaketakeRightunionwithoutzipzipObjectaveragegcdlcmfindNextPositivePowerOfTwoisEvenisPowerOfTwogenerateRandomIntanagramsbyteSizecapitalizecapitalizeEveryWordcountVowelsescapeRegExpfromCamelCaseisAbsoluteURLisLowerCaseisUpperCaseisPalindromeisNumericmaskreverseStringsortCharactersInStringsplitLinestoCamelCasetoKebabCasematchtoSnakeCasetruncateStringwordsstringToIntegersconvertInputStreamToStringreadFileAsStringgetCurrentWorkingDirectoryPathtmpDirNamestackTraceAsStringosNameisDebuggerEnabledgetAllInterfacesIsInnerClassgetEnumMap指定されたサイズの小さな配列に配列をチャンクします。
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 ()));
}配列内の値の発生をカウントします。
arrays.stream（）。filter（）。count（）を使用して、指定された値に等しい値の総数をカウントします。
public static long countOccurrences ( int [] numbers , int value ) {
return Arrays . stream ( numbers )
. filter ( number -> number == value )
. count ();
}深いアレイを平らにします。
再帰を使用します。 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 ();
}2つの配列間の違いを返します。
bからセットを作成し、asray.stream（）。filter（）を使用して、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 ();
}コンパレータ関数がtrueを返さない配列からすべての値をフィルターします。
INTのコンパレータは、IntBinaryOperator関数を使用して実装されます。
arrays.stream（）。フィルターとarrays.stream（）。nonematch（）を使用して、適切な値を見つけます。
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 ();
}配列のすべての異なる値を返します。
arrays.stream（）。個別（）を使用して、すべての重複した値を破棄します。
public static int [] distinctValuesOfArray ( int [] elements ) {
return Arrays . stream ( elements ). distinct (). toArray ();
}渡された関数がtrueを返すまで、配列内の要素を削除します。配列内の残りの要素を返します。
Array.CopyOfRange（）を使用して配列をループして、関数から返された値がtrueになるまで配列の最初の要素をドロップします。残りの要素を返します。
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 ;
}N要素が右から削除された新しい配列を返します。
nが指定された配列よりも短いかどうかを確認し、array.copyofrange（）を使用してそれに応じてスライスするか、空の配列を返します。
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 ];
}配列内のすべてのnth要素を返します。
intstream.range（）。フィルター（）を使用して、特定の配列のすべてのnth要素を含む新しい配列を作成します。
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 ();
}配列内の要素のインデックスを見つけます。要素が存在しない場合に-1を返します。
intstream.range（）。フィルター（）を使用して、配列内の要素のインデックスを見つけます。
public static int indexOf ( int [] elements , int el ) {
return IntStream . range ( 0 , elements . length )
. filter ( idx -> elements [ idx ] == el )
. findFirst ()
. orElse (- 1 );
}配列内の要素の最後のインデックスを見つけます。要素が存在しない場合に-1を返します。
intstream.iterate（）。limit（）。filter（）を使用して、配列内の要素のインデックスを見つけます。
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 );
}配列内の非ユニーク値をフィルターします。
ARRAYS.STREAM（）。フィルター（）を使用して、一意の値のみを含む配列に。
public static int [] filterNonUnique ( int [] elements ) {
return Arrays . stream ( elements )
. filter ( el -> indexOf ( elements , el ) == lastIndexOf ( elements , el ))
. toArray ();
}配列を平らにします。
arrays.stream（）。flatmaptoint（）。toarray（）を使用して、新しい配列を作成します。
public static int [] flatten ( Object [] elements ) {
return Arrays . stream ( elements )
. flatMapToInt ( el -> el instanceof int []
? Arrays . stream (( int []) el )
: IntStream . of (( int ) el )
). toArray ();
}指定された深さまで配列を平らにします。
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 ();
}指定された関数に基づいて配列の要素をグループ化します。
arrays.stream（）。collect（collectors.groupingby（））を使用して、グループ化関数に基づいてグループに基づいてグループに基づいてグループに使用します。
public static < T , R > Map < R , List < T >> groupBy ( T [] elements , Function < T , R > func ) {
return Arrays . stream ( elements ). collect ( Collectors . groupingBy ( func ));
}最後の要素を除く配列のすべての要素を返します。 arrays.copyofrange（）を使用して、最後を除くすべてを返します
public static < T > T [] initial ( T [] elements ) {
return Arrays . copyOfRange ( elements , 0 , elements . length - 1 );
}開始と終了が包括的である指定された範囲の数値を含む配列を初期化します。
public static int [] initializeArrayWithRange ( int end , int start ) {
return IntStream . rangeClosed ( start , end ). toArray ();
}指定された値で配列を初期化して埋めます。
public static int [] initializeArrayWithValues ( int n , int value ) {
return IntStream . generate (() -> value ). limit ( n ). toArray ();
}両方の配列に存在する要素のリストを返します。
2番目からセットを作成し、aを使用して、aでstream（）。フィルター（）を使用して、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 ();
}配列が昇順でソートされている0は1 -1ます。
最初の2つの要素の順序directionを計算します。ループを使用して、配列アイテムを繰り返してペアで比較します。 directionが変更された場合は0または最後の要素に到達した場合はdirectionを返します。
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 ;
}配列のすべての要素を文字列に結合し、この文字列を返します。セパレーターとエンドセパレーターを使用します。
Arrayアイテムを使用して、intstream.rangeにzipインデックスを使用します。次に、 Stream.reduceを使用して要素を文字列に結合します。
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 );
}配列のn番目の要素を返します。
Arrays.copyOfRange()を使用して、そもそもn番目の要素を含む配列を取得します。
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 ];
}オブジェクトから指定されたキーに対応するキー価値のペアを選択します。
Arrays.streamを使用して、 arrに存在するすべてのキーをフィルタリングします。次に、 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 ));
}不特定のキーをフィルタリングしながら、条件に基づいてオブジェクトの配列をフィルタリングします。
Arrays.stream().filter()を使用して、述語fnに基づいて配列をフィルタリングして、条件が真であるオブジェクトを返すようにします。フィルターされた各マップオブジェクトについて、 keysにキーが存在する新しいマップを作成します。最後に、すべてのマップオブジェクトを配列に収集します。
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 );
}配列からランダムな要素を返します。
Math.random()を使用して乱数を生成し、 lengthを掛け、 Math.floor()を使用して最も近い総数に丸めます。この方法は、文字列でも動作します。
public static < T > T sample ( T [] arr ) {
return arr [( int ) Math . floor ( Math . random () * arr . length )];
}arrayからarrayのサイズまで、一意のキーでnランダムな要素を取得します。
Fisher-Jatesアルゴリズムを使用して配列をシャッフルします。 Array.copyOfRange()を使用して、最初のn要素を取得します。
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 );
}アレイの値の順序をランダム化し、新しい配列を返します。
Fisher-Jatesアルゴリズムを使用して、配列の要素を再注文します。
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 ;
}両方の配列に表示される要素の配列を返します。
Arrays.stream().filter()を使用してArrays.stream().anyMatch()を使用して決定されたsecondの一部ではない値を削除します。
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 ()));
}ソート順序を維持するために、値を配列に挿入する最低インデックスを返します。
配列が下降順にソートされているかどうかを確認します（ゆるく）。 IntStream.range().filter()を使用して、要素を挿入する必要がある適切なインデックスを見つけます。
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 );
}2つの配列間の対称差を返します。
各配列からSetを作成し、それぞれにArrays.stream().filter()を使用して、他の値に含まれていない値のみを保持します。最後に、両方の配列を連結して新しい配列を作成して返します。
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 ()));
}最初の要素を除くすべての要素を配列内のすべての要素を返します。
return Arrays.copyOfRange(1)配列のlengthが1以上の場合、アレイ全体を返します。
public static < T > T [] tail ( T [] arr ) {
return arr . length > 1
? Arrays . copyOfRange ( arr , 1 , arr . length )
: arr ;
}最初からN要素が削除されたArrayを返します。
public static < T > T [] take ( T [] arr , int n ) {
return Arrays . copyOfRange ( arr , 0 , n );
}n要素が端から削除された配列を返します。
Arrays.copyOfRange()を使用して、端から採取したn要素を持つ配列のスライスを作成します。
public static < T > T [] takeRight ( T [] arr , int n ) {
return Arrays . copyOfRange ( arr , arr . length - n , arr . length );
}2つの配列のいずれかに存在するすべての要素を1回返します。
aとbのすべての値を持つSetを作成し、配列に変換します。
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 ()));
}指定された値の1つを持つ配列の要素をフィルターします。
Arrays.strean().filter()を使用して、（ !Arrays.asList(elements).contains()を使用して）すべての値を除外する配列を作成します。
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 ()));
}元の配列の位置に基づいてグループ化された要素の配列を作成します。
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 ());
}有効なプロパティ識別子の配列と値の配列が与えられた場合、プロパティを値に関連付けるオブジェクトを返します。
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 );
}2つ以上の数値の平均を返します。
public static double average ( int [] arr ) {
return IntStream . of ( arr )
. average ()
. orElseThrow (() -> new IllegalArgumentException ( "Array is empty" ));
}数字の配列の最大の共通点（GCD）を計算します。
arrays.stream（）。reduce（）とGCD式（再帰を使用）を使用して、数字の配列の最大の共通点を計算します。
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 );
}数値の配列の最低一般的な倍数（LCM）を計算します。
arrays.stream（）。reduce（）およびLCM式（再帰を使用）を使用して、数字の配列の最も低い共通倍数を計算します。
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 );
}値以上の2つの次のパワーを見つけます。
この方法では、左船のオペレーターを使用して、右側の値で1を1シフトします。右側は、 Integer.numberOfLeadingZerosメソッドを使用して計算されます。
Integer.numberOfLeadingZerosは、価値を主導するゼロの数を与えます。たとえば、 Integer.numberOfLeadingZeros(3)を呼び出すと、30と値が値が与えられます。これは、3がバイナリで11として表されるためです。整数には32ビットがあるため、0の30ビットがあります。左シフト演算子の右側は32-30 = 2になります。左シフト1 x 2 IE 001 << 2は100になります。小数点の100 4に等しくなります。
public static int findNextPositivePowerOfTwo ( int value ) {
return 1 << ( 32 - Integer . numberOfLeadingZeros ( value - 1 ));
}番号が均一かどうかを確認してください。
この方法では、ビットワイズと演算子を使用します。 0b1は1のバイナリ表現です。なぜなら、Java 7は、 0bまたは0Bのいずれかでそれらをプレフィックスすることでバイナリリテラルを記述できるためです。 ＆オペレーターは、数値が均等になると0を返します。たとえば、 IsEven(4) 100 & 001になります。 & 000の結果。
public static boolean isEven ( final int value ) {
return ( value & 0b1) == 0 ;
}値が2つの正のパワーであるかどうかを確認します。
それがどのように機能するかを理解するために、私たちがIsPowerOfTwo(4)電話したと仮定します。
値は0より大きいため、 &&演算子の右側が評価されます。
(~value + 1)の結果は、値自体に等しくなります。 ~100 + 001 => 011 + 001 => 100 。これは価値に等しい。
(value & value)の結果は価値です。 100 ＆ 100 => 100 。
これは、値が値に等しいため、式をtrueに評価します。
public static boolean isPowerOfTwo ( final int value ) {
return value > 0 && (( value & (~ value + 1 )) == value );
} Integer.MIN_VALUEとInteger.MAX_VALUEの間にランダムな整数を生成します。
public static int generateRandomInt () {
return ThreadLocalRandom . current (). nextInt ();
}文字列のすべてのアナグラムを生成します（複製を含みます）。
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 ());
}文字列の長さをバイト単位で返します。
public static int byteSize ( String input ) {
return input . getBytes (). length ;
}文字列の最初の文字を大文字にします。
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 ()));
}文字列内のすべての単語の最初の文字を大文字にします。
public static String capitalizeEveryWord ( final String input ) {
return Pattern . compile ( " \ b(?= \ w)" ). splitAsStream ( input )
. map ( w -> capitalize ( w , false ))
. collect ( Collectors . joining ());
}提供された文字列で母音のnumberを返します。
public static int countVowels ( String input ) {
return input . replaceAll ( "[^aeiouAEIOU]" , "" ). length ();
}正規表現で使用する文字列を逃がします。
public static String escapeRegExp ( String input ) {
return Pattern . quote ( input );
}CamelCaseから文字列を変換します。
public static String fromCamelCase ( String input , String separator ) {
return input
. replaceAll ( "([a-z \ d])([A-Z])" , "$1" + separator + "$2" )
. toLowerCase ();
}与えられた文字列が絶対的なURLである場合はtrueを返し、それ以外の場合はfalse 。
public static boolean isAbsoluteUrl ( String url ) {
return Pattern . compile ( "^[a-z][a-z0-9+.-]*:" ). matcher ( url ). find ();
}文字列が小文字であるかどうかを確認します。
public static boolean isLowerCase ( String input ) {
return Objects . equals ( input , input . toLowerCase ());
}文字列が大文字であるかどうかを確認します。
public static boolean isUpperCase ( String input ) {
return Objects . equals ( input , input . toUpperCase ());
}文字列がパリンドロームであるかどうかを確認します。
public static boolean isPalindrome ( String input ) {
String s = input . toLowerCase (). replaceAll ( "[ \ W_]" , "" );
return Objects . equals (
s ,
new StringBuilder ( s ). reverse (). toString ()
);
}文字列が数値であるかどうかを確認します。
public static boolean isNumeric ( final String input ) {
return IntStream . range ( 0 , input . length ())
. allMatch ( i -> Character . isDigit ( input . charAt ( i )));
}文字の最後のnumを除くすべてのものを指定されたマスク文字に置き換えます。
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 );
}文字列を逆にします。
public static String reverseString ( String input ) {
return new StringBuilder ( input ). reverse (). toString ();
}文字列で文字をアルファベット順にソートします。
public static String sortCharactersInString ( String input ) {
return Arrays . stream ( input . split ( "" )). sorted (). collect ( Collectors . joining ());
}マルチライン文字列を一連の行に分割します。
public static String [] splitLines ( String input ) {
return input . split ( " \ r? \ n" );
}文字列を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 );
}文字列をケバブケースに変換します。
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 ;
}文字列をヘビのケースに変換します。
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 ( "_" ));
}指定された長さまで文字列を切り捨てます。
public static String truncateString ( String input , int num ) {
return input . length () > num
? input . substring ( 0 , num > 3 ? num - 3 : num ) + "..."
: input ;
}特定の文字列を単語の配列に変換します。
public static String [] words ( String input ) {
return Arrays . stream ( input . split ( "[^a-zA-Z-]+" ))
. filter ( s -> ! s . isEmpty ())
. toArray ( String []:: new );
}スペースで区切られた一連の数字をINTの配列に変換します。
public static int [] stringToIntegers ( String numbers ) {
return Arrays . stream ( numbers . split ( " " )). mapToInt ( Integer :: parseInt ). toArray ();
}入力ストリームを文字列に変換します。
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 ());
}ファイルのコンテンツを文字列に読み取ります
public String readFileAsString ( Path path ) throws IOException {
return new String ( Files . readAllBytes ( path ));
} public static String getCurrentWorkingDirectoryPath () {
return FileSystems . getDefault (). getPath ( "" ). toAbsolutePath (). toString ();
} java.io.tmpdirシステムプロパティの値を返します。最後に存在しない場合、セパレーターを追加します。
public static String tmpDirName () {
String tmpDirName = System . getProperty ( "java.io.tmpdir" );
if (! tmpDirName . endsWith ( File . separator )) {
tmpDirName += File . separator ;
}
return tmpDirName ;
}例外スタックトレースを文字列に変換します。
public static String stackTraceAsString ( final Throwable throwable ) {
final StringWriter sw = new StringWriter ();
throwable . printStackTrace ( new PrintWriter ( sw ));
return sw . toString ();
}オペレーティングシステムの名前を小文字として取得します。
public static String osName () {
return System . getProperty ( "os.name" ). toLowerCase ();
}デバッガがJVMに接続されているかどうかを確認します。
public static boolean isDebuggerAttached () {
final RuntimeMXBean runtimeMXBean = ManagementFactory . getRuntimeMXBean ();
return runtimeMXBean . getInputArguments ()
. stream ()
. anyMatch ( arg -> arg . contains ( "-agentlib:jdwp" ));
}このメソッドは、指定されたクラスとそのスーパークラスによって実装されたすべてのインターフェイスを返します。
この方法は、2つのストリームを連結することで機能します。最初のストリームは、インターフェイスとインターフェイスによって実装されたすべてのインターフェイスを備えたストリームを作成することにより、再帰的に構築されます。 2番目のストリームは、スーパークラスでも同じことを行います。その結果、複製を削除した後の2つのストリームの連結が得られます。
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 ());
}この方法は、指定されたクラスが内部クラスまたは静的ネストクラスであるかどうかをチェックします
public static boolean isInnerClass ( final Class <?> cls ) {
return cls != null && cls . getEnclosingClass () != null ;
}キーが名前と値が列挙自体である場所でマップするために列挙に変換します。
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 ()));
}このプロジェクトは、30秒コードのJavaフォークとして始まりました。努力をしてくれたプロジェクトの協力者に感謝します。
