=> 동적 배열 : 인덱스 수 유동적
=> 유동적으로 객체 추가, 검색, 삭제하기 위함
cf. 일반 배열 => 처음 선언한 인덱스로 한정됨
1.List
1) 순서 유지, 저장
2) 중복 저장 가능
3) 구현클래스 - ArrayList, Vector, LinkedList,..
2. Set
1) 순서 없이 저장
2) 중복 저장 불가
3) 구현클래스 - HashSet, TreeSet
3. Map
1) 키&값 쌍으로 저장
2) 키는 중복 저장 안 됨
3) 구현클래스 - HashMap, Hashtable, TreeMap
List
객체를 일렬로 정렬, 인덱스로 관리하는 구조
- ArrayList
상위 타입인 Object 타입으로 배열 생성 => 요소 접근에 탁월
요소 삽입, 삭제 시 그 뒤의 요소들은 한 칸씩 밀어야 하거나 당겨야 하기 때문에 비효율적
- 요소 삽입, 삭제
import java.util.ArrayList;
import java.util.List;
public class ArrayListEx1 {
public static void main(String[] args) {
//일반 배열
String[] subject = new String[5];
subject[0]="java";
subject[1]="html";
subject[2]="css";
subject[3]="javascript";
subject[4]="react";
System.out.println("총 과목 수 : "+subject.length);
for (int i=0;i<subject.length;i++) {
System.out.println("과목 "+(i+1)+ " "+ subject[i]);
}
//ArrayList //배열 목록화
List<String> subject2 = new ArrayList<String>();
subject2.add("java");
subject2.add("html");
subject2.add("css");
subject2.add("javascript");
subject2.add("react");
subject2.add(2, "nodejs"); //2번째 자리에 삽입
subject2.remove(2); //nodejs 삭제
subject2.remove(2); //css 삭제 => javascript가 인덱스 2로 옴
subject2.remove("react");
System.out.println("총 과목 수 : "+subject2.size());
for (int i=0;i<subject2.size();i++) {
System.out.println("과목 "+(i+1)+ " "+ subject2.get(i));
}
}
}
//
총 과목 수 : 3
과목 1 java
과목 2 html
과목 3 javascript
- 초기화
import java.util.Arrays;
import java.util.List;
public class ArrayListEx2 {
public static void main(String[] args) {
//배열의 초기화
String[] names = {"홍길동","김철수","이영희","박찬호","손흥민"};
//고정된 객체들로 구성된 List 생성
for (String n:names) {
System.out.println(n);
}
//ArrayList의 초기화 -> add, remove X
List<String> names2 = Arrays.asList("홍길동","김철수","이영희","박찬호","손흥민");
List<Integer> nums2 = Arrays.asList(10,20,30);
for (int num:nums2) { //자동언박싱
System.out.println(num);
}
}
}
- Vector
ArrayList와 유사
동기화 지원 -> 멀티스레드 환경에서 안전 (여러 스레드가 동시에 데이터에 접근 시 순차적으로 처리)
public class Board {
String subject;
String content;
String writer;
public Board(String subject, String content, String writer) {
this.subject=subject;
this.content=content;
this.writer=writer;
}
}
import java.util.List;
import java.util.Vector;
public class VectorEx1 {
public static void main(String[] args) {
List<Board> list = new Vector<Board>();
list.add(new Board("코로나", "코로나 확진 시 격리 1주","홍길동"));
list.add(new Board("자바활용", "5/20 시험(변수~참조)", "김철수"));
list.add(new Board("자바구현", "프론트엔드 시작 전 자바 구현 : 스마트폰", "이영희"));
//list.remove(1);
for (int i=0;i<list.size();i++) {
Board board = list.get(i);
System.out.println("제목 : "+board.subject);
System.out.println("내용 : "+board.content);
System.out.println("글쓴이 : "+board.writer);
System.out.println("---------------------");
}
}
}
//
제목 : 코로나
내용 : 코로나 확진 시 격리 1주
글쓴이 : 홍길동
---------------------
제목 : 자바활용
내용 : 5/20 시험(변수~참조)
글쓴이 : 김철수
---------------------
제목 : 자바구현
내용 : 프론트엔드 시작 전 자바 구현 : 스마트폰
글쓴이 : 이영희
---------------------
- LinkedList
값들 앞, 뒤로 연결되어 있음
=> 인접 참조 링크해 체인처럼 관리
=> 특정 인덱스 객체 제거 시 앞뒤 링크만 변경됨
ArrayList와 유사하며 삽입, 삭제 빈번할 때에는 성능 더 좋음
메모리 많이 사용됨
cf. ArrayList : 제거 시 뒤의 객체 인덱스 모두 1씩 당겨짐
- ArrayList - LinkedList 성능 비교
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class LinkedListEx1 {
public static void main(String[] args) {
List<String> list1 = new ArrayList<String>();
List<String> list2 = new LinkedList<String>();
long startTime;
long endTime;
startTime=System.nanoTime();
for (int i=0;i<10000;i++) {
list1.add(0, String.valueOf(i));
//int->String //0 자리에 문자 삽입해서 뒤 문자들 계속 밀려나도록
}
endTime=System.nanoTime();
System.out.println("ArrayList 시간 : "+ (endTime-startTime)+"ns");
startTime=System.nanoTime();
for (int i=0;i<10000;i++) {
list2.add(0, String.valueOf(i));
}
endTime=System.nanoTime();
System.out.println("LinkedList 시간 : "+ (endTime-startTime)+"ns");
}
}
//
ArrayList 시간 : 5326500ns
LinkedList 시간 : 1404200ns => 더 빠름
Set
Set = 집합
인덱스값 없으므로 get(), for 반복문 사용 불가
- HashSet
- Iterator 통해 출력
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class HashSetEx1 {
public static void main(String[] args) {
Set<String> set1 = new HashSet<String>();
set1.add("java");
set1.add("html");
set1.add("css");
set1.add("react");
set1.add("java"); //중복 제외됨
set1.remove("css");
System.out.println("총 자료 수 : "+set1.size());
Iterator<String> iter = set1.iterator(); //get() 대신 Iterator 사용
while(iter.hasNext()) { //자료 있으면 true
System.out.println(iter.next()); //한 객체 꺼냄
}
}
}
//
총 자료 수 : 3 //중복 제외
java
html
react
- TreeSet
족보와 유사
검색 강화 위한 컬렉션
70
| |
62 95
| | |
67 88 98
|
80
=> 첫숫자 기준으로
=> 가장 큰 숫자 : 맨오른쪽 / 가장 작은 숫자 : 맨왼쪽
- TreeSet 메소드 통해 출력
import java.util.TreeSet;
public class TreeSetEx1 {
public static void main(String[] args) {
TreeSet<Integer> scores = new TreeSet<Integer>();
//TreeSet 검색 메소드 사용 위해 TreeSet타입으로 대입
scores.add(70);
scores.add(95);
scores.add(62);
scores.add(88);
scores.add(80);
scores.add(67);
scores.add(98);
System.out.println("가장 높은 점수 : "+scores.last()); //last : 가장 높은
System.out.println("가장 낮은 점수 : "+scores.first()); //first : 가장 낮은
System.out.println("88 아래 점수 : "+scores.lower(88));
System.out.println("88 위 점수 : "+scores.higher(88));
int jumsu;
while(!scores.isEmpty()) { //
jumsu = scores.pollFirst(); //제일 작은 숫자 꺼냄
System.out.println("꺼낸 점수 : "+jumsu);
System.out.println("남은 자료 수 : "+scores.size());
}
}
}
//
가장 높은 점수 : 98
가장 낮은 점수 : 62
88 아래 점수 : 80
88 위 점수 : 95
꺼낸 점수 : 62
남은 자료 수 : 6
꺼낸 점수 : 67
남은 자료 수 : 5
꺼낸 점수 : 70
남은 자료 수 : 4
꺼낸 점수 : 80
남은 자료 수 : 3
꺼낸 점수 : 88
남은 자료 수 : 2
꺼낸 점수 : 95
남은 자료 수 : 1
꺼낸 점수 : 98
남은 자료 수 : 0
- NavigableSet의 subset() 통해 정렬, 검색
import java.util.NavigableSet;
import java.util.TreeSet;
public class TreeSetEx2 {
public static void main(String[] args) {
TreeSet<String> tree1 = new TreeSet<String>();
tree1.add("bear");
tree1.add("student");
tree1.add("banana");
tree1.add("car");
tree1.add("tree");
tree1.add("forever");
tree1.add("cherry");
tree1.add("fruit");
System.out.println("b~f 단어 검색");
NavigableSet<String> rangeSet = tree1.subSet("b", true, "g", true);
//NavigableSet 인터페이스의 메소드 subset 사용 => 정렬, 검색
//(시작 객체, 시작 객체 존재 여부, 마지막 객체, 마지막 객체 존재 여부)
for (String word:rangeSet) {
System.out.println(word);
}
}
}
//
b~f 단어 검색
banana
bear
car
cherry
forever
fruit
Map
key, value 로 구성된 객체 저장하는 구조
=> key 중복값 불가
- HashMap
- Set.keySet(), Iterator 이용해 value 출력
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashMapEx1 {
public static void main(String[] args) {
Map<String, Integer> map1 = new HashMap<String, Integer>();
map1.put("김철수", 90); //중복 없는 값으로 key 지정 추천
map1.put("홍길동", 70);
map1.put("이영희", 97);
map1.put("박찬호", 85);
map1.put("손흥민", 77);
System.out.println("총 자료 수 : "+map1.size());
//System.out.println(map1.get("박찬호"));
Set<String> keySet = map1.keySet(); //Iterator 사용 위해 Set 타입에 대입
Iterator<String> iter = keySet.iterator(); //Iterator : Set 안 원소 출력 위한 클래스
while (iter.hasNext()) {
String key = iter.next(); //key 값
Integer score = map1.get(key); //value 값
System.out.println(key + " : "+ score);
}
}
}
//
총 자료 수 : 5
홍길동 : 70
손흥민 : 77
이영희 : 97
박찬호 : 85
김철수 : 90
- Map.entry, Iterator 이용해 key, value 출력
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashMapEx1 {
public static void main(String[] args) {
Map<String, Integer> map1 = new HashMap<String, Integer>();
map1.put("김철수", 90);
map1.put("홍길동", 70);
map1.put("이영희", 97);
map1.put("박찬호", 85);
map1.put("손흥민", 77);
System.out.println("총 자료 수 : "+map1.size());
/*Set<String> keySet = map1.keySet(); //전체 key 가져옴
Iterator<String> iter = keySet.iterator();
while (iter.hasNext()) {
String key = iter.next(); //key 값 문자열에 넣음
Integer score = map1.get(key); //value 값
System.out.println(key + " : "+ score); //key 통해 value 가져옴
}
//map1.remove("이영희");*/
Set<Map.Entry<String, Integer>> entrySet = map1.entrySet();
//entrySet() : 자료 가져옴 (해당 map의 key와 value를 가지는 Set 객체 리턴)
Iterator<Map.Entry<String, Integer>> iter = entrySet.iterator();
//Iterator : Set 의 자료 가져옴
while (iter.hasNext()) {
Map.Entry<String, Integer> entry = iter.next();
String key = entry.getKey(); //Map.Entry 메소드
Integer score = entry.getValue();
System.out.println(key + " : "+score);
}
}
}
//
총 자료 수 : 5
홍길동 : 70
손흥민 : 77
이영희 : 97
박찬호 : 85
김철수 : 90
- Hashtable
동기화 메소드로 구성돼 하나의 스레드 실행 완료한 후 다른 스레드 실행
import java.util.Hashtable;
import java.util.Map;
import java.util.Scanner;
public class HashtableEx1 {
public static void main(String[] args) {
Map<String, String> map1 = new Hashtable<String, String>();
map1.put("hong", "12345");
map1.put("chanho", "77777");
map1.put("young", "22222");
map1.put("son", "33333");
map1.put("park", "11111");
Scanner sc = new Scanner(System.in);
while(true) {
System.out.println("아이디 비밀번호 입력해주세요");
System.out.print("아이디>> ");
String id = sc.next();
System.out.print("비밀번호>> ");
String pass = sc.next();
if (map1.containsKey(id)) { //containsKey : 해당 Key값 존재 여부 확인
if (map1.get(id).equals(pass)){
//id 상응하는 기존 value 값 - 입력한 pass 값 비교
System.out.println("로그인 성공");
break;
} else {
System.out.println("비밀번호 존재하지 않음");
}
}else {
System.out.println("입력한 아이디 존재 X");
}
}
}
}
//
아이디 비밀번호 입력해주세요
아이디>> son
비밀번호>> 33333
로그인 성공
- Treemap
5
| |
3 7
| |
8 10
import java.util.Map;
import java.util.TreeMap;
public class TreeMapEx1 {
public static void main(String[] args) {
TreeMap<Integer, String> mapList = new TreeMap<Integer, String>();
mapList.put(5, "홍길동");
mapList.put(7, "김철수");
mapList.put(10, "이영희");
mapList.put(3, "손흥민");
mapList.put(8, "박찬호");
Map.Entry<Integer, String> entry=null;
entry = mapList.firstEntry(); //가장 낮은 값
System.out.println("가장 낮은 번호 : "+entry.getKey()+" ☞ "+entry.getValue());
entry = mapList.lastEntry(); //가장 높은 값
System.out.println("가장 높은 번호 : "+entry.getKey()+" ☞ "+entry.getValue());
while(!mapList.isEmpty()) {
entry = mapList.pollFirstEntry();
System.out.print(entry.getKey()+" ☞ "+entry.getValue());
System.out.println(" (남은 자료 수 : "+mapList.size()+")");
}
}
}
//
가장 낮은 번호 : 3 ☞ 손흥민
가장 높은 번호 : 10 ☞ 이영희
3 ☞ 손흥민 (남은 자료 수 : 4)
5 ☞ 홍길동 (남은 자료 수 : 3)
7 ☞ 김철수 (남은 자료 수 : 2)
8 ☞ 박찬호 (남은 자료 수 : 1)
10 ☞ 이영희 (남은 자료 수 : 0)
참고:
'Programming > 자바' 카테고리의 다른 글
| 자바 재정리 - 람다식 (0) | 2022.09.08 |
|---|---|
| 자바 재정리 - 제네릭 (0) | 2022.09.08 |
| 자바 재정리 - 멀티 스레드 (0) | 2022.09.07 |
| 자바 재정리 - API (0) | 2022.09.05 |
| 자바 재정리 - 예외 처리 (0) | 2022.08.26 |