자바 람다 쓰레드 문제 푼거 정리

▶ 스트림으로 평균 구하기

package Stream;

import java.util.Arrays;
import java.util.List;

public class exc_1 {
    public static void main(String[] args) {
        List<Integer> lst = Arrays.asList(1,2,3,4,5,6);

        Integer avg = (int) lst.stream()
                .mapToInt(Integer::intValue)
                .average().orElse(0);
        System.out.println(avg);

        double average = lst.stream()
                .mapToDouble(Integer::doubleValue)
                .average()
                .orElse(0.0);

        System.out.println(average);

    }
}

 

▶ 스트림으로 대문자 소문자

 

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class exc_2 {
    public static void main(String[] args) {

        List<String> lst = Arrays.asList("db","os","DataStrucTure");
        lst.replaceAll(str -> str.toLowerCase());
        lst.forEach(System.out::println);


        lst.replaceAll(str -> str.toUpperCase());
        lst.forEach(System.out::println);


        System.out.println("-----sol---------------------");

        List < String > colors = Arrays.asList("RED", "grEEn", "white", "Orange", "pink");

        List<String> uppercaseStrings = colors.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());

        System.out.println(uppercaseStrings);

        System.out.println("----------------------------------");

        List<String> lowercaseStrings = colors.stream()
                .map(String::toLowerCase)
                .collect(Collectors.toList());
        System.out.println(lowercaseStrings);

    }
}

▶ 스트림으로 짝수 홀수의 합을 구하기

 

import java.util.Arrays;
import java.util.List;

public class exc_3 {
    public static void main(String[] args) {
        List<Integer> lst = Arrays.asList(
                1,2,3,4,5,6
        );

        int sum_of_even =lst.stream().filter(num ->num %2==0)
                .reduce(0,Integer::sum);

        System.out.println(sum_of_even);



        int sum_of_odd = lst.stream()
                .filter(num -> num %2 !=0)
                .reduce(0,Integer::sum);

        System.out.println(sum_of_odd);


        int sumOfEvens = lst.stream()
                .filter(num -> num % 2 == 0)
                .mapToInt(Integer::intValue)
                .sum();

        System.out.println("Sum of even numbers: " + sumOfEvens);

        // Sum of odd numbers
        int sumOfOdds = lst.stream()
                .filter(num -> num % 2 != 0)
                .mapToInt(Integer::intValue)
                .sum();

        System.out.println("Sum of odd numbers: " + sumOfOdds);
    }
}

▶ 스트림으로 중복되는 수 제거

 

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class exc_4 {
    public static void main(String[] args) {
        List<Integer> lst = Arrays.asList(
                1,2,3,3,3,4,4,5
        );

        lst.stream().distinct().forEach(System.out::println);


        List < Integer > nums = Arrays.asList(10, 23, 22, 23, 24, 24, 33, 15, 26, 15);
        System.out.println("Original List of numbers: " + nums);
        // Remove duplicates
        List < Integer > distinctNumbers = nums.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println("After removing duplicates from the said list: " + distinctNumbers);
    }
}

▶ 스트림으로 특정 문자 시작하는 것을 찾는 코드

 

import java.util.Arrays;
import java.util.List;

public class exc_5 {
    public static void main(String[] args) {
        List < String > colors = Arrays.asList("Red", "Green", "Blue", "Pink", "Brown");
        System.out.println("Original list of strings (colors): " + colors);
        char startingLetter = 'B';
        // Count strings starting with a specific letter
        long ctr = colors.stream()
                .filter(s -> s.startsWith(String.valueOf(startingLetter)))
                .count();
        System.out.println("\nNumber of colors starting with '" + startingLetter + "': " + ctr);
        char startingLetter1 = 'Y';
        // Count strings starting with a specific letter
        ctr = colors.stream()
                .filter(s -> s.startsWith(String.valueOf(startingLetter1)))
                .count();
        System.out.println("\nNumber of colors starting with '" + startingLetter1 + "': " + ctr);

    }
}

 

▶ 스트림으로 알파벳 오름차순 반대로 알파벳 내림차순 정렬

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class exc_6 {
    public static void main(String[] args) {
        List<String> lst = Arrays.asList("a" ,"b", "c","z","r");

       lst.stream()
               .sorted()
               .collect(Collectors.toList()).forEach(System.out::println);

        System.out.println("--------------------------------------------------");
        lst.stream()
                .sorted(Comparator.reverseOrder())
                .collect(Collectors.toList()).forEach(System.out::println);


        List < String > colors = Arrays.asList("Red", "Green", "Blue", "Pink", "Brown");
        System.out.println("Original List of strings(colors): " + colors);
        // Sort strings in ascending order
        List < String > ascendingOrder = colors.stream()
                .sorted()
                .collect(Collectors.toList());

        // Sort strings in descending order
        List < String > descendingOrder = colors.stream()
                .sorted(Comparator.reverseOrder())
                .collect(Collectors.toList());

        System.out.println("\nSorted in Ascending Order: " + ascendingOrder);
        System.out.println("\nSorted in Descending Order: " + descendingOrder);

    }

}

▶ 스트림으로 가장 큰 값과 작은 값 찾는 방법

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class exc_7 {
    public static void main(String[] args) {
        List<Integer> lst = Arrays.asList(1,2,3,4,5,5,6,10);

        int max_num =lst.stream().distinct().max(Integer::max).orElse(0);
        System.out.println(max_num);

        int min_num = lst.stream().distinct().min(Integer::min).orElse(0);
        System.out.println(min_num);


        List < Integer > nums = Arrays.asList(1, 17, 54, 14, 14, 33, 45, -11);
        System.out.println("Original list of numbers: " + nums);
        // Find the maximum value
        Integer max_val = nums.stream()
                .max(Integer::compare)
                .orElse(null);

        // Find the minimum value
        Integer min_val = nums.stream()
                .min(Integer::compare)
                .orElse(null);

        System.out.println("\nMaximum value of the said list: " + max_val);
        System.out.println("\nMinimum value of the said list: " + min_val);

    }
}

▶ 스트림으로 두번째로 가장 큰 값과 작은 값찾는 방법

 

import java.util.Arrays;
import java.util.List;

public class exc_8 {
    public static void main(String[] args) {
        List<Integer> lst = Arrays.asList(1,2,3,4,4,5,6,7,7,10);

        int secondSmallest = lst.stream()
                .sorted()
                .skip(1)
                .findFirst()
                .orElse(-1);

        System.out.println(secondSmallest);

        int secondLargest = lst.stream()
                .sorted((a,b) -> b -a)
                .skip(1)
                .findFirst()
                .orElse(-1);
        System.out.println(secondLargest);

        List < Integer > nums = Arrays.asList(1, 17, 54, 14, 14, 33, 45, -11);
        System.out.println("List of numbers: " + nums);
        // Find the second smallest element
        Integer scdSmallest = nums.stream()
                .distinct()
                .sorted()
                .skip(1)
                .findFirst()
                .orElse(null);

        // Find the second largest element
        Integer scdLargest = nums.stream()
                .distinct()
                .sorted((a, b) -> Integer.compare(b, a))
                .skip(1)
                .findFirst()
                .orElse(null);

        System.out.println("\nSecond smallest element: " + scdSmallest);
        System.out.println("\nSecond largest element: " + scdLargest);
    }
}