개발자 아지트

자바에서는 함수를 메서드라 한다. 

public class Method1{
	public static void main(String[] args) {
    
    	int a = 1;
        int b = 2;
        
        int sum = a + b;
    	int sum 2 = add(10, 20);
    }
    
    public static int add(int a, int b){ // 선언부
    	int sum = a + b;  // 본문 시작
        return sum;
    }
}

모든 메서드는 return을 호출해야한다. 

반환타입이 void인 경우에는 return이 생략가능하다. (자바가 알아서 return을 넣어준다.)

return문 만나면 즉시 함수를 빠져나간다. 

함수의 반환값이 있어도 반환값을 안받고 무시도 가능하다. 

(void는 받으면 안됨)

함수 이름은 동사로 시작 시킴 

단축키:  함수이름 누르고 command + b하면 해당 함수로 이동함

함수 호출시 메모리공간이 할당됨

함수 실행 끝나면 사라짐 

인수(Argument) == 인자

호출할 때 넘기는 값. 즉, 내부로 들어가는 값

매개변수(Parameter)

메서드 정의 시 선언한 변수를 말함

넘어오는 값을 중간에서 전달하는, 매개하는 변수

메서드 내부에서 사용할 수 있는 변수

메서드 호출 및 값 전달 

자바는 항상 변수의 값을 복사해서 대입한다. 

메서드 형변환

메서드를 호출할 인자와 매개변수의 타입이 맞지 않는경우에 형변환이 필요하다.

타입이 다른경우에는 자동 형변환이 가능한 경우(인자 타입이 함수의 매개변수 타입보다 작은 타입인 경우)에만 호출이 가능하다. 

public class Casting{
	public static void main(String[] args){
    	int number = 100;
        printNum(number); // 인자로 넘김 
    }
    
    public static void printNum(double n){// 매개변수로 받음, 자동형변환됨 int -> double
    	System.out.println(n);
    }
}

메서드 오버로딩

함수 이름이 같고 매개변수가 다른(매개변수의 순서와 타입이 다른경우) 메서드를 여러개 정의하는 것을 메서드 오버로딩(Overloading)이라 한다. 

(Overloading의 의미: 과하게 물건을 적재했다)

(반환 타입만 다른 경우는 취급하지 않는다. )

==메서드 시그니처(메서드를 구분할 수 있는 기준)

int plus(int a, int b)
int plus(int c, int d)

// 위와 같은 경우도 취급하지 않는다.

자기 타입에 맞는 메서드를 찾아서 실행해되, 없는 경우에는 형 변환 가능한 타입의 메서드를 찾아서 실행함 

코드를 메서드를 사용하는 식으로 리펙토링을 하면 main()은 상세 코드가 아닌, 전체 구조(목차같은 느낌)를 한눈에 볼 수 있게 되는 모습으로 된다. (모듈처럼 만들어두는 모습) 이런 리펙토링을 메서드 추출(Extract Method)라고 한다. 꼭 재사용 하지 않더라도 보기좋게 하기 위해서 리펙토링을 진행한다. 

기본형(Primitive Type) : 변수에 사용할 값을 직접 넣을 수 있는 데이터 타입

참조형(Reference Type) : 데이터에 접근하기 위한 참조(주소)를 저장하는 데이터 타입

배열과 객체, 클래스를 담는 변수 등은 참조형에 속함.

배열은 동적으로 사이즈를 변경할 수 있다. 

코드가 실행되는 시점에 배열의 크기가 정해지기 때문이다. 

예를 들면, 사용자 입력을 받아 배열의 크기를 설정할 수 있다. 

기본 형태

	public class Array1{
    	public static void main(String[] args){
        	int[] team; // 배열 변수 선언
            teams = new int[4]; // 배열 생성
        }
    
    }

	public class Array1{
    	public static void main(String[] args){
        	int[] team; // 배열 변수 선언
            teams = new int[]{1, 2, 3, 4}; // 배열 생성
        }
    
    }

	public class Array1{
    	public static void main(String[] args){
        	int[] team = new int[]{1, 2, 3, 4}; // 배열 생성
        }
    
    }

	public class Array1{
    	public static void main(String[] args){
        	int[] team = {1, 2, 3, 4}; // 배열 생성
        }
    
    }

