저녕호의 개발 블로그

실습

1. turnOn(), turnOff() 인터페이스 생성

( 인터페이스를 생성하면 해당하는 메소드를 무조건 선언 및 구현해야 한다 )

2. Main 에서는 각각 냉장고와 에어컨을 선택하여 조절할 수 있음

3. 냉장고, 에어컨은 각각 켜기, 끄기, 온도 올리기, 온도 내리기 기능을 가짐

package main;

public interface HomeAppliances {
	void turnOn();
	void turnOff();
}

인터페이스 생성

package main;

import java.util.Scanner;

import airConditioner.AirConditioner;

public class Main {
	public static void main(String[] args) {
		while(true) {
			Scanner sc = new Scanner(System.in);
			System.out.println("\n제어할 가전제품 선택 : 1. 냉장고, 2. 에어컨, 3. 종료");
			System.out.print("입력 >>> ");
			int option = sc.nextInt();
			
			if(option == 1) {
				Refrigerator refrigerator = new Refrigerator();
				int refOption;
				while(refrigerator.showOption() != 5) {
					// 옵션 선택
					refOption = refrigerator.showOption();
					// 옵션 실행
					refrigerator.doOption(refOption);
				}
			}
			
			if(option == 2) {
				AirConditioner airConditioner = new AirConditioner();
				int airOption;
				while(airConditioner.getOption()!=5) {
					// 옵션 선택
					airOption = airConditioner.chooseOption();
					// 옵션 실행
					airConditioner.doOption(airOption);
				}
				System.out.println("이전으로 이동합니다.");
			}
			
			if(option == 3) {
				System.out.println("\n종료합니다.");
				break;
			}
		}
	}
}

main 코드 작성

package main;

import java.util.Scanner;

public class Refrigerator implements HomeAppliances{

    private int temperature;
    private boolean isOpen = false;
    
    public int showOption() {
    	Scanner sc = new Scanner(System.in);
    	System.out.println("\n1. 열기");
    	System.out.println("2. 닫기");
    	System.out.println("3. 온도 내리기");
    	System.out.println("4. 온도 올리기");
    	System.out.println("5. 이전으로");
    	System.out.print("입력 >>> ");
    	return sc.nextInt();
    }
    
    public void doOption(int option) {
    	if(option == 1) turnOn();
    	else if(option == 2) turnOff();
    	else if(option == 3) upTem();
    	else if(option == 4) downTem();
    }
    
    // 열기
	@Override
    public void turnOn() {
		if(isOpen == false) {
			temperature = 0;
	        System.out.println("\n냉장고를 엽니다. 현재 설정온도 : " + temperature);
	        isOpen = true;
		}
		else System.out.println("\n이미 냉장고가 열려있습니다.");
    }
	
	// 닫기
    @Override
    public void turnOff() {
    	if(isOpen == true) {
	        System.out.println("냉장고를 닫습니다.");
	        isOpen = false;
    	}
    	else System.out.println("이미 냉장고가 닫혀있습니다.");
    }
    
    // 온도 내리기
    public void upTem() {
    	if (temperature > -20) {
	    	temperature = temperature -1;
	    	System.out.println("\n온도를 1도 내립니다. 현재 온도 : " + temperature);
    	}
    	else System.out.println("\n최저 온도는 -20도 입니다. 현재 온도 : " + temperature);
    }
    
    // 온도 올리기
    public void downTem() {
    	if (temperature < 10) {
	    	temperature = temperature +1;
	    	System.out.println("\n온도를 1도 내립니다. 현재 온도 : " + temperature);
    	}
    	else System.out.println("\n최고 온도는 10도 입니다. 현재 온도 : " + temperature);
    }
    
}

냉장고 코드 작성

package airConditioner;

import java.util.Scanner;

import main.HomeAppliances;

public class AirConditioner implements HomeAppliances {
	
	private int temperature;
	private boolean isOn = false;
	private int option=0;
	
	// 에어컨 번호 선택 getter / setter
	public int getOption() {
		return option;
	}
	public void setOption(int option) {
		this.option = option;
	}
	
	// 에어컨 on/off getter / setter
	public boolean isOn() {
		return isOn;
	}
	public void setOn(boolean isOn) {
		this.isOn = isOn;
	}
	
	// 온도 getter / setter
	public int getTemperature() {
		return temperature;
	}
	public void setTemperature(int temperature) {
		this.temperature = temperature;
	}
	
