[JAVA]_기말고사 출제 예상

전희주·2023년 4월 24일

Java

JAVA

목록 보기

20/24

기말 시험 개요

시험 유형: 중간고사와 유사

시험 출제 범위:

함수형 인터페이스 안 나옴

컬렉션 나옴

배열 크기 구하는 거 나옴

시험 유의 사항: 가장 정확한 오답, 정답을 선택할 것!

기말고사 출제 예상 20선

1번

(O,X) 컬렉션 개념

컬렉션(Collection Api)
- 참조 data만 저장 가능 => 기본형 Data는 Wrapper로 저장 가능
- 크기 변경 가능
- ✨ Data 사용 여부에 따라 저장하는 자료구조가 달라짐
- 여러 개 값 저장 (자료형의 제약 없음)
  - 다양한 자료형의 데이터 저장 가능 (자료형 불일치로 인한 컴파일 에러는 발생하지 않음)
- 크기 변경 가능 (삭제, 추가, 삽입 가능)

2번

컬렉션 계층 구조

컬렉션 인터페이스 SET, LIST, MAP 관련

컬렉션 내용 설명 후, 다음 중 틀린 것은?
- EX) 리스트는 순서가 있고 중복이 허용
- 컬렉션 종류
- set 계열: 순서 무시, 중복 불가
  - ✨ HashSet 기억
- list 계열: 순서 준수(배열과 유사한 특징), 중복 가능(순서가 존재하므로)
  - 크기 변경 가능하다는 점에서 배열과 차이
  - 출력 시 저장한 순서대로 나옴
  - ✨ ArrayList 기억
- Map 계열: 인터페이스 , key(name)와 value(데이터)가 한 쌍으로 저장됨
  - Map 계열: key/value 쌍으로 저장, Collection 인터페이스와 무관
  - cf. List, Set은 값을 저장
  - key(name) 이용하기 때문에 검색속도가 가장 빠르다
  - HashMap: 클래스
  - keySet()의 반환타입은 Set 인터페이스 (순서 존재하지 않음)
  - key 중복시 최신의 값으로 덮어쓴다.
  - 일치하는 key가 없으면 null 반환

✨ Collection 계층구조 외우기 (자바의 컬렉션과 관련된 클래스 상속관계(계층구조))
- Map 인터페이스는 Collection 인터페이스와 무관
- 참고

3번

(주관식) 제네릭스 관련

제네릭스:
- 컬렉션에 특정한 자료형 값만 저장하고 싶을 때 사용
제네릭스 문법

Hash set = new HashSet(); // 제네릭스 사용 안 한 경우 

Hash<String> set = new HashSet<String>(); // new HashSet<>(); 동일// 제네릭스 사용

✨ (제네릭스 미사용시) 결론
- 1) 제네릭스 미사용 시 잘못된 데이터를 컴파일 할 때가 아닌 실행 시 알 수 있다.
  - (컴파일 에러가 발생하지 않기에)
- 2) 반드시 형 변환해서 가져와야 한다.

//출력: 문자열의 길이를 출력하자
		for (Object obj : set) {
			String s = (String)obj;
			System.out.println(s +"\t" + s.length());
		}

✨ (제네릭스 사용시) 결론
- 1) 제네릭스를 사용하면 잘못된 데이터를 컴파일 시점에 알 수 있다
- 2) 형 변환 불필요

// 1. 제넥릭스 사용
		Set<String> set = new HashSet<String>(); // new HashSet<>(); 동일
		
		//조건은 이름인 문자열만 저장하자
		set.add("홍길동1");
		set.add("홍길동2");
		set.add("홍길동3");
		// set.add(10);  1) 컴파일 시점에 잘못 저장된 것을 확인할 수 있다

//출력: 문자열의 길이를 출력하자
		for (String s : set) {  // 2) 형변환이 불필요하다.
			System.out.println(s+"\t"+s.length());
		}

4번

유틸리티 클래스 중에서 String Builder 메서드와 관련된 것 → 주관식

StringBuilder 클래스는 문자열을 생성할 때, 생성자를 이용해 초기값을 지정
- "hello"라는 문자열을 초기값으로 지정하여 b라는 StringBuilder 객체를 생성

public class StringBuilderTest {

