1. Collection
|__ List
|__ ArrayList, LinkedList
2. Collection
|__ Set
|__ HashSet, TreeSet
3. Map<K, V>
|__ HashMap<K, V>, TreeMap<K, V>
[실습코드]
1. Lec19_String
1) com.lec.java.string02 패키지, String02Main 클래스
package com.lec.java.string02;
/* String 생성자, String literal(상수)
*/
public class String02Main {
public static void main(String[] args) {
System.out.println("String 생성자, literal(상수)");
int num1 = 1;
int num2 = 1;
if (num1 == num2) {
System.out.println("같은 숫자");
} else {
System.out.println("다른 숫자");
}
System.out.println();
System.out.println("[1] String literal 사용");
// "Hello"는 literal이기 때문에, 한 번 만들어지면 재사용됨
// 그래서, str1과 str2는 같은 곳(주소)에 있는 문자열 "Hello"를 가리키게 됨
// 즉, str1과 str2에는 같은 값이 저장되게 됨
// literal : 직접 입력 하는 값
String str1 = "Hello";
String str2 = "Hello";
// 주소를 비교한것..!!
if(str1 == str2) {
System.out.println("동일한 곳(문자열 ) 참조");
} else {
System.out.println("다른 곳(문자열) 참조");
}
// 위의 값이 참이 나온 이유
// 동일한 리터럴은 중복되서 발생하지 않음
// 중복되서 만들어지면 메모리 낭비야 ㅜㅜ
System.out.println();
System.out.println("[2] String 생성자 사용");
// 생성자는 호출될 때마다 새로운 인스턴스를 힙에 생성하게 됨
// str3과 str4는 서로 다른 인스턴스를 가리키게 됨
// 즉, str3과 str4에는 서로 다른 값이 저장되게 됨
String str3 = new String("Hello");
String str4 = new String("Hello");
if(str3 == str4) {
System.out.println("동일한 곳(문자열 ) 참조");
} else {
System.out.println("다른 곳(문자열) 참조");
}
System.out.println();
System.out.println("[2-2] String intern() 결과 비교");
// intern() String 객체가 실제로 참조하는 문자열 리턴
System.out.println("\nstr3.intern() == str4.intern()");
if(str3.intern() == str4.intern()) {
System.out.println("intern() 동일한(문자열) 참조");
} else {
System.out.println("intern() 다른 곳(문자열) 참조");
}
System.out.println("\nstr1.intern() == str2.intern()");
if(str1.intern() == str2.intern()) {
System.out.println("intern() 동일한(문자열) 참조");
} else {
System.out.println("intern() 다른 곳(문자열) 참조");
}
System.out.println("\nstr1.intern() == str4.intern()");
if(str1.intern() == str4.intern()) {
System.out.println("intern() 동일한 (문자열) 참조");
} else {
System.out.println("intern() 다른 곳 (문자열) 참조");
}
// == 연산자는 실제 문자열이 같은 지 다른 지를 비교하는 것이 아니고,
// 참조 변수(지역 변수) str3과 str4에 저장된 값(주소)가 같은 지 다른 지를 비교하는 것임.
// 문자열 비교를 == 으로 하지 말것!!!!
System.out.println();
System.out.println("[3] String equals() 메소드");
// 문자열 비교는 equals() 사용하자. 참고로 equals() 는 Object 의 메소드다.
// 실제 안에 있는 값을 동일한지 하나 하나 비교함
if(str3.equals(str4)) {
System.out.println("equals() 같은 문자열");
} else {
System.out.println("equals() 다른 문자열");
}
System.out.println();
System.out.println("[4] String compareTo() 메소드");
// compareTo() 는 두 문자열의 문자코드량 의 비교
// (lexicographical comparison based on the Unicode value)
// 이경우 유니코드 값을 비교하게 됨.
System.out.println("compareTo(): " + str3.compareTo(str4));
String str5 = "A";
String str6 = "C";
// 출력값 : A - C = -2
System.out.println("compareTo(): " + str5.compareTo(str6));
// 출력값 : C - A = 2
System.out.println("compareTo(): " + str6.compareTo(str5));
System.out.println();
str5 = "AaAa";
str6 = "aAaA";
System.out.println("compareTo(): " + str5.compareTo(str6));
System.out.println("compareTo(): " + str6.compareTo(str5));
System.out.println();
str5 = "xaAa";
str6 = "xAaA";
System.out.println("compareTo(): " + str5.compareTo(str6));
System.out.println("compareTo(): " + str6.compareTo(str5));
System.out.println("\n프로그램 종료");
} // end main()
} // end class
2) com.lec.java.string03 패키지, String03Main 클래스
package com.lec.java.string03;
/* StringBuffer, StringBuilder
String 클래스는 immutable 클래스이고,
StringBuffer, StringBuilder는 mutable 클래스임
StringBuffer:
Java ver 1.0부터 있던 클래스
쓰레드에 안전(thread-safe), 속도가 느림
StringBuilder:
Java 5부터 생긴 클래스
쓰레드에 안전하지 않다(thread-unsafe), 속도가 빠름.
그 외에는 StringBuffer와 StringBuilder는 같은 기능(메소드)을 갖고 있음
** 웹 프로그래밍 등에선 문자열을 '붙여 나가며' 완성하는 동작을 많이 함
실무에서는
String 을 concat() (혹은 + 연산)하기 보다는
StringBuffer 를 append() 하는 것을 더 많이 사용함 (성능 UP)
※ 그러나 학습예제에선 예제단순화를 위해 String 을 기본적으로 사용하니 참조 바랍니다
*/
public class String03Main {
// immutable : 변할 수 없는
// mutable : 변할 수 있는
public static void main(String[] args) {
System.out.println("[1] StringBuffer, StringBuilder");
// String 클래스는 immutable 클래스이고,
// StringBuffer, StringBuilder는 mutable 클래스임
System.out.println("[String: immutable]");
String str1 = "Hello";
String str2 = str1;
System.out.println("str1 = " + str1);
System.out.println("str2 = " + str2);
// 출력 값 : "== 동일 참조"
if(str1 == str2) {
System.out.println("== 동일 참조");
} else {
System.out.println("== 다른 참조");
}
System.out.println(str1.concat("Java"));
System.out.println(str1); // str1이 실제로 변경되지 않는다. immutable...!!!
// Heap에 저장된 [Hello Java] 값의 주소 값이 str1에 저장된다..!!
str1 = str1.concat("Java");
System.out.println(str1);
// 출력 값 : == 다른 참조
if(str1 == str2) {
System.out.println("== 동일 참조");
} else {
System.out.println("== 다른 참조");
}
System.out.println();
System.out.println("[StringBuffer: mutable]");
StringBuffer buff1 = new StringBuffer("Hello");
StringBuffer buff2 = buff1;
System.out.println("buff1 = " + buff1);
System.out.println("buff2 = " + buff2);
// 주소 비교한 거
if(buff1 == buff2) {
System.out.println("== 동일 참조");
} else {
System.out.println("== 다른 참조");
}
System.out.println(buff1.append("Java"));
System.out.println(buff1); // buff1 값이 변경됨...!!! 이게 바로 mutable...!!!
if(buff1 == buff2) {
System.out.println("== 동일 참조");
} else {
System.out.println("== 다른 참조");
}
// 심지어 buff2도 값이 변경됬다...!!
// 왜? 같은 곳을 레퍼런싱을 하고 있기 때문이다.
System.out.println(buff2);
// 성능은 StringBuffer가 더 좋음
// 왜냐하면 StringBuffer는 append를 이용하여 직접 값을 변경하면 되지만
// String은 concat을 이용하여 새롭게 만드는 과정이 필요하기 때문에 시간이 필요함
// 그렇기 때문에 주로 실무에서는 StringBuffer를 더 많이 사용함
// StringBuffer:
// Java ver 1.0부터 있던 클래스
// 쓰레드에 안전(thread-safe), 속도가 느림
// StringBuilder:
// Java 5부터 생긴 클래스
// 쓰레드에 안전하지 않다(thread-unsafe), 속도가 빠름.
// 그 외에는 StringBuffer와 StringBuilder는 같은 기능을 갖고 있음
System.out.println();
StringBuilder buff3 = new StringBuilder("Hello");
System.out.println(buff3.append("Java"));
System.out.println("\n프로그램 종료");
} // end main()
} // end class
2. Lec21_Wrapper
1) com.lec.java.wrapper01 패키지, Wrapper01Main 클래스
package com.lec.java.wrapper01;
/* Wrapper 클래스: 기본 자료형(primitive type)의 데이터를 감싸는 클래스
* 기본 자료형: boolean, char, byte, short, int, long, float, double
* Wrapper: Boolean, Character, Byte, Short, Integer, Long, Float, Double
*
* Wrapper 클래스는 immutable 하다!
*
*/
// 자바 세상에서는...!! final 대문자, static 기울림, 파란색은 멤버 변수
public class Wrapper01Main {
public static void main(String[] args) {
System.out.println("Wrapper 클래스");
System.out.println("wrapper 클래스에 값을 저장하는 방법");
System.out.println();
Integer i1 = 100; // reference <= primitive ?!?!?
// 호에에에!??!? 둘이 타입이 다른데 어캐 대입된거지??
i1 = i1 + 200; // 호에에에..!!! reference 가 산술연산을!?!?!?!?
System.out.println("i1 = " + i1); // 300
// Wrapper 클래스는 마치 primitive 타입처럼 동작한다!
// 1. 생성자 이용
Integer num1 = new Integer(123);
System.out.println("num1 = " + num1);
// 2. wrapper 클래스의 static 메소드인 valueOf() 메소드를 사용
Integer num2 = Integer.valueOf(123);
System.out.println("num2 = " + num2);
// == 로 비교해보면 다르다고 나옴
if(num1 == num2) {
System.out.println("== 같다");
} else {
System.out.println("== 다르다!");
}
// equals()로 비교해보면 같다고 나옴
if(num1.equals(num2)) {
System.out.println("== 같다");
} else {
System.out.println("== 다르다");
}
// 3. new Integer() VS Integer.valueOf()
Integer num3 = new Integer(123); // new 는 새로운 instance 생성
Integer num4 = Integer.valueOf(123);
// valueOf()는 생성한 Object 를 cache(캐시) 해둔다.
// 동일 literal 로 valueOf() 생성하면, 기존의 생성된 Object 리턴
// 왜..?? 메모리 절약을 위해...!!!
// new 로 생성한 것들끼리 비교
if(num1 == num3) {
System.out.println("생성자: 같은 참조");
} else {
System.out.println("생성자: 다른 참조");
}
// valueOf() 로 생성한 것들끼리 비교
if(num2 == num4) {
System.out.println("valueOf(): 같은 참조");
} else {
System.out.println("valueof(): 다른 참조");
}
// 4. literal 상수로 생성
System.out.println();
Integer num5 = 123;
// Integer.valueOf(123) 과 동일한 코드가 동작됨! (Auto-Boxing)
if(num4 == num5) {
System.out.println("literal 같은 참조");
} else {
System.out.println("literal 다른 참조");
}
// 5. valueOf(문자열) 가능!
Integer num6 = Integer.valueOf("123");
System.out.println(num6);
if(num6 == num5) {
System.out.println("같은 참조");
} else {
System.out.println("다른 참조");
}
// 6. 산술 연산 가능
num6 *= 2; // Wrapper 의 연산 결과는 새로운 Wrapper 생성(immutable!)
System.out.println(num6);
if(num6 == num5) {
System.out.println("같은 참조");
} else {
System.out.println("다른 참조"); // 다르다! Wrapper 는 immutable 하다!
}
System.out.println("\n프로그램 종료");
} // end main()
} // end class
2) com.lec.java.wrapper02 패키지, Wrapper02Main 클래스
package com.lec.java.wrapper02;
/* Java 5부터 wrapper 클래스의 auto-boxing/unboxing 기능 제공
* boxing(포장): 기본자료형의 값을 wrapper 클래스에 저장하는 것
* unboxing(개봉): wrapper 클래스에 저장된 기본자료형 값을 꺼내는 것
*/
public class Wrapper02Main {
public static void main(String[] args) {
System.out.println("auto-boxing, auto-unboxing");
// auto-boxing : 말하지 않아도 자동으로 포장해서 넣어준다는 뜻...!!
Integer num1 = 10; // Integer.valueOf(10); <-- auto-boxing
Integer num2 = 20;
// auto-unboxing : 말하지 않아도 자동으로 안에 있는 것을 꺼내준다는 뜻...!
System.out.println(num1 + num2); // auto-unboxing!
System.out.println(num1.intValue() + num2.intValue()); // <-- 이와 같이 동작
// 연산을 위해 auto-unboxing을 하고 값을 저장하기 위해 auto-boxing을 한다.
Integer num3 = num1 + num2;
// 아래와 같이 동작한다
Integer num30 = Integer.valueOf(num1.intValue() + num2.intValue());
System.out.println();
System.out.println("boxing/unboxing");
// boxing(포장): 기본자료형의 값을 wrapper 클래스에 저장하는 것
// unboxing(개봉): wrapper 클래스에 저장된 기본자료형 값을 꺼내는 것
Integer num4 = 100; // Integer.valueOf(100);
int n4 = num4; // num4.intValue();
System.out.println("n4 = " + n4);
System.out.println();
System.out.println("auto-boxing/auto-unboxing");
System.out.println();
System.out.println("wrapper 클래스들");
Long num100 = Long.valueOf(100000000000000L);
Long num101 = 100000000000000L;
double num200 = 3.14; // Double.valueOf(3.14)
System.out.println(num1.intValue());
System.out.println(num1.doubleValue()); // unboxing 은 원하는 타입으로 가능
System.out.println("\n프로그램 종료");
} // end main()
} // end class
3) com.lec.java.wrapper05 패키지, Wrapper05Main 클래스
package com.lec.java.wrapper05;
/* Wrapper 클래스의 유용성
* 1. Object 타입이 모~든 (심지어 primitive) 타입도 받을수 있다.
* 2. Collection 과 같은 Generic 클래스에선
* primitive 타입을 담을수 없다. 그러나 ,Wrapper 를 통해 가능하다.
*/
public class Wrapper05Main {
public static void main(String[] args) {
System.out.println("Wrapper 클래스의 유용성");
Object[] obj = new Object[5];
obj[0] = new Wrapper05Main();
obj[1] = new A();
obj[2] = new A2();
obj[3] = new B();
obj[4] = 123; // 호에에..!! Object 가 primitive type도 받을 수 있다...?!?!? 가능..!!
// 왜? Auto-Boxing + Polymorphism(다형성)
// Object <-- Integer <-- int
for(Object e : obj) {
System.out.println(e);
// Wrapper 는 자동적으로 Auto-unboxing 발생
}
System.out.println();
// 실타입이 Object 이면
// auto-unboxing 등이 필요한 연산식에서는 '형변환' 해주어야 동작한다.
//int num = obj[4] * 3; // 에러
// The operator * is undefined for the argument type(s) Object, int
int num = (Integer)obj[4] * 3;
System.out.println("\n프로그램 종료");
} // end main()
} // end class
class A{}
class A2 extends A{}
class B{}
3. Lec22_Collection
1) com.lec.java.generic01 패키지, Generic01Main 클래스
package com.lec.java.generic01;
/* Generic 클래스:
* 클래스의 멤버변수나 혹은 메소드의 리턴'타입', 매개변수 등의 '타입'을
* 지정하지 않고 generic(일반적으로)하게 정의하는 클래스
*
* '동작' 은 같으나, '데이터 타입' 만 다른 경우 Generic 으로 설계함으로 코드 생산성 향상
*/
public class Generic01Main {
public static void main(String[] args) {
System.out.println("Generics(제네릭스)");
System.out.println();
System.out.println("[1] generic 클래스 사용 전");
Orange orange1 = new Orange(10);
OrangeBox orangeBox1 = new OrangeBox(orange1);
orangeBox1.pullOut().displaySugar();
Apple a1 = new Apple(100);
AppleBox applebox1 = new AppleBox(a1);
applebox1.pullout().displayWeight();
// 동작은 pullOut() 으로 같음에도 불구하고,
// 다루는 데이터가 다르다는 이유로 클래스를 매 데이터마다 정의하는 것은 매우 비효율
// 그래서 자바에서는 generic 클래스를 제공
System.out.println();
System.out.println("[2] generic 클래스 사용");
Orange orange2 = new Orange(100);
FruitBox<Orange> orangeBox2 = new FruitBox<Orange>(orange2);
orangeBox2.pullOut().displaySugar();
// 사과, 바나나를 각각 담는 FruitBox 생성하고 pullOut 해보기
Apple a2 = new Apple(200);
FruitBox<Apple> appleBox2 = new FruitBox<Apple>(a2);
appleBox2.pullOut().displayWeight();
Banana b2 = new Banana(300);
FruitBox<Banana> bananaBox2 = new FruitBox<Banana>(b2);
bananaBox2.pullOut().displayNum();
System.out.println("\n프로그램 종료");
} // end main()
} // end class
//---------------------------------------------
// '과일' 클래스들 정의
class Banana{
int num;
public Banana() {}
public Banana(int num) {this.num = num;}
public void displayNum() {
System.out.println("바나나 송이개수: " + num);
}
} // end class Banana
class Orange{
int sugar;
public Orange() {}
public Orange(int sugar) {this.sugar = sugar;}
public void displaySugar() {
System.out.println("오렌지 당도: " + sugar);
}
} // end class Orange
class Apple{
int weight;
public Apple() {}
public Apple(int weight) {this.weight = weight;}
public void displayWeight() {
System.out.println("사과 무게: " + weight);
}
} // end class Apple
//------------------------------------------
// 위 과일 들을 담을 box 클래스들 정의
class BananaBox {
Banana banana;
public BananaBox() {}
public BananaBox(Banana banana) {this.banana = banana;}
public Banana pullOut() {return banana;}
}
class OrangeBox{
Orange orange;
public OrangeBox() {}
public OrangeBox(Orange orange) {this.orange = orange;}
public Orange pullOut() {return orange;}
}
class AppleBox {
Apple apple;
public AppleBox() {}
public AppleBox(Apple apple) {this.apple = apple;}
public Apple pullout() {return apple;}
}
// Generic 클래스:
// 클래스의 멤버변수나 혹은 메소드의 리턴'타입', 매개변수 등의 '타입'을
// 지정하지 않고 generic(일반적으로)하게 정의하는 클래스
// < > 안에 타입매개변수 (type parameter) 지정
class FruitBox<T> {
T fruit; // T 타입
public FruitBox() {}
public FruitBox(T fruit) {this.fruit = fruit;}
public T pullOut() {return this.fruit;} // T 타입 리턴
}
2) com.lec.java.generic02 패키지, Generic02Main 클래스
package com.lec.java.generic02;
/* 제네릭 클래스의 타입
* 제네릭 클래스에서 사용되는 타입은
* 기본 자료형(primitive type)은 사용될 수 없고,
* Object 타입의 자료형들만 올 수 있음.
* (예) int는 사용할 수 없고, Integer를 사용해야 함
* (예) double은 사용할 수 없고, Double을 사용해야 함
*/
public class Generic02Main {
public static void main(String[] args) {
System.out.println("Generic 클래스 2");
Test<Integer, String> t1 = new Test<Integer, String>(123, "Hello, Java1");
t1.display();
System.out.println();
Test<Integer, Double> t2 = new Test<Integer, Double>(111, 3.14);
t2.display();
System.out.println("\n프로그램 종료");
} // end main
} // end class Collection02Main
class Test<T, U> {
T item1;
U item2;
public Test(T item1, U item2) {
this.item1 = item1;
this.item2 = item2;
}
public void display() {
System.out.println("item1: " + item1);
System.out.println("item2: " + item2);
}
}
3) com.lec.java.collection01 패키지, Collection01Main 클래스
package com.lec.java.collection01;
import java.util.ArrayList;
import java.util.Iterator;
/* ArrayList<E>
※계층도 숙지 중요
Collection<E>
|__ List<E>
|__ ArrayList<E>, LinkedList<E>
List 특징(ArrayList와 LinkedList의 공통점)
1. 중복 저장 허용
2. 저장 순서 유지 (인덱스 존재)
ArrayList:
1. 저장 용량을 늘리는 데 많은 시간 소요 - 단점
2. 데이터를 삭제하는 데 많은 연산 - 단점
3. 데이터 참조 매우 빠름 - 장점
LinkedList:
1. 저장 용량을 늘리는 과정이 매우 간단 - 장점
2. 데이터를 삭제하는 과정이 간단 - 장점
3. 데이터 참조가 불편 - 단점
※ Vector<E> <-- ArrayList 와 비슷하나... ArrayList 추천.
*/
public class Collection01Main {
public static void main(String[] args) {
System.out.println("ArrayList<E>");
// ArrayList 선언 - ArrayList 인스턴스 생성
ArrayList<Integer> list1 = new ArrayList<Integer>();
// 데이터 추가(저장): add(element) 메소드 사용
// add(idnex, element) -> index 번째 삽입
list1.add(100);
list1.add(400);
list1.add(500);
list1.add(200);
list1.add(400);
list1.add(2, 700); // index 2 위치에 삽입
// 데이터 참조(읽기, 검색): get(index) 메소드 사용
// size(): ArrayList의 크기를 반환(리턴)
System.out.println("size() : " + list1.size());
for(int i = 0; i < list1.size(); i++) {
System.out.println(list1.get(i));
}
// 데이터 삭제: remove(index) 메소드 사용
list1.remove(3);
System.out.println("삭제 후");
for(int i = 0; i < list1.size(); i++) {
System.out.println(list1.get(i));
}
// 데이터 수정: set(index, element) 메소드 사용
list1.set(2, 333);
System.out.println("수정후");
for(int i = 0; i < list1.size(); i++) {
System.out.println(list1.get(i));
}
// ArrayList 출력 방법
// 1) for
// 2) Enhanced-for 사용
// 3) Iterator(반복자) 사용
// 4) forEach() 사용
System.out.println("Enhanced for를 사용한 출력");
// Enhanced for 사용 가능
for(Integer e : list1) {
System.out.println(e);
}
System.out.println("Iterator 를 사용한 출력");
// Iterator(반복자) 사용법
// iterator() 메소드를 사용해서 인스턴스 생성
Iterator<Integer> itr = list1.iterator();
// hasNext(): iterator가 다음 원소를 가지고 있는 지(true/false)
// next(): 현재 iterator 위치의 원소를 값을 리턴하고,
// iterator의 위치를 다음 원소의 위치로 변경
while(itr.hasNext()) {
System.out.println(itr.next());
}
System.out.println("forEach() 를 사용한 출력");
// forEach() + functional interface
// Java8 부터 등장
list1.forEach(System.out::println);
System.out.println("\n프로그램 종료");
} // end main
} // end class
4) com.lec.java.collection03 패키지, Collection03Main, Score, Student 클래스
** Collection03Main 클래스
package com.lec.java.collection03;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;
public class Collection03Main {
public static void main(String[] args) {
System.out.println("ArrayList 연습");
// Student 타입을 담는 ArrayList를 만드고
// 사용자로부터 3개의 Student 데이터 을 입력받아서
// (id, name, kor, eng, math)
// 3가지 방법으로 출력해보세요.
// for, Enhanced-for, Iterator
ArrayList<Student> list = new ArrayList<Student>();
Scanner sc = new Scanner(System.in);
for(int i = 0; i < 3; i++) {
System.out.print("아이디를 입력하세요 : ");
int id = sc.nextInt();
sc.nextLine();
System.out.print("이름을 입력하세요 : ");
String name = sc.nextLine();
System.out.print("국어, 영어, 수학: ");
int kor = sc.nextInt();
int eng = sc.nextInt();
int math = sc.nextInt();
Student stu = new Student(id, name, new Score(kor, eng, math));
list.add(stu);
}
// 1) for
System.out.println("\n1) for");
for(int i = 0; i < list.size(); i++) {
System.out.print(list.get(i));
}
// 2) Enhanced-for
System.out.println("\n2) Enhanced-for");
for(Student e : list) {
System.out.print(e);
}
// 3) Iterator
System.out.println("\n3) Iterator");
Iterator<Student> itr = list.iterator();
while(itr.hasNext()) {
System.out.print(itr.next());
}
System.out.println("\n프로그램 종료");
} // end main()
} // end class
** Score 클래스
package com.lec.java.collection03;
public class Score {
private int korean;
private int english;
private int math;
public Score() {}
public Score(int kor, int eng, int math) {
this.korean = kor;
this.english = eng;
this.math = math;
}
public int getKorean() {
return korean;
}
public void setKorean(int korean) {
this.korean = korean;
}
public int getEnglish() {
return english;
}
public void setEnglish(int english) {
this.english = english;
}
public int getMath() {
return math;
}
public void setMath(int math) {
this.math = math;
}
} // end class Score
** Student 클래스
package com.lec.java.collection03;
public class Student {
private int id;
private String name;
private Score score;
public Student() {}
public Student(int id, String name, Score s) {
this.id = id;
this.name = name;
this.score = s;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Score getScore() {
return score;
}
public void setScore(Score score) {
this.score = score;
}
// com.lec.java.colleciton07 이후
@Override
public String toString() {
String str = "";
str += "id:" + id + "\t";
str += "name:" + name + "\t";;
str += "국어:" + score.getKorean() + "\t";
str += "영어:" + score.getEnglish() + "\t";
str += "수학:" + score.getMath() + "\n";
return str;
}
public static void printTotal(Student stu){
System.out.println("id:" + stu.getId());
System.out.println("이름:" + stu.getName());
System.out.println("총점:" + (stu.getScore().getEnglish() + stu.getScore().getKorean() + stu.getScore().getMath()));
}
} // end class Student
5) com.lec.java.collection04 패키지, Collection04Main, MemberModel 클래스
** Collection04Main 클래스
package com.lec.java.collection04;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;
public class Collection04Main {
public static void main(String[] args) {
System.out.println("ArrayList 연습");
// MemberModel 타입을 담는 ArrayList를 만들고
// 사용자로부터 3개의 Student 데이터를 입력받아서
// (id, passwd)
// 3가지 방법으로 출력해보세요
// for, Enhanced-for, Iterator
ArrayList<MemberModel> list = new ArrayList<MemberModel>();
Scanner sc = new Scanner(System.in);
for(int i = 0; i < 3; i++) {
System.out.print("아이디를 입력하세요 : ");
String id = sc.nextLine();
System.out.print("패스워드를 입력하세요 : ");
String pw = sc.nextLine();
MemberModel model = new MemberModel(id, pw);
list.add(model);
}
sc.close();
// 1) Iterator
System.out.println("\n1) Iterator");
Iterator<MemberModel> itr = list.iterator();
while(itr.hasNext()) {
itr.next().displayInfo();
}
// 2) Enhanced-for
System.out.println("\n2) Enhanced-for");
for(MemberModel e : list) {
e.displayInfo();
}
// 3) for
System.out.println("\n3) for");
for(int i = 0; i < list.size(); i++) {
list.get(i).displayInfo();
}
System.out.println("\n프로그램 종료");
} // end main()
} // end class
** MemberModel 클래스
package com.lec.java.collection04;
public class MemberModel {
private String id;
private String passwd;
public MemberModel() {}
public MemberModel(String id, String pw) {
this.id = id;
this.passwd = pw;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
public void displayInfo() {
System.out.println("아이디: " + id);
System.out.println("비밀번호: " + passwd);
}
} // end class MemberModel
6) com.lec.java.collection05 패키지, Collection05Main 클래스
package com.lec.java.collection05;
import java.util.Iterator;
import java.util.LinkedList;
/* LinkedList
Collection<E>
|__ List<E>
|__ ArrayList<E>, LinkedList<E>
List:
1. 중복 저장 허용
2. 저장 순서 유지(인덱스 존재)
ArrayList:
1. 저장 용량을 늘리는 데 많은 시간 소요 - 단점
2. 데이터를 삭제하는 데 많은 연산 - 단점
3. 데이터 참조 매우 빠름 - 장점
LinkedList:
1. 저장 용량을 늘리는 과정이 매우 간단 - 장점
2. 데이터를 삭제하는 과정이 간단 - 장점
3. 데이터 참조가 불편 - 단점
※ 걍 ArrayList 쓰세요~~~
*/
public class Collection05Main {
public static void main(String[] args) {
System.out.println("Linked List");
// Integer 타입을 저장할 수 있는 LinkedList 인스턴스 생성
LinkedList<Integer> list = new LinkedList<Integer>();
// LinkedList에 데이터 저장: add()
list.add(100);
list.add(500);
list.add(300);
list.add(600);
list.add(800);
list.add(700);
System.out.println(list);
System.out.println();
// 검색: get()
System.out.println("list.get(4) : " + list.get(4));
System.out.println("list.get(0) : " + list.get(0));
System.out.println();
// 데이터 삭제: remove()
list.remove(4);
System.out.println(list);
System.out.println();
// 데이터 수정: set()
list.set(4, 800);
System.out.println(list);
System.out.println();
// Iterator 만들어서 데이터 출력
System.out.println("Iterator 사용");
Iterator<Integer> itr = list.iterator();
while(itr.hasNext()) {
System.out.println(itr.next());
}
System.out.println("\n프로그램 종료");
} // end main()
} // end class
7) com.lec.java.collection06 패키지, Collection06Main 클래스
package com.lec.java.collection06;
import java.util.HashSet;
import java.util.Iterator;
/* Set, HashSet<E>
Collection<E>
|__ Set<E>
|__ HashSet<E>, TreeSet<E>
Set:
1. 자료의 중복 저장이 허용되지 않는다. (hashCode() 값의 중복여부!)
2. 저장 순서가 유지되지 않는다.(인덱스 없다.)
(예) {1, 2, 3} = {1, 1, 2, 2, 3} : 중복 저장이 안되기 때문에 같은 Set
(예) {1, 2, 3} = {1, 3, 2}: 저장 순서가 중요하지 않기 때문에 같은 Set
HashSet: 매우 빠른 검색 속도를 제공
(※ HashXXX ← '검색속도 향상'을 쓰는 자료구조 입니다)
*/
public class Collection06Main {
public static void main(String[] args) {
System.out.println("HashSet 클래스");
// Integer 타입을 저장할 수 있는 HashSet 인스턴스 생성
HashSet<Integer> set = new HashSet<Integer>();
// 데이터 저장: add()
// 성공하면 true, 실패하면 false를 리턴
set.add(100);
set.add(200);
set.add(300);
set.add(100);
set.add(400);
set.add(600);
set.add(1);
set.add(2);
System.out.println(set.add(100));
// HashSet의 크기: size()
System.out.println("HashSet 의 크기 : " + set.size());
// Set은 중복 저장을 허용하지 않는다.
// 데이터 검색:
// Set은 인덱스가 없기 때문에 get() 메소드를 제공하지 않습니다.
// 왜냐하면 순서가 없기 때문에...!!
// 데이터 검색을 위해서는 Iterator를 사용해야 함
System.out.println();
Iterator<Integer> itr = set.iterator();
while(itr.hasNext()) {
System.out.println(itr.next());
// 출력 결과, 저장순서와는 관계 없다.
}
// 데이터 삭제
// remove(element): Set에 있는 element를 찾아서 삭제
// element 있다면 삭제 후 true를 리턴
// element 없다면 false 리턴
System.out.println("삭제 결과 : " + set.remove(2)); // 데이터 2를 삭제함
// (2번째 삭제가 아니다!!)
System.out.println("삭제 결과 : " + set.remove(2));
System.out.println();
System.out.println("삭제 후:");
itr = set.iterator();
while(itr.hasNext()) {
System.out.println(itr.next());
}
// Iterator는 일회용이다..!!
//itr.next(); // 어떤 결과가 나올까?
// 에러 : java.util.NoSuchElementException
// Set 자료형 데이터 변경을 할 수 있는 set() 메소드를 제공하지 않습니다.
// 삭제(remove) 후 추가(add)하면 변경하는 효과
// 600 -> 777
set.remove(600);
set.add(777);
System.out.println("변경 후");
// enhanced-for 사용
System.out.println();
System.out.println("Enhanced for 사용 출력");
for(Integer x : set) {
System.out.println(x);
}
// forEach() 메소드 사용하여 출력 가능함
System.out.println("\n프로그램 종료");
} // end main()
} // end class
8) com.lec.java.collection07 패키지, Collection07Main 클래스
package com.lec.java.collection07;
import java.util.HashSet;
import java.util.Iterator;
public class Collection07Main {
public static void main(String[] args) {
System.out.println("HashSet 연습");
// String 타입을 저장할 수 있는 HashSet 를 생성하고
// 5개 이상의 데이터는 저장, 수정, 삭제 등의 동작을 해보고,
// iterator, enhanced-for 문을 사용해서 출력해보기
// String 타입을 저장할 수 있는 HashSet 인스턴스 생성
HashSet<String> set = new HashSet<String>();
// 데이터 저장
System.out.println(set.add("안녕"));
set.add("하세요");
set.add("배고파");
set.add("자고싶다");
set.add("웃기다");
set.add("치킨먹고싶다");
set.add("방가방가");
System.out.println();
System.out.println("데이터 저장");
System.out.println("데이터 개수 : " + set.size());
System.out.println();
System.out.println(set);
System.out.println();
// 데이터 삭제
set.remove("하세요");
set.remove("자고싶다");
System.out.println("삭제 후");
System.out.println(set);
// 1) iterator
System.out.println("\n1) iterator");
Iterator<String> itr = set.iterator();
while(itr.hasNext()) {
System.out.println(itr.next());
}
// 2) enhanced-for
// enhanced for는 인덱스가 필요 없는 for문이기 때문에
// set 타입의 자료형에서도 사용 가능
System.out.println("\n2) enhanced-for");
for(String e : set) {
System.out.println(e);
}
System.out.println("\n프로그램 종료");
} // end main()
} // end class
9) com.lec.java.collection08 패키지, Collection08Main, MyClass 클래스
** Collection08Main 클래스
package com.lec.java.collection08;
import java.util.HashSet;
import java.util.Iterator;
public class Collection08Main {
public static void main(String[] args) {
System.out.println("HashSet 연습");
// MyClass 타입을 저장할 수 있는 HashSet 인스턴스 생성
// 데이터 3개 이상 저장해보고 iterator, enahnce-for 등을
// 사용하여 출력해보기
HashSet<MyClass> hset = new HashSet<MyClass>();
// 데이터 3개 저장
MyClass mc1 = new MyClass(1, "Abc");
MyClass mc2 = new MyClass(2, "Def");
MyClass mc3 = new MyClass(1, "ABC");
hset.add(mc1);
hset.add(mc2);
hset.add(mc3);
System.out.println("size = " + hset.size());
// 검색: Iterator, enhanced for
System.out.println();
System.out.println("Iterator");
Iterator<MyClass> itr = hset.iterator();
while (itr.hasNext()) {
System.out.println(itr.next());
} // end while
System.out.println();
System.out.println("enhanced for");
for(MyClass e : hset) {
e.displayInfo();
}
// String toString() 오버라이딩 재정의
System.out.println();
System.out.println(hset);
System.out.println("\n프로그램 종료");
} // end main()
} // end class
** MyClass 클래스
package com.lec.java.collection08;
// Set 에서 같은지 다른지, 식별 가능하려면
// hashCode 와 equals 가 오버라이딩 되어야 한다
// hashCode() 값이 같고 equals() 결과가 true 이어야만 같은 객체로 판정한다.
public class MyClass {
private int id;
private String name;
public MyClass() {}
public MyClass(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void displayInfo() {
System.out.println("학번: " + id);
System.out.println("이름: " + name);
}
@Override
public String toString() {
return "학번: " + id + "\n" + "이름: " + name + "\n";
}
@Override
public boolean equals(Object obj) {
MyClass other = (MyClass)obj;
// 대소문자 구분
//boolean result = (this.id == other.id) && (this.name.equals(other.name));
// 대소문자 구분 안함
boolean result = (this.id == other.id) && (this.name.equalsIgnoreCase(other.name));
return result;
}
@Override
public int hashCode() {
return this.id;
}
} // end class MyClass
10) com.lec.java.collection09 패키지, Collection09Main 클래스
package com.lec.java.collection09;
import java.util.Iterator;
import java.util.TreeSet;
/* TreeSet
Collection<E>
|__ Set<E>
|__ HashSet<E>, TreeSet<E>
TreeSet: 데이터가 정렬된 상태로 저장(오름차순, 내림차순)
(※ TreeXXX ← 주로 '정렬'에 특화된 자료구조 입니다)
*/
public class Collection09Main {
public static void main(String[] args) {
System.out.println("TreeSet 클래스");
// Integer 타입을 저장할 수 있는 TreeSet 인스턴스 생성
TreeSet<Integer> tset = new TreeSet<Integer>();
// 데이터 저장 : add()
tset.add(11);
tset.add(2);
tset.add(14);
tset.add(1);
tset.add(7);
tset.add(15);
tset.add(5);
tset.add(8);
// 데이터 검색 - Iterator 사용
// TreeSet인 경우에 iterator() 메소드 오름차순 정렬
System.out.println("오름차순:");
Iterator<Integer> itr = tset.iterator();
while(itr.hasNext()) {
System.out.println(itr.next());
}
System.out.println();
System.out.println("내림차순:");
// 내림차순 Iterator : descendingIterator() 사용
Iterator<Integer> itr2 = tset.descendingIterator();
while(itr2.hasNext()) {
System.out.println(itr2.next());
}
// enhanced for
System.out.println();
System.out.println("enhanced for");
for(Integer e : tset) {
System.out.println(e);
}
// subset() 메소드
// 시작값과 끝값을 매개변수로 받아, 그것을 범위로, 부분 set 추출
System.out.println("\nsubSet()");
TreeSet<Integer> subSet = (TreeSet<Integer>)tset.subSet(5, 14);
// 5부터 시작해서 14전까지
// for(Integer e : subSet) {
// System.out.println(e);
// }
// toString이 오버라이딩되어 있어서 [5, 7, 8, 11]로 출력 가능함
System.out.println(subSet);
subSet = (TreeSet<Integer>)tset.subSet(5, true, 14, true);
// 5도 포함, 14도 포함한 범위
System.out.println(subSet);
subSet = (TreeSet<Integer>)tset.subSet(3, 10);
System.out.println(subSet);
System.out.println("\n프로그램 종료");
} // end main()
} // end class
11) com.lec.java.collection10 패키지, Collection10Main 클래스
package com.lec.java.collection10;
import java.util.Iterator;
import java.util.TreeSet;
public class Collection10Main {
public static void main(String[] args) {
System.out.println("TreeSet 연습");
// String 타입을 저장할 수 있는 TreeSet 인스턴스 생성
// 5개 이상의 데이터를 저장해보고
// 오름차순, 내림차순으로 출력해보기
TreeSet<String> tset = new TreeSet<String>();
// 데이터 저장
tset.add("안녕");
tset.add("자바공부");
tset.add("하고 있어");
tset.add("오늘도");
tset.add("알찬");
tset.add("수업시간이구나!");
tset.add("치킨 먹고 싶다ㅜ^ㅜ");
// 오름차순으로 출력하기 - Iterator
System.out.println("\n오름차순으로 출력");
Iterator<String> itr = tset.iterator();
while(itr.hasNext()) {
System.out.println(itr.next());
}
// 내림차순으로 출력하기
System.out.println("\n\n내림차순으로 출력");
Iterator<String> itr2 = tset.descendingIterator();
while(itr2.hasNext()) {
System.out.println(itr2.next());
}
System.out.println("\n프로그램 종료");
} // end main
} // end class
12) com.lec.java.collection11 패키지, Collection11Main 클래스
package com.lec.java.collection11;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/* Map<K, V>, HashMap<K, V>
Collection<E>
|__ List<E>, Set<E>
List<E>
|__ ArrayList<E>, LinkedList<E>
Set<E>
|__ HashSet<E>, TreeSet<E>
Map<K, V>
|__ HashMap<K, V>, TreeMap<K, V>
검색, 정렬
Map: key-value 저장 방식의 자료 구조
1. key는 중복되지 않는 값만 허용
2. value는 같더라도 key 값이 다르면 저장 가능
3. 검색, 수정, 삭제를 할 때 key를 사용
*/
public class Collection11Main {
public static void main(String[] args) {
System.out.println("HashMap 클래스");
// HashMap 인스턴스 생성 : 검색에 특화
// Key - Integer 타입
// Value - String 타입
HashMap<Integer, String> hmap = new HashMap<Integer, String>();
// 데이터 저장: put() 메소드 사용
// 새로운 key 값이면 null 리턴
// 기존 key 값이면 기존의 값이 리턴
System.out.println(hmap.put(1, "장수영"));
System.out.println(hmap.put(2, "김광진"));
System.out.println(hmap.put(3, "주낙경"));
System.out.println(hmap.put(4, "정세헌"));
System.out.println(hmap.put(4, "조현주")); // "정세현" -> "조현주"
// 같은 키 값으로 데이터를 put하게 되면, 기존 값이 수정(replace)이 됨.
// 저장된 데이터 개수 확인 : size()
System.out.println("데이터 개수: " + hmap.size());
System.out.println();
// 데이터 읽기
// get(key) 사용해서 읽기
System.out.println(hmap.get(1));
System.out.println(hmap.get(2));
System.out.println(hmap.get(5)); // 없는 key값은 null 리턴
// 데이터 삭제
// remove(key) : 삭제된 value 리턴
System.out.println("삭제 : " + hmap.remove(2));
// 방법1 HashMap에서 Iterator 사용
// 1. HashMap의 keySet() 메소드를 사용해서
// 저장된 키(key)값들로만 이루어진 Set을 만듦.
// 2. 1에서 만들어진 Set에 있는 iterator() 메소드를 사용해서
// Iterator를 생성
Set<Integer> keySet = hmap.keySet();
Iterator<Integer> itr = keySet.iterator();
while(itr.hasNext()) {
int key = itr.next();
System.out.println(key + " : " + hmap.get(key));
}
// 초창기에 많이하는 실수
// 한줄로 실수하려고 아래와 같이 줄여서 사용하는데 절대 이렇게 사용하면 안됨
// 귀찮더라도 두줄로 나눠서 위의 코드와 같이 사용해야함..!!!
// 에러 : java.util.NoSuchElementException
// while(itr.hasNext()) {
// System.out.println(itr.next() + " : " + hmap.get(itr.next()));
// }
System.out.println();
// 방법2 : Map.Entry 사용
// entrySet() 은 Set<Entry<Integer, String>> 리턴함
for(Map.Entry<Integer, String> m : hmap.entrySet()) {
System.out.println(m.getKey() + " : " + m.getValue());
}
System.out.println();
// 도전과제
// arr[] = {2, 4, 5, 4, 3, 3, 4}
// 주어진 배열이 위와 같을때 다음과 같이 발생회수 나타내기
// 2 : 1개
// 3 : 2개
// 4 : 3개
// 5 : 1개
System.out.println("HashMap 응용: 배열에서 발생빈도 구하기");
int arr[] = {2, 4, 5, 4, 3, 3, 4, 5, 5, 5, 5, 4, 4, 4};
printFreq(arr);
System.out.println("\n프로그램 종료");
} // end main()
static void printFreq(int arr[]) {
HashMap<Integer, Integer> hmap = new HashMap<Integer, Integer>();
// 발생빈도
for (int i = 0; i < arr.length; i++) {
Integer v = hmap.get(arr[i]); //arr[i] 가 key
if(v == null) { // 기존에 해당하는 Key 값이 없었다면(즉! 첫등장이면)
hmap.put(arr[i], 1); // 등장횟수 1
} else { // 등장횟수 1 이상
hmap.put(arr[i], v + 1); // 기존 등장횟수에 +1 증가
}
}
// 결과출력
for(Map.Entry<Integer, Integer> e : hmap.entrySet()) {
System.out.println(e.getKey() + " : " + e.getValue() + "개");
}
}
} // end class
13) com.lec.java.collection12 패키지, Collection12Main 클래스
package com.lec.java.collection12;
import java.util.HashMap;
import java.util.Iterator;
import java.util.NavigableSet;
import java.util.Set;
import java.util.TreeMap;
// Hash: 검색을 빠르게 하기 위한 용도
// Tree: 데이터 정렬을 하기 위한 용도
public class Collection12Main {
public static void main(String[] args) {
System.out.println("TreeMap 클래스");
// TreeMap<Integer, String> 타입 인스턴스 생성
TreeMap<Integer, String> tmap = new TreeMap<Integer, String>();
// 데이터 저장: put(key, value) 메소드 사용
tmap.put(1, "aaa");
tmap.put(4, "qwerty");
tmap.put(3, "asdfg");
tmap.put(2, "zxcv");
// values() : value 들로 이루어진 Collection 리턴
System.out.println("values()");
for(String value : tmap.values()) {
System.out.println(value);
}
// 데이터 검색: get(key) 메소드를 사용
// 1. 키값들로만 이루어진 Set을 만듦
Set<Integer> kset = tmap.keySet();
// 2. keySet을 가지고 iterator를 만듬
Iterator<Integer> itr = kset.iterator();
while(itr.hasNext()) {
int key = itr.next();
System.out.println(key + " : " + tmap.get(key));
}
System.out.println();
// TreeMap에만 있는 KeySet을 만들어 내는 메소드
NavigableSet<Integer> navi = tmap.navigableKeySet();
Iterator<Integer> itr2 = navi.descendingIterator();
while(itr2.hasNext()) {
int key = itr2.next();
System.out.println(key + " : " + tmap.get(key));
}
// HashMap --> TreeMap 전환하기
System.out.println("HashMap() -> TreeMap() ");
HashMap<String, Integer> hmap = new HashMap<String, Integer>();
hmap.put("세종대왕", 10000);
hmap.put("신사임당", 50000);
hmap.put("퇴계이황", 5000);
hmap.put("이순신", 100);
System.out.println(hmap);
TreeMap<String, Integer> tmap2 = new TreeMap<String, Integer>(hmap);
// 키에 대한 오름차순으로 정렬되어 출력
System.out.println(tmap2);
System.out.println("\n프로그램 종료");
} // end main()
} // end class'웹_프론트_백엔드 > JAVA프레임윅기반_풀스택' 카테고리의 다른 글
| 2020.03.30 (0) | 2020.03.30 |
|---|---|
| 2020.03.27 (0) | 2020.03.27 |
| 2020.03.25 (0) | 2020.03.25 |
| 2020.03.24 (0) | 2020.03.24 |
| 2020.03.23 (0) | 2020.03.23 |