	// 옵션 출력, 입력 받기
	public int chooseOption() {
			Scanner sc = new Scanner(System.in);
			System.out.println("<<< 기능 선택 >>>");
			System.out.println("1. 전원 켜기");
			System.out.println("2. 전원 끄기");
			System.out.println("3. 온도 올리기");
			System.out.println("4. 온도 내리기");
			System.out.println("5. 이전으로");
			System.out.print("번호를 입력하세요 >>> ");
			option = sc.nextInt();
			return option;
	}
	
	// 선택 기능으로 메소드 실행
	public void doOption(int option) {
		if (option == 1) choose1();
		else if (option == 2) choose2();
		else if (option == 3) choose3();
		else if (option == 4) choose4();
	}
	
	public void choose1() {
		if(isOn == false) turnOn();
		else System.out.println("에어컨이 이미 켜져있습니다.");
		System.out.println();
	}
	
	public void choose2() {
		if(isOn == true) turnOff();
		else System.out.println("에어컨이 이미 꺼져있습니다.");
		System.out.println();
	}
	
	public void choose3() {
		if(isOn == true) {
			System.out.println("현재 온도를 1도 올립니다.");
			setTemperature(getTemperature() + 1);
			System.out.println("현재 온도 : " + getTemperature());
			System.out.println();
		}
		else System.out.println("에어컨을 먼저 켜주세요"); 
	}
	
	public void choose4() {
		if (isOn == true) {
			System.out.println("현재 온도를 1도 내립니다.");
			setTemperature(getTemperature() - 1);
			System.out.println("현재 온도 : " + getTemperature());
			System.out.println();
		}
		else System.out.println("에어컨을 먼저 켜주세요"); 
	}
	
	
	
	// 에어컨 실행
	@Override
	public void turnOn() {
		System.out.println("에어컨을 켭니다.");
		isOn = true;
		temperature = 25;
		System.out.println("기본 설정 온도 : " + getTemperature());
	}

	// 에어컨 종료
	@Override
	public void turnOff() {
		System.out.println("에어컨을 끕니다.");
		isOn = false;
	}
	
}

에어컨 코드 작성

this

package this_;

class Test01{
	public int num = 12345;
	public void test() {
		int num = 303030;
		System.out.println("this : " + this); // this 는 자기 자신에 대한 정보를 의미 ( 클래스의 위치 )
		System.out.println("this : " + this.num); // 12345
		System.out.println("num : " + num); // 303030
		// this 를 사용하지 않으면 현재 지역에서 먼저 해당 값을 찾아서 출력한다
		// this 를 사용하면 자신 클래스 위치에서 부터 해당 값을 찾아서 하위로 내려온다
	}
}

public class Ex01 {
	public static void main(String[] args) {
		Test01 t = new Test01();
		System.out.println(" main : " + t); // Test01 클래스가 저장되어 있는 위치 값 반환
		System.out.println("main num : " + t.num); // Test01 클래스 하위의 num 메소드를 반환하여 실행
		
		t.test(); // Test01 클래스가 저장되어 있는 위치로 접근하여 해당 클래스 하위의 test() 메소드를 실행
		// this : this_.Test01@2133c8f8
		// this : 12345
		// num : 303030
	}
}

this 의 사용법과 의미

은닉화

package set_get;

class Test01{
	// 접근 제어자 private 을 사용하여 인스턴스 변수 num 을 은닉화 시킴 ( 외부 접근을 허용하지 않음 )
	private int num = 12345;
	public void test(int n) {
		// private 은 외부에서는 접근이 불가하지만 내부에서는 접근이 가능!!!
		num = n;
	}
	public int test2() {
		return num;
	}
}

public class Ex01 {
	public static void main(String[] args) {
		Test01 t = new Test01();
		t.test(1000); // 인스턴스 변수인 num 에 직접 접근하지는 못하지만 메서드를 이용하여 같은 클래스에 접근하여 값을 변경
		System.out.println(t.test2()); // 마찬가지로 출력도 메서드를 사용하여 private 값에 접근하여 값을 출력
	}
}

은닉화 하는 방법

( 은닉화의 문제점은 값에 접근하고 값을 가져오는데 최소 메소드가 2개씩 필요..... 메소드를 많이 만들다보니 메소드의 이름이 규격화되지 않아 헷갈리게 된다...... )

( getter / setter 를 사용하여 해당 메소드를 규격화 하였음....!!! )

getter / setter

