30 seconds of java

Java의 30 초

빠르게 이해할 수있는 유용한 Little Java 8 기능의 선별 된 모음.

목차

정렬

내용을 봅니다

• chunk
• countOccurrences
• deepFlatten
• difference
• differenceWith
• distinctValuesOfArray
• dropElements
• dropRight
• everyNth
• filterNonUnique
• flatten
• flattenDepth
• groupBy
• head
• initial
• initializeArrayWithRange
• initializeArrayWithValues
• intersection
• isSorted
• join
• nthElement
• pick
• reducedFilter
• remove
• sample
• sampleSize
• shuffle
• similarity
• sortedIndex
• symmetricDifference
• tail
• take
• takeRight
• union
• without
• zip
• zipObject

수학

내용을 봅니다

• average
• gcd
• lcm
• findNextPositivePowerOfTwo
• isEven
• isPowerOfTwo
• generateRandomInt

끈

내용을 봅니다

• anagrams
• byteSize
• capitalize
• capitalizeEveryWord
• countVowels
• escapeRegExp
• fromCamelCase
• isAbsoluteURL
• isLowerCase
• isUpperCase
• isPalindrome
• isNumeric
• mask
• reverseString
• sortCharactersInString
• splitLines
• toCamelCase
• toKebabCase
• match
• toSnakeCase
• truncateString
• words
• stringToIntegers

io

내용을 봅니다

• convertInputStreamToString
• readFileAsString
• getCurrentWorkingDirectoryPath
• tmpDirName

예외

내용을 봅니다

• stackTraceAsString

체계

내용을 봅니다

• osName
• isDebuggerEnabled

수업

내용을 봅니다

• getAllInterfaces
• IsInnerClass

열거적

내용을 봅니다

• getEnumMap

정렬

큰 덩어리

배열을 지정된 크기의 더 작은 배열로 청크합니다.

 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 ()를 사용하여 지정된 값과 동일한 총 값 수를 계산합니다.

 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 ();
}

차이점

두 배열의 차이를 반환합니다.

B에서 세트를 작성한 다음 A arrays.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 함수를 사용하여 구현됩니다.

Array.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 ();
}

array의 고유 한 Values

배열의 모든 뚜렷한 값을 반환합니다.

Array.Stream (). Contrat ()를 사용하여 모든 복제 된 값을 폐기합니다.

 public static int [] distinctValuesOfArray ( int [] elements ) {
    return Arrays . stream ( elements ). distinct (). toArray ();
}

드롭 요소

전달 된 함수가 true가 반환 될 때까지 배열에서 요소를 제거합니다. 배열에서 나머지 요소를 반환합니다.

배열을 사용하여 array.copyofRange ()를 사용하여 기능에서 반환 된 값이 참이 될 때까지 배열의 첫 번째 요소를 삭제합니다. 나머지 요소를 반환합니다.

 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 ];
}

매번

배열에서 모든 n 번째 요소를 반환합니다.

intstream.range (). filter ()를 사용하여 주어진 배열의 모든 n 번째 요소가 포함 된 새 배열을 만듭니다.

 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 ();
 }

인덱스

배열에서 요소 색인을 찾으십시오. 요소가 존재하지 않는 경우 return -1.

intstream.range (). filter ()를 사용하여 배열에서 요소의 색인을 찾습니다.

 public static int indexOf ( int [] elements , int el ) {
    return IntStream . range ( 0 , elements . length )
            . filter ( idx -> elements [ idx ] == el )
            . findFirst ()
            . orElse (- 1 );
}

lastindexof

배열에서 요소의 마지막 인덱스를 찾으십시오. 요소가 존재하지 않는 경우 return -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 );
}

Filternonunique

배열에서 비 유니 값을 필터링합니다.

고유 값 만 포함 된 배열에 Array.Stream (). Filter ()를 사용하십시오.

 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 ();
}

flattendepth

지정된 깊이까지 배열을 평평하게합니다.

 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 (). 그룹화 함수를 기반으로 그룹에 수집 (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 ));
}

초기의

마지막 요소를 제외한 배열의 모든 요소를 ​​반환합니다. Array.copyOfRange ()를 사용하여 마지막을 제외한 모든 것을 반환하십시오

 public static < T > T [] initial ( T [] elements ) {
    return Arrays . copyOfRange ( elements , 0 , elements . length - 1 );
}

InitializearRayWithRange

시작과 끝이 포함되는 지정된 범위의 숫자를 포함하는 배열을 초기화합니다.

 public static int [] initializeArrayWithRange ( int end , int start ) {
    return IntStream . rangeClosed ( start , end ). toArray ();
}

InitializearRaywithValues