리펙토링 :

기존 코드의 기능은 유지하면서 내부 구조를 개선하는 것을 말함.

(중복 제거, 복잡성을 줄이기, 이해하기 쉬운 코드로 다시 작성)

2차원 배열

arr[행][열] 

	public class Array1{
    	public static void main(String[] args){
        	int[][] team = new int[2][3]; // 배열 생성
        }
    
    }

	public class Array1{
    	public static void main(String[] args){
        	int[][] team = new int[2][3]{
                {1, 2, 3},
                {4, 5, 6}    
            }; // 배열 생성
        }
    }

향상된 for 문

코드가 간결하고 가독성이 좋음

public class test{
	public static void main(String[] args){
    int[] numbers = {1, 2, 3, 4, 5};
    
 	for (int number : numbers){
    	System.out.println(number);
    }
    }

}

(단축키 - iter) 

import java.util.Scanner;

public class Scanner1 {
	public static void main(String[] args){
    	Scanner scanner = new Scanner(System.in);
        
        String str = scanner.nextLine(); // 사용자 입력을 받는 부분
        // 엔터를 입력할 때 까지 문자를 가져옴 
        
        
        int intValue = scanner.nextInt(); // 정수값을 사용자 입력으로 받는 부분
        
        
        double doubleValue = scanner.nextDouble(); // 입력을 double로 받는 부분
        
        
    }

}

print() 다음 라인으로 넘기지 않는다. 

println() 다음 라인으로 넘긴다. 

변수의 종류

변수의 종류는 변수 선언 위치에 따라 아래와 같이 나뉜다. 

지역변수, 멤버 변수(클래스 변수, 인스턴스 변수)

지역변수

지역 변수는 특정 지역에서만 사용할 수 있는 변수이며, 지역은 코드 블록을 말한다. 

자신이 선언된 블록 외에서 자신에게 접근하려고 하면 접근할 수 없다. 

ex) if 문 안에서 선언한 변수는 if문 안에서만 사용할 수 있다. 

왜 지역 변수인가? 자신의 지역 안에서만 생존할 수 있기 때문이다. 

스코프의 표현

스코프 범위가 길다. 

스코프가 범위가  짧다. 

스코프는 왜 필요한가?

• 비효율적인 메모리 사용을 막기 위함
• 코드 복잡성을 낮추기 위함 
  • 좋은 코드는 군더더기 없는 단순한 코드임 
• 좋은 프로그램은 무한 자유가 있는 프로그램이 아닌 적절한 제약이 있는 프로그램이다.

형변환(캐스팅)

(cast-다른 물질을 녹여 특정 형태나 모양을 만드는 과정)

작은 범위에서 큰 범위로의 값은 허용함

이때, 사용자가 타입을 맞춰주지 않는 경우에는 자바에서 자동으로 형변환을 해줌(묵시적 형변환)

큰 범위의 값을 작은 범위로의 대입은 명시적 형변환이 필요하다. \

이때, 오버플로우 및 소수점 버림을 유의하고, 명시적 형변환을 사용하도록 해야한다.  

(명시적 형변환을 한다 하더라도 형변환 하기전의 변수값과 타입은 유지된다. )

타입의 범위 

int < long < double

자바에서의 계산

같은 타입끼리의 계산은 같은 타입의 결과를 나타낸다. 

서로 다른 타입의 계산은 큰 범위로 자동 형변환이 일어난다. 

do-while문 구조

조건에 만족하지 않아도 한번은 코드를 처한다. 

Continue

while(조건식){
	코드1;
    continue; // 즉시 조건식으로 이동한다. 
    코드2;
}

continue를 만날경우 즉시 조건식으로 가서 조건을 확인한다. 

향상된 for문 == for each