	public static void main(String[] args) {
		
		// 1. 문자열 생성
        // StringBuilder 클래스는 문자열을 생성할 때, 생성자를 이용해 초기값을 지정
        //  "hello"라는 문자열을 초기값으로 지정하여 b라는 StringBuilder 객체를 생성
		StringBuilder b = new StringBuilder("hello"); // 성능향상, 안전성 떨어짐
		StringBuffer b2 = new StringBuffer("hello");  // 성능떨어짐. 안전성 향상
		
		System.out.println(b);
		System.out.println(b2);

StringBuilder 객체 x를 생성하고, append(), insert(), delete(), reverse() 등의 메서드를 호출하여 값을 추가, 중간 삽입, 삭제, 거꾸로 출력하는 등의 작업을 수행
- delete()
  : StringBuilder 객체 x의 문자열에서 delete() 메서드를 이용하여, 인덱스 0부터 5미만까지의 문자열을 삭제하는 작업을 수행

	//2. 메서드
		StringBuilder x = new StringBuilder();
		
		System.out.println("1. 값 추가:" + x.append("Hello"));
		System.out.println("1. 값 추가:" + x.append(10));
		System.out.println("1. 값 추가:" + x.append(3.14));
		System.out.println("1. 값 추가:" + x.append(true));
		
		System.out.println("2. 값 중간삽입:" + x.insert(0, "홍길동") ); // 홍길동Hello103.14true
		
		System.out.println("3. 값 삭제:" + x.delete(0, 5) ); //llo103.14true
		
		System.out.println("4. 거꾸로" + x.reverse()); // eurt41.301oll

String 클래스에서 제공하는 메서드들인 length(), charAt(), indexOf(), substring() 등도 StringBuilder 클래스에서 사용
- substring(1):
  인덱스 1부터 끝까지의 부분 문자열을 추출하는 작업을 수행

		//String 클래스에도 있던 메서드
		System.out.println("5. 문자열 길이:" + x.length());
		System.out.println("6. 특정문자 얻기:" + x.charAt(0));
		System.out.println("7. 특정문자 위치:" + x.indexOf("t")); // 3
		
		System.out.println("8. 부분열:" + x.substring(1)); // 
		System.out.println("8. 부분열:" + x.substring(1, 6)); // 1 ~ 5 까지

StringBuilder 클래스는 문자열을 가변적으로 변경할 수 있기 때문에, 최종적으로 x.toString()을 호출하여 String 객체로 변환하여 저장
- StringBuilder 객체 x의 값은 변하지 않은 채로 유지

		
		// StringBuilder 를 String로 저장할때는 반드시 toString() 호출해야 된다.
		String s = x.toString();
		System.out.println("9. String로 저장:" + s);
		
		//최종적으로 확인: 원본 문자열이 변경 여부 ==> StringBuilder 는 원본이 변경됨. 
		System.out.println(x);
		
	}

}

실행 결과

5번

ITERATOR 주관식 출제

ITERATOR 쓰는 두 가지 메서드

반복문, 값 가져오는 두 가지 메서드

인터페이스 Iterator 이용 (new 키워드로 객체 생성 불가)
Iterator는 컬렉션 프레임워크에서 컬렉션에 저장된 요소들을 순차적으로 접근하는 객체

hasNext() 메서드: 다음에 읽어올 요소가 있는지를 확인. 요소가 있다면 true를 반환하고, 없다면 false를 반환
next() 메서드: 현재 위치에서 다음 요소를 반환하고, 커서를 다음 요소로 이동

set 컬렉션에서의 iterator 활용

//출력3 - Iterator 이용 ( ***** )
		Iterator ite = set.iterator();
		while(ite.hasNext()) {
			System.out.println(">>"+ ite.next());
		}

list 컬렉션에서의 iterator 활용

//출력3 - Iterator
		Iterator<String> ite = list.iterator();
		while(ite.hasNext()) {
			String x = ite.next();
			System.out.println(x);
		}

Iterator 객체는 컬렉션에 저장된 요소들을 순차적으로 접근
이를 이용하여 while문을 사용하여 Set 컬렉션의 요소들을 순차적으로 접근하고, hasNext() 메서드를 사용하여 다음 요소가 있는지 확인
그리고 next() 메서드를 사용하여 다음 요소를 가져와 출력
Set 컬렉션에 저장된 요소들을 ite라는 Iterator 객체를 이용하여 하나씩 출력하는 작업이 수행되며, 출력 결과는 ">>"와 Set에 저장된 요소들이 순차적으로 출력
참고 1

package p01;

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

public class SetTest {

	public static void main(String[] args) {
		// Set 계열 : 순서없고 중복불가
		
		// 다형성
		Set set = new HashSet();
		
		set.add("홍길동");
		set.add(24);
		set.add(3.14);
		
		set.add("홍길동");
		set.add(24);
		set.add(3.14);

		//출력1 - toString() 이용
		System.out.println(set);  // [홍길동, 3.14, 24]
		System.out.println("============");
		//출력2 - foreach문 이용
		for (Object obj : set) {
			System.out.println(obj);
		}
		System.out.println("============");
		
		//출력3 - Iterator 이용 ( ***** )
		Iterator ite = set.iterator();
		while(ite.hasNext()) {
			System.out.println(">>"+ ite.next());
		}
		System.out.println("===========");
		
		//추가 메서드
		/*
		 *   배열크기(길이): 배열명.length  
		 *   문자열길이:     s.length()
		 *   컬렉션크기:    변수명.size()
		 */
		System.out.println("크기:" + set.size());
		System.out.println("비어있냐:" + set.isEmpty());
		System.out.println("특정값이 있냐:" + set.contains(24));
		
		//삭제
		set.remove("홍길동");
		System.out.println(set);  // [3.14, 24]
		
		//전체삭제
		set.clear();
		System.out.println(set);  // []
		
	}
}

실행 결과 1
참고 2

package p02;

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

public class ListTest {

	public static void main(String[] args) {
		// List 계열:  순서 보장, 중복 가능
		
		ArrayList<String> list = new ArrayList<>();
		
		//저장
		list.add("홍길동1");
		list.add("홍길동2");
		list.add("홍길동3");
		list.add("홍길동2");
//		list.add(10);   // 문자열이 아니면 저장 불가

		//출력1 - toString()
		System.out.println(list);
		System.out.println();
		
		
		//출력2 - foreach
		for (String s : list) {
			System.out.println(">>" + s);
		}
		System.out.println();
		
		//출력3 - Iterator
		Iterator<String> ite = list.iterator();
		while(ite.hasNext()) {
			String x = ite.next();
			System.out.println(x);
		}
		System.out.println();
		//출력4 - get(idx)
		String x = list.get(0);
		String x2 = list.get(1);
		System.out.println(x +"\t" + x2);
		
	}//end main
}//end class

