String

replace(바꾸고싶은 원본글자,바뀌게될 글자)

class Solution {
    public String solution(String my_string, String letter) {
        String answer = "";

        answer = my_string.replace(letter, "");

        return answer;
    }
}

letter을 ""로 바꾸는 함수

replaceAll(정규식,정규식으로 바뀌게 될 글자)

class Solution {
    public String solution(String my_string) {
        String answer = "";

        answer = my_string.replaceAll("[aeiou]", "");

        return answer;
    }
}

정규 표현식 [aeiou]은 소문자 모음(a, e, i, o, u)을 나타냅니다. 여기에서 대괄호([])는 문자 클래스(character class)를 나타냅니다. 문자 클래스는 괄호 안의 어떤 문자든지 매칭시킬 수 있다는 것을 의미

• [abc]: a, b, c 중 어떤 문자와도 매칭됩니다.
• [0-9]: 0부터 9까지의 숫자 중 어떤 숫자와도 매칭됩니다.
• [a-zA-Z]: 영문 알파벳 중 어떤 대소문자 알파벳과도 매칭됩니다.
• [^0-9]: 0-9가 아닌 문자와 매칭됨

이런식으로 사용

length()

class Solution {
    public int solution(String message) {
        return message.length()*2;
    }
}

문자열길이 구하기

⭐️toCharArray()

class Solution {
    public int solution(String my_string) {
        // 결과를 저장할 변수를 초기화합니다.
        int answer = 0;
        
        // 정규 표현식을 사용하여 문자열에서 숫자만을 추출하여 새로운 문자열을 생성합니다.
        // [^0-9]는 숫자가 아닌 모든 문자를 의미하며, replaceAll("[^0-9]","")은 
        //숫자가 아닌 모든 문자를 제거합니다.
        String str = my_string.replaceAll("[^0-9]", "");

        // 추출한 숫자들을 char로 변환하고, 각 숫자를 더하여 answer 변수에 누적합니다.
        for (char ch : str.toCharArray()) {
            // char를 숫자로 변환하여 더합니다.
            answer += Character.getNumericValue(ch);
        }

        // 결과값을 반환합니다.
        return answer;
    }
}

문자열을 char형 배열로 변환

⭐️toUpperCase()

class Solution {
    public String solution(String myString) {
        return myString.toUpperCase();
    }
}

문자열을 대문자로 바꿔주는 util

⭐️toLowerCase()

import java.util.*;
class Solution {
    public String solution(String myString) {
        String answer = myString.toLowerCase();
        return answer;
    }
}

문자열을 소문자로 바꿔주는 util

⭐️substring(자르기 시작할 index,자를 끝 index)

class Solution {
    public String solution(String my_string, int n) {
        return my_string.substring(my_string.length() - n);
    }
}

startIndex부터 lastIndex 전까지의 문자열을 잘라서 리턴

⭐️contains(문자열)

if(!tUserName.contains(userName)){
            result.setResultCode(400);
            result.setResultMsg("본인인증 정보와 이름이 일치하지 않습니다.");
            return result;
        }

tUserName에 userName이 포함되어있는지 확인

indexOf(문자열)

class Solution {
    public int solution(String myString, String pat) {
        int answer = 0;
        String str = myString.toLowerCase();
        String str2 = pat.toLowerCase();

        if (str.indexOf(str2) != -1) {
            return 1;
        }
        return 0;
    }
}

str 문자열 중에 str2의 index위치를 찾아주는 기능이다.

⭐️repeat(반복할 횟수)

class Solution {
    public String solution(String my_string, int k) {
        return my_string.repeat(k);
    }
}

my_string을 k번 반복

startsWith(검사할 문자열)

class Solution {
    public int solution(String my_string, String is_prefix) {
        if (my_string.startsWith(is_prefix)) return 1;
        return 0;
    }
}

is_prefix로 my_string이라는 문자열이 시작하는지 검사
공백도 취급하니 확인필수!

trim()

class Solution {
    public String[] solution(String my_string) {
        return my_string.trim().split("[ ]+");
    }
}

