2021.04.26
ArrayList - Q24번문제 풀이
public class Ex64_ArrayList {
public static void main(String[] args) {
MyList list = new MyList();
System.out.println(list); //[0,0,0,0]
list.add(100);
System.out.println(list); //[100,0,0,0]
list.add(200);
System.out.println(list);//[100,200,0,0]
list.add(300);
System.out.println(list);//[100,200,300,0]
list.add(400);
System.out.println(list);//[100,200,300,400]
//배열 길이 초과 -> 배열 길이 늘려주기
list.add(500);
System.out.println(list); //[100,200,300,400,500,0,0,0]
list.add(600);
list.add(700);
list.add(800);
list.add(900);
System.out.println(list); //[100,200,300,400,500,600,700,800,900,0,0,0,0,0,0,0]
System.out.println("list.get(0):"+ list.get(0));
System.out.println("list.get(0):"+ list.get(3));
System.out.println("list.get(0):"+ list.get(5));
//for(int i=0; i<16; i++) {
// System.out.println(list.get(i)); -> 빈방 0으로 출력 -> 에러
//}
//System.out.println(list.get(20)); -> 에러
System.out.println("size : "+ list.size()); //9
list.set(0, 1000);
System.out.println(list); //[1000,200,300,400,500,600,700,800,900,0,0,0,0,0,0,0]
list.set(8, 9000);
System.out.println(list); //[1000,200,300,400,500,600,700,800,8000,0,0,0,0,0,0,0]
System.out.println(list.size()); //9개 -> 배열의 길이 -> 9
//사용자는 방이 9개까지만 있는 걸로 알고 있음 -> 논리적 오류
//list.set(14, 10000);
//list.set(1000, 20000);
list.remove(4);
System.out.println(list); //[1000,200,300,400,600,700,800,9000,9000,0,0,0,0,0,0,0]
list.add(1);
System.out.println(list);
list.add(5,5);
System.out.println(list); //[1000, 200, 300, 400, 600, 5, 800,9000, 1, 0, 0, 0, 0, 0, 0, 0]
list.add(5,5);
list.add(5,5);
list.add(5,5);
list.add(5,5);
list.add(5,5);
list.add(5,5);
list.add(5,5);
System.out.println(list);
list.add(5, 5);
System.out.println(list);
list.clear();
System.out.println(list); //개발 + 디버깅 -> 출력 결과는 개발자들만 열람
//System.out.println(list.size());
//System.out.println(list.get(0));
list.add(100);
list.add(200);
System.out.println(list.size()); //2
for (int i=0; i<list.size(); i++) {
System.out.println(list.get(i)); //100, 200
}
System.out.println();
System.out.println();
System.out.println();
System.out.println(list); //[ 100, 200, 300, 400, 600, 5, 800,9000, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
list.trimToSize();
System.out.println(list); //[ 100, 200]
}
}
class MyList {
private int[] list; //내부 배열
private int index; //현재 데이터를 넣을 방의 위치
//생성자
public MyList() {
this.list = new int[4]; //초기 배열 크기
this.index = 0; //처음 넣은 방 번호
}
//추가하기(Append)
public void add(int n) {
//1. 방의 갯수 확인 -> 2배로 늘리기
doubling();
//2. 데이터 추가하기
this.list[this.index] = n;
this.index++;
}//add
//배열을 2배로 늘려주는 메소드
private void doubling() {
if(this.index >= this.list.length) {
int[] temp = new int[this.list.length * 2];//현재 크기의 2배
//깊은 복사(짧은 배열 길이만큼 반복)
for(int i=0; i<this.list.length; i++) {
temp[i] = this.list[i]; //원래배열의 방 -> 2배 배열의 방 -> 1:1 복사
}
this.list = temp; //배열 교체
}
}
@Override
public String toString() {
String temp = "[";
for(int n: this.list) {
temp += String.format("%4d,", n);
}
temp = temp.substring(0,temp.length()-1); //끝에 , 안나오게 출력
temp += "]";
return String.format("length: %d\nindex: %d\n%s\n" //자기가 가진 데이터를 문자열로 반환
, this.list.length //실제 내부 배열의 길이
, this.index //현재 방번호
, temp); //배열 출력
//배포용 버전
// String temp = "[";
//
// for (int i=0; i<this.index; i++) {
// temp += String.format("%4d,", this.list[i]);
// }
//
// temp = temp.substring(0, temp.length()-1);
//
// temp += "]";
//
// return temp;
}
//가져오기(get)
public int get(int index) {
//요청하는 방번호를 자신이 집어넣은 데이터 갯수 범위 내를 넘으면 에러
if(index>=0 && index < this.index) { //this.index : 마지막에 들어있는 방 번호 + 1임.
return this.list[index];
} else {
throw new IndexOutOfBoundsException(); //예외 던지기
}
}
//현재 요소 개수
// - 배열의 길이(x)
// - 배열의 길이와 상관없이 넣은 데이터의 갯수(o)
public int size() {
return this.index;
}
//수정하기
//집어넣은 길이만큼만 수정, 읽기의 대상이 되도록 설정
public void set (int index,int n) {
if(index>=0 && index < this.index) {
this.list[index] = n;
} else {
throw new IndexOutOfBoundsException(); //예외 던지기
}
}
//삭제하기(왼쪽 시프트)
public void remove(int index) {
if (index >= 0 && index < this.index) {
//좌측 시프트
for (int i=index; i<this.index-1; i++) {
this.list[i] = this.list[i+1];
}
this.index--;//요소가 하나 없어졌으니 그 다음 방 번호도 하나 감소
} else {
throw new IndexOutOfBoundsException(); //예외 던지기
}
}
//추가하기(오른쪽 시프트)
public void add(int index, int n) {
if(index >= 0 && index < this.index) {
doubling();
for(int i=this.index-1; i>=index; i--) {
this.list[i] = this.list[i];
}
//비어있는 방에 새로운 값 대입
this.list[index] = n;
this.index++; //값이 추가되었으니 방번호 증가
} else {
throw new IndexOutOfBoundsException(); //예외 던지기
}
}
//------------------------------------------ 반드시 구현 업무!!
//indexOf : 몇번째 방에 있는지
public int indexOf(int n) {
for(int i=0; i<this.index; i++) {
if(this.list[i] == n) {
return i; //찾은 방번호 반환
}
}
return -1; //못찾으면 -1 반환
}
public int lastIndexOf(int n) {
for(int i=this.index-1; i>=0; i--) {
if(this.list[i] == n) {
return i;
}
}
return -1;
}
public void clear () {
//Case A.
//for (int i=0; i<this.index; i++) {
// this.list[i] = 0;
//}
//Case B.
//this.list = new int[4];
//Case C.
this.index = 0; //첫번째 방부터 덮어쓰기 된다.(그 전에 입력된 값은 쓰레기 데이터가 됨.)
}
//contains : 있는지 없는지 확인
public boolean contains(int n) {
for (int i=0; i<this.index; i++) {
if (this.list[i] == n) {
return true;
}
}
return false;
}
//길어진 배열을 데이터 갯수만큼으로 줄이기
//더이상 아이템을 추가할 일이 없을때 배열을 줄임.
public void trimToSize() {
//현재 길이 -> size
int[] temp = new int[this.index]; //현재 데이터 갯수만큼의 길이를 가지는 배열
for (int i=0; i<temp.length; i++) {
temp[i] = this.list[i]; //짧은 배열만큼 반복
}
this.list = temp; //짧은 배열로 바꾸기 (새로운 배열로 교체하기)
}
//비었는지?
public boolean isEmpty() {
return this.index == 0 ? true : false;
}
}- 좌측 시프트
- 우측시프트
ArrayList vs HashMap
HashMap
- 방번호 없음 -> 요소의 순서가 없음
- 방이름 있음
- 사전 구조(Dictionary), 맵(Map), 연관 배열
- 키(key)와 값(Value)으로 요소 관리
- 루프 적용 불가능(단점x) -> 애초에 루프를 돌릴 목적으로 만드는 배열이 아니다.
- 가독성 때문에 사용하는 배열 -> 방의 이름이 명확!!! (이름보고 찾기 쉽다.)
ArrayList
- 요소 접근 -> 첨자(index) 사용 -> 요소의 순서가 있음
- 스칼라 배열(Scalar Array)
- 루프 적용 가능(장점)
HashMap 사용법
import java.util.HashMap;
public class Ex65_HashMap {
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<String, Integer>();
//요소 추가
// - Associates the specified value with the specified key in this map.
map.put("국어",100);
map.put("영어",90);
map.put("수학",80); //데이터(80), 키(수학) -> 키 : 방의 이름
//강의실 6개
// -> 1강의실, 2강의실, 3강의실 -> ArrayList (번호로 관리)
// -> 햇님반, 달님반, 별님반 -> HashMap (이름으로 관리)
// - Returns the number of key-value mappings in this map.
// - 요소의 갯수 반환
System.out.println(map.size());
//데이터 가져오기
//System.out.println(list.get(0)); -> ArrayList : 안에 뭐가 들었는지 알 기 어렵다.
System.out.println(map.get("국어")); //내용을 알 수 있다. 하지만 방의 번호가 숫자가 아니라서 루프를 돌릴 수 없다.
System.out.println(map.get("영어"));
System.out.println(map.get("수학"));
//수정(덮어쓰기)
map.put("국어", 60);
System.out.println(map.get("국어"));
HashMap<String, String> group = new HashMap<String, String>();
group.put("반장", "홍길동");
group.put("부반장", "아무개");
group.put("체육부장", "하하하");
System.out.println(map.get("반장"));
HashMap<String, Boolean> result = new HashMap<String, Boolean>();
result.put("홍길동", true);
result.put("아무개", false);
result.put("하하하", true);
System.out.println(result.get("홍길동"));
System.out.println(result.get("호호호")); //null
Scanner scan = new Scanner(System.in);
System.out.print("응시자명: ");
String name = scan.nextLine();
if(result.get(name) != null) {
if(result.get(name)) {
System.out.println("합격하셨습니다.");
} else {
System.out.println("불합격하셨습니다.");
}
} else {
System.out.println("응시자 명단에 없습니다.");
}
//HashMap
// - key : 주로 String. 다른 자료형은 잘 사용 안함
// - value : Integer, Double, String, Boolean....
//요소의 최대 갯수 -> 2개
HashMap<Boolean, String> map2 = new HashMap<Boolean, String>();
map2.put(true, "홍길동");
map2.put(false, "아무개");
map2.put(true, "호호호");
//사용하지 말 것
// - 1. 키의 의미를 알기가 힘들다.
// - 2. 루프용으로 사용하지 말 것 -> ArrayList or Array 쓸 것
HashMap<Integer, String> map3 = new HashMap<Integer, String>();
map3.put(1, "빨강");
map3.put(2, "노랑");
map3.put(3, "파랑");
}
}순수배열, 클래스, ArrayList, HashMap 선택 기준
public class Ex65_HashMap {
public static void main(String[] args) {
/*
데이터의 집합이 필요할 때(순수배열, 클래스, ArrayList, HashMap)
<선택 기준>
1. 같은 자료형이 필요하다
a. 순수 배열
b. ArrayList
c. HashMap
2. 다른 자료형의 집합이 필요하다.
a. 클래스
1. 길이가 고정이다.
a. 순수배열
2. 길이가 가변이다.
a. ArrayList
b. HashMap
1. 데이터의 의미를 구분하기 쉽게 관리한다.
a. 클래스(멤버 변수명)
b. HashMap(Key)
2. 일괄 처리 한다.
a. 순수 배열
b. ArrayList
*/
//학생 정보를 관리하고 싶다. -> 데이터 집합 필요 -> 학생 1명 단위의 데이터 자료형이 필요하다.
// - 이름, 주소, 전화번호, 나이
//1. 순수배열 -> x(의미를 알기 어렵다.)
//2. ArrayList -> x(의미를 알기 어렵다.)
//3. 클래스 -> o (의미 알기 쉬움)
// - 반복되는 틀로써의 역할이 만족스럽다.
// - 규칙을 컴퓨터가 제어한다.
// - 클래스 선언 비용이 발생한다.
// - 같은 형식의 객체를 여러개 만들때 사용한다.
//4. HashMap -> o (의미 알기 쉬움)
// - 반복되는 틀로써의 역할이 부족하다.
// - 규칙을 사람이 제어한다.
// - 선언 비용이 없다.
// - 같은 타입의 객체를 1개 만들때 사용한다.
Student2 s1 = new Student2();
s1.name = "홍길동";
s1.address = "서울시";
s1.tel = "010-1523-456";
s1.age = 20;
Student2 s2 = new Student2();
s2.name = "아무개";
s2.address = "서울시";
s2.tel = "010-5422-456";
s2.age = 25;
HashMap<String, String> s3 = new HashMap<String, String>();
s3.put("name", "하하하");
s3.put("address", "인천시");
s3.put("tel", "010-6589-6235");
s3.put("age", "21");
System.out.println(s2.name);
System.out.println(s3.get("name"));
HashMap<String, String> s4 = new HashMap<String, String>();
s4.put("name", "호호호");
s4.put("address", "인천시");
s4.put("tel", "010-3564-6584");
s4.put("age","24");
}
}
class Student2 {
public String name;
public String address;
public String tel;
public int age;
}public class Ex65_HashMap {
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<String, Integer>(10); //내부 배열이 10칸부터 시작
//map.clear();
map.put("국어", 100);
map.put("영어", 90);
map.put("수학", 80);
System.out.println(map.size());
System.out.println(map.containsKey("국어")); //국어 점수 있니? -> true
System.out.println(map.containsValue(100)); //100점 맞은 과목이 있니? -> true
System.out.println(map.get("영어"));
System.out.println(map.isEmpty()); //들어있으면 true, 없으면 false
map.remove("국어");
System.out.println(map.size()); // 3 -> 2
System.out.println(map.get("국어")); // null
}
}HashMap - Q25문제 풀이
import java.util.Arrays;
public class Ex66_HashMap {
public static void main(String[] args) {
MyMap map = new MyMap();
System.out.println(map); //[null, null, null, null]
map.put("red", "빨강");
System.out.println(map); //[(red,빨강), null, null, null]
map.put("blue", "파랑");
System.out.println(map); //[(red,빨강), (blue,파랑), null, null]
map.put("yellow", "노랑");
map.put("green", "녹색");
map.put("white", "흰색");
System.out.println(map); //[(red,빨강), (blue,파랑), (yellow,노랑), (green,녹색), (white,흰색), null, null, null]
System.out.println(map.get("red")); //빨강
System.out.println(map.get("blue")); //파랑
System.out.println(map.get("yellow")); //노랑
System.out.println(map.get("black")); //null
//수정
map.put("white", "하양");
System.out.println(map); //[(red,빨강), (blue,파랑), (yellow,노랑), (green,녹색), (white,하양), null, null, null]
} //main
} //Ex66
class MyMap {
private Entry[] list; //참조변수 배열
private int index;
//생성자
public MyMap() {
this.list = new Entry[4];
this.index = 0;
}
@Override
public String toString() {
return String.format("length: %d\nindex: %d\n%s\n"
, this.list.length
, this.index
, Arrays.toString(this.list)); //Arrays.toString(this.list) -> 배열을 넣으면 배열에 있는 데이터를 문자열로 반환해줌.
}
public void put(String key, String value) {
//공간 체크 -> 2배로 늘림.
doubling();
//항목 추가하기 and 항목 수정하기 : key가 배열안에 들어있으면 수정, 없으면 추가
if (!containsKey(key)) {
//항목 추가하기
Entry e = new Entry();
e.key = key;
e.value = value; //1차 포장(작은 상자)
//작은 상자(Entry) -> 큰상자(Array) : 배열에 담기
//2차 포장
this.list[this.index] = e;
this.index++;
} else {
//항목 수정하기
this.list[getIndex(key)].value = value;
}
}
//똑같은 key가 있는지 검사하는 메소드 - 있으면 true, 없으면 false
private boolean containsKey(String key) {
for (int i=0; i<this.index; i++) { //첫번째 방부터 index까지 루프
if (this.list[i].key.equals(key)) {
return true;
}
}
return false;
}
//똑같은 value가 있는지 검사하는 메소드
private boolean containsValue(String value) {
for (int i=0; i<this.index; i++) {
if (this.list[i].value.equals(value)) {
return true;
}
}
return false;
}
//배열이 꽉 차면 2배로 늘리는 메소드
private void doubling() {
if (this.index >= this.list.length) {
Entry[] temp = new Entry[this.list.length * 2];
for (int i=0; i<this.list.length; i++) {
temp[i] = this.list[i];
}
this.list = temp;
}
}
//key를 넣으면 value를 호출
public String get(String key) {
// for (int i=0; i<this.index; i++) {
// if (this.list[i].key.equals(key)) {
// return this.list[i].value;
// }
// }
int index = getIndex(key);
if (index > -1) {
return this.list[index].value;
} else {
return null; //찾는 key가 없을때는 null 반환.
}
}
//key가 몇번째 방에 있는지 찾는 메소드
public int getIndex(String key) {
for (int i=0; i<this.index; i++) {
if (this.list[i].key.equals(key)) {
return i; //찾은 방번호 반환
}
}
return -1; //못찾으면 -1반환
}
}
class Entry {
public String key;
public String value;
@Override
public String toString() {
return String.format("(%s,%s)", this.key, this.value);
}
}
모르면 괴롭고 알면 즐겁다.