for(타입 변수명: 배열명) {
	System.out.println(변수명); // 예시, 배열의 원소를 출력함
}

기본 형태

public class test{
	public static void main(String[] args){
    int a = 19;
    
    if (a == 1) {
    	// 필요한 코드
    } else if (a == 2) {
    	// 필요한 코드
    } else{
    	// 필요한 코드
    }   
    }

}

팁

if문의 명령이 한개만 있어도 가독성이나 유지보수성을 고려했을때 중괄호를 사용하는것이 좋다. 

자바 14이상의 새로운 case문 

public class test{
	public static void main(String[] args){
    int a = 1;
    
   	int ticket = switch (a){
    	case 1 -> 100;
        case 2 -> 200;
        case 3 -> 300;
        default -> 500;
    };
    
    System.out.println(ticket); // 100 출력
    
    }
}

삼항 연산자 == 조건 연산자 

public class test{
	public static void main(String[] args){
    int a = 19;
    
   	String result = (a>=19) ? "네" : "아니오"; // result는 "네" 가됨
}

문자열 비교

문자열을 비교할 때는 .equals() 메서드를 사용한다.

만약 ==을 사용할 경우 실패할 경우가 발생할 수 있기때문이다. 

public class Test1{
	public static void main(String[] args){
    	String str1 = "hi";
        String str2 = "hello";
        
        boolean result = "hello".equals("hello"); // 리터럴 비교, true
        boolean result1 = str1.equals("hi");		// true
        boolean result2 = str1.equals(str2);		// false
    	
    }
}

문장 완성 단축키 : ctrl+ shift+ enter

논리 연산자

• &&: 두개의 피연산자가 모두 참이면 true를 반환, 둘 중 하나라도 거짓이면 false
• ||: 두개의 피연산자중 하나라도 참이면 true를 반환, 둘 다 모두 거짓이면 false

삼항 연산자:  ? :

instanceof 연산자 

• 객체의 타입을 반환한다. 

비트 연산자

• 실무에서 사용할 일이 거의 없음. 그때그때 찾아보면 

큐

자바에서는 큐 구현을 위해서 ArrayDeque를 많이 사용함. 

덱은 Double Ended Queue를 줄인 말로써, 양 끝에서 삽입 삭제를 가능토록 한 큐를 구현한 것이다. 

package Mar0308;

import java.util.Queue;
import java.util.ArrayDeque;


public class Test {	

	public static void main(String[] args) {
		
		// ArrayDeque으로 큐 구현
		Queue<Integer> queue = new ArrayDeque<>();
		
		// 큐에 데이터 추가 
		queue.add(1);
		queue.add(2);
		
		// 큐의 맨앞 데이터 제거 후 반환
		int first = queue.poll();
		System.out.println(first); // 1
		
	}

}

덱을 큐처럼 사용하는 코드 

package Mar0308;

import java.util.ArrayDeque;


public class Test {	

	public static void main(String[] args) {
		
		ArrayDeque<Integer> q = new ArrayDeque<>();
		
		q.addLast(1);
		q.addLast(2);
		
		// 큐의 맨 앞 데이터 제거 후 반환
		int first = q.pollFirst();
		System.out.println(first);
		
		
	}

}

데이터를 addFirst()로만 넣고, pollLast()로만 꺼내면 덱을 통해 스택을 구현할 수 있음

배열(배열 크기 정적 구현)

public class Test {	
	public static void main(String[] args) {
		
		int[] arr = {0, 0, 0};
		int[] arr = new int[3];
		
		// 두줄의 결과값이 동일하다. 	
        
        //관련 메소드 3가지 
        System.out.println(arr.length); // 1, ArrayList의 원소 개수를 반환하는 메소드 
		Arrays.sort(arr); // Array의 모든 데이터를 정렬
		// 정렬 대상외의 다른 인수를 추가하지 않으면 오름차순으로 정렬함, 
		// 특정 범위의 데이터만 정렬할 시, from, to 인덱스를 지정할 수 있음 
        
        // 배열의 모든 데이터를 String으로 반환하는 메서드
		System.out.println(Arrays.toString(arr)); 
        
	}
}

배열 사용시 시간 복잡도

*배열 데이터에 접근하기 위한 시간 복잡도는 O(1)

*배열에 데이터를 추가할 경우 