trim : 문자열 앞뒤 공백 제거
[ ]+ : 공백 찾기
\\s+ : 공백 찾기 (참조 https://sebhastian.com/slash-s-plus-java/)

endsWith()

class Solution {
    public int solution(String my_string, String is_suffix) {
        if(my_string.endsWith(is_suffix)) {
            return 1;
        } else {
            return 0;
        }
    }
}

endsWith() 메서드는 문자열이 특정 접미사로 끝나는지 확인하는 Java의 내장 메서드입니다.
my_string.endsWith(is_suffix)는 my_string이 is_suffix로 끝나면 true를 반환하고, 그렇지 않으면 false를 반환합니다.

⭐️chars()⭐️

class Solution {
    public int solution(String numStr) {
        return numStr.chars().map(c -> c - 48).sum();
    }
}

numStr.chars(): 이 부분은 문자열 numStr을 각 문자의 정수 표현으로 변환한 IntStream을 생성합니다.

.map(c -> c - 48): 이 부분은 각 문자를 해당 문자의 유니코드 값에서 숫자 '0'의 유니코드 값을 뺀 결과로 매핑합니다. 이를 통해 문자를 숫자로 변환합니다. 예를 들어, 문자 '3'은 유니코드 값으로 51이고, '0'은 유니코드 값으로 48입니다. 따라서 '3' - '0'은 51 - 48으로 3이 되어 숫자로 변환됩니다.

"12345"라는 문자열을 numStr.chars()로 변환하면 각 문자의 유니코드 값이 순차적으로 들어있는 스트림이 생성됩니다.
실제로 numStr.chars()가 반환하는 스트림은 다음과 같이 됩니다:
49, 50, 51, 52, 53 (각 문자의 ASCII 코드 값)
-> 실제로는 1,2,3,4,5 임

.sum(): 변환된 각 숫자들의 합계를 계산합니다.

예를 들어, 만약 numStr이 "12345"라면, 이 코드는 1 + 2 + 3 + 4 + 5를 계산하여 15를 반환할 것입니다.

format(포맷형식,포맷할 문자열)

package study.softeer;

import java.util.*;


public class 전광판
{
    public static void main(String args[])    {

            String d1 = String.format("%5s",data[i][0]); //다섯자리 글자수로 
            //맞춘다. -> 4444면  공백1칸4444로 d1에 대입
            String d2 = String.format("%5s", data[i][1]);

    }
}

4444-> _4444로 맞춰지는거니까 format을 잘할 필요가 있다

split(나눌 문자, 제한 할 수)

제한할 수 만큼만 문자열 나눠줍니다

public class Split {
	public static void main(String[] args)  {	
		String str = "123 4 5 67 890  ";
		
		String[] LimitThree = str.split(" ", 3);
		String[] LimitExceed = str.split(" ", 10);
		String[] LimitZero = str.split(" ", 0);
		String[] LimitMinus = str.split(" ", -1);
		
		System.out.println("----LimitThree----");
		for(int i = 0; i < LimitThree.length; i++)
			System.out.println(i + "배열 : " + LimitThree[i]);
            //----LimitThree----
            //0배열 : 123
            //1배열 : 4
            //2배열: 5 67 890
		System.out.println("----LimitExceed----");
		for(int i = 0; i < LimitExceed.length; i++)
			System.out.println(i + "배열 : " + LimitExceed[i]);
            //----LimitExceed----
            //0배열 : 123
            //1배열 : 4
            //2배열: 5
            //3배열: 67 
            //4배열: 890
            //5배열:
            //6배열:
		System.out.println("----LimitZero----");
		for(int i = 0; i < LimitZero.length; i++)
			System.out.println(i + "배열 : " + LimitZero[i]);
            //----LimitZero----
            //0배열 : 123
            //1배열 : 4
            //2배열: 5
            //3배열: 67 
            //4배열: 890
		System.out.println("----LimitMinus----");
		for(int i = 0; i < LimitMinus.length; i++)
			System.out.println(i + "배열 : " + LimitMinus[i]);
            //----LimitExceed----
            //0배열 : 123
            //1배열 : 4
            //2배열: 5
            //3배열: 67 
            //4배열: 890
            //5배열:
            //6배열:
	}
}
출처: https://crazykim2.tistory.com/549 [차근차근 개발일기+일상:티스토리]

두 번째 매개변수로 전달된 -1은 구분자로 빈 문자열이나 공백도 인식하도록 합니다.

charAt(index)

class Solution {
    public String solution(String my_string, int num1, int num2) {
        String answer = "";

        char[] ch = my_string.toCharArray();

        ch[num1] = my_string.charAt(num2);
        ch[num2] = my_string.charAt(num1);

        answer = String.valueOf(ch);
        return answer;
    }
}

charAt:my_string이 가리키고 있는 문자열에서 num1번째에 있는 문자를
char타입으로 변환한다
String.valueOf(ch): 여러 기본 타입을 String 클래스로 변경할 수 있도록 하는 내장 메서드이며, ch를 String으로 변환한다

valueOf(변수)

char c = 'a';

String str = String.valueOf(c);
System.out.println(str);

char형 c를 String형으로 변환

join(각 문자를 이을 문자열, 문자열 배열)

class Solution {
    public String solution(String[] arr) {
        return String.join("", arr);
    }
}

new String(str)

import java.util.*;
class Solution {
    public String solution(String my_string) {
        char[] c = my_string.toLowerCase().toCharArray();
        Arrays.sort(c);
        return new String(c);
    }
}

String array의 문자열을 이어서 string으로 반환할 수 잇는 방법

sum()

class Solution {
    public boolean solution(int x) {
        int sum = String.valueOf(x).chars().map(ch -> ch - '0').sum();
        return x % sum == 0;
    }
}

이 코드는 주어진 숫자 x의 각 자릿수를 더한 값으로 x를 나누었을 때 나머지가 0인지를 확인하는 메소드를 구현하고 있습니다.

String.valueOf(x)를 사용하여 정수 x를 문자열로 변환합니다.
.chars() 메소드를 사용하여 이 문자열의 각 문자를 나타내는 스트림을 생성합니다.
map(ch -> ch - '0')을 사용하여 각 문자를 해당하는 숫자로 변환합니다. 이때 '0'은 ASCII 값으로 문자 '0'의 값이며, 이를 빼줌으로써 각 숫자 문자에 해당하는 숫자 값으로 변환됩니다.
.sum() 메소드를 사용하여 변환된 숫자들의 합을 계산합니다.
x % sum == 0을 사용하여 x를 변환된 숫자들의 합으로 나누었을 때 나머지가 0인지를 확인합니다. 이 결과가 참이면 true를 반환하고, 그렇지 않으면 false를 반환합니다.
즉, 이 메소드는 x의 각 자릿수의 합으로 x를 나누었을 때 나머지가 0이면 true를 반환하고, 그렇지 않으면 false를 반환합니다.

String[]

repeat

class Solution {
    public String solution(String my_string, int n) {
        String answer = "";
        String[] arr = my_string.split("");

        for(int j=0; j<my_string.length(); j++){
            answer+= arr[j].repeat(n);
        }


        return answer;
    }
}

repeat: String[j]가 n번 반복된 문자열을 반환

StringBuilder

⭐️reverse⭐️

import java.util.*;

class Solution {
    public String solution(String my_string) {
    //StringBuilder 객체를 생성하여 주어진 문자열을 저장
        StringBuilder sb = new StringBuilder();
        sb.append(my_string);
        //문자열 뒤집기
        sb.reverse();

        return sb.toString(); //StringBuilder 객체 문자 출력
    }
}

reverse()를 사용해서 문자열을 뒤집음

public String reverseStr(String str){
        char[] sol = str.toCharArray();
    Arrays.sort(sol);
    return new StringBuilder(new String(sol)).reverse().toString();
    }

이건 append안쓰고 그냥 new StringBuilder(new String(sol))
이렇게 사용한거..신기

Character

⭐️getNumericValue(char형 문자)

class Solution {
    public int solution(String num_str) {
        int answer = 0;
        for(char c : num_str.toCharArray()){
            answer += Character.getNumericValue(c) ;
        }
        return answer;
    }
}

char형 문자중에 숫자로되어있는 char형 문자를 int형 숫자로 반환해주는 함수

isUpperCase(char형 문자)

import java.util.*;
class Solution {
    public String solution(String my_string) {
        String answer = "";
        char[] arr = my_string.toCharArray();
        
        for(char c : arr){
            if(Character.isUpperCase(c)){
                answer += Character.toLowerCase(c);
            }else{
                answer += Character.toUpperCase(c);
            }
        }
        return answer;
    }
}

대문자인지 확인

Character.isLowerCase(char형 문자): 소문자인지 확인
Character.toLowerCase(char형 문자):char형 문자를 소문자로 변경
Character.toUpperCase(char형 문자):char형 문자를 대문자로 변경

isDigit(char형 문자)

/**
	 * 문자열이 전부 숫자로 이루어져있는지 판단
	 * @param String
	 * @return boolean
	 */
public static boolean isNumberic(String str) {
		return str.chars().allMatch(Character::isDigit);
	}

character 문자가 숫자인지 판단해주는 함수

Integer

toString(정수)

class Solution {
    public String solution(String n_str) {
        String answer = Integer.toString(Integer.parseInt(n_str));

        return answer;
    }
}

compare(정수1,정수2)

import java.util.stream.IntStream;

class Solution {
    public int solution(int[] arr1, int[] arr2) {
        int answer = Integer.compare(arr1.length, arr2.length);

        if(answer == 0) {
            answer = Integer.compare(IntStream.of(arr1).sum(), 
            IntStream.of(arr2).sum());
        }

        return answer;
    }
}

Integer.compare(정수1,정수2)는 정수1이 정수2보다 크면 1을 반환
정수1이 정수2보다 작으면 -1, 정수1과 정수2가 같으면 0을 반환한다.

HashMap

getOrDefault(해쉬맵의 key, 해쉬맵이없다면 default로 가져올 자료형)

import java.util.*;

boolean[] timeUsedArr = reservationMap.getOrDefault(meetingRoom, 
	new boolean[19]);

meetingRoom이라는 key가 없으면 boolean[19]를 가져와라 라는 뜻

ArrayList

toArray(배열)

import java.util.*;
class Solution {
    public String[] solution(String[] todo_list, boolean[] finished) {
        List<String> list = new ArrayList<>();

        for(int i=0; i<todo_list.length; i++){
            if(finished[i] == false)
                list.add(todo_list[i]);
        }

        String[] answer = new String[list.size()];
        answer = list.toArray(answer);
        return answer;
    }
}

List 객체인 list를 배열로 변환하는 메소드

stream()

List<Integer> list = new ArrayList<>();
int[] array = list.stream().mapToInt(i->i).toArray();

List형태를 stream형태로 변환

Arrays

sort(Arrays, Collections)

import java.util.Arrays;
import java.util.Collections;

class Solution {
    public String solution(String s) {
        String answer = "";
        
        String[] str = s.split("");
        Arrays.sort(str, Collections.reverseOrder());
        
        for(String a : str)
           answer += a;
        
        return answer;
    }
}

문자열 내림차순

⭐️copyOfRange(복사할 배열,start index, finish index)

--num_list를 n-1부터 num_list.length까지 복사해주는 기능
import java.util.*;
class Solution {
    public int[] solution(int[] num_list, int n) {
        int[] a= Arrays.copyOfRange(num_list, n-1, num_list.length);
        return a;
    }
}

Arrays.copyOfRange(num_list,0,n);

copyOf(복사할배열,생성할 배열크기)

import java.util.*;
class Solution {
    public int[] solution(int[] num_list) {
        int[] answer = Arrays.copyOf(num_list, num_list.length + 1);

        if(num_list[num_list.length-1] > num_list[num_list.length-2]){
            answer[num_list.length] =  
                num_list[num_list.length-1] - num_list[num_list.length-2];
        }else{
            answer[num_list.length] = 
               num_list[num_list.length-1] * 2; 
        }

        return answer;
    }
}

num_list를 복사하는데 num_list.length+1 크기의 Int 배열을 answer을 생성한다

asList(배열)

import java.util.Arrays;
public class FindKim {
    public String findKim(String[] seoul){
        //x에 김서방의 위치를 저장하세요.
        int x = Arrays.asList(seoul).indexOf("Kim");        
        return "김서방은 "+ x + "에 있다";
    }

    // 실행을 위한 테스트코드입니다.
    public static void main(String[] args) {
        FindKim kim = new FindKim();
        String[] names = {"Queen", "Tod","Kim"};
        System.out.println(kim.findKim(names));
    }
}

seoul 배열을 List 형태로 바꾸는 함수

setAll(배열,람다식)

import java.util.*;

class Solution {
    public int[][] solution(int n) {
        int[][] answer = new int[n][n];

        Arrays.setAll(answer, i -> {
            int[] array = answer[i];
            array[i] = 1;
            return array;
        });
        return answer;
    }
}

setAll() : 배열을 채우는데 사용할 함수형 인터페이스를 매개변수로 받는다. 함수형객체나 람다식을 매개변수로 지정해야함

여기서는 answer배열을 사용해서 answer의 행을 array에 저장후
array의 열을 1로 설정하고 array를 리턴해서 해당 array처럼 answer을 채워준 코드이다.

Stream

import java.util.Arrays;

class Solution {
    public int[] solution(String[] strList) {
        return Arrays.stream(strList).mapToInt(String::length).toArray();
    }
}

문자열 리스트(strList)에 있는 각 문자열의 길이를 계산하여 정수 배열로 반환하는 code. 결과적으로, strList에 있는 각 문자열의 길이가 배열에 저장됩니다.

• mapToInt() 메서드는 각 요소에 대해 주어진 함수를 적용하고 그 결과를 정수로 매핑합니다. 여기서는 문자열의 길이를 계산하여 정수로 매핑
  => String::length 이거 뜻이 문자열의 length를 구해라 라는 뜻이므로 근데 그 length를 구한다음에 그걸 int로 바꾸는 메서드이다.

먼저 strList를 배열로 만들고 그 배열의 내용은 mapToInt메서드에서 strList의 string의 length를 toArray => 즉 다시 배열로만들어라

⭐️mapToInt(람다표현식 or 자료형 선언)

스트림을 IntStream으로 변환해주는 메서드다.
IntStream을 제외한 모든 스트림에서 동일하게 제공하는 메서드다.

import java.util.Arrays;

class Solution {
    public int[] solution(String myString) {

        return Arrays.stream(myString.split("x", myString.length()))
            .mapToInt(x -> x.length())
            .toArray();
    }
}

import java.util.Arrays;

class Solution {
    public int[] solution(String[] strList) {
        return Arrays.stream(strList).mapToInt(String::length).toArray();
        //mapToInt(반환할 자료형 타입:: 해야할 일 = length를 구해라)
        //예를들어 .mapToInt(Integer::parseInt)라면 Integer로 반환하는데
        //parseInt를 해라 라는 거지ㅓ!@@@
    }
}

• 이렇게 mapToInt(String::length)로 쓰일수도,
  mapToInt(x -> x.length())로 쓰일수도 있다
• intStream으로 변환할 때에도 사용된다.

filter

import java.util.Arrays;

class Solution {
    public int solution(int[] array, int height) {
        return (int) Arrays.stream(array).filter(value -> value > height)
        .count();
    }
}

array에서 value중에 value가 height보다 큰 것들의 count를 세서 정수형으로 캐스팅한다음 리턴해라

⭐️reduce

class Solution {
    public int solution(int[] numList) {
        return (Arrays.stream(numList).reduce((acc, i) -> acc * i)
        .getAsInt() < Math.pow(Arrays.stream(numList).sum(), 2)) ? 1 : 0;
    }
}

Stream.reduce(accumulator) 함수는 Stream의 요소들을 하나의 데이터로 만드는 작업을 수행
예를 들어, Stream에서 1부터 10까지 숫자가 전달될 때, 이 값을 모두 합하여 55의 결과가 리턴되도록 만들 수 있습니다. 여기서 연산을 수행하는 부분은 accumulator 함수이며, 직접 구현해서 인자로 전달해야 합니다.

reduce 사용방법 예시

가령, 주어진 배열이 [2, 3, 4, 5]라고 가정해봅시다.

첫 번째 요소와 초기값이 없는 경우:

reduce 함수에서 초기값이 주어지지 않으면 첫 번째 요소가 초기 누적값으로 사용됩니다. 
배열 [2, 3, 4, 5]에서 첫 번째 요소는 2입니다. 그래서 초기 누적값은 2가 됩니다.

초기 누적값 (acc) = 2
현재 요소 (i) = 3
acc * i 연산을 하면 2 * 3 = 6이 됩니다. 이제 누적값 (acc)은 6이 됩니다.

두 번째 요소부터:

이제 초기 누적값이 6이고 다음 요소인 4가 현재 요소 (i)로 사용됩니다.

초기 누적값 (acc) = 6
현재 요소 (i) = 4
acc * i 연산을 하면 6 * 4 = 24가 됩니다. 누적값 (acc)은 24가 됩니다.

마지막 요소까지 반복:

마지막으로, 초기 누적값이 24이고 마지막 요소 5가 현재 요소 (i)로 사용됩니다.

초기 누적값 (acc) = 24
현재 요소 (i) = 5
acc * i 연산을 하면 24 * 5 = 120이 됩니다. 최종 누적값은 120이 됩니다.

따라서 reduce 함수는 주어진 배열의 요소를 왼쪽에서 오른쪽으로 차례대로 가져와서 
누적값 (acc)과 현재 요소 (i)에 대해 정의된 연산을 수행합니다. 각 단계에서의 누적값은 
다음 단계의 연산에 사용됩니다. 최종적으로는 모든 요소가 처리된 후 최종 누적값이 반환됩니다.

import java.util.Arrays;

class Solution {
    public int solution(int[] numbers, int n) {
        return Arrays.stream(numbers).reduce(0, (acc, i) -> n >= acc ? 
        acc + i : acc);
    }
}

reduce함수에서 첫번째 인자는 초기값, 두번째 인자(acc,i) 중 acc는 누적값, i는 배열의 각 요소다.
위 코드에서 n은 문제에서 제시한 변수이고, acc(누적값)이 n보다 작거나 같으면 누적값은 acc+i가 되고 아니면 acc가 된다는 것이다.

⭐️sorted()

import java.util.Arrays;

class Solution {
    public int[] solution(int[] numList) {
        return Arrays.stream(numList).sorted().skip(5).toArray();
    }
}

sorted()는 Arrays.sort(정수배열)과 같은 역할을 한다.

skip(숫자)

앞에서부터 숫자 갯수만큼 skip하는것이다.

toArray()

import java.util.*;

class Solution {
    public String[] solution(String[] strArr) {
        return Arrays.stream(strArr).filter(s -> !s.contains("ad")).toArray(String[]::new);
    }
}

배열로 다시 만들어라라는 뜻인데
어떤 배열로 만들지 알려줘야된다.
예를 들어 String[]형태의 array를 만들고싶다면 toArray(String[]::new)이렇게 알려주는게 좋다.

나같은 경우에는

import java.util.*;
import java.util.stream.Stream;
class Solution {
    public String[] solution(String[] strArr) {
        List<String> list = new ArrayList<>();
        for(String str : strArr){
            if(!str.contains("ad")){
                list.add(str);
            }
        }

        return list.stream().toArray(String[]::new);
        //return list.stream().toArray(); 이렇게 했더니 
        // error: incompatible types: Object[] cannot be converted to 
        //String[]
        //이런 오류남
    }
}

toArray() 메소드가 Object[]를 반환하는데, 여러 가지 타입으로 구성된 Stream을 다룰 때는 toArray()를 호출할 때 반환 타입을 지정해 줘야하는데 지정해주지 않아 생긴 오류였다. 지정해주도록 하자 꼭!

map()

import java.util.*;

class Solution {
    public int[] solution(int[] arr, int k) {
        return Arrays.stream(arr).map(operand -> 
        k % 2 == 0 ? operand + k : operand * k).toArray();
    }
}

map 함수는 각 요소에 대해 주어진 람다 표현식을 적용하고 그 결과를 새로운 스트림으로 반환

⭐️boxed()⭐️

import java.util.*;
import java.util.stream.Collectors;

class Solution {
    public List<Integer> solution(int[] arr) {
        return Arrays.stream(arr).boxed().flatMap(num -> 
        Collections.nCopies(num, num).stream())
        .collect(Collectors.toList());
    }
}

boxed(): 각 정수를 박싱하여 스트림의 요소로 변환합니다. 이로써 int 스트림이 **Integer 객체 스트림으로 변환**됩니다.
왜냐면 arr가 int형 배열이었으므로!

flatMap(): 스트림의 각 요소에 대해 함수를 적용하고, 각 함수가 반환한 스트림을 하나의 스트림으로 평탄화(flatten)합니다. 즉, 각 요소에 대해 여러 개의 요소를 생성할 수 있고, 그러한 스트림들을 평탄화하여 하나의 스트림으로 만듭니다.

Collections.nCopies(num, num).stream():
예를 들어, Collections.nCopies(3, 7)을 호출하면, 값이 7인 요소를 3개 갖는 리스트를 생성합니다. 이 리스트는 {7, 7, 7}과 같이 세 개의 7로 구성됩니다. 이 리스트는 불변이기 때문에 요소를 변경할 수 없습니다. 그렇기 때문에 생성된 리스트를 수정하려고 하면 UnsupportedOperationException 예외가 발생할 것입니다.
그리고 stream()에 의해 리스트를 스트림으로 변환하는 것

collect(Collectors.toList()): 스트림의 각 요소를 리스트로 수집합니다.

limit(제한할 갯수)

import java.util.*;

class Solution {
    public int[] solution(int[] num_list) {
        return Arrays.stream(num_list)
            .sorted()
            .limit(5)
            .toArray();
    }
}

num_list를 stream으로 만든다음 오름차순 한다음에 5개만 배열로 만든다

⭐️collect()

import java.util.*;
import java.util.stream.Collectors;

class Solution {
    public String solution(String[] strList, String ex) {
        return Arrays.stream(strList).filter(s -> !s.contains(ex))
        .collect(Collectors.joining());
    }
}

Java의 스트림 API에서 .collect() 메서드는 스트림의 요소들을 수집하여 새로운 컬렉션이나 다른 데이터 구조로 변환하는 데 사용됩니다.

.collect(Collectors.joining()): 필터링된 스트림 요소들을 하나의 문자열로 합칩니다.

of()

import java.util.stream.Stream;
import java.util.stream.Collectors;

class Solution {
    public int solution(String myString, String pat) {
        return myString.contains(Stream.of(pat.split("")).
        map(str -> "A".equals(str)?"B":"A").collect(Collectors.joining()))
        ?1:0;
    }
}

Stream.of(pat.split(""))는 pat 문자열의 각 문자로 구성된 스트림을 생성하는 것입니다. 이 스트림을 통해 각 문자에 대한 작업을 수행할 수 있습니다.

max(비교함수)

import java.util.*;
import java.util.stream.Collectors;

class Solution {
    public int[] solution(int[] array) {
        List<Integer> list = Arrays.stream(array).boxed().
        collect(Collectors.toList());
        int max = list.stream().max(Integer::compareTo).orElse(0);
        int index = list.indexOf(max);
        return new int[] {max, index};
    }
}

.max(Integer::compareTo)는 스트림에서 최댓값을 찾습니다. Integer::compareTo는 비교 함수(comparator)로, 정수를 비교하는 기준을 제공합니다.
.orElse(0)은 최댓값이 존재하지 않을 경우 기본값으로 0을 사용하도록 합니다. 따라서 최댓값을 찾지 못하면 0이 반환됩니다.
int index = list.indexOf(max);은 리스트에서 최댓값 max의 인덱스를 찾아서 변수 index에 저장합니다.

flatMapToInt(람다식)

import java.util.*;

class Solution {
    public int[] solution(int[] arr, int[][] intervals) {
        return Arrays.stream(intervals)
        .flatMapToInt(ints -> Arrays.stream(
        Arrays.copyOfRange(arr, ints[0], ints[1] + 1))).toArray();
    }
}

자바의 flatMapXXXX( )  메서드는 기존의 스트림의 데이터를 다수의 데이터로 구성된 새로운 스트림으로 리턴하는 역할을 한다.  여기서의 플랫은 다양한 타입의 매개변수를 받을 수 있으며, 또한 flatMapToInt / flatMapToDouble 등과 같이 제네릭 타입을 특정 타입으로 매핑해주는 것 도 가능

flatMapToInt란?
기존의 String 형태의 배열을 인트형 배열로 변환시키기 위해 인트형으로 매핑하는 flatMapToInt 메소드를 사용하여, 인트형 배열 스트림을 리턴

average()

import java.util.*;
import java.lang.*;

class Solution {
    public double solution(int[] arr) {

        return Arrays.stream(arr).average().getAsDouble();
    }
}

평균값을 구하는 함수
getAsDouble: double형으로 변경

IntStream

forEach(화살표함수)

import java.util.Scanner;
import java.util.stream.IntStream;

public class Solution {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();

        StringBuilder sb = new StringBuilder();
        IntStream.range(0, a).forEach(s -> sb.append("*"));
        IntStream.range(0, b).forEach(s -> System.out.println(sb.toString()));
    }
}

