코테 공부

 

삼항 연산

int answer = num % n == 0 ? 1 : 0;

int a = (조건문) ? (참):(거짓) ;

equals() 문자열 비교

if (str1.equals(str2)) {
 
}
=> str1 하고 str2 같으면 참 아니면 거짓이 나온다 
 

형변환 

문자-> 숫자 

int b=Integer.valueOf(str2);
double d_num = Double.valueOf(s);
float f_num = Float.valueOf(s);

 

숫자 -> 문자열

String s;
int i;

s= String.valueOf(i); 
s= Integer.toString(i);
s = ""+i;

s = String.valueOf(f); 
s = Float.toString(f); 
		
s = String.valueOf(d); 
s = Double.toString(d);

 

정수 <--> 실수

--(int)실수값
double d_num = 10.101010;
float f_num = 10.1010

int i_num;
i_num = (int)d_num; --Double-> Int
i_num = (int)f_num; --Float -> Int

--(int)실수값
int i_num = 10;
	
double d_num = (double)i_num; --Int -> Double
float f_num = (float)i_num; --Int -> Float

문자=>숫자

	char c = '5';
	int intValue = Character.getNumericValue(c);
	System.out.println(intValue); // 출력 결과: 5

문자열=> 문자

String temp = "캐릭터 변환하기";
char[] array = temp.toCharArray();
String change = "";
            
for (int j = 0; j < array.length; j++) {
    change+= Character.toString(array[j]);
}
System.out.println(change);

 

제곱

 Math.pow(sum,2)

 

문자열 하나하나씩 축출

=>str 이라는 문자열