지정된 값으로 배열을 초기화하고 채 웁니다.

 public static int [] initializeArrayWithValues ( int n , int value ) {
    return IntStream . generate (() -> value ). limit ( n ). toArray ();
}

교차로

두 배열 모두에 존재하는 요소 목록을 반환합니다.

Sec

 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 ();
}

issorted

배열이 오름차순으로 정렬 된 경우 1 , 내림차순으로 정렬 된 경우 -1 또는 정렬되지 않은 경우 0 을 반환합니다.

처음 두 요소의 순서 direction 계산하십시오. 루프를 사용하여 배열 항목을 반복하고 쌍으로 비교하십시오. 마지막 요소에 도달하면 direction 변경되거나 direction 변경되면 0 반환하십시오.

 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 ;
}

가입하다

배열의 모든 요소를 ​​문자열로 결합 하고이 문자열을 반환합니다. 분리기와 끝 분리기를 사용합니다.

intstream.range를 사용하여 배열 항목으로 Zip Index를 정렬하십시오. 그런 다음 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 );
}

nthelement

배열의 n 번째 요소를 반환합니다.

Arrays.copyOfRange() 사용하여 NTH 요소가 포함 된 배열을 처음부터 가져옵니다.

 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-Yates 알고리즘을 사용하여 배열을 셔플하십시오. 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-Yates 알고리즘을 사용하여 배열의 요소를 재정렬합니다.

 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 ()));
}

SortedIndex

정렬 순서를 유지하기 위해 값을 배열에 삽입 해야하는 가장 낮은 지수를 반환합니다.

배열이 내림차순으로 정렬되어 있는지 확인하십시오 (느슨하게). 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 );
}

대칭 변환

두 배열 사이의 대칭 차이를 반환합니다.

각 배열에서 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 보다 1이면 전체 배열을 반환하십시오.

 public static < T > T [] tail ( T [] arr ) {
    return arr . length > 1
            ? Arrays . copyOfRange ( arr , 1 , arr . length )
            : arr ;
}

가져가다

N 요소가 처음부터 제거 된 배열을 반환합니다.

 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 );
}

노동 조합

두 배열 중 하나에 존재하는 모든 요소를 ​​한 번 반환합니다.

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 ()));
}

없이

지정된 값 중 하나가있는 배열의 요소를 필터링합니다.

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 ());
}

zipobject

유효한 속성 식별자 배열과 값 배열이 주어지면 속성을 값에 연결하는 객체를 반환하십시오.

 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

숫자 배열의 가장 큰 공통 분모 (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

숫자 배열의 가장 낮은 일반적인 배수 (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 );
}

findNextPesitivePowerOftWo

값보다 크거나 동일한 다음 전력을 찾습니다.

이 방법은 왼쪽 선박 연산자를 사용하여 오른쪽의 값으로 1을 이동합니다. 오른쪽은 Integer.numberOfLeadingZeros 방법을 사용하여 계산됩니다.

Integer.numberOfLeadingZeros 값을 이끄는 0의 수를 제공합니다. 예를 들어, 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 ));
}

ISEEVEN

번호가 짝수지 확인하십시오.

이 방법은 Bitwise & Operator를 사용합니다. 0b1 은 1의 이진 표현입니다. Java 7 이후 0b 또는 0B 로 접두사를 통해 이진 리터럴을 쓸 수 있습니다. & 운영자는 숫자 일 때 0을 반환합니다. 예를 들어, IsEven(4) 100 & 001 초래합니다. 결과는 & 000 .

 public static boolean isEven ( final int value ) {
    return ( value & 0b1) == 0 ;
}

ispoweroftwo

값이 2의 긍정적 인 전력인지 확인합니다.

그것이 어떻게 작동하는지 이해하기 위해 IsPowerOfTwo(4) 호출했다고 가정 해 봅시다.

값은 0보다 크기 때문에 && 운영자의 오른쪽이 평가됩니다.

(~value + 1) 의 결과는 값 자체와 같습니다. ~100 + 001 => 011 + 001 => 100 . 이것은 가치와 같습니다.

(value & value) 의 결과는 값입니다. 100 & 100 => 100 .

이것은 값이 값과 동일하므로 표현식을 참으로 평가합니다.

 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 ()));
}

Capitalizeeveryword

문자열의 모든 단어의 첫 글자를 대문자로 만듭니다.

 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 ();
}

ESCAPEREGEXP

정규 표현식으로 사용할 문자열을 탈출합니다.

 public static String escapeRegExp ( String input ) {
    return Pattern . quote ( input );
}

Camelcase에서

Camelcase에서 문자열을 변환합니다.

 public static String fromCamelCase ( String input , String separator ) {
    return input
            . replaceAll ( "([a-z \ d])([A-Z])" , "$1" + separator + "$2" )
            . toLowerCase ();
}