.forEach(s -> sb.append("*")) : 이 부분은 각 정수에 대해 실행될 동작을 정의합니다. 여기서 s는 각 정수를 나타냅니다. 이 코드는 sb라는 StringBuilder 객체에 '*' 문자를 a번만 추가합니다.

⭐️rangeClosed⭐️

import java.util.stream.IntStream;

class Solution {
    public int solution(int n) {
        // 1부터 n까지의 정수 범위를 생성하고, n을 각 정수로 나누어 떨어지는 수를 필터링한 
        //후, 그 개수를 반환합니다.
        return (int) IntStream.rangeClosed(1, n).filter(i -> n % i == 0)
        .count();
    }
}

(int): count() 메서드의 반환값은 long 타입입니다. 이 값을 int로 형변환하여 최종 결과를 반환합니다.

import java.util.stream.IntStream;
import java.util.Arrays;

class Solution {
    public int[] solution(int n) {
        return IntStream.rangeClosed(1, n).filter(i -> n % i == 0)
        .toArray();
    }
}

1~n까지 int형 스트림을 생성한다.

내림차순 배열 만들기

import java.util.stream.IntStream;

class Solution {
    public int[] solution(int start, int end) {
        return IntStream.rangeClosed(-start, -end).map(i -> -i).toArray();
    }
}