for (int i=0 ; i<str.length();i++){
    char a= str.charAt(i);

 

대문자 소문자 구별 메소드

Character.isUpperCase(변수) 메서드 =>대문자일 경우 true를 반환하고 아니면 false를 반환한다
Character.isLowerCase(변수) 메서드 =>소문자일 경우 true를 반환하고 아니면 false를 반환한다
이 2개의 메서드를 이용하여 대소문자를 구별 할수 있다 여기서 변수는 char타입값또는 int값으로 할수 있다
 

대문자 소문자 변환 메소드

Character.toUpperCase(변수) =>대문자를 소문자로 변환한다
Character.toLowerCase(변수) =>소문자를 대문자로 변환한다

 

문자열 슬라이싱

str="1234567"
str.substring(0,5) => 12345가 나온다 
 

문자 배열을 문자열로 변환하기 (join)사용

str=String.join("구분자", arr);

arr에 담긴 문자들의 구분자로 구분하여 합처준다 \
만약 arr에 [a,b,c]가 담겨 있다면 
str는 abc를 저장하게 된다 
 
 

동적배열 (ArrayList)

import java.util.ArrayList;

ArrayList<Integer> list = new ArrayList<>(); //ArrayList선언

//데이터 추가
list.add(data)

//ArrayList의 값을 반환 하는방법
list.get();

//.size() ArrayList크기를 반환한다
for(int i=0;i<list.size();i++) { 
			변수= list.get(i);
		}

 

Arrays 클래스 메소드

import java.util.Arrays;

//배열 복사
int[] arr2 =Arrays.copyOf(arr1,arr1.length);
//arr1의 배열의 크기만큼 arr2로 복사

int[] arr1= {1, 2, 3, 4, 5};
int[] arr2 = new int[5];

System.arraycopy(arr1, 0, arr2, 0, arr1.length);
				(원본배열,원본시작인덱스,넣을배열,넣을배열의 시작인덱스,복사개수)
                
//배열 정렬
Arrays.sort(배열);

//배열 항목검색 (정렬후 가능)

int idx=Arrays.binarySearch(배열,"찾을값");

//배열 동일 값으로 채우기
int[] arr = new int[5];
Arrays.fill(arr, 10);
//arr 배열을 10으로 채워둠

int[] arr = {1, 2, 3, 4, 5};
Arrays.fill(arr, 1, 3, 10); // 배열 arr의 인덱스 1부터 3까지를 10으로 채움

//배열 항복비교
Arrays.equals(arr1, arr2) 는 Object의 주소는 달라도 참조값은 같나 비교
Arrays.deepEquals(arr1, arr2) 는 Object와 참조값의 주소는 달라도 값은 같나 비교

 
Stream 사용법
 
filtering

List<String> list = Arrays.asList("a","b","c");
Stream<String> stream = list.stream()
	.filter(item -> item.contains("a"));
    // 'a'가 들어간 요소만 선택  [a]

 
Mapping
스트림 내 요소들을 하나씩 특정 값으로 변환하는 작업, 값을 변환하기 위한 람다를 인자로 받는다.
스트림을 원하는 모양의 새로운 스트림으로 변환하고싶을 때 사용

Stream<String> stream = list.stream()
	.map(String::toUpperCase);
	//[A,B,C]
    
    .map(Integers::parseInt);
    // 문자열 -> 정수로 변환

스트림에 있는 값을 원하는 메소드에 입력값으로 넣으면 메소드 실행 결과(반환 값)가 담긴다.
 
정렬

Stream<String> stream = list.stream()
	.sorted() // [a,b,c] 오름차순 정렬
    .sorted(Comparator.reverseOrder()) // [c,b,a] (내림차순)
    
List<String> list = Arrays.asList("a","bb","ccc");
Stream<String> stream = list.stream()
	.sorted(Comparator.comparingInt(String::length)) // [ccc,bb,a] //문자열 길이 기준 정렬

Stream<String> stream = list.stream()
	.distinct() // 중복 제거
    .limit(max) // 최대 크기 제한
    .skip(n)    // 앞에서부터 n개 skip하기
    .peek(System.out::println) // 중간 작업결과 확인

IntStream stream = list.stream()
	.count()   //스트림 요소 개수 반환
    .sum()     //스트림 요소의 합 반환
    .min()     //스트림의 최소값 반환
    .max()     //스트림의 최대값 반환
    .average() //스트림의 평균값 반환

IntStream stream = IntStream.range(1,5);
	.reduce(10, (total,num)->total+num);
    //reduce(초기값, (누적 변수,요소)->수행문)
    // 10 + 1+2+3+4+5 = 25

// toList() - 리스트로 반환
members.stream()
	.map(Person::getLastName)
    .collect(Collectors.toList());
    // [lee, kim, park]
    
// joining() - 작업 결과를 하나의 스트링으로 이어 붙이기
members.stream()
	.map(Person::getLastName)
    .collect(Collectors.joining(delimiter = "+" , prefix = "<", suffix = ">");
    // <lee+kim+park>
    
//groupingBy() - 그룹지어서 Map으로 반환
members.stream()
	.collect(Collectors.groupingBy(Person::getAge));
	// {26 = [Person{lastName="lee",age=26}],
    //  23 = [Person{lastName="kim",age=23},Person{lastName="park",age=23}]}
    
//collectingAndThen() - collecting 이후 추가 작업 수행
members.stream()
	.collect(Collectors.collectingAndThen (Collectors.toSet(),
    									   Collections::unmodifi

Person person = members.stream()
					.findAny()   //먼저 찾은 요소 하나 반환, 병렬 스트림의 경우 첫번째 요소가 보장되지 않음
                    .findFirst() //첫번째 요소 반환

import java.util.stream.IntStream;

public class test{
    public static void main(String[] args){
        IntStream.range(1,11).forEach(i->{
            System.out.println(i);
        });
    }
}

// output:
1
2
3
4
5
6
7
8
9
10

 

IntStream 

 

IntStream.range(1, 10); // 1부터 9까지의 정수 스트림
IntStream.iterate(1, i -> i + 1); // 1부터 시작하여 계속 증가하는 무한 정수 스트림
int[] array = intStream.toArray();
intStream.forEach(System.out::println); // 각 요소를 출력
intStream.filter(i -> i % 2 == 0); // 짝수 요소로 구성된 스트림 생성intStream.map(i -> i * i); // 각 요소의 제곱으로 구성된 스트림 생성