package set_get;

class Test02{
	private int num, age; // 접근 제어자 private 을 사용하여 외부에서 접근을 금지
	public void setNum(int n) { // set
		num = n;
	}
	public int getNum() { // get
		return num;
	}
	public void setAge(int a) { // set
		age = a;
	}
	public int getAge() { // get
		return age;
	}
}

public class Ex02 {
	public static void main(String[] args) {
		Test02 t = new Test02();
		t.setNum(3); // set 을 사용하여 priavte 인스턴스 변수에 접근 및 변경
		t.setAge(20); // set 을 사용하여 priavte 인스턴스 변수에 접근 및 변경
		int num = t.getNum(); // get 을 사용하여 인스턴스 변수에 접근
		int age = t.getAge(); // get 을 사용하여 인스턴스 변수에 접근
		System.out.println(num + ", " + age); // 3, 20 출력
	}
}

get / set 메소드 생성 및 사용

package set_get;

class Test02{
	private int num, age; // 접근 제어자 private 을 사용하여 외부에서 접근을 금지

	public int getNum() {
		return num;
	}

	public void setNum(int num) {
		this.num = num;
		// this 를 사용하여 최상단 자기 자신의 클래스부터 num 이라는 변수를 찾아서 사용
		// this.num 을 사용함으로써 클래스 내의 인스턴스 변수인 num 을 의미한다고 명시
		// 이후 우항의 num 은 매개변수로 받아온 num 이 대입된다
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
		// this 를 사용하여 최상단 자기 자신의 클래스부터 num 이라는 변수를 찾아서 사용
		// this.age 을 사용함으로써 클래스 내의 인스턴스 변수인 age 를 의미한다고 명시
		// 이후 우항의 age 는 매개변수로 받아온 age 가 대입된다
	}
	
}

public class Ex02 {
	public static void main(String[] args) {
		Test02 t = new Test02();
		t.setNum(3); // setter 를 사용하여 priavte 인스턴스 변수에 접근 및 변경
		t.setAge(20); // setter 를 사용하여 priavte 인스턴스 변수에 접근 및 변경
		int num = t.getNum(); // getter 를 사용하여 인스턴스 변수에 접근
		int age = t.getAge(); // getter 를 사용하여 인스턴스 변수에 접근
		System.out.println(num + ", " + age); // 3, 20 출력
	}
}

java 는 getter / setter 를 자동 생성할때 setter 의 매개변수를 실제 변수의 이름으로 생성하게 되는데 이때, 변수명이

서로 같아지게 되므로 this 를 사용하여 자신이 속한 클래스의 인스턴스 변수임을 선언하여 사용한다.

오버로딩 ( overloading )

package overloading;

class TestClass01{
	public void sumFunc() {
		System.out.println("매개변수 없는 sumFunc");
	}
	
	public void sumFunc(int a, int b) {
		System.out.println("매개변수가 있는 sumFunc");
		System.out.println(a + b);
	}
	
	public void sumFunc(String a, String b) {
		System.out.println(a + b);
	}
}



public class Ex01 {
	public static void main(String[] args) {
		TestClass01 t= new TestClass01();
		t.sumFunc(); // 매개변수가 존재하지 않는 sumFunc 메소드를 호출
		t.sumFunc(10, 20); // int 자료형 두 개가 매개변수로 존재하는 sumFunc 메소드를 호출
		t.sumFunc("안녕", "하세요"); // String 자료형 두 개가 매개변수로 존재하는 sumFunc 메소드를 호출
	}
}

매개변수의 갯수에 따라 동일한 메소드 명이라고 하더라도 호출되는 메소드가 다르다

( 만약 오버로딩이 불가능하다면, 동작은 동일하게 하지만 매개변수의 숫자가 달라질때마다 메소드의 이름을 계속 다르게 생성해야하기 때문에 오버로딩을 사용한다 )

변수의 종류

package variable;

class Test01{
	public int test1() { // test1 범위 생성
		int num = 100; // test1 의 지역변수
		System.out.println("test1 : " + num);
		return num;
	}
	public void test2(int num) { // test2 범위 생성
		System.out.println("num : " + num);
		
	}
}