IntStream.rangeClosed(-start, -end)는 -start부터 -end까지의 정수를 포함하는 IntStream을 생성합니다. map(i -> -i)는 각 요소에 대해 음수를 취하고, toArray()는 스트림의 요소를 배열로 변환합니다.

따라서, 이 코드에서 음수를 취하는 이유는 start와 end 사이의 정수를 내림차순으로 배열에 저장하기 위해서입니다.

예를 들어, start가 2이고 end가 5인 경우, 함수는 배열 [-5, -4, -3, -2]를 반환합니다.

그니까 한마디로 rangeClosed(start,last)는 걍 START~LAST배열을 만드는건데
여기서는 일부러 -start,-last로 해서 내림차순처럼 보이도록 만들고 다시 음수를 양수로 바꿔주는것이다.

filter()

import java.util.stream.IntStream;
class Solution {
    public int[] solution(int n, int k) {

        return IntStream.rangeClosed(1,n).filter(i -> i%k == 0).toArray();
    }
}

주의사항 : java.util.*로 하면 IntStream을 못읽음
1~n까지 정수중에서 i%k==0인 것만 정수 배열로 만드는 문법

intStream으로 정수 배열 만들기

import java.util.stream.IntStream;
class Solution {
    public int[] solution(int n) {
        int[] answer = 
        IntStream.rangeClosed(1, n).filter(i -> i % 2 == 1).toArray();
        return answer;
    }
}

