본문 바로가기
Programming/JAVA

이론_21. 자료구조 관련 클래스

by yoon9i 2024. 3. 6.
/*
    <자료구조 관련 클래스>

    ◎ Collections
        - Collections (클래스, java.util.Collections) 클래스는 유틸리티 클래스 중 하나로, Collection(java.util.Collection) 과
          관련된 유용한 기능을 가지고 있다.
        - 객체 메서드 : 유틸리티 클래스는 객체 메서드를 가지지 않는다.
        - 정적 메서드
            -> <T>addAll(Collection<? super T> c, T... ts)
                : Collection<T> 타입의 c(collection) 객체에 ts 가 가진 T 타입의 인자를 모두 추가한다.
            -> <T>copy(List<? super T> dest, List<? extends T> source)
                : source 가 가진 인자를 dest 에 복사한다. 단, dest 의 길이는 source 의 길이 이상이어야 한다.
            -> <T>fill(List<? super T> c, T t)
                : c 가 가진 모든 인자를 t 로 변경한다.
            -> frequency(Collection<?> c, Object o)
                : c 가 가진 모든 인자 중 전달 받은 o 와 equals() 호출 결과가 true 인것의 개수( int )를 반환한다.
            -> <T>replaceAll(List<T> c, T o, T n)
                : c 가 가지는 모든 인자 중에 o와 equals() 가 true 인 인자들을 모두 n 으로 대체한다.
            -> reverse(List<?> c)
                : c 가 가지는 인자들의 순서를 뒤집는다.(원래있는 순서를 뒤집는것, 정렬x)
            -> <T>reverseOrder()
                : sort() 메서드에 활용할 수 있는 Comparator<T> 객체를 반환한다. 내림차순 정렬을 위해 사용한다.
            -> shuffle(List<?> c)
                : c 가 가지는 인자들의 순서를 무작위로 섞는다.
            -> <T>sort(List<T> c)
                : c 가 가지는 인자를 오름차순으로 정렬한다.
            -> <T>sort(List<T> c, Comparator<? super T> p)
                : c 가 가지는 인자를 주어진 비교자 p 의 기준에 맞게 정렬한다.
            -> <T>unmodifiableCollection(Collection<? extends T> c)
                : c 객체가 가지는 인자를 그대로 가지는 새로운 Collection 객체를 반환한다. 단, 반환된 객체의 인자 변경은 불가능하다.
            -> <K, T>unmodifiableList(List<? extends T> c)
                : c 객체가 가지는 인자를 그대로 가지는 새로운 List 객체를 반환한다. 단, 반환된 객체의 인자 변경은 불가능하다.
            -> <T>unmodifiableMap(Map<? extends T> c)
                : c 객체가 가지는 인자를 그대로 가지는 새로운 Map 객체를 반환한다. 단, 반환된 객체의 인자 변경은 불가능하다.
            -> <T>unmodifiableSet(Set<? extends T> c)
                : c 객체가 가지는 인자를 그대로 가지는 새로운 Set 객체를 반환한다. 단, 반환된 객체의 인자 변경은 불가능하다.


    ◎ Arrays
        - Arrays (클래스, java.util.Arrays) 클래스는 기본 자료형인 배열( [] ) 및 리스트 (java.util.List) 등과 관련된 편의 사항을
          제공하는 유틸리티 클래스이다.
        - 객체 메서드 : 유틸리티 클래스는 객체 메서드를 가지지 않는다.
        - 정적 메서드
            -> <T>asList(T... ts) // T... : 타입으로 따지면 배열 (== T[])
                : T 에 대한 배열(T[])을 T 에 대한 java.util.List 객체(List<T>)로 반환한다.
            -> <T>compare(T[] a, T[] b)
                : 전달된 배열 a와 b의 길이가 같고 각 순서에 동일한 인자가 들어있을 경우 0을 반환한다.
                  a가 b보다 작을 경우 음수를,a가 b보다 클 경우 양수를 반환한다.
            -> <T>copyOf(boolean[] a, int n)
                : 전달받은 배열 a 의 인자를 그대로 가지는 길이가 s인 새로운 배열을 반환한다.
                  단, 전달 받은 배열의 길이가 s 보다 크다면 후순위에 있는 인자를 자르고(Truncation), s가 배열의 길이보다 크다면,
                  빈 공간을 기본값으로 채운다(Padding).
            -> <T>copyOfRange(T[] a, int s,int t)
                : <T>copyOf(...) 와 용법은 비슷하나 길이가 아닌 인덱스 범위를 직접 지정해주는 부분이 다르다.
                  순번 s 부터 t 앞까지의 내용만을 가지는 배열을 반환한다.
            -> <T>equals(T[] a, T[] b)
                : <T>compare(...) 의 결과 값이 0인가에 대한 여부(boolean)를 반환한다.
                  즉, a 와 b의 길이 및 인자의 순서가 모두 같아야 true 가 반환한다.
            -> fill(?[] a, ? b)
                : 어떤 타입의 배열 a 의 모든 칸을 동일한 타입의 값 b 로 채운다.
            -> <T>mismatch(T[] a, T[] b)
                : a 와 b 배열을 첫 순번 부터 비교하여 같은 순번하에 그 값이 다른 순번을 반환한다.
                  모든 순번하의 값이 같다면 -1을 반환한다.
            -> <T>sort(T[] ts)
                : 배열 ts가 가지는 값을 오름차순 정렬한다.
                  만약, T가 참조타입이라면 Comparable 에서 정의하는 값으로 비교한다.
            -> <T>sort(T[] ts,Comparator<? super T> c)
                : 배열 ts 가 가지는 값을 c 의 기준에 따라 정렬한다.
            -> <T>stream(T[] ts)
                : StreamAPI 를 사용하기 위한 ts 에 대한 Stream 객체를 반환한다.

    ◎ List

        -정적 메서드
            -> <T>copyOf(Collections<? extends T> c)
                : c 가 가진 인자를 동일하게 가지는 새로운 수정 불가능한(Unmodifiable) List<T> 객체를 반환한다.
            -> <T>of()
                : 인자를 가지지 않는 새로운 수정 불가능한(Unmodifiable) List<T> 객체를 반환한다.
            -> <T>of(T...ts)
                : T[] 인 ts가 가지는 인자를 인자로 가지는 수정 불가능한(Unmodifiable) List<T> 객체를 반환한다.

    ◎ 반복자(Iterator)

        - 어떠한 Collection 객체가 가진 인자를 반복(Iteration) 하고자 할때 사용한다. 일반적인 경우는 for 등의 반복문을 사용하면 되나,
          반복 중 인자를 제거(Remove)하는 로직이 있다면 반복자를 사용하는 것이 좋다.
          (인덱스가 있는 경우 역순 for 를 사용해도 무방함.)

    ◎ Stream API

        - Stream API 는 배열(Array)이나 리스트(List)의 사용을 보다 쉽게(?) 해준다.
        - Stream<T> 형식으로 사용하며 이 객체는 T 타입의 인자들에 대한 여러 기능을 가지고 있다.
        - Stream<T> 타입의 객체가 가진 여러 메서드는 Predicate<? super T> 타입의 객체를 매개변수로 받는데 이는 함수 인터페이스로,
          전달 받은 매개변수에 대해 논리값(boolean)을 반환토록 하는 구성요소이다. (인자) -> {(함수)} 형식이며 함수의 첫 구분이 논리
          값에 대한 return 이라면 (인자) -> [구문] 형식으로 작성한다. 이를 람다(Lambda) 라고 부르기도 한다.

        - 객체메서드
            -> <T>allMath(Predicate<? super T> P)
                :Stream<T> 객체가 가진 인자 전체가 주어진 함수 인터페이스 p 를 만족하는가에 대한 여부(boolean)를 반환한다.
            -> <T>anyMath(Predicate<? super T> P)
                :Stream<T> 객체가 가진 인자중 하나 이상이 주어진 함수 인터페이스 p 를 만족하는가에 대한 여부(boolean)를 반환한다.
            -> <T>noneMath(Predicate<? super T> P)
                :Stream<T> 객체가 가진 인자 전체가 주어진 함수 인터페이스 p 를 만족하지않는가에 대한 여부(boolean)를 반환한다.
            -> <T>distinct()
                : Stream<T> 객체가 가지느 인자 중 중복되는 인자를 제거한 새로운 Stream<T> 를 반환한다.
                  이떄 인자가 기초 타입이면 == 비교를, 참조타입이면 equals() 호출을 통해 같은가에 대한 여부를 가린다.
            -> <T>filter(Predicate<? super T> p)
                :Stream<T> 객체가 가진 인자 중 주어진 함수 인터페이스 p의 조건을 만족하는 인자만을 가지는
                새로운 Stream<T> 객체를 반환한다.
            -> <T>forEach(Consumer<? super T> c)
                : Stream<T> 객체가 가진 인자에 대해 c 함수를 반복하여 호출한다.
                  반환 값이 없음에 유의한다.
            -> <T>map(Function<? super T, ? extends R> m)
                : 객체가 가진 T 타입의 인자에 대해 주어진 함수 m을 적용한 새로운 Stream<T> 를 반환한다.
            -> sorted()
                : Stream<T> 객체가 가진 인자를 오름차순 정렬하여 새로운 Stream<T> 객체로 반환한다.
            -> toArray()
                : Stream<T> 객체가 가진 인자를 Object[] 타입으로 반환한다.
            -> toArray(T[]::new)
                : Stream<T> 객체가 가진 인자를 T[] 타입으로 반환한다.
                    - T::m 형식은 메서드 참조(Method Reference)라고 하며, 어떠한 인자(들)에 대해 실행할 메서드가 단 하나일때
                      사용할수 있다. T[]::new 에서 new 는 메서드는 아니지만 객체화를 하기 위한 생성자 호출과 동일하다고 생각할 수 있다.
                      마찬가지로 인자의 구조와 참조되는 메서드의 매개변수 구조가 같아야 하며, 이에 변수 전달은 생략한다.
            -> skip(int n)
                : 호출 대상이 되는 Stream 객체가 가진 인자 중 앞 n개를 버린 새로운 Stream 객체를 돌려준다.
            -> limit(int n)
                : 호출 대상이 되는 Stream 객체가 가진 인자 중 앞 n개만 인자로 가지는 Stream 객체를 돌려준다.

*/

'Programming > JAVA' 카테고리의 다른 글

이론_23. 의존성  (0) 2024.03.06
이론_22. JDBC  (0) 2024.03.06
이론_20. 자료구조  (0) 2024.03.06
이론_19. 제네릭  (0) 2024.03.06
이론_18. 인터페이스  (0) 2024.03.06