public class Ex01 {
	public static void main(String[] args) {
		
		Test01 t = new Test01();
		int a = t.test1(); // test1 메소드의 지역변수를 return 값으로 받아와서 변수에 저장
		t.test2(a); // 저장한 변수를 test2 메소드에 매개변수로 전달하여 사용
		
		
		
		
		
		
		
		String name = "홍길동"; // main 의 지역 변수
		if(true) {
			String n = "1111"; // if 문의 지역 변수
			name = "김개똥";
		}
		// main > if
		// if 문의 지역 변수를 main 에서 사용할 수 없기 때문에 오류 발생
		// System.out.println(n);
		System.out.println(name);
		
	}
}

지역변수와 변수의 범위

package variable;

class Test02{
	public int num; // 인스턴스 변수 선언
	
	public void test1() {
		num = 100; // 인스턴스 변수의 값을 변경 ( 같은 클래스 내에서 가능 )
		System.out.println("test1 : " + num);
	}
	public void test2() {
		// 상위의 num 이라는 클래스 변수가 존재하기 때문에 해당 변수 num 을 사용
		System.out.println("test2 : " + num);
	}
	
}

public class Ex02 {
	public static void main(String[] args) {
		Test02 t = new Test02();
		// 객체를 생성할때는 클래스 변수, 인스턴스 변수, 메소드 명을 가지고 객체가 생성된다
		// 이때 생성된 객체는 상속받은 클래스의 메소드 내의 지역변수는 가지고 태어나지 않으며
		// 클래스 변수와 메소드 명만 가지고 태어난 후 메소드를 사용할 때
		// 메소드 내에 선언된 지역변수를 호출하여 사용한뒤 메소드 사용이 끝나면 해당 지역변수는
		// 다시 폐기처리된다.
		t.test1();
		t.test2();
	}
}

클래스 변수와 지역변수의 차이

package variable;

public class Variable {
	int instanceVariable; // 인스턴스 변수 - 클래스를 호출하여 인스턴스화 시켜야 사용할 수 있다
	static int classVariable; // 클래스 변수 - 클래스를 호출하여 인스턴스화 시키지 않아도 사용할 수 있다
	
	public int method() {
		int localVariable = 0; // 지역 변수 - 메소드가 실행될때 사용할 수 있다
		return localVariable;
	}
	
	public static void main(String[] args) {
		
		// 클래스 변수는 객체를 호출하여 인스턴스화 하지 않아도 바로 사용이 가능하다
		Variable.classVariable = 1;
		System.out.println(Variable.classVariable);
		
		// 인스턴스 변수는 객체를 호출하여 인스턴스화 해야 사용이 가능하다
		Variable variableTest = new Variable();
		variableTest.instanceVariable = 2; // 인스턴스화 한 뒤에야 변수 호출이 가능
		System.out.println(variableTest.instanceVariable);
		
		// 
		int num = variableTest.method();
		System.out.println(num);
		
	}
}

인스턴스 변수, 클래스 변수, 지역 변수의 차이

객체 - 틀

인스턴스 - 틀로 찍어낸 상품

클래스 변수는 인스턴스화 시키지 않아도 클래스에 접근할 수 있으면 호출할 수 있는 변수이다.

인스턴스 변수는 객체를 호출하여 인스턴스화 시킨 뒤 호출할 수 있는 변수이다.

즉, 인스턴스 변수는 같은 클래스 내에서는 바로 접근이 가능하기 때문에 같은 클래스 내부의 메소드에서 많이 사용되는 변수의 경우

인스턴스 변수로 선언하여 사용하며, 클래스 변수는 다른 파일들에서 동일한 변수 값을 많이 사용해야하는 경우 클래스 호출만으로

변수를 사용하기 위해 사용된다.

package variable;

class Test04{
	public int num; // 인스턴스 변수
	public static String msg = "연습"; // 클래스 변수
}

public class Ex04 {
	public static void main(String[] args) {
		
		System.out.println("변경 전 : " + Test04.msg); // 클래스 변수 호출
		Test04.msg = "1111"; // 클래스 변수 변경
		System.out.println(Test04.msg); // 변경된 클래스 변수 호출
		
		Test04 t = new Test04(); // 인스턴스 생성
		t.num = 100; // 인스턴스 변수 호출 및 변경
	}
}

클래스 변수와 인스턴스 변수

package variable;

class Test07{
	public static final String KOREA = "대한민국";
	public static int num;
	static {
		num = 12345;
	}
}

public class Ex07 {
	public static void main(String[] args) {
		System.out.println(Test07.KOREA);
		System.out.println(Test07.num);
		// final 로 KOREA 변수 값을 상수화 시켰기 때문에 변경 불가
		// Test07.KOREA = "미국";
	}
}