1~n까지 숫자중에 해당숫자%2가 1인것만 배열로 만들어라

⭐️of⭐️

IntStream.of(numList).anyMatch(num -> num == n) ? 1 : 0;

IntStream.of()는 정수 값을 포함하는 IntStream을 생성하는 정적 메서드
이 메서드는 입력된 정수들을 스트림으로 변환합니다. 예를 들어, IntStream.of(1, 2, 3, 4, 5)와 같이 사용하면 1, 2, 3, 4, 5를 요소로 갖는 IntStream을 생성할 수 있습니다.

.anyMatch(num -> num == n) 부분은 IntStream의 각 요소에 대해 주어진 조건식(num == n)을 만족하는지 검사합니다. 만약 리스트에서 조건을 만족하는 요소가 존재하면 true를 반환하고, 그렇지 않으면 false를 반환합니다.

sum()

import java.util.stream.IntStream;

class Solution {
    public int solution(int[] num_list) {
        IntStream stream = IntStream.of(num_list);
        return num_list.length>10?stream.sum():stream.reduce(1, (a, b) -> 
        a * b);
    }
}

stream의 합계를 구해주는 함수

⭐️range(index시작,index끝)⭐️

IntStream에서 index를 만들어내는 함수

import java.util.Arrays;
import java.util.stream.IntStream;