실행 결과 2

6번

예외처리

설명 중 올바르지 않는 것은?

"예외처리는 자바 프로그램에서 빈번하게 발생하는 오류를 사전에 방지하고, 이를 미리 예측하여 대처할 수 있도록 하는 기술이다." (X)
- 프로그램에서 예외가 발생했을 경우 프로그램의 갑작스러운 종료를 막고, 정상 실행을 유지할 수 있도록 처리하는 것을 의미
catch 블록이 여러 개라 할지라도 단 하나의 catch 블록만 실행된다. (O)
- try 블록에서 동시 다발적으로 예외가 발생하지 않고, 하나의 예외가 발생하면 즉시 실행을 멈추고 해당 catch 블록으로 이동하기 때문임
throws는 새로운 예외를 발생시키기 위해 사용된다 (X)
try {} 블록에서 return 문을 사용하면 finally {} 블록은 실행되지 않는다 (X)
- finally 블록은 try 블록에서 실행되던 중 예외가 발생하더라도 항상 실행되기 때문에, try 블록에서 return 문이 실행(메서드 종료)되더라도 finally 블록은 실행됨.

7번

컬렉션

HashMap관련 코드 주면 => 해당 코드 실행 결과를 적기

참고 1

package p03;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;


public class MapTest {

	public static void main(String[] args) {
		// Map 계열:  key/value 쌍으로 저장, Collection 인터페이스와 무관
		
		//1. HashMap
		// 다형성
		Map<String, String> map = new HashMap<>();
		
		//데이터 저장
		map.put("p01", "홍길동1");
		map.put("p02", "홍길동2");
		map.put("p03", "홍길동3");
		map.put("p03", "이순신");  // key 중복시 덮어쓴다.

		//출력1- get(key)
		String n = map.get("p01");
		System.out.println(n);
		System.out.println(map.get("p02"));
		System.out.println(map.get("p100")); // 일치하는 key가 없으면 null 반환.
		
		//출력2 - key값만 먼저 얻고 나중에 value 얻기
		Set<String> keys = map.keySet();
		System.out.println(keys); // [p01, p03, p02]
		for (String key : keys) {
			System.out.println(key+"\t"+ map.get(key));
		}
		//출력3 - toString
		System.out.println(map); // {p01=홍길동1, p03=이순신, p02=홍길동2}
		
		
		
		
		
		
	}//end main
}//end class

실행 결과 1
참고 2

package p03;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;


public class MapTest2 {

	public static void main(String[] args) {
		// Map 계열:  key/value 쌍으로 저장, Collection 인터페이스와 무관
		
		//1. HashMap
		// 다형성
		Map<String, String> map = new HashMap<>();
		
		//데이터 저장
		map.put("p01", "홍길동1");
		map.put("p02", "홍길동2");
		map.put("p03", "홍길동3");

		
		System.out.println("크기:" + map.size());
		System.out.println("특정 key가 있냐:" + map.containsKey("p01"));
		System.out.println("특정 value가 있냐:" + map.containsValue("홍길동1"));
		System.out.println("비어 있냐:" + map.isEmpty());
		
		
		//삭제 remove(key)
		map.remove("p03");
		
		//치환 replace(key, value)
		map.replace("p01", "이순신");
		
		//전체 삭제
		map.clear();
		
		System.out.println(map);
		
	}//end main
}//end class

실행 결과 2

8번

THROWS/THROW 빈칸 출제
다.

Throw 구문은 의도적으로 예외를 만들어 발생시키는 것을 의미하며, throws 구문은 메소드를 호출한 쪽으로 예외 처리 미루는 개념
✨ throws / throw 빈칸 채우기 출제

package p06;

import java.util.Random;

class MyRandom{
	public void getrandom() throws NullPointerException{
		// 난수값 발생 : 0 ~ 2
		Random r = new Random();
		int n = r.nextInt(3); // 0 ~ 2
		//비즈니스 규칙 변경됨. 0이면 예외라고 가정하자.
//		if(n==0)throw new Exception("랜덤값 0으로 인해 예외발생");
		if(n==0)throw new NullPointerException("랜덤값 0으로 인해 예외발생"); //런타임 에러임으로 컴파일 언체크드 
		System.out.println("값:" + n);
		
	}
}
//throws와 throw 빈칸 채우기 나옴!! 위치도 알아놓기!!


public class ExceptionTest {
	public static void main(String[] args) {
		
		System.out.println("start");
		MyRandom x = new MyRandom();
		try{
		x.getrandom();
		}catch(NullPointerException e) {
			System.out.println("예외처리" + e.getMessage());
		}
		System.out.println("end - 정상종료");
	}

}

9번

상속 장단점으로 틀린 것을 고르시오

상속의 장단점