static - 호출하지 않아도 미리 생성

final - 상수화

실습 예제

예제 풀이

package variable;

public class MainClass {
	public static void main(String[] args) {
		
		TestClass test = new TestClass();
		test.input();
		test.operate();
		test.printData();
		
	}
}

MainClass

package variable;

import java.util.Scanner;

public class TestClass {
	public String name, grade;
	public int kor, eng, math, sum;
	public double avg;
	
	// 입력 메소드
	public void input() {
		Scanner sc = new Scanner(System.in);
		System.out.print("이름을 입력하세요 : ");
		name = sc.next();
		System.out.print("국어 점수를 입력하세요 : ");
		kor = sc.nextInt();
		System.out.print("영어 점수를 입력하세요 : ");
		eng = sc.nextInt();
		System.out.print("수학 점수를 입력하세요 : ");
		math = sc.nextInt();
	}
	
	// 연산 메소드
	public void operate() {
		sum = kor + eng + math;
		avg = (double)sum / 3;
		if(avg > 90)	grade = "A";
		else if(avg > 80)	grade = "B";
		else grade = "C";
	}
	
	// 출력 메소드
	public void printData() {
		System.out.println("이름 : " + name);
		System.out.printf("국 : %d, 영 : %d, 수 : %d\n", kor, eng, math);
		System.out.println("합 : " + sum);
		System.out.println("평균 : " + avg);
		System.out.println("등급 : " + grade);
	}
}

TestClass

클래스 ( class )

메소드 ( method )

메소드를 사용할때 입력과 출력(return)의 자료형을 잘 맞춰주는 것이 중요하다

실습 예제

1. 두 수를 입력 받아 큰 수를 출력하는 함수를 만드시오

package class_;

public class MainTest {
	public static void main(String[] args) {
		
		TestMethod1 test1 = new TestMethod1();
		int[] nums = test1.inputNum();
		int moreBig = test1.moreBig(nums);
		test1.printBig(moreBig);
		
	}
}

main

package class_;

import java.util.Scanner;

public class TestMethod1 {
	// 수 입력받는 메소드
	public int[] inputNum() {
		Scanner sc = new Scanner(System.in);
		int[] nums = new int[2];
		
		for(int i=0; i<nums.length; i++) {
			System.out.print("비교할 수를 입력 >>> ");
			nums[i] = sc.nextInt();
		}
		return nums;
	}
	
	// 비교 연산 메소드
	public int moreBig(int[] a) {
		int moreBig = 0;
		if(a[0] > a[1]) {
			moreBig = a[0];
		}else {
			moreBig = a[1];
		}
		return moreBig;
	}
	
	// 출력 메소드
	public void printBig(int a) {
		System.out.println("더 큰 숫자 : " + a);
	}
}

메서드

2. 입력 받는 값이 짝수인지 홀수인지 판별하는 함수 제작

package class_;

public class MainTest {
	public static void main(String[] args) {
		
		TestMethod2 test2 = new TestMethod2();
		int inputnum = test2.inputNum();
		String even = test2.even(inputnum);
		test2.printEven(inputnum, even);
		
	}
}

main

package class_;

import java.util.Scanner;

public class TestMethod2 {
	
	// 수 입력받는 메소드
	public int inputNum() {
		int num;
		Scanner sc = new Scanner(System.in);
		System.out.print("수를 입력 >>> ");
		num = sc.nextInt();
		return num;
	}
	
	// 입력받은 수가 짝수인지 홀수인지 연산
	public String even(int a) {
		if(a % 2 == 0) {
			return "짝수";
		}else {
			return "홀수";
		}
	}
	
	// 출력
	public void printEven(int a, String b) {
		System.out.printf("입력하신 %d는 %s입니다.", a, b);
	}
}

메서드

3. 3의 배수를 판별하는 함수를 만들고 이 함수를 이용하여 main 에서 3의 배수만 출력하시오

package class_;

import java.util.ArrayList;

public class MainTest {
	public static void main(String[] args) {
		
		TestMethod3 test3 = new TestMethod3();
		ArrayList<Integer> inputNum = test3.inputNum();
		ArrayList<Integer> even3 = test3.even3(inputNum);
		test3.printEven3(even3);
		
	}
}

main

package class_;

import java.util.ArrayList;
import java.util.Scanner;