    1. 맨 뒤에 삽입할 경우 시간복잡도 : 맨 뒤에 임의 접근이 가능하고, 다른 데이터에 영향을 주지 않음, O(1)

    2. 맨 앞에 삽입할 경우 시간복잡도 : 기존 데이터들을 한칸씩 뒤로 미는 연산 필요함, 밀어야하는 데이터의 개수가 N이면,  O(N)

    3. 중간에 삽입할 경우 시간복잡도 : 삽입한 데이터 이후의 값들을 모두 한칸씩 뒤로 미는 연산 필요, 밀어야하는 데이터의 개수가 N이면,  O(N)

배열 사용시 고려할점 

임의 접근이 가능하여 빠르게 접근할 수 있지만, 이를 위해 충분한 메모리 공간이 필요함. 

배열의 중간이나 맨앞에 데이터 삽입이 많은지 확인해야함. 

ArrayList(배열 크기 동적 구현)

package Mar0308;

import java.util.ArrayList;
import java.util.Collections;

public class Test {	

	public static void main(String[] args) {
		
		ArrayList<Integer> list = new ArrayList<>();
		
		list.add(0); 
		list.add(1); // 리스트의 끝에 값 추가 
		
		
		// 다른 컬렉션을 통한 초기화 
		
		ArrayList<Integer> list2 = new ArrayList<Integer>(list);
		System.out.println(list2); //[0, 1]
		
		// 인덱스를 통한 접근
		System.out.println(list2.get(0)); // 0
		
		// 데이터 삭제
		list.remove(list.size() -1); // 마지막 데이터 삭제 
		System.out.println(list); // [0]
		
		// 관련 메소드 3가지 
		
		System.out.println(list.size()); // 1, ArrayList의 원소 개수를 반환하는 메소드 
		System.out.println(list.isEmpty()); // false, ArrayList에 저장된 데이터가 하나도 없는지 여부를 반환하는 메소드 
		Collections.sort(list); // ArrayList의 모든 데이터를 정렬
		// 정렬 대상외의 다른 인수를 추가하지 않으면 오름차순으로 정렬함, 
		// 특정 범위의 데이터만 정렬할 시, from, to 인덱스를 지정할 수 있음 
		System.out.println(list); 
		
	}

}

레퍼런스 타입은 참조형 변수이므로 프리미타입 보다 연산 속도가 느림 

따라서 프리미티브 타입을 주로 사용하는 것을 권장함

레퍼런스 타입이란 Integer, Long,Float, Double을 말하고

프리미티브 타입은 int, long, float, double을 말함

그러나 레퍼런스 타입에 대해서는 컬렉션 프레임워크 사용시, Integer, Float 타입을 저장할 때 사용하므로 알고는 있어야함. 
*컬렉션 프레임워크: 데이터를 저장하는 자료구조와 알고리즘을 구조화 하여 클래스로 구현해놓은 것을 말함

컬렉션 프레임워크

컬렉션 프레임워크는 다양한 자료구조를 직접 구현하지 않고 사용하게 해준다. 

주로 리스트(ArrayList), 스택(Stack), 큐(Queue), 데크(ArrayDeque), 해시맵(HashMap) 등을 사용한다. 

배열

import java.util.Arrays;

public class Test {