상속 extends
클래스를 상속, 공통된 부모를 가지를 가지는 것 끼리 묶음. is a 관계
상속의 장점
- 코드의 재사용성: 상속을 통해 부모 클래스의 멤버를 재사용할 수 있기 때문에, 코드를 반복해서 작성하지 않아도 됩니다.
- 코드의 유지보수성: 부모 클래스에 공통적으로 있는 기능을 부모 클래스에서 관리하기 때문에, 이 기능을 변경하면 자식 클래스들도 같이 변경되므로 유지보수성이 좋습니다.
- 다형성의 구현: 상속을 통해 부모 클래스의 참조 변수로 자식 클래스의 객체를 참조할 수 있기 때문에, 다형성을 구현할 수 있습니다.
상속의 단점
- 상속 구조가 복잡해지면 코드의 가독성이 떨어집니다.
- 상속 구조가 불필요하게 깊어지면 성능에 영향을 미칠 수 있습니다.
- 상위 클래스의 변경이 하위 클래스에 영향을 미칠 수 있습니다.
- 다중 상속을 지원하지 않는 언어에서는 여러 개의 클래스로부터 상속을 받을 수 없습니다.
- 접근자에 대한 제약이 강하게 걸린다.
  - 초기에 public 으로 공개해놨던 필드나 메서드를 이용하는 자식 클래스가 여럿 있다면, private 으로 바꿀 필요를 느껴도 바꿀 수 없다.

10번

ARRAYLIST

컬렉션 중 ArrayList 의 주어진 출력결과가 나오게 빈칸 작성하는 문제

코드상에서 빈칸 채우기를 완성해서 제시된 결과 창이 나오도록 구현

참고 1

package p02;

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

public class ListTest {

	public static void main(String[] args) {
		// List 계열:  순서 보장, 중복 가능
		
		ArrayList<String> list = new ArrayList<>();
		
		//저장
		list.add("홍길동1");
		list.add("홍길동2");
		list.add("홍길동3");
		list.add("홍길동2");
//		list.add(10);   // 문자열이 아니면 저장 불가

		//출력1 - toString()
		System.out.println(list);
		System.out.println("=======================");
		
		//출력2 - foreach
		for (String s : list) {
			System.out.println(">>" + s);
		}
		System.out.println("=======================");
		
		//출력3 - Iterator
		Iterator<String> ite = list.iterator();
		while(ite.hasNext()) {
			String x = ite.next();
			System.out.println(x);
		}
		System.out.println("=======================");
		
		//출력4 - get(idx)
		String x = list.get(0);
		String x2 = list.get(1);
		System.out.println(x +"\t" + x2);
		System.out.println("=======================");
		
	}//end main
}//end class

실행 결과 1
참고 2

package p02;

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

class Cat{
	
	String name;
	int age;
	String gender;
	
	public Cat() {}