public class TestMethod3 {
	public ArrayList<Integer> inputNum() {
		// 수를 무한대로 입력받는 부분
		Scanner sc = new Scanner(System.in);
		ArrayList<Integer> nums = new ArrayList<>();
		
		while(true) {
			System.out.print("수를 입력하세요(종료:0) >>> ");
			int num = sc.nextInt();
			if(num == 0)	break;
			nums.add(num);
		}
		
		// 숫자를 저장한 List 를 반환
		return nums;
	}
	
	public ArrayList<Integer> even3(ArrayList<Integer> a){
		// List 배열의 수가 3의 배수인지 확인하는 메소드
		ArrayList<Integer> even3 = new ArrayList<Integer>();
		for(int i : a) {
			if (i%3 == 0) {
				// 3의 배수라면 even3 이라는 List 에 값 추가
				even3.add(i);
			}
		}
		// 3의 배수가 담긴 List 인 even3 을 return
		return even3;
	}
	
	public void printEven3(ArrayList<Integer> a) {
		System.out.println("- 3의 배수 목록 -");
		for (int i : a) {
			System.out.print(i + " ");
		}
	}
}

메서드

Set

package set;

import java.util.ArrayList;
import java.util.HashSet;

public class Ex01 {
	public static void main(String[] args) {
		
		HashSet<String> set = new HashSet<>();
		set.add("라면");
		set.add("김밥");
		set.add("순대");
		set.add("라면");
		
		ArrayList<String> arr = new ArrayList<>();
		arr.add("라면");
		arr.add("김밥");
		arr.add("순대");
		arr.add("라면");
		
		// ArrayList 와 차이점 : 중복이 발생되지 않는다, 데이터가 순서대로 저장되지 않는다
		System.out.println(set);	// [김밥, 순대, 라면]
		System.out.println(arr);	// [라면, 김밥, 순대, 라면]
		
	}
}

Set 사용법과 List 와 차이점

package baseball;

import java.util.HashSet;

public class Ex02 {
	public static void main(String[] args) {
		
		HashSet<String> set = new HashSet<>();
		set.add("111");
		set.add("222");
		set.add("333");
		System.out.println("set : " + set); // set : [111, 222, 333]
		set.remove("111");
		System.out.println("삭제 set : " + set); // 삭제 set : [222, 333]
		
	}
}

Set 컬렉션에 자료 추가 및 삭제

package set;

import java.util.ArrayList;
import java.util.Iterator;

public class Ex04 {
	public static void main(String[] args) {
		
		ArrayList<String> arr = new ArrayList<>();
		arr.add("일");
		arr.add("이");
		arr.add("삼");
		System.out.println("arr : " + arr);
		
		/*
		 Interator : 반복자 ( 배열 형식의 데이터로 만든다 )
		 - hasNext : 다음 위치에 값이 있으면 true, 없으면 false 
		 - next : 다음 위치로 이동 후 값을 얻어옴
		 
		 baf : 데이터의 시작을 의미
		 eaf : 데이터의 끝을 의미
		 
		 it => [ baf, 일, 이, 삼, eaf ]
		 */
		Iterator<String> it = arr.iterator();
		System.out.println(it.hasNext()); // baf 값의 다음 값이 존재하는지 여부 확인
		System.out.println(it.next()); // 다음 값인 "일" 로 이동 후 값을 꺼내옴
		System.out.println(it.next()); // 다음 값인 "이" 로 이동 후 값을 꺼내옴
		System.out.println(it.next()); // 다음 값인 "삼" 으로 이동 후 값을 꺼내옴
		System.out.println(it.hasNext()); // 현재 위치에서 다음 값이 존재하는지 여부 확인
										  // 다음 값이 없기 때문에 false 출력
		System.out.println(it.next()); // 다음 값이 없기 때문에 이동할 수 없으며 console 오류 출력
		
	}
}

Iterator

package set;

import java.util.HashSet;
import java.util.Iterator;