class Solution {
    public String[] solution(String[] strArr) {
        return IntStream.range(0, strArr.length).mapToObj(i -> 
        i % 2 == 0 ? 
        strArr[i].toLowerCase() : 
        strArr[i].toUpperCase()).toArray(String[]::new);
    }
}

IntStream.range(0, strArr.length): 이 부분은 0부터 strArr.length - 1까지의 정수 스트림을 생성합니다. 이 스트림은 배열의 인덱스를 나타냅니다.

.mapToObj(i -> i % 2 == 0 ? strArr[i].toLowerCase(): strArr[i].toUpperCase()): 이 부분은 각 인덱스에 대해 조건에 따라 대문자 또는 소문자로 변환된 문자열을 생성합니다. 짝수 인덱스의 경우 해당 문자열을 소문자로 변환하고, 홀수 인덱스의 경우 해당 문자열을 대문자로 변환합니다.

.toArray(String[]::new): 이 부분은 스트림의 결과를 문자열 배열로 변환합니다.

anyMatch(변수 -> 비교식)

import java.util.stream.IntStream;

class Solution {
    public int[] solution(int[] arr, int[] delete_list) {
        return IntStream.of(arr).filter(i -> !IntStream.of(delete_list).anyMatch(s -> s == i)).toArray();
    }
}