	public static void main(String[] args) {
		
		int[] array = { 2, 2, 2, 5 };
		
		// 배열을 출력할 때, java.util.Arrays의 toString()을 사용하면 쉽다.
        System.out.println(Arrays.toString(array)); // [2, 2, 2, 5]
		
		
	}

}

리스트

package Mar0308;

import java.util.ArrayList;

public class Test {	
	public static void main(String[] args) {
    
		// 리스트 객체 생성
		ArrayList<Integer> list = new ArrayList<>();
		
		list.add(1);
		list.add(2);
		
		System.out.println(list.get(1)); // 2
		System.out.println(list); // [1, 2]
		
	}
}

해시맵

해시맵은 키와 값 쌍을 저장하는 해시 테이블로 구현되어 있음

package Mar0308;

import java.util.HashMap;

public class Test {	
	public static void main(String[] args) {
		
		// 키는 문자열, 값은 정수형을 저장하는 해시맵 선언
		HashMap<String, Integer> map = new HashMap<>();
		
		// 해시맵 값 삽입
		map.put("vanilla cream cold brew", 1);
		map.put("ice americano", 2);
		map.put("ice vanilla latte", 3);
		
		// 해시맵 값 출력
		System.out.println(map); // {vanila cream cold brew=1, ice americano=2, ice vanila latte=3}
		
		
		
		// 해시맵에서 데이터 검색
		String key = "ice americano";
		
		if(map.containsKey(key)) {
			int value = map.get(key);
			System.out.println("key: " + key +  " value: " + value);
		}else {
			System.out.println("can't find");
		}
	
		
		// 해시맵 수정
		
		map.put("ice americano", 100);
		System.out.println(map); // {vanila cream cold brew=1, ice americano=100, ice vanila latte=3}
		
		// 해시맵 삭제
		
		map.remove("ice vanilla latte");
		System.out.println(map); // {vanila cream cold brew=1, ice americano=100}
		
		
	}

}

문자열

문자열은 문자들이 배열의 형태로 구성되어 있는 것이고, 이뮤터블 객체(변경할 수 없는 객체)이다. 

시간 복잡도 관점에서 사용시 주의 해야 한다. String의 값을 변경하는 연산이 많을 때는, StringBuilder 클래스나 StringBuffer클래스를 사용하는 것이 효율적이다.  

package Mar0308;

public class Test {	
	public static void main(String[] args) {
		
		// 문자열은 큰따옴표를 사용하여 표현한다. 
		String strr = "hi";
		
		// 문자열 추가 및 삭제 
		// 이때, 문자열은 이뮤터블 객체이므로 기존 객체를 수정하지 않고 새로운 객체를 생성하여 반환한다. 
		
		strr += "!!";
		
		// 반환시 기존 객체는 버리고 새로 생성한 객체만 사용함. 
		
		System.out.println(strr); // "hi!!"
		
		// 문자열 수정
		
		// replace(a, b) 
		// a에는 찾을 문자열, b에는 변경할 문자열 넣어 사용
		
		strr = strr.replace("i", "ello"); // "i" 를 모두 삭제함
		System.out.println(strr); // "hello!!"
		
	}
}

메서드

람다식

다른 말로 익명 함수라고도 한다. 코드에서 딱 한번 실행할 목적으로 사용하거나 함수 자체를 다른 함수의 인수로 전달할 때도 사용할 수 있다. 가독성이 좋아진다. 

package Mar0308;

import java.util.Arrays;
import java.util.Comparator;

public class Test {	
	
	private static class Node{
		int dest, cost;
		
		public Node(int dest, int cost) {
			this.dest = dest;
			this.cost = cost;
		}
	}
	
	public static void main(String[] args) {
		Node[] nodes = new Node[5];
		nodes[0] = new Node(1, 11);
		nodes[1] = new Node(2, 21);
		nodes[2] = new Node(3, 16);
		nodes[3] = new Node(4, 6);
		nodes[4] = new Node(5, 26);
        
        // 아래의 람다식과 일반식은 같은 역할을 수행한다...
		
		// 람다식
		Arrays.sort(nodes, (o1, o2) -> Integer.compare(o1.cost, o2.cost));
		
		// 일반식 
		Arrays.sort(nodes, new Comparator<Node>() {
			@Override
			public int compare(Node o1, Node o2) {
				return Integer.compare(o1.cost, o2.cost);
			}
		});
		
		
		System.out.println(Arrays.toString(nodes));
				
	}

}