public class Ex05 {
	public static void main(String[] args) {
		
		HashSet<String> set = new HashSet<>();
		set.add("111");
		set.add("222");
		set.add("333");
		
		System.out.println("set : " + set); // set : [111, 222, 333]
		Iterator<String> it;
		it = set.iterator();
		// it 를 Iterator 자료형으로 변경
		// Set 컬렉션은 순서가 존재하지 않는다 ( index 가 존재하지 않는다 )
		// 그러므로 내부의 값에 접근하기 위해 Iterator 컬렉션으로 변경하여 사용한다
		
		// Iterator 컬렉션으로 변경하게 되면
		// it => [ baf, 111, 222, 333, eaf ]
		// 위와 같이 배열의 값의 맨 처음(baf)과 맨 뒤(eaf) 값이 추가된다.
		// 첫 위치는 baf 에서부터 출발하며 .hasNext() 메소드를 사용하여 다음 위치인
		// "111" 의 값이 존재하는지 확인하고
		// .next() 메소드를 사용하여 다음 위치로 이동 및 해당 위치의 값을 출력한다
		
		// 현재 위치에서 다음 값이 존재하지 않을때까지 반복
		while(it.hasNext()) {
			System.out.println(it.next());
			// 111
			// 222
			// 333
		}
		System.out.println("종료!!!");
		
	}
}

Iterator 사용하여 set 의 저장값 출력

( set 에는 순서인 인덱스가 존재하지 않기 때문에 Iterator 컬렉션으로 변환하여 내부의 저장값에 접근한다 )

MAP

package map;

import java.util.HashMap;

public class Ex01 {
	public static void main(String[] args) {
		
		HashMap<String, String> map = new HashMap<>();
		map.put("num", "100");
		map.put("name", "홍길동");
		map.put("선풍기", "1000만원");
		System.out.println(map); // {num=100, name=홍길동, 선풍기=1000만원}
		
		// .get(키) 메소드로 해당 키에 대한 값을 가져온다
		System.out.println(map.get("num")); // 100
		System.out.println(map.get("선풍기")); // 1000만원
		System.out.println(map.get("없는 키")); // null
		// 입력한 키가 존재하지 않으면 null 값을 반환한다
		
	}
}

map 사용법

package map;

import java.util.HashMap;

public class Ex02 {
	public static void main(String[] args) {
		
		HashMap<String, Integer> map = new HashMap<>();
		map.put("num", 100);
		map.put("age", 10);
		System.out.println(map); // {num=100, age=10}
		
		// 출력 시 저장값인 Integer 형으로 출력됨
		System.out.println(map.get("num")); // 100
		
		// 출력 값인 Integer 형으로 변수를 지정하여 출력 값을 저장
		int num = map.get("age");
		System.out.println(num); // 10
		
		// 키 값이 있는지 .containsKey() 메소드로 확인
		System.out.println( map.containsKey("age") ); // true
		
		// 저장 값이 있는지 .containsValue() 메소드로 확인
		System.out.println( map.containsValue(2000) ); // false
		
		// 이미 존재하는 키를 입력하면 키가 중복되는 대신
		// 기존 키의 값이 변경됨
		// map 은 키 중복이 불가능, 값은 중복이 가능하다
		map.put("age", 12345);
		System.out.println( map ); // {num=100, age=12345}
		
		// 삭제
		map.remove("age");
		System.out.println( map ); // {num=100}
		
	}
}

map 에 값 추가, 삭제, 값이 있는지 확인

package map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class Ex03 {
	public static void main(String[] args) {
		
		HashMap<String, String> map = new HashMap<>();
		map.put("이름", "홍길동");
		map.put("나이", "20");
		System.out.println(map); // {이름=홍길동, 나이=20}
		
		// .keySet() : 키만 출력
		System.out.println( "key set : " + map.keySet() ); // key set : [이름, 나이]
		
		// .values() : 값만 출력
		System.out.println( "values : " + map.values() ); // values : [홍길동, 20]
		
		// .keySet() 의 값은 반환 자료형이 Set 이기 때문에 Set 컬렉션 자료형에 담아준다
		Set<String> set = map.keySet();
		System.out.println(set); // [이름, 나이]
		
		// map 의 키를 저장한 set 의 값에 접근하기 위해 Iterator 컬렉션으로 다시 저장
		// it => [ baf, 이름, 나이, eaf ]
		Iterator<String> it = set.iterator();
		for( ; it.hasNext(); ) {
			// System.out.println(it.next());
			// 이름
			// 나이
			
			String key = it.next();
			System.out.println( key + " : " + map.get(key) );
			// 이름 : 홍길동
			// 나이 : 20
		}
		
		System.out.println("종료!!!");
		
	}
}

map 의 키로 값에 접근하는 방법

Wrapper Class

List, Set, Map 클래스를 사용하는 경우 자바의 기본 자료형을 사용할 수 없으므로

Wrapper Class 를 사용하여 기본 자료형의 값을 저장한다.

package baseball;