	public Cat(String name, int age, String gender) {
		this.name = name;
		this.age = age;
		this.gender = gender;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	@Override
	public String toString() {
		return "Cat [name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}
	
}//

public class ListTest2 {

	public static void main(String[] args) {
		// List 계열:  순서 보장, 중복 가능

		// 야옹이 2 암컷,   나비 1 숫컷 , .....
		
		//1. 배열 이용
		Cat [] catArr = { new Cat("야옹이",2, "암컷"),
					      new Cat("나비",1, "숫컷")
				        };
		//추가, 삽입, 삭제 불가능하다. 출력만 가능하다.
		for (Cat cat : catArr) {
			System.out.println(">>>" + cat);
		}
		System.out.println("================");
		//2. List 이용 ( 다형성 )
		List<Cat> list = new ArrayList<Cat>();
		list.add(new Cat("야옹이",2, "암컷"));
		list.add(new Cat("나비",1, "숫컷"));
		
		//많이 사용되는 패턴 ==> 추가 작업 불가
//		List<Cat> list2 = Arrays.asList(new Cat("야옹이",2, "암컷"),
//				                        new Cat("나비",1, "숫컷"));
		
		//추가 가능
		list.add(new Cat("망치",3,"수컷"));
		
		//삽입 가능
		list.add(0,new Cat("블랙",1,"암컷") );
		
		//수정 가능
		list.set(0, new Cat("블랙",1,"수컷"));
		
		//삭제 가능
		list.remove(0);
		
		//출력
		System.out.println(list);
		System.out.println("================");
		
	}//end main
}//end class

실행 결과 2
참고 3

package p02;

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

public class ListTest3 {

	public static void main(String[] args) {
		// List 계열:  순서 보장, 중복 가능
		
		// 다형성 
		List<Integer> list = new ArrayList<>();
		list.add(10);
		list.add(20);
		list.add(30);
		
		System.out.println("길이:"+ list.size());
		System.out.println("비어있냐:"+ list.isEmpty());
		System.out.println("값이 있냐:"+ list.contains(10));
		System.out.println("값이 있냐:"+ list.contains(40));
		
		System.out.println("특정값의 위치값:"+ list.indexOf(10));
		
		//배열로 반환
		Object [] obj = list.toArray();
		System.out.println("배열로 변환:" + Arrays.toString(obj)); // [10, 20, 30]
		
		//부분 리스트
		List<Integer> subList = list.subList(0, 2); // 0 ~ 1
		System.out.println(subList);  // [10, 20]
		
	}//end main
}//end class

실행 결과 3

11번

추상클래스, 인터페이스 개념 출제

(예상) 추상클래스, 인터페이스 개념 비교 문항
✨ 인터페이스에서 인터페이스로 다중 상속은 가능. (O)
✨ 클래스에 여러 인터페이스 다중 구현 가능. (O)
추상 클래스에서는 명시적으로 public abstract 기재 안하면 에러 발생 (O)
인터페이스는 객체로 생성할 수 없기 때문에 (추상 클래스와 공통점) 생성자를 가질 수 없다. (O)
인터페이스 타입의 로컬 변수는 선언할 수 없다 (X)
구현 객체가 인터페이스 타입으로 변환되는 것은 자동타입변환에 해당 (O)
클래스는 필드, 생성자, 메소드를 구성 멤버로 가지는 데 비해 인터페이스는 상수 필드와 추상 메소드만을 구성멤버로 가진다. (O)

12번

추상클래스, 인터페이스 개념 출제

(예상)
인터페이스 타입으로 자동 타입 변환된 매개값을 메소드 내에서 다시 구현 클래스 타입으로 강제 타입 변환해야 한다면 반드시 매개 값이 어떤 객체인지 instanceof 연산자로 확인하고 안전하게 강제 타입 변환을 해야 한다. (O)
추상 클래스를 상속받는 자식 클래스에서는 추상 클래스의 추상 메서드를 구현해야 하며, 구현하지 않는다면 컴파일러가 오류 발생. (✨ 추상 메서드 재정의 필수) (O)
추상 클래스라고 해서 반드시 추상메서드를 가지고 있는 것은 아님. (역은 성립) (O)
추상 클래스에는 최소한 하나의 추상 메소드가 있어야 한다 (X)
추상 메소드가 있더라도 해당 클래스가 꼭 추상 클래스가 될 필요는 없다 (X)
추상 클래스는 직접 new 연산자로 객체를 생성할 수 없다. (O)
추상 클래스는 부모 클래스로만 사용된다. (O)

13번

HASHMAP 개념 관련 출제

(코드를 주면 출력 되는 것이 무엇인지, 4지 선다 출제)

참고 1

package p03;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;


public class MapTest {

	public static void main(String[] args) {
		// Map 계열:  key/value 쌍으로 저장, Collection 인터페이스와 무관
		
		//1. HashMap
		// 다형성
		Map<String, String> map = new HashMap<>();
		
		//데이터 저장
		map.put("p01", "홍길동1");
		map.put("p02", "홍길동2");
		map.put("p03", "홍길동3");
		map.put("p03", "이순신");  // key 중복시 덮어쓴다.

		//출력1- get(key)
		String n = map.get("p01");
		System.out.println(n);
		System.out.println(map.get("p02"));
		System.out.println(map.get("p100")); // 일치하는 key가 없으면 null 반환.
		
		//출력2 - key값만 먼저 얻고 나중에 value 얻기
		Set<String> keys = map.keySet();
		System.out.println(keys); // [p01, p03, p02]
		for (String key : keys) {
			System.out.println(key+"\t"+ map.get(key));
		}
		//출력3 - toString
		System.out.println(map); // {p01=홍길동1, p03=이순신, p02=홍길동2}
		
		
		
		
		
		
	}//end main
}//end class

실행 결과 1
참고 2

package p03;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;


public class MapTest2 {

	public static void main(String[] args) {
		// Map 계열:  key/value 쌍으로 저장, Collection 인터페이스와 무관
		
		//1. HashMap
		// 다형성
		Map<String, String> map = new HashMap<>();
		
		//데이터 저장
		map.put("p01", "홍길동1");
		map.put("p02", "홍길동2");
		map.put("p03", "홍길동3");

		
		System.out.println("크기:" + map.size());
		System.out.println("특정 key가 있냐:" + map.containsKey("p01"));
		System.out.println("특정 value가 있냐:" + map.containsValue("홍길동1"));
		System.out.println("비어 있냐:" + map.isEmpty());
		
		
		//삭제 remove(key)
		map.remove("p03");
		
		//치환 replace(key, value)
		map.replace("p01", "이순신");
		
		//전체 삭제
		map.clear();
		
		System.out.println(map);
		
	}//end main
}//end class

실행 결과 2

14번

배열 생성하는 방법

1. 기본형 데이터 배열 생성

// 배열 생성
int[] arr = new int[5];
double[] arr2 = new double[10];
boolean[] arr3 = new boolean[3];

// 값 할당
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;

1. 참조형 데이터 배열 생성

// 배열 생성
String[] arr = new String[3];
Object[] arr2 = new Object[5];
Date[] arr3 = new Date[10];

// 값 할당
arr[0] = "Java";
arr[1] = "Python";
arr[2] = "C++";

1. 컬렉션 API를 사용하여 배열 생성

// 배열 생성
List<String> list = new ArrayList<String>();
list.add("Java");
list.add("Python");
list.add("C++");

// 배열로 변환
String[] arr = list.toArray(new String[list.size()]);

set 활용

	// 1. 제넥릭스 사용
		Set<String> set = new HashSet<String>(); // new HashSet<>(); 동일
		
		//조건은 이름인 문자열만 저장하자
		set.add("홍길동1");
		set.add("홍길동2");
		set.add("홍길동3");
		// set.add(10);  1) 컴파일 시점에 잘못 저장된 것을 확인할 수 있다
		
		//출력: 문자열의 길이를 출력하자
		for (String s : set) {  // 2) 형변환이 불필요하다.
			System.out.println(s+"\t"+s.length());
		}

list 활용

List<Cat> list = new ArrayList<Cat>();
		list.add(new Cat("야옹이",2, "암컷"));
		list.add(new Cat("나비",1, "숫컷"));
		
		//많이 사용되는 패턴 ==> 추가 작업 불가
//		List<Cat> list2 = Arrays.asList(new Cat("야옹이",2, "암컷"),
//				                        new Cat("나비",1, "숫컷"));
		
		//추가 가능
		list.add(new Cat("망치",3,"수컷"));
		
		//삽입 가능
		list.add(0,new Cat("블랙",1,"암컷") );
		
		//수정 가능
		list.set(0, new Cat("블랙",1,"수컷"));
		
		//삭제 가능
		list.remove(0);
		
		//출력
		System.out.println(list);
		System.out.println("================");

map 활용

	//1. HashMap
		// 다형성
		Map<String, String> map = new HashMap<>();
		
		//데이터 저장
		map.put("p01", "홍길동1");
		map.put("p02", "홍길동2");
		map.put("p03", "홍길동3");
		map.put("p03", "이순신");  // key 중복시 덮어쓴다.
        
        //출력1- get(key)
		String n = map.get("p01");
		System.out.println(n);
		System.out.println(map.get("p02"));
		System.out.println(map.get("p100")); // 일치하는 key가 없으면 null 반환.

15번

THREAD 개념

다음 설명 중 맞는 것은?

thread 특징

공유 가능
- 하나의 프로세스 내에서 여러 개의 Thread가 생성될 수 있으며, 이들은 같은 프로세스 내에서 실행
- 이러한 Thread들은 같은 자원(메모리 등)을 공유할 수 있음
- 이를 통해 데이터 공유, 작업 분할 등이 가능해져 병행 처리에 적합
병행 처리 가능
- Thread들이 동시에 작업을 수행하면서 병행으로 처리하므로, 실행 시간을 단축
우선 순위 지님
- 실행 단계에서 쓰레드는 다른 우선순위의 쓰레드에 의해 쫓겨날 수 있다
- 우선 순위가 가장 높은 스레드가 다른 스레드보다 먼저 실행 기회를 얻음
- Java에서 스레드를 생성할 때마다 항상 우선 순위가 할당
- 우선순위는 스레드를 생성하는 동안 JVM에서 제공하거나 프로그래머가 명시적으로 제공

16번

(주관식) 배열의 길이, 컬렉션의 크기, 문자열의 크기

→ 순서대로 적는 것

✨ 추가 메서드 (출제)
- 배열 크기(길이): 배열명.length
- 문자열 길이: s.length()
- 컬렉션 크기: 변수명.size() <= set계열, list 계열

System.out.println("크기:" + set.size());

문제 예)

int[] arr = {1, 2, 3, 4, 5};
String str = "Hello, world!";
List<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add("orange");
Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
set.add(3);
Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);

