1. Collection (데이터의 모임) -Vector
=> java에서는 데이터의 모임을 표현하는 List와 Set 인터페이스의 상위 인터페이스
=> java.util.Collection
=> 유사한 역할을 하는 메소드의 이름을 동일하게 만들기 위해 생성
2. java.util.Collection
=>List 와 Set 인터페이스의 상위 인터페이스
=>List 와 Set의 공통된 메소드 이름만 소유
Interface Collection<E>
=><E>는 제너릭스 기능으로 객체를 생성할 때 자료형을 지정해주어야 한다는 표히
=>자료형을 지정하지 않으면 Object 타입이 되고 Object 타입으로 만들어지면 꺼내서 사용할 때 원래의 자료형으로 강제 형 변환해서 사용해야 합니다.
3. Enumeration & Iterator
=>우리말로는 반복자로 번역을 하는데 여러 개의 데이터를 순차적으로 접근할 때 이전에 접근했던 데이터의 위치를 기억하고 있다가 다음 데이터를 접근하는 방식입니다.
=>Enumeration이 예전의 인터페이스이고 지금은 Iterator로 변경이 되었습니다.
1) Enumeration
- boolean hasMoreElements(): 다음 요소가 있는지 없는지 여부를 판단해주는 메소드
- E nextElement(): 열거에 1개 이상의 요소가 남아 있는 경우는 다음의 요소를 리턴하는데 객체를 생성할 때 자료형을 지정했으면 그 자료형의 데이터를 리턴해주고 자료형을 지정하지 않았으면 Object 타입으로 리턴합니다.
2) Iterator
- boolean hasNext(): 다음 요소가 있는 지 여부를 리턴
- E next(): 반복 처리로 다음의 요소를 리턴
- void remove(): 마지막으로 요소를 삭제
3) 최근에는 빠른 열거를 이용하는 방법으로 많이 대체가 되고 있습니다.
for(임시변수 : 컬렉션){
컬렉션의 모든 데이터를 순서대로 임시변수에 대입
}
4. List 인터페이스
=>순서가 있는 데이터의 집합
1) 메소드
boolean add(E e): 데이터를 마지막에 추가
void add(int index, Object element): index 번째에 데이터를 추가
Object get(index): index 번째 데이터를 리턴
int indexOf(Object o): o가 있는지 찾아서 위치를 리턴 : 없으면 음수리턴
int lastIndexOf(Object o):o가 있는지 찾아서 위치를 리턴 : 뒤에서 부터 찾습니다.
Object remove(int index): index 번째 데이터 삭제
void sort(Comparator c): Comparator의 메소드를 이용해서 정렬
List subList(int fromIndex, int toIndex): fromIndex 부터 toIndex 번째 데이터까지를 잘라서 List로 리턴
2) ArrayList 클래스 - 이전에는 Vector
=>데이터를 입력한 순서대로 저장하는 List 클래스
=>이 때 데이터를 연속적으로 저장합니다.
=>크기가 변경되는 가변 배열
=>데이터를 순서대로 접근하는 경우에 적합
=>데이터를 끝이 아닌 중간에 삽입하거나 삭제하는 것은 어렵습니다.
=>빠른 열거 사용 가능합니다.
=>generics가 적용되어 있습니다.
3) 생성자
ArrayList(): 비어있는 리스트 생성
ArrayList(Collection c): c의 내용을 복사해서 생성
ArrayList(int initialCapacity): 처음 저장할 수 있는 객체의 개수를 지정해서 생성할 수 있습니다.
4)실습 - 생성하고 데이터 추가하고 데이터 전체 접근하고 필요없는 데이터 삭제하는 작업
import java.util.ArrayList;
public class Main1 {
public static void main(String[] args) {
//정수를 저장할 수 있는 ArrayList를 생성
ArrayList<Integer> a1 = new ArrayList<Integer>();
//<>안에 기재하는 자료형은 참조형만 가능
//정수 데이터 추가
a1.add(10);
a1.add(50);
a1.add(3);
a1.add(60);
//ArrayList의 모든 데이터를 순회해서 출력
//일반적인 반복문 사용
int size = a1.size();
for(int i=0; i<size; i=i+1) {
System.out.println(a1.get(i));
}
//ArrayList의 데이터 1개 삭제
a1.remove(2);
//ArrayList의 모든 데이터를 순회해서 출력
//빠른 열거 이용
System.out.println("===================");
for(Integer temp : a1) {
System.out.println(temp);
}
}
}
5) List의 sort 메소드
public void sort(Comparator<? super E> c)
=>List의 데이터를 정렬할 수 있는데 이 때는 매개변수로 Comparator 인터페이스를 구현한 객체를 대입해야 합니다.
=>Comparator는 generice를 사용할 수 있기 때문에 인터페이스를 구현할 때 실제 자료형을 설정해야 주어야 합니다.
=>이 때의 자료형은 List에 설정한 자료형과 동일하게 설정해야 합니다.
6) 사용자 정의 클래스의 객체를 저장한 ArrayList의 정렬
=>번호(정수), 이름(문자열), 나이(정수), 소속그룹(문자열)을 저장할 수 있는 클래스 만들기
=>toString() 재정의: toString()은 객체의 내용을 문자열로 리턴해주는 메소드로 재정의하지 않으면 클래스 이름과 해시코드를 합쳐서 리턴합니다.
=>print 메소드에 객체의 이름을 대입하면 toString()의 결과가 출력됩니다.
public class Data {
private int number;
private String name;
private int age;
private String group;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
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 getGroup() {
return group;
}
public void setGroup(String group) {
this.group = group;
}
//내부 데이터를 빠르게 확인하기 위한 메소드 - 디버깅용
@Override
public String toString() {
return "Data [number=" + number + ", name=" + name + ", age=" + age + ", group=" + group + "]";
}
}
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;
public class Main2 {
public static void main(String[] args) {
//Singer 객체를 저장하는 ArrayList 생성
ArrayList <Data> a1 = new ArrayList <Data>();
Data d1 = new Data();
d1.setAge(27);
d1.setName("수");
d1.setGroup("와우");
d1.setNumber(2011);
a1.add(d1);
Data d2= new Data();
d2.setAge(32);
d2.setName("영");
d2.setGroup("롤");
d2.setNumber(2008);
a1.add(d2);
Data d3= new Data();
d3.setAge(30);
d3.setName("윰");
d3.setGroup("wow");
d3.setNumber(2010);
a1.add(d3);
//a1의 데이터 정령
//List 의 데이터를 정렬할 때는 sort 메소드에게 comparator
//인터페이스를 implements 한 클래스의 객체를
//대입해 주어야합니다.
//Comparator 인터페이스를 implements 할 때 generics가
//적용되어있기 때문에 List에 저장한 자료형을 설정해야 합니다.
//anonymous 클래스 만들기
//한번만 생성해도됨
Scanner sc = new Scanner(System.in);
//무한 반복문
while(true) {
System.out.println("정렬할 옵션을 선택하세요.");
System.out.println("1.번호의 오름차순\n2.번호의 내림차순\n3.이름의 오름차순"
+ "\n4.이름의 내림차순\n5.나이의 오름차순\n6.나이의 내림차순\n7.종료");
System.out.print("메뉴선택: ");
String menu = sc.nextLine();
if(menu.equals("1")) {
System.out.println("번호의 오름차순 정렬");
//Comparator를 상속받는 객체 생성
Comparator<Data> numComp = new Comparator<Data>() {
@Override
public int compare(Data o1, Data o2) {
return o1.getNumber()-o2.getNumber();
}
};
a1.sort(numComp);
}else if(menu.equals("2")) {
System.out.println("번호의 내림차순 정렬");
Comparator<Data> numComp = new Comparator<Data>() {
@Override
public int compare(Data o1, Data o2) {
return o2.getNumber()-o1.getNumber();
}
};
a1.sort(numComp);
}else if(menu.equals("3")) {
System.out.println("이름의 오름차순 정렬");
Comparator<Data> nameComp = new Comparator<Data>() {
@Override
public int compare(Data o1, Data o2) {
return o1.getName().compareTo(o2.getName());
}
};
a1.sort(nameComp);
}else if(menu.equals("4")) {
System.out.println("이름의 내림차순 정렬");
System.out.println("이름의 오름차순 정렬");
Comparator<Data> nameComp = new Comparator<Data>() {
@Override
public int compare(Data o1, Data o2) {
return o2.getName().compareTo(o1.getName());
}
};
a1.sort(nameComp);
}else if(menu.equals("5")) {
System.out.println("나이의 오름차순 정렬");
Comparator<Data> ageComp = new Comparator<Data>() {
@Override
public int compare(Data o1, Data o2) {
return o1.getAge()-o2.getAge();
}
};
a1.sort(ageComp);
}else if(menu.equals("6")) {
System.out.println("나이의 내림차순 정렬");
Comparator<Data> ageComp = new Comparator<Data>() {
@Override
public int compare(Data o1, Data o2) {
return o2.getAge()-o1.getAge();
}
};
a1.sort(ageComp);
}else if(menu.equals("7")) {
System.out.println("프로그램 종료");
break; //System.exit(0); - 프로그램 아예 종료
}else {
System.out.println("잘못된 메뉴를 선택하셨습니다.");
continue;
}
//전체 데이터 출력
for(Data temp : a1) {
System.out.println(temp);
}
System.out.println("\n");
}
//스캐너 객체 사용헤제
sc.close();
}
}
=>크기 비교가 가능한 객체의 List 나 배열은 바로 sort가 가능하지만 크기 비교가 안되는 클래스의 객체는 Comparator를 구현해서 크기 비교가 가능하도록 만들어 주어야만 정렬이 가능
4. Vector
=>ArrayList의 이전 버전
=>멀티 스레드에 안전한 버전
=>데이터를 사용할 때 마다 다른 프로세스가 사용 중인 지 확인하고 데이터를 사용
5. Stack
=>LIFO(Last In First Out): 마지막에 삽입된 데이터가 먼저 출력되는 자료구조
=>메소드가 호출될 때 만들어지는 메모리 영역이 Stack 자료구조로 생성됩니다.
=>java에서는 클래스로 제공됩니다.
=>주요 메소드
=>push(데이터): 데이터 삽입
=>pop(): 마지막에 삽입된 데이터를 삭제하고 리턴해주는 메소드
6. Queue
=>FIFO(First In First Out): 먼저 삽입된 데이터가 먼저 출력되는 자료구조
=>명령어를 저장하는 자료구조를 설계할 때 사용할 수 있습니다.
=>공장자동화 프로그램에 이용 가능
=>Java에서는 인터페이스로 제공
=>LinkedList 나 PriorityQueue라는 클래스가 Queue 인터페이스를 implements 한 클래스입니다.
=>PriorityQueue 클래스는 데이터를 정렬해서 저장하고 있는 Queue 입니다.
7. Deque
=>양쪽에서 삽입과 삭제가 가능한 자료구조
=>세로 방향으로 자르면 Stack 이 되고 가로 방향으로 자르면 Queue 입니다.
=>인터페이스로 제공되고 ArrayDeque가 Deque를 구현한 클래스 입니다.
=>삽입할 때는 addFirst() 나 addLast()를 이용하고 데이터를 가져올 때는 getFirst() 나 getLast()를 이용합니다.
import java.util.ArrayDeque;
import java.util.PriorityQueue;
import java.util.Stack;
public class ListMain4 {
public static void main(String[] args) {
//문자열을 저장하는 스택 객채 생ㅅㅇ
Stack <String> stack = new Stack <String>();
//데이터 제공
stack.push("wow");
stack.push("lol");
stack.push("sena");
//데이터 출력
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println();
//문자열을 저장하는 PriorityQueue 클래스 객체 생성
//Priority는 정렬을 해버린다.
PriorityQueue <String> queue = new PriorityQueue <String> ();
queue.add("wow");
queue.add("lol");
queue.add("sena");
//데이터 출력
System.out.println(queue.poll());
System.out.println(queue.poll());
System.out.println(queue.poll());
System.out.println();
ArrayDeque <String> oop = new ArrayDeque <String>();
oop.addFirst("캡슐화-enclpsu");
oop.addFirst("상속성-Inheritacn0");
oop.addFirst("다형성-polymorphism");
System.out.println(oop.getFirst());
System.out.println(oop.getLast());
}
}
8. Set
=>데이터를 입력하는 순서와 상관없이 해싱을 이용해서 저장하는 자료구조
=>중복된 데이터를 저장하지 않습니다.
=>검색속도는 빠릅니다.
=> Hashing: 데이터의 저장위치를 결정하는 방법
=> 모든 데이터의 검색시간이 동일
=> 평균 검색시간이 가장 빠름
=> set은 index 사용이 안됨
=> 전체 데이터 순회는 빠른 열거로만 가능
=>인덱스를 이용해서 하나의 데이터만 가져오는 것은 안됩니다.
=>전체 데이터를 순회하고자 할 때는 for를 이용한 빠른 열거만 가능합니다.
=>자바에서는 Set이 인터페이스로 제공되고 이를 implements 한 클래스로는 HashSet, TreeSet, LinkedHashSet이 있습니다.
=>TreeSet은 크기 순서대로 데이터를 저장한 구조이고 LinkedHashSet은 입력된 순서대로 저장하는 Set 입니다.
import java.util.HashSet;
public class SetMain {
public static void main(String[] args) {
//String을 저장하는 HashSet 객체를 생성
HashSet <String> hashSet = new HashSet <String>();
//데이터를 삽입
hashSet.add("IE");
hashSet.add("Chrome");
hashSet.add("FireFox");
hashSet.add("Opera");
//Set은 빠른 열거를 이용해서만 모든 데이터를 순회
for(String msg:hashSet) {
System.out.println(msg);
}
}
}
9. Map(Dictionary라고도 합니다)
=>데이터를 저장할 때 Key 와 Value를 같이 저장
=>데이터에 이름을 붙여서 저장합니다.
=>Key는 Set으로 저장하기 때문에 Key의 값은 중복될 수 없습니다.
=>인터페이스 형태로 존재하고 구현된 클래스로는 HashMap, LinkedHashMap, TreeMap이 존재합니다.
=>Key 와 Value 모두 Generics가 적용되어 있어서 객체를 생성할 때 2개의 자료형을 같이 기재해야 합니다.
=>특별한 경우가 아니면 Key 의 자료형은 String
1) 메소드
데이터 저장:put(key, value)
데이터 가져오기:get(key)-저장되어 있지 않은 key를 사용하면 null 리턴
데이터 삭제:remove(key)
키의목록 모두 가져오기: keys()
값의목록 모두 가져오기: values()
2) 활용범위
=>웹 프로그래밍에서 데이터 전달은 전부 Map
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapMain {
public static void main(String[] args) {
//Map 객체를 생성
//상위클래스나 구현된 인터페이스 타입의 변수에
//하위 클래스 타입의 객체 주소를 대입할 수 있다.
Map <String,Object/*String*/> map = new HashMap <String,Object/*String*/>();
//map에 데이터 삽입
//value에 서로 다른 자료형의 데이터를 저장하려면
//Map 객체를 생성할 때 value의 자료형으로 Object 사용
map.put("name", "수현");
map.put("group", "computer");
map.put("age", "27");
//Map의 데이터 갱신
//map의 key는 set구조라서 동일한 데이터가 중복 저장이 안됨
//동일한 key 에 데이터를 2번이상 삽입하면 갱신됩니다.
map.put("name", "영우");
map.put("position", "healer");
//map.put("age", "33");
//Map에서 데이터를 가져와서 출력하기
System.out.println(map.get("name"));
//없는 key의 값을 가져오려고 하면 null
System.out.println(map.get("num"));
//모든 키의 값을 set을 저장
System.out.println();
Set <String> keys = map.keySet();
for(String key: keys) {
System.out.println(key+": "+map.get(key));
}
}
}
10. MVC(Model View Controller)
=>데이터를 만들어주는 부분과 출력하는 부분을 별개로 구현해서 데이터를 만들어주는 부분이 변경되더라도 출력하는 부분을 수정할 필요가 없도록 해야 하고 출력하는 부분을 변경하더라도 데이터를 만들어주는 부분에 변화가 없도록 해야 한다는 디자인 패턴
=>프로그래밍에서 가장 기본이 되는 디자인 패턴
*
주소결정방법(Hash 함수 - OS가 결정)
OS(Operating System) - 운영체제
'IT > JAVA (17.12.18~)' 카테고리의 다른 글
| 16일 JAVA(16) (0) | 2018.01.10 |
|---|---|
| 15일 JAVA(15) (0) | 2018.01.10 |
| 13일차 JAVA(13) (0) | 2018.01.05 |
| 12일차 JAVA(12) (0) | 2018.01.04 |
| 11일차 JAVA(11) (0) | 2018.01.03 |