import java.util.ArrayList;

public class Ex02 {
	public static void main(String[] args) {
		
		// int 자료형은 List에 담을 수 없음
		// ArrayList<int> arr = new ArrayList<>();
		
		//Wrapper Class 를 사용하여 자바의 기본 자료형을 List, Set, Map 에 담는다 
		ArrayList<Integer> arr = new ArrayList<>();
		
	}
}

실습 예제

실습 풀이

package test;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Scanner;

public class test1 {
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		HashMap<String, Integer> menu = new HashMap<>();
		
		int choice = 0;
		String addMenu = null;
		int addPrice = 0;
		
		while(choice != 3) {
			// 메인 출력
			System.out.print("1. 메뉴 등록\n2. 메뉴별 가격 보기\n3. 종 료\n>>> ");
			choice = sc.nextInt();
			
			// 1. 메뉴 등록
			if(choice == 1) {
				System.out.print("추가할 메뉴 이름 >>> ");
				addMenu = sc.next();
				System.out.print(addMenu + " 가격 >>> ");
				addPrice = sc.nextInt();
				menu.put(addMenu, addPrice);
			}
			
			// 2. 메뉴 출력
			if(choice == 2) {
				// key 를 set 으로 변형 후 바로 iterator 컬렉션으로 변환
				Iterator<String> strMenu = (menu.keySet()).iterator();
				System.out.println("===== 메뉴판 =====");
				// 메뉴 출력
				while(strMenu.hasNext()) {
					String key = strMenu.next();
					System.out.println(key + " : " + menu.get(key));
				}
				System.out.println("=================");
				
				// 가격 수정,메뉴 삭제, 나가기 출력
				System.out.println("1.가격 수정 2.메뉴 삭제 3.나가기");
				int menuEdit = 0;
				System.out.print(">>> ");
				menuEdit = sc.nextInt();
				
				// 가격 수정 구현
				if(menuEdit == 1) {
					System.out.print("가격 수정할 메뉴 입력 >>> ");
					String editName = null;
					editName = sc.next();
					if(menu.containsKey(editName)) {
						System.out.print("수정할 금액 입력 >>> ");
						int editPrice = 0;
						editPrice = sc.nextInt();
						menu.put(editName, editPrice);
						System.out.println(editName + "의 가격을 " + editPrice + "로 변경 완료!!");
					}else {
						System.out.println("해당하는 메뉴가 존재하지 않습니다.");
					}
				}
				
				// 메뉴 삭제 구현
				if(menuEdit == 2) {
					System.out.print("삭제할 메뉴를 입력해주세요 >>> ");
					String removeMenu = null;
					removeMenu = sc.next();
					if(menu.containsKey(removeMenu)) {
						menu.remove(removeMenu);
						System.out.println(removeMenu + "가 삭제되었습니다.");
					}else {
						System.out.println("해당 메뉴가 존재하지 않습니다.");
					}
				}
				
			}
			
		}
		System.out.println("프로그램을 종료합니다.");
		
	}
}

- 이해해야할 부분 -

메뉴를 출력하는 부분에서 map 컬렉션에 저장된 key 를 추출할때 map 컬렉션의 .keySet() 메소드를 사용하여 key 를 반환받게 되는데 이때 .keySet() 메소드의 반환 값이 set 컬렉션이므로( 순서가 없기 때문에 index 도 존재하지 않아서 저장 값에 접근할 수 없음 ) 이 값을 다시 iterator 컬렉션으로 변환하여 key 에 접근할 수 있게 변환한 뒤 key 들을 변수로 저장하여 사용한다

컬렉션 프레임워크 ( collection Framework )

List - 배열에 비해 공간에 대한 제약이 자유롭다
( 배열은 공간을 지정해줘야 사용할 수 있지만 List 는 공간 값을 지정하지 않아도 된다 )

난수 ( random )

1. Math.random() : 0.0000.....1 ~ 0.99999..... 까지의 난수를 생성

( 여기에 3을 곱한다면 정수 값으로 올라올 수 있는 수는 0, 1, 2 가 되며 int 자료형으로 형변환 하면 0, 1, 2 값만 남는다 )

2. java.util 패키지의 Random 클래스 사용 : Random 자료형의 변수로 선언 후 nextInt 등 클래스 메소드를 사용

문자열 ( String )

문자열 대문자, 소문자 정렬

문자열 공백 제거

문자열 특정 문자 치환

문자열 int 로 변환