배열 arr의 크기(길이): arr.length (예: 5)
문자열 str의 길이: str.length() (예: 12)
리스트 list의 크기: list.size() (예: 3)
집합 set의 크기: set.size() (예: 3)
맵 map의 크기: map.size() (또는 map.keySet().size()) (예: 3)

17번

다형성 문제 출제

중간고사에서 배웠던 문제를 클래스만 바꿔 출제
강아지가 잔다 만 출력 되도록 하는 예제 참고

// 강아지가 잔다(sleep()) 만 출력하시오?
for (Pet pet : pets) {
    if(pet instanceof Dog) {
        Dog d = (Dog) pet;
        System.out.println(d.sleep()); 
    }
}

instanceof 실습 (고양이 나이만 확인)


package p05;

public class TestPet2 {

	public static void main(String[] args) {

		// 배열
		Pet [] pets = { 
						new Cat("야옹1", "암컷", 2),
						new Dog("망치1","암컷",4, "불독"),
						new Cat("야옹2", "암컷", 2),
				        new Dog("망치2","암컷",1, "치와와"),
				        new Cat("야옹3", "암컷", 2)
				      };
		
		for (Pet pet : pets) {
			System.out.println(pet.getPet()); // 동적바인딩
		}
		System.out.println();
		
		//고양이만 출력하시오? ==>  (변수 instanceof 타입) 연산자
		for (Pet pet : pets) {
			if(pet instanceof Cat) {
				System.out.println("Cat:" + pet.getPet()); 
			}
		}
	
		System.out.println();
		//고양이의 age 만 출력하시오 ? ==> instanceof + 형변환
		for (Pet pet : pets) {
			if(pet instanceof Cat) {
				Cat c = (Cat)pet;
				System.out.println("Cat 나이:" + c.getAge()); 
			}
		}
		/////////////////////////////////////////////////////////////
		System.out.println();
		// 고양이만 출력 다른 표기 
		for (Pet pet  : pets) {
			if (pet  instanceof Cat) { // x가 Cat 클래스의 인스턴스인지 확인
				System.out.println("Cat:" +((Cat) pet ).getPet()); // Cat 타입으로 캐스팅하여 getPet() 사용
					}
		}
				
		System.out.println();
		// 고양이의 age 만 출력	 다른 표기 
		for (Pet pet  : pets) {
			if (pet  instanceof Cat) { // x가 Cat 클래스의 인스턴스인지 확인
				System.out.println("Cat 나이:" +((Cat) pet ).age); // Cat 타입으로 캐스팅하여 age 필드 사용
					}
				}
	}
}

