자료구조

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]

//        TODO : 모든 자료 삭제하기

        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"));


    }
}