Isabsoluteurl

주어진 문자열이 절대 URL 인 경우 true 반환합니다. 그렇지 않으면 false .

 public static boolean isAbsoluteUrl ( String url ) {
    return Pattern . compile ( "^[a-z][a-z0-9+.-]*:" ). matcher ( url ). find ();
}

Islowercase

문자열이 소문자인지 확인합니다.

 public static boolean isLowerCase ( String input ) {
    return Objects . equals ( input , input . toLowerCase ());
}

Isuppercase

문자열이 대문자인지 확인합니다.

 public static boolean isUpperCase ( String input ) {
    return Objects . equals ( input , input . toUpperCase ());
}

이 팔린 드롬

문자열이 Palindrome인지 확인합니다.

 public static boolean isPalindrome ( String input ) {
    String s = input . toLowerCase (). replaceAll ( "[ \ W_]" , "" );
    return Objects . equals (
            s ,
            new StringBuilder ( s ). reverse (). toString ()
    );
}

isnumeric

문자열이 숫자인지 확인합니다.

 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 ();
}

SortCharactersinstring

알파벳순으로 문자열로 문자를 정렬합니다.

 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 );
}

Tokebabcase

문자열을 케밥 케이스로 변환합니다.

 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 ;
}

Tosnakecase

문자열을 뱀 케이스로 변환합니다.

 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 ( "_" ));
}

Truncatestring

지정된 길이까지 문자열을 잘립니다.

 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 );
}

StringTointEgers

공간별로 분리 된 숫자 문자열을 int 배열로 변환합니다.

 public static int [] stringToIntegers ( String numbers ) {
        return Arrays . stream ( numbers . split ( " " )). mapToInt ( Integer :: parseInt ). toArray ();
}

io

ConvertInputStreamToString

입력 스트림을 문자열로 변환합니다.

 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 ());
}

readFiLeasString

파일의 내용을 문자열로 읽습니다

 public String readFileAsString ( Path path ) throws IOException {
    return new String ( Files . readAllBytes ( path ));
}

GetCurrentWorkingDirectoryPath

 public static String getCurrentWorkingDirectoryPath () {
    return FileSystems . getDefault (). getPath ( "" ). toAbsolutePath (). toString ();
}

tmpdirname

java.io.tmpdir 시스템 속성의 값을 반환합니다. 끝에 없으면 분리기가 추가됩니다.

 public static String tmpDirName () {
    String tmpDirName = System . getProperty ( "java.io.tmpdir" );
    if (! tmpDirName . endsWith ( File . separator )) {
        tmpDirName += File . separator ;
    }

    return tmpDirName ;
}

예외

Stacktraceasstring

예외 스택 추적을 문자열로 변환합니다.

 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 ();
}

isdebuggerenabled

디버거가 JVM에 부착되어 있는지 확인합니다.

 public static boolean isDebuggerAttached () {
    final RuntimeMXBean runtimeMXBean = ManagementFactory . getRuntimeMXBean ();
    return runtimeMXBean . getInputArguments ()
            . stream ()
            . anyMatch ( arg -> arg . contains ( "-agentlib:jdwp" ));

}

수업

GetAllinterfaces

이 방법은 주어진 클래스와 슈퍼 클래스에서 구현 한 모든 인터페이스를 반환합니다.

이 방법은 두 개의 스트림을 연결하여 작동합니다. 첫 번째 스트림은 인터페이스와 인터페이스에서 구현 된 모든 인터페이스를 갖춘 스트림을 만들어 재귀 적으로 구축됩니다. 두 번째 스트림은 슈퍼 클래스에서도 동일합니다. 결과적으로 복제물을 제거한 후 두 스트림의 연결이 발생합니다.

 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 ());
}

IsinnerClass

이 방법은 지정된 클래스가 내부 클래스인지 정적 중첩 클래스인지 확인합니다.

 public static boolean isInnerClass ( final Class <?> cls ) {
    return cls != null && cls . getEnclosingClass () != null ;
}

열거적

getenummap

열거로 변환하여 키가 이름이고 값 자체가있는 곳에 매핑됩니다.

 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 ()));
}

뉴스에서

1. JetBrains Java는 1 월 뉴스 레터에서 매월 덮여있는 작은 자바 비전에 주석을 달았습니다.
2. Javachannel Podcast는 에피소드 11에서 작은 자바 기능을 다루었습니다.
3. Little-Java-Finctions는 2018 년 1 월 8 일에 Github 트렌드 리포지토리였습니다.

감사해요

이 프로젝트는 30 초의 코드의 Java 포크로 시작되었습니다. 노력에 대한 프로젝트 공동 작업자에게 감사드립니다.