Cat c = (Cat) pet; 형 변환 이유
- pet 변수가 Cat 클래스 타입의 객체를 참조하고 있다는 것은, Cat 클래스가 Pet 클래스의 자식 클래스이기 때문에 가능
- 그러나 pet 변수는 Pet 클래스 타입으로 선언되어 있기 때문에, Cat 클래스의 멤버인 getAge() 메서드를 직접 호출할 수는 없음.
- 따라서 pet 변수를 Cat 클래스 타입으로 형변환하여 getAge() 메서드를 호출해야 함.
- 이렇게 하면 pet 변수가 참조하는 객체가 Cat 클래스의 인스턴스라는 것이 보장되기 때문에, getAge() 메서드를 호출할 수 있게 됨.

18번

(예상) JAVA 예외처리

✨ throw + 예외클래스에서 throw 키워드 생략 불가
✨ e.printStackTrace() 키워드

19번

(예상) thread 생성 방법 (✨ 출제)

thread 생성 방법 (✨ 출제)

extends Thread
- Thread 클래스를 상속받아 run 메소드를 오버라이딩
- 완벽한 thread
- run 메소드
implements Runnable
- Runnable 인터페이스를 implements 하여 run 메소드를 정의
- 준 thread + 완벽한 thread로 만들기
- run 메서드 재정의 위한 코드 필요

thread의 상태 (✨ 출제)

✨ (주의) 우리는 run 메서드를 직접 호출하지 않고, start()만 수행
void run()
- 스레드 코드로서 JVM에 의해 호출된다. 반드시 오버라이딩하여 스레드 코드를 작성
- 이 메소드가 종료하면 스레드도 종료
void start()
- JVM에게 스레드를 실행을 시작하도록 요청(run() 메소드 호출)
쓰레드 실행 순서 ✨
- 시작 준비 단계: 쓰레드 객체를 생성한 후 start() 메서드를 호출합니다. 이 때, JVM은 해당 쓰레드를 실행 가능한 상태인 "Runnable" 상태로 만들고, 해당 쓰레드가 사용할 스레드 스택(Thread Stack)을 생성합니다.
  - t1. start(), t2.start()
  - t1-5, t2-5, t3-10
- Block 단계: 쓰레드가 실행 가능한 상태가 되면, 스케줄러(Scheduler)에 의해 CPU가 할당되고, 해당 쓰레드가 실행됩니다. 실행 중인 쓰레드가 다른 쓰레드에 의해 중지되는 경우, 해당 쓰레드는 "Block" 상태로 변경됩니다.
  - 명시적 대기 상태 전환
  - sleep(), yield(), join() 메서드는 쓰레드를 일시적으로 block 상태로 만들고, 다른 쓰레드가 실행될 수 있도록 함
- Wait 단계: 쓰레드가 Block 상태에 있을 때, 일시적으로 실행을 중단하고 다른 쓰레드의 notify() 메서드 호출을 기다리는 경우, 해당 쓰레드는 "Wait" 상태로 변경됩니다. 이 때, 쓰레드는 wait() 메서드를 호출하여 일시적으로 실행을 중단합니다.
- Notify 단계: Wait 상태에 있는 쓰레드가 다시 실행되기 위해서는, 다른 쓰레드가 notify() 메서드를 호출해야 합니다. 이 때, notify() 메서드를 호출하는 쓰레드와 wait() 메서드를 호출한 쓰레드는 동일한 객체의 모니터를 공유해야 합니다.
- 제거 단계: 쓰레드가 실행을 마치면, 해당 쓰레드는 종료됩니다. 이 때, JVM은 해당 쓰레드가 사용한 자원을 해제하고, 해당 쓰레드의 스택을 제거합니다.

20번

(예상) JDBC API Flow

Java => 접속(by JDBC) => Oracle, ms-SQL...
어떤 데이터 베이스든 ✨ 일관된 방법(interface)으로 연동이 가능하다.
✨ JDBC API Flow
✨(중요) Java 진영에서 인터페이스를 구현
- ✨ 각 벤더(Oracle, MySQL 등)는 인터페이스를 implements
- 드라이버 필요 (*.jar 사용하도록 build path 해야 한다) => 컴파일러에게 알려줌
- JDBC 드라이버(각 벤더에서 생성된 클래스 파일들)는 DB와 통신을 담당하는 인터페이스로, DB와 연결하는 Driver 클래스를 만들 때 반드시 implements 해야 한다.
cf. MyBatis
: => jdbc 단점을 해결하기 위해 사용
- jdbc 단점
- 1) JDBC는 1개의 클래스에 반복된 코드가 존재한다
- 2) 자바언어와 sql언어 2가지가 하나의 클래스에 있기 때문에 재사용성이 좋지 않다
MyBatis
- 기존 DAO클래스에서 DB실행을 위해 작성한 JDBC 코드를 XML로 분산한다
- xml의 이름만 호출하면 DB연결을 할 수 있다
- DAO클래스 내 코드를 작성할 필요가 없어진다

✨ DTO 패턴

(appendix)

stream

List<String> list = Arrays.asList("홍길동","이순신","유관순","이순신");
Stream<String> stream = list.stream();

 ...
 
 stream.filter(t-> t.startsWith("이")).forEach(System.out::println); //중요

stream 객체를 사용하여 배열 names에서 filter 메소드를 사용하여 "이"로 시작하는 문자열만 필터링
- filter 메소드는 Stream의 모든 요소를 조건식으로 확인하여 조건을 충족하는 요소로 이루어진 새로운 Stream을 반환
- "이"로 시작하는 문자열만 걸러내기 위해 람다 표현식 t -> t.startsWith("이")를 인자로 전달
  - t는 람다식에서 사용되는 매개변수
  - stream.filter(t-> t.startsWith("이"))에서 t는 스트림의 각 요소를 의미
