ArrayList
package chap12.sec01.exam01;
import java.util.ArrayList; // ArrayList를 사용하기 위한 유틸패키지 import
import java.util.List; // List를 사용하기 위한 유틸패키지 import
/**
* packageName : chap12.sec01.exam01
* fileName : ArrayListApplication
* author : GGG
* date : 2023-09-25
* description :
* 요약 :
* <p>
* ===========================================================
* DATE AUTHOR NOTE
* —————————————————————————————
* 2023-09-25 GGG 최초 생성
*/
public class ArrayListApplication {
public static void main(String[] args) {
// 객체 생성 : 리스트 : 다형성(자식에 따라 결과가 달라짐)
List<String> list = new ArrayList<>();
// TODO: 리스트에 추가하기
// 사용법 : 리스트객체변수.add(값); // 최소 0 인덱스 번호에 추가됨
list.add("Java"); // 1st(0: 인덱스 번호)
list.add("JDBC"); // 2nd
list.add("Servlet/JSP"); // 4th
list.add(2, "Database"); // 3rd
list.add("myBATIS"); // 5th
// 결과출력
System.out.println(list);
// TODO : 향상된 배열의 크기 가져오기 (vs. 일반배열.length)
int size = list.size();
// 결과 출력
System.out.println("총 객체 수"+ size);
}
}
// 결과
[Java, JDBC, Database, Servlet/JSP, myBATIS]
* List : 인터페이스, 배열을 개선한 자료구조
* 배열(고정길이) vs 향상된 배열(크기 자동증가) : 기본 10개
* 부모인터페이스를 상속받은 자식클래스들
* 리스트 : 다형성(자식에 따라 결과가 달라짐)
* ArrayList(*) : 순차적으로 추가/삭제시 속도 빠름
* 중간에 추가/삭제시 속도 저하
* LinkedList : 중간에 추가/삭제시 속도 향상, 순차적일때 속도 저하
* Vector : 멀티 쓰레드 환경에서 사용하는 자료구조
// TODO : 향상된 배열의 크기 가져오기 (vs. 일반배열.length)
// 사용법 : 객체변수.size();
int size = list.size();
// 결과 출력
System.out.println("총 객체 수 : "+ size);
총 객체 수 : 5
// TODO : 저장된 데이터 가져오기
// 예제 1) 3번째 자료 가져오기
// 사용법 : 객체변수.get(인덱스 번호)
String skill = list.get(2); // 0 ~ n : 0부터 시작
// 결과출력
System.out.println("3번째 자료 : " + skill);
3번째 자료 : Database
// TODO : 반복문을 이용해서 자료 모두 출력하기
for (int i = 0; i < list.size(); i++) {
String str = list.get(i);
System.out.println(i + " : " + str);
}
0 : Java
1 : JDBC
2 : Database
3 : Servlet/JSP
4 : myBATIS
// TODO : 자료 수정하기
// 사용법 : 객체변수.set(인덱스번호, 값);
list.set(0, "자바");
System.out.println("수정된 값 : " + list.get(0));
수정된 값 : 자바
// TODO : 자료 삭제하기
// 사용법 : 객체변수.remove(인덱스번호)
// 사용법 : 객체변수.remove(값)
list.remove(2); // 2번 인덱스 위치의 값 삭제
list.remove(2);
list.remove("myBATIS"); // 값(myBATIS) 찾아서 삭제
// 결과출력
System.out.println(list);
[자바, JDBC]
list.clear(); // 모든 자료 삭제
// 결과출력
System.out.println(list);
[]
Vector
* Vector : 멀티쓰레드 환경에서 사용하는 자료구조, ArrayList 거의 유사
* (병렬처리 : 속도 향상(장점), 코딩 복잡도 증가(동기화 문제 등))
* 속도 : ArrayList > Vector
public class Board {
String subject; // 제목
String content; // 내용
String writer; // 작성자
// 매개변수 3개 생성자
public Board(String subject, String content, String writer) {
this.subject = subject;
this.content = content;
this.writer = writer;
}
// .equals(), .hashCode() 재정의
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Board board = (Board) o;
return Objects.equals(subject, board.subject) && Objects.equals(content, board.content) && Objects.equals(writer, board.writer);
}
@Override
public int hashCode() {
return Objects.hash(subject, content, writer);
}
// TODO 편리성 증진 : 함수 재정의 toString() : 객체를 문자열로 변환하는 함수
@Override
public String toString() {
return "["+ subject + "," + content + "," + writer +"]";
}
public class BoardApplication {
public static void main(String[] args) {
// 백터 객체 생성 : 다형성 이용
// TODO : Vector의 부모 : List ( add(): [추가], get(): [조회), set(): [수정], remove(): [삭제] )
List<Board> list = new Vector<>();
// 객체 추가
list.add(new Board("제목1", "내용1", "글쓴이1"));
list.add(new Board("제목2", "내용2", "글쓴이2"));
list.add(new Board("제목3", "내용3", "글쓴이3"));
list.add(new Board("제목4", "내용4", "글쓴이4"));
list.add(new Board("제목5", "내용5", "글쓴이5"));
System.out.println(list); // 속성 : toString() : list에서 생략해도됨 (자동 실행)
// 삭제 2건
list.remove(2); // 2번 삭제 후 자동으로 자료가 당겨짐
list.remove(3);
System.out.println(list);
}
실행결과
[[제목1,내용1,글쓴이1], [제목2,내용2,글쓴이2], [제목3,내용3,글쓴이3], [제목4,내용4,글쓴이4], [제목5,내용5,글쓴이5]]
[[제목1,내용1,글쓴이1], [제목2,내용2,글쓴이2], [제목4,내용4,글쓴이4]]
LinkedList
* LinkedList vs ArrayList
* 구분 | 순차 추가/삭제 | 중간에 추가/삭제
* ArrayList | 빠름 | 느림
* LinkedList | 느림 | 빠름
public class LinkedListApplication {
public static void main(String[] args) {
// TODO : 예제 1) 속도 비교 : ArrayList vs LinkedList
// 객체 생성 : 다형성을 이용
List<String> list = new ArrayList<>();
List<String> list2 = new LinkedList<>();
// 시간 변수 2개
long startTime;
long endTime;
// TODO 1) 처음시간 : System 객체 : 시간을 재는 함수 : nanoTime()
startTime = System.nanoTime();
// TODO 2) 실행 : 반복문 ( 0 ~ 10000 까지 배열에 값을 추가 )
for (int i = 0; i < 10000 ; i++) {
// 중간에 추가 : add(인덱스번호, 값)
list.add(0, String.valueOf(i)); // 정수 -> 문자열 반환 추가
}
// TODO 3) 종료 시간 : System 객체 nanoTime()
endTime = System.nanoTime();
System.out.println("ArrayList 소요시간 : " + (endTime - startTime));
System.out.println("---------------------------LinkedList----------------------------");
// TODO 1) 처음시간 : System 객체 : 시간을 재는 함수 : nanoTime()
startTime = System.nanoTime();
// TODO 2) 실행 : 반복문 ( 0 ~ 10000 까지 배열에 값을 추가 )
for (int i = 0; i < 10000 ; i++) {
// 중간에 추가 : add(인덱스번호, 값)
list2.add(0, String.valueOf(i)); // 정수 -> 문자열 반환 추가
}
// TODO 3) 종료 시간 : System 객체 nanoTime()
endTime = System.nanoTime();
System.out.println("LinkedList 소요시간 : " + (endTime - startTime));
}
Set
* 복습 : List : (ArrayList, LinkedList, Vector)
* Set : (HashSet, LinkedHashSet, TreeSet 등)
* Set : 집합을 표현한 인터페이스, 자식클래스 (HashSet, LinkedHashSet, TreeSet 등)
* 특징 : 순서가 없음(인덱스번호가 없음), 중복이 허용되지 않음
* vs List 특징(순서 있음(인덱스), 중복 허용됨)
public class HashSetApplication {
public static void main(String[] args) {
// 객체 생성 : 다형성
Set<String> set = new HashSet<>();
// TODO : 자료 추가 / 사용법 : 객체변수.add(값)
set.add("Java");
set.add("JDBC");
set.add("Servlet/JSP");
set.add("Java");
set.add("myBATIS");
System.out.println(set);
// set의 특징 : 중복을 허용하지 않음
// TODO : 자료 크기 보기 / 사용법 : 객체변수.size();
int size = set.size();
System.out.println("총 객체수 : " + size);
// TODO : 자료 삭제 / 사용법 : 객체변수.remove(값);
set.remove("JDBC");
System.out.println(set);
// TODO 참고 : 모두 삭제 / 사용법 : 객체변수.clear()
set.clear();
System.out.println(set);
}
HashSet 예제
package chap12.sec01.exam05;
import java.util.Objects;
/**
* packageName : chap12.sec01.exam05
* fileName : Member
* author : GGG
* date : 2023-09-25
* description : 회원 객체
* 요약 :
* <p>
* ===========================================================
* DATE AUTHOR NOTE
* —————————————————————————————
* 2023-09-25 GGG 최초 생성
*/
public class Member {
public String name; // 이름
public int age; // 나이
public Member(String name, int age) {
this.name = name;
this.age = age;
}
// 객체 비교
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Member member = (Member) o;
return age == member.age && Objects.equals(name, member.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "[" + name + "," + age +"]";
}
}
public class HashSetApplication {
public static void main(String[] args) {
// 객체 생성 : 다형성
Set<Member> set = new HashSet<>();
// 객체 추가
set.add(new Member("홍길동", 30));
set.add(new Member("홍길동", 30));
// TODO : 중복 제거되었는지 확인(.hashCode() 재정의)
System.out.println(set);
}
}
Map
* 복습 : List(**) : (ArrayList(*), LinkedList, Vector), 향상된 배열
* Set : (HashSet, LinkedHashSet 등), 집합 구현
* Map(**) : (HashMap(*), HashTable 등) (키, 값 : 엔트리) 이루어진 자료구조
* (vs List (인덱스번호, 값)
* 특징 : 키 - 유일한 값 (중복 금지), 값 - 중복 허용
public class HashMapApplication {
public static void main(String[] args) {
// 객체 생성 : 다형성
// TODO : Map<키_자료형, 값_자료형> map = new HashMap<>();
// Object : 자바 최고 조상 객체
Map<String, Object> map = new HashMap<>();
// TODO : 자료 추가 : 객체변수.put(키, 값);
map.put("no", 1);
map.put("name", "홍길동");
System.out.println(map);
// TODO : 자료크기 : 객체변수.size()
System.out.println("총 객체 수 : " + map.size());
// TODO : 키로 값을 조회하기 : 객체변수.get("키이름") => 결과 : 값이 출력
System.out.println(map.get("no"));
System.out.println(map.get("name"));
// TODO : 수정하기 : 객체변수.put(키, 값)
map.put("no", 2); // no=1->2 값 수정
System.out.println("1 -> 2 : " + map.get("no"));
// TODO : 삭제하기 : 객체변수.remove(키이름);
map.remove("no");
System.out.println("키 삭제 : " + map.get("no"));
}
}