anyMatch() 메서드는 주어진 조건에 일치하는 요소가 하나라도 있는지 여부를 반환합니다.

⭐️iterate(초기 값,종료 조건을 나타내는 람다 함수,값이 어떻게 변경될지를 나타내는 람다 함수)

import java.util.stream.IntStream;

class Solution {
    public int solution(int[] num_list) {
        return Integer.max(
        IntStream.iterate(0, i -> i < num_list.length, i -> i + 2)
                .map(i -> num_list[i])
                .sum(), 
                IntStream.iterate(1, i -> i < num_list.length, i -> i + 2)
                .map(i -> num_list[i])
                .sum());
    }
}

IntStream.iterate(0, i -> i < num_list.length, i -> i + 2)를 사용하여 짝수 인덱스를 갖는 스트림을 생성합니다. 여기서 i는 인덱스를 나타냅니다. i가 배열의 길이보다 작은 동안 계속해서 2씩 증가합니다.
( for 루프문과 문법이 상당히 유사하다고 생각하면된다)

⭐️mapToObj(람다식)

입력 스트림으로부터 무언가를 받아서, 새로운 결과 가지고 있는 스트림으로 변환하는 것(stream을 토대로 Obj로 이루어진 스트림을 새로 생성)
mapToXXX는 스트림의 요소들을 다른 요소로 바꾼 새로운 스트림을 돌려줍니다.

import java.util.stream.*;

class Solution {
    public String solution(String[] myStrings, int[][] parts) {
        return IntStream.range(0, myStrings.length).
        mapToObj(i -> myStrings[i].substring(parts[i][0], parts[i][1] + 1))
        .collect(Collectors.joining());
    }
}

.mapToObj(i -> myStrings[i].substring(parts[i][0], parts[i][1] + 1)): 각 인덱스에 대해 myStrings[i]에서 parts[i][0]부터 parts[i][1]까지의 부분 문자열을 추출합니다. substring 메서드의 두 번째 매개변수는 종료 인덱스이므로 +1을 해서 해당 인덱스까지의 문자열을 포함하도록 합니다.