필터링 된 결과를 forEach 메소드를 사용하여 출력
- 반환된 새로운 Stream에 대해서 forEach 메소드를 사용하여, 각 요소에 대해 System.out.println을 호출하여 콘솔에 출력
  - stream에서 "이"로 시작하는 요소들만 필터링하여 출력
실행예외 vs 일반예외
- 일반 예외는 컴파일 체크 예외라고도 하는데, 자바 소스를 컴파일하는 과정에서 예외 처리 코드가 필요한지 검사하기 때문이다.
  만약 예외 처리 코드가 없다면 컴파일 오류가 발생하게 된다.
- 실행 예외는 컴파일하는 과정에서 예외 코드를 검사하지 않는 예외를 말한다.
  - NullPointerException(NPE)
  - ArrayIndexOutOfBoundsException
  - NumberFormatException
  - ClassCastException

✨ 빌드 툴 실행 순서 (maven으로 자동화 가능)
- 개발시 2~6을 자동 수행해주는 툴: maven (pom.xml), gradle(build.gradle)
- 1) 소스 파일 작성
- 2) jar 다운로드 + build path
  - (pom.xml에서 지정)
- 3) compile : 리소스 복사 후 컴파일 실행
  - => 명령어: mvn compile
- 4) 소스 파일 검증 (특정 기능 검증), 단위 테스트
  - mvn test
- 5) 패키징 (압축: jar, war)
  - mvn package
- 6) 배포
  로컬 mvn install
  maven의 로컬 저장소 경로: C:\Users\TECH5-20.m2\repository\com\app\MavenTest\0.0.1-SNAPSHOT
  원격

컬렉션 인터페이스와 map 인터페이스는 무관하다 (독립적으로 존재)
컬렉션 타입(자료형) 제한 방법: <> 제네릭스
리스트는 인덱스로 접근 (순서 있고 중복 가능)
set은 순서 없고 중복 불가 (인덱스 없음)
StringBuilder를 활용해 문자열 저장하려면 toString 사용 필
예외 처리 (2)
- 컴파일 체크 예외 (일반 예외, cheked => 예외처리 안하면 컴파일 에러 발생 ) 
	입출력(I/O) 관련 예외( IOException )
	SQL 관련 예외 (SQLException)
 
- 런타임 예외 (실행 예외, unchecked)
	ArithmeticException
  	NullPointerException(NPE)
	ArrayIndexOutOfBoundsException
	NumberFormatException
	ClassCastException

- map에서 key 값 중복 불가
key, value 
a 홍길동
a 이순신
=>홍길동이 이순신으로 최신화

- ArrayList 홍길동 이순신 세종대왕 왕건 을지문덕
	5개 저장했는데 출력은 홍길동 이순신 정도전 세종대왕 왕건 을지문덕으로 6개 출력되도록 하는 코드 구현
	list.insert 함수 활용 필 => 중간에 들어가니까 삽입

final
final 클래스 => 상속 불가
final 변수 =>  값 수정 불가
final 메소드 =>  오버`라이딩`  불가 (오버로딩이 아님 주의) 


배열 생성 방법 
총 8개 예시가 나오는데 그 중 틀린 방법 2개 고르기
new, literal, 혼합 
=> new, literal 혼합하는 방법은 대괄호에 갯수를 지정하면 안됨
1) new
배열명 = new 데이터타입[배열크기];
	Ex) num_arr = new int [3];
2) literal

자료형 [ ] 배열명  = { 값1, 값2, .... , 값N };
	=> 배열의 크기는 값이 들어온 개수만큼 설정된다. ⇒ 별도로 지정할 경우 에러 발생

3) new 키워드 + 리터럴
자료형 [] 배열명 = new 자료형[]{값 1, 값 2, ..., 값 N};

			or

자료형 [] 배열명;   // 선언
배열명 = new 자료형 [] {값1, 값2, ... , 값 N};       // 생성&초기화
	=> (new를 이용한) 방법과 다르게, 크기를 지정하지 않아야 한다. 크기 지정시, 에러 발생


스레드 개념 (O/X)
우리는 run 메서드를 직접 호출하지 않고, start()만 수행

스레드 생성 방법 (2)
extends Thread
	Thread 클래스를 상속받아 run 메소드를 오버라이딩
	완벽한 thread
	run 메소드

implements Runnable
	Runnable 인터페이스를 implements 하여 run 메소드를 정의
	준 thread + 완벽한 thread로 만들기
	run 메서드 재정의 위한 코드 필요


배열, 컬렉션, 문자열 길이 순서대로 작성하는 주관식 
	배열 arr의 크기(길이): arr.length (예: {1, 2, 3, 4, 5} => 5)
	문자열 str의 길이: str.length() (예: Hello, world! => 12)
	리스트 list의 크기: list.size() (예: 3)
	집합 set의 크기: set.size() (예: 3)
	맵 map의 크기: map.size() (또는 map.keySet().size()) (예: 3)

전희주

이전 포스트

[JAVA]_스트림 API

다음 포스트

[JAVA]_빌드 툴 (build tool)_Maven

6개의 댓글

이현규

2023년 4월 28일

비밀댓글입니다.

2개의 답글

SG L

2023년 4월 28일

비밀댓글입니다.

1개의 답글