package generic_003_method1;
public class BoxingMethodExample {
public static void main(String[] args) {
Box<Integer> box1 = Util.boxing(100);
// Box<Integer> box1 = Util.<Integer>boxing(100);
System.out.println(box1.get());
Box<String> box2 = Util.boxing("홍길동");
System.out.println(box2.get());
}
}
package generic_003_method1;
public class Box<T> {
private T t;
public T get() { return t; }
public void set(T t) { this.t = t; }
}
package generic_003_method1;
public class Util {
public static <T> Box<T> boxing(T t) { // <Integer>Box<Integer>(Integer(100))
//Method에서 사용시 클래스명 앞에 <>한번 더 기술
Box<T> box = new Box<T>(); //Box<Integer> box = new Box<Integer>();
box.set(t);
return box;
}
}
100
홍길동
generic_003_method2
package generic_003_method2;
public class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
public void setKey(K key) {this.key = key;}
public void setValue(V value) {this.value = value;}
public K getKey() {return key;}
public V getValue() {return value;}
}
generic_004_wildcard
package generic_004_wildcard;
import java.util.Arrays;
public class WildCardExample {
public static void registerCourse(Course<?> course) {
//<?> => WildCard : 전체 다, 무엇이든지 (*같은)
//단독으로 사용불가하며, 반드시 소속된 클래스가 앞에 명시되어야한다.
System.out.println(course.getName() + "수강생: " +
Arrays.toString(course.getStudents()));
//toString이 배열 출력시 [ , , , ]로 출력
}
public static void registerCourseStudent(Course<? extends Student> course) {
//Student포함 자식,자손 전부 포함. Interface는 자식, 자속까지만 허용
System.out.println(course.getName() + "수강생: " +
Arrays.toString(course.getStudents()));
}
public static void registerCourseWorker(Course<? super Worker> course) {
//? super Worker의 부모,조상클래스가 앞에 나온다.
//? super는 Generic으로 ?만 가능
System.out.println(course.getName() + "수강생: " +
Arrays.toString(course.getStudents()));
}
public static void main(String[] args) {
Course<Person> personCourse = new Course<Person>("일반인과정", 5);
personCourse.add(new Person("일반인"));
personCourse.add(new Worker("직장인"));
personCourse.add(new Student("학생"));
personCourse.add(new HighStudent("고등학생"));
registerCourse(personCourse);
Course<Worker> workerCourse = new Course<Worker>("직장인과정", 5);
workerCourse.add(new Worker("직장인"));
registerCourse(workerCourse);
Course<Student> studentCourse = new Course<Student>("학생과정", 5);
studentCourse.add(new Student("학생"));
studentCourse.add(new HighStudent("고등학생"));
registerCourse(studentCourse);
Course<HighStudent> highStudentCourse = new Course<HighStudent>("고등학생과정", 5);
highStudentCourse.add(new HighStudent("고등학생"));
registerCourse(highStudentCourse);
System.out.println();
//registerCourseStudent(personCourse); (x) person이 부모라
//registerCourseStudent(workerCourse); (x) worker와 상속관계x
registerCourseStudent(studentCourse);
registerCourseStudent(highStudentCourse);
System.out.println();
registerCourseWorker(personCourse);
registerCourseWorker(workerCourse);
// registerCourseWorker(studentCourse); (x)
// registerCourseWorker(highStudentCourse); (x)
}
}
package generic_004_wildcard;
public class Course <T> {
private String name;
private T[] students;
public Course (String name, int capacity) {
this.name = name;
students = (T[]) (new Object[capacity]);
//배열객체 5개 형성
}
public String getName() { return name;}
public T[] getStudents() { return students;}
public void add(T t) {
for(int i=0; i<students.length; i++) {
if(students[i] == null) {
students[i] = t;
break; //최초 반복문 종료 중괄호 밖으로.
}
}
}
}
package generic_004_wildcard;
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
public String getName() {return name;}
public String toString() {return name;}
}
package generic_004_wildcard;
public class Worker extends Person {
public Worker(String name) {
super(name);
}
}
package generic_004_wildcard;
public class Student extends Person {
public Student(String name) {
super(name);
}
}
package generic_004_wildcard;
public class HighStudent extends Student {
public HighStudent(String name) {
super(name);
}
}
List Interface - ArrayList클래스, LinkedList, Vector, Stack, Queue - 배열객체가 보완되어 나온 자료형, 방구조를 변경할 수 있다. - 중복값o - 인덱스(순서)o
Set Interface - HashSet, TreeSet - 리스트와 비슷하지만 중복값x, 덮어쓰기됨 -인덱스(순서)x가 없다
MapInterface - HashMap, TreeMap - key와 value의 쌍으로 이루어진 자료형 - key는 (권장) 문자열자료형(String)으로 지정해준다. - 중복key는 불가하며 인덱스번호 역할 중복value는 가능하다. - 인덱스(순서)o가 있다
List <자료형>객체명 = new ArrayList <자료형>(); List <자료형>객체명 =ArrayList.asList([값,값2,값3...]); ArrayList<자료형>객체명 = newArrayList<자료형>();
Set <자료형>객체명 = new HashSet<자료형>(); HashSet<자료형>객체명 = new HashSet<자료형>();
Map<키자료형,값자료형>객체명 = new HashMap<키자료형,값자료형>(); HashMap<키자료형,값자료형> 객체명 = new HashMap<키자료형,값자료형>
List< String > Collection Framework는 Generic기반의 자료형이므로 반드시 요소의 자료형은 클래스급 이상의 자료형으로 지정해주어야 한다.
순서가 없으며 키와 값의 쌍으로 이루어진 자료형 키는 중복값 불가, 값은 중복값 가능 키와 값에 null값을 허용하지 않는 자료형 : Hashtable
Iterator인터페이스 자료형 : - 한줄로 나열된(순서여부 상관없음. Set, List가능) - 데이터를 하나씩 떼어서 반복해서 가져올 수있는 자료형 - 형식 : Iterator<자료형>객체명 = 한줄로나열된객체명.iterator(); hasNext() : - 다음 요소가 있는지 확인, 데이터를 가져오지 않음. ture,false(boolean)으로 값의 유무를 반환함 next() : 다음의 요소 한 개를 가져옴. 해당 값을 반환함.
**Generic형식으로 자료형을 반드시 기술해주어야 하나씩 요소를 떼어올 때 쉽게 가져올 수 있다.
List
Set
Map <k, v=""> map</k,>
추가
add( 추가할 값 ) method 마지막에 값을 추가
put(key명,추가할 값);
add(인덱스번호, 추가할 값) 해당 인덱스에 값을 추가하고, 기존의 인덱스번호부터~마지막인덱스까지 한 칸씩 뒤로 밀림
map.put 기존값 없을시 새로 추가 중복값 입력시 마지막값으로 덮어쓰기됨
제거
remove(인덱스번호) 제거, 칸수만 줄어들고 뒤 인덱스값들이 앞으로 당겨짐
set.remove(인덱스번호) 제거, 칸수만 줄어들고 뒤 인덱스값들이 앞으로 당겨짐 set.remove(객체명주소값)
remove(삭제값) 찾아서 제거 (맨 첫번째 값)
removeall(컬렉션프레임워크자료형객체) 해당 자료형으로 지정해둔 값과 일치하는 값이 있으면 모두 제거 ArrayList<String> aAlist = new ArrayList<String>(); aAlist.add("홍길동") aAlist.add("고길동")
ArrayList<String> bAlist = newArrayList(); bAlist.add("홍길동") aAlist. removeall( bAlist ); // aAlist객체에서bAlist에 있는 값이 모두 제거됨
키 중복이 허용되지 않으므로 key 키가 존재하지 않으면 put은 insert가능 키가 존재하면 put은 update기능으로 처리됨.
package collectionex;
import java.util.*;
public class CollEx01 {
public static void main(String[] args) {
//리스트 생성
ArrayList<String> arrList = new ArrayList<String>();
//ArrayList<String> arrList = new ArrayList<>();
//선언하는 곳에만<String>명시해도 객체생성하는 곳은 <>비워도된다.
//배열객체 생성시 방개수 지정시 : String[] sList = new String[5];
//ArrayList arrList = new ArrayList(); <>없이 선언 및 값은 add되지만 추후 값 추출시 에러발생가능
//리스트에 요소의 저장
arrList.add("넷");
arrList.add("둘");
arrList.add("셋");
arrList.add("하나");
System.out.println("arrList1: " + arrList); // arrList주소값이 아닌 값이 출력
//리스트 요소의 출력
for (String s : arrList) { // arrList > s
System.out.println(s);
}
System.out.println("arrList의 크기: " + arrList.size());
arrList.remove(1); //해당 객체 삭제
// arrList.clear(); //모든 객체 삭제, arrList = null
System.out.println("arrList의 크기: " + arrList.size());
System.out.println("arrList2: "+ arrList);
List<String> lst = new ArrayList<String>();
lst.add("alpha");
lst.add("beta");
lst.add("charlie");
System.out.println("lst객체: " + lst);
Iterator<String> iter = lst.iterator();
//Iterator iter = lst.iterator();
while (iter.hasNext()) { //hasNext() : 다음 값만 확인
String str = iter.next(); //명시해야함
System.out.println(str);
}
for (String str : lst) {
System.out.println(str);
}
}
}
arrList1: [넷, 둘, 셋, 하나]
넷
둘
셋
하나
arrList의 크기: 4
arrList의 크기: 3
arrList2: [넷, 셋, 하나]
lst객체: [alpha, beta, charlie]
alpha
beta
charlie
alpha
beta
charlie
CollEx02.java
package collectionex;
import java.util.ArrayList;
import java.util.Iterator;
public class CollEx02 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("사과");
list.add("바나나");
list.add("귤");
list.add("오렌지");
list.add("바나나");
// list.add(0, "바나나"); 인덱스 명시시 기존 값들은 순차적으로 미뤄짐
System.out.println("요소의 개수 : " + list.size());
System.out.println(">> Iterator 객체로 요소 얻기 <<");
// Iterator elements = list.iterator(); // 1.5이전
Iterator<String> elements = list.iterator();
while (elements.hasNext()) {
// String str = (String) elements.next(); // 1.5 이전
String str = elements.next();
System.out.println(str + "\t");
}
System.out.println("\n");
System.out.println(">> get메소드로 요소 얻기 <<");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i) + "\t"); //list.get(해당 인덱스번호)
}
System.out.println();
}
}
요소의 개수 : 5
>> Iterator 객체로 요소 얻기 <<
사과
바나나
귤
오렌지
바나나
>> get메소드로 요소 얻기 <<
사과
바나나
귤
오렌지
바나나
CollEx03.java
package collectionex;
import java.util.ArrayList;
import java.util.Iterator;
public class CollEx03 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
// ArrayList list = new ArrayList(); // <>미기재시 실행은 되지만 노란줄 생김
list.add("사과");
list.add("수박");
list.add("귤");
list.add("딸기");
list.add("체리");
prn(list); //main method에서 static이 붙어있어서 이탤릭.
//list.add(인덱스번호, 값) 삽입
System.out.println(">> 인덱스 2인 위치에 키위 삽입 <<");
list.add(2, "키위");
prn(list);
//list.set(인덱스번호, 값) 변경
System.out.println(">> 인덱스 4인 위치의 데이터를 포도로 변경 <<");
list.set(4, "포도");
prn(list);
//list.remove(인덱스번호) 제거, 칸수만 줄어들고 뒷인덱스값들이 앞으로 당겨짐
System.out.println(">> 인덱스 1인 위치의 데이터를 제거 <<");
list.remove(1);
prn(list);
//list.remove(삭제값) 찾아서 제거(맨 첫번째 값)
System.out.println(">> 사과 데이터를 찾아서 제거 <<");
list.remove("사과");
prn(list);
//list.remove(삭제값) 모두 찾아서 제거
System.out.println(">> 사과 데이터를 모두 찾아서 제거 <<");
list.remove("사과");
ArrayList<String> apple = new ArrayList<String>();
apple.add("사과");
list.removeAll(apple);
prn(list);
}
static void prn(ArrayList<String> list) {
for(int i = 0; i < list.size(); i++) {
//list.get(인덱스번호) 해당 값을 호출
System.out.println(list.get(i) + "\t");
}
System.out.println("\n");
}
}
사과
수박
귤
딸기
체리
>> 인덱스 2인 위치에 키위 삽입 <<
사과
수박
키위
귤
딸기
체리
>> 인덱스 4인 위치의 데이터를 포도로 변경 <<
사과
수박
키위
귤
포도
체리
>> 인덱스 1인 위치의 데이터를 제거 <<
사과
키위
귤
포도
체리
>> 사과 데이터를 찾아서 제거 <<
키위
귤
포도
체리
>> 사과 데이터를 모두 찾아서 제거 <<
키위
귤
포도
체리
CollEx04.java
package collectionex;
import java.util.*;
public class CollEx04 {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<Student>();
list.add(new Student ("자바왕", 1, 1));
list.add(new Student ("자바짱", 1, 2));
list.add(new Student ("홍길동", 2, 1));
list.add(new Student ("전우치", 2, 2));
Iterator<Student> it = list.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.name + " " + s.ban + "반 " + s.no + "번");
}
}
}
class Student {
String name = "";
int ban;
int no;
//아래에 기본생성자, 기타생성자, getter, setter메소드만 존재
Student() {}
Student(String name, int ban, int no) {
this.name = name;
this.ban = ban;
this.no = no;
}
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getBan() { return ban; }
public void setBan(int ban) { this.ban = ban; }
public int getNo() { return no; }
public void setNo(int no) { this.no = no; }
}
자바왕 1반 1번
자바짱 1반 2번
홍길동 2반 1번
전우치 2반 2번
CollEx05.java
package collectionex;
import java.util.*;
public class CollEx05 {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<String, String>();
//key가 인덱스번호 역할을 하며 중복값을 갖지 못 한다. set로 가져올 수 있음
//value는 중복값을 가질 수는 있음
map.put("one", "하나");
map.put("two", "둘");
map.put("three", "셋");
map.put("four", "넷");
map.put("five", "다섯");
Set<String> keys = map.keySet(); //
Iterator<String> iter = keys.iterator();
while (iter.hasNext()) {
String key = iter.next();
System.out.printf("key : %s\t value : %s\n", key, map.get(key));
}
//Collection
Collection<String> value = map.values();
iter = value.iterator();
//iterator - 한줄로 나열되어있는 값에서 분리해서 사용할 때 사용하는 메소드
while (iter.hasNext()) {
System.out.printf("value : %s\n", iter.next());
// for(String s : key) { for문을 사용해서 한줄로 나열된 값을 호출 및 출력 가능
// System.out.println("key : %s\t value : %s\n", key, map.get(key));
// }
}
}
}
key : four value : 넷
key : one value : 하나
key : two value : 둘
key : three value : 셋
key : five value : 다섯
value : 넷
value : 하나
value : 둘
value : 셋
value : 다섯
CollEx06.java
package collectionex;
import java.util.HashMap;
import java.util.Scanner;
public class CollEx06 {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<String, String>();
//new가 들어가서 공간이 생성되면 null값을 갖지 못 한다.
map.put("castello", "1234");
map.put("java", "1111");
map.put("lang", "1234");
Scanner s = new Scanner(System.in);
while (true) {
System.out.println("id와 password를 입력해주세요.");
System.out.print("id : ");
String id = s.nextLine().trim();
//nextLine() 공백이 있는 한 줄 입력값을 받을 수 있는
//trim() 양쪽 공백 삭제
System.out.print("password : ");
String password = s.nextLine().trim();
System.out.println();
if(!map.containsKey(id)) {
//!부정연산자 값이 하나로 됨.
//ap.containsKey(id) 해당값을 가진 것을 추출
System.out.println("입력하신 id는 존재하지 않습니다. 다시 입력해주세요.\n");
} else {
if(!map.get(id).equals(password)) {
System.out.println("비밀번호가 일치하지 않습니다. 다시 입력해주세요.\n");
} else {
System.out.println("id와 비밀번호가 일치합니다.");
break;
}
}
}
}
}
id와 password를 입력해주세요.
id : castello
password : fdsafjdsaklf
비밀번호가 일치하지 않습니다. 다시 입력해주세요.
id와 password를 입력해주세요.
id : java
password : 1111
id와 비밀번호가 일치합니다.
CollEx07.java
package collectionex;
import java.util.*;
import java.util.Map.Entry; //생략 불가 interface가 2개
public class CollEx07 {
//String s = null;
//Integer i = null;
public static void main(String[] args) {
HashMap<String, Integer> hm = new HashMap<String, Integer>();
//key, value로 입력이 가능
hm.put("hello", 123);
hm.put("world", 345);
//key를 null로 할 수 있고 value도 null로 할 수 있다.
hm.put(null, 555);
hm.put("nullKey", null);
System.out.println(hm + "\n");
for (String key : hm.keySet()) {
System.out.println("key : " + key + ", value : " + hm.get(key));
}
//entrySet 메서드는 key, value를 볼 수 있게 해준다.
for (Entry<String, Integer> s : hm.entrySet()) {
System.out.println(s.getKey() + ", " + s.getValue());
}
LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>();
//Linked순서가 있게끔 만들어준다.
lhm.put("hello", 123);
lhm.put("world", 345);
//key를 null로 할 수 있고 value도 null로 할 수 있다.
lhm.put(null, 555);
lhm.put("nullKey", null);
// lhm.put("world", 345); 추가 선언시 마지막값으로 재정의된다.
System.out.println(lhm + "\n");
for (String key : lhm.keySet()) {
System.out.println("key : " + key + ", value : " + lhm.get(key));
}
//entrySet 메서드는 key, value를 볼 수 있게 해준다.
for (Entry<String, Integer> s : lhm.entrySet()) {
System.out.println(s.getKey() + ", " + s.getValue());
}
}
}
{null=555, nullKey=null, world=345, hello=123}
key : null, value : 555
key : nullKey, value : null
key : world, value : 345
key : hello, value : 123
null, 555
nullKey, null
world, 345
hello, 123
{hello=123, world=345, null=555, nullKey=null}
key : hello, value : 123
key : world, value : 345
key : null, value : 555
key : nullKey, value : null
hello, 123
world, 345
null, 555
nullKey, null