.collect(Collectors.joining()): 추출된 부분 문자열을 하나의 문자열로 결합합니다. 이때, 아무런 구분자 없이 단순히 이어 붙입니다.
이 함수에 의해 Stream<String>형태 였던 객체가 String을 결합하게 되며 최종적으로 String형태를 return하게 되는 것이다.

그리고 range를 쓰는 이유는 위 streamAPI에서 index를 i라는 걸로 활용하고있기 때문에 range,rangeClosed,iterate와 같은 Index를 계산할 수 있는 역할을 하는 함수를 쓰는 것이 필수적이다.

findFirst()

import java.util.stream.IntStream;

class Solution {
    public int solution(int[] arr, int idx) {
        return IntStream.range(idx, arr.length).filter(i -> arr[i] == 1)
        .findFirst().orElse(-1);
    }
}

IntStream.range(idx, arr.length): 배열의 인덱스 idx부터 배열의 끝까지의 인덱스를 스트림으로 생성합니다.
.findFirst(): 필터링된 원소 중 첫 번째 원소를 반환
.orElse(-1): 만약 찾지 못하면 기본값으로 -1을 반환합니다.

allMatch(람다식)

import java.util.stream.*;

class Solution {
    public int solution(int[][] arr) {
        // IntStream.range(0, arr.length): 0부터 arr.length - 1까지의 인덱스를 
        //스트림으로 생성
        // allMatch(i -> ...): 모든 i에 대해서 주어진 조건이 true인지 확인

        // IntStream.range(i + 1, arr.length): i보다 큰 인덱스부터 
        // arr.length - 1까지의 인덱스를 스트림으로 생성
        // allMatch(j -> ...): 모든 j에 대해서 주어진 조건이 true인지 확인
        return IntStream.range(0, arr.length)
            .allMatch(i -> IntStream.range(i + 1, arr.length)
                .allMatch(j -> arr[i][j] == arr[j][i])) ? 1 : 0;
    }
}

allMatch는 스트림의 모든 요소가 주어진 조건을 만족하는지 확인하는 메서드

findFirst()

import java.util.stream.IntStream;

class Solution {
    public int solution(int n) {
        return IntStream.range(2, n).filter(i -> n % i == 1).findFirst().orElse(0);
    }
}

첫번째로 찾아지는 것 반환

LongStream

iterate(시작요소, 요소를 생성하는 람다식)

import java.util.stream.LongStream;

class Solution {
  // x: 시작 값, n: 요소 개수
  public long[] solution(int x, int n) {
      // LongStream.iterate를 사용하여 등차 수열 생성
      // iterate 메소드의 첫 번째 인자는 시작 요소, 두 번째 인자는 요소를 생성하는 람다식
      // limit 메소드를 사용하여 요소 개수 제한
      // toArray 메소드를 사용하여 Long 배열로 변환 후 반환
      return LongStream.iterate(x, i -> i + x).limit(n).toArray();
  }
}

long형의 x로 시작하는 배열을 만드는데 x, x+x, x+x+x 이런식으로 하라는 뜻이다.

Math

ceil (올림)

class Solution {
    public int solution(int n) {
        return (int) Math.ceil(n / 7.0);
    }
}

Math.ceil(double형 숫자) 이런식으로 사용해야 하기 때문에 int형인 answer에 맞춰서 다시 캐스팅 해줫음....

⭐️sqrt(숫자)

lass Solution {
    public int solution(int n) {
        if (n % Math.sqrt(n) == 0) {
            return 1;
        } else {
            return 2;
        }
    }
}

정수 n이 제곱수인지 여부를 확인하고 제곱수면 1 아니면2 리턴하는 코드이다
Math.sqrt(n): 숫자 n의 제곱근 값을 리턴

⭐️pow(제곱하고싶은수, 몇제곱)

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

        double result = Math.pow(5, 2); //5의제곱
        System.out.println("5의 제곱은 : "+result);
    }
}

return되는 값이 double형이므로 주의

⭐️max(비교할 수1,비교할 수2)

class Solution {
    public int solution(int a, int b) {
        String strA = String.valueOf(a);
        String strB = String.valueOf(b);
        String strSum1 = strA + strB;
        String strSum2 = strB + strA;
        return Math.max(Integer.valueOf(strSum1), 
        	Integer.valueOf(strSum2)); //같으면 어차피 같은값 리턴됨
    }
}

수1과 수2를 비교해서 더 큰 수 리턴

abs(숫자)

절대값 리턴해줌

floor(숫자)

class Solution {
  public long solution(long n) {

    double i = Math.sqrt(n);

    return Math.floor(i) == i ? (long) Math.pow(i + 1, 2) : -1;
  }
}

i를 내림차순하는 것

Collections

swap(list,인덱스1,인덱스2)

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

class Solution {
    public String solution(String myString, int num1, int num2) {
        List<String> list = Arrays.stream(myString.split(""))
        .collect(Collectors.toList());

        Collections.swap(list, num1, num2);
        return String.join("", list); //리스트의 각 요소를 지정된 
        //구분자(이 경우에는 빈 문자열)로 연결하여 하나의 문자열로 만드는 역할
    }
}

List 안에 있는 데이터 순서를 변경하고 싶은 경우

java에서 제공하는 Collections swap을 사용해서 변경할 수 있다.