자바

[Java 고급] 1장 Collection Framework와 List

반응형

 

컬렉션 프레임워크 (Collection Framework)

 

: 데이터 그룹을 저장하는 클래스들을 표준화한 설계

 

컬렉션 프레임워크 트리

 

 

 

ArrayList

 

: Collection 인터페이스를 확장한 자료형. 중복 데이터를 입력 가능하며 순차적인 특징을 가지고 있다.

 

 

  • 사용법
사용법 뜻
add() 데이터 추가
get() 데이터 가져오기
set() 데이터 변경
remove() 데이터 삭제
size() 데이터 개수 확인
cotains(비교객체) 객체가 있는지 없는지 확인
indexOf(비교객체) 객체가 존재하는 index 정보 반환

 

 

package kr.or.ddit.basic;

import java.util.ArrayList;
import java.util.List;

public class T01ArrayListTest {
	public static void main(String[] args) {
		
		//Dafault Capacity = 10
		//ArrayList 내부적으로 배열 사용, 순서대로 
		List list1 = new ArrayList();
		
		//add() 메서드를 이용하여 데이터 추가
		list1.add("aaa");
		list1.add("bbb");
		//list1.add(new Integer(111)) ==list1.add(111) 
		list1.add(111);
		list1.add('k');
		list1.add(true);
		list1.add(12.34);
		
		//size() = > 데이터 개수
		System.out.println("size =>" + list1.size());
		System.out.println("list1 =>" + list1);
		System.out.println();
		
		//get() 이용하여 데이터 가져오기
		System.out.println("1번째 자료 :" + list1.get(0));
		
		//데이터 끼워넣기(인덱스값,값)
		list1.add(0,"zzz");
		System.out.println("zzz 추가후   list1 => "+ list1);
		System.out.println();
		
		//데이터 변경하기(인덱스값, 값)
		String temp = (String) list1.set(0, "yyy"); // 변경 시 변경되기 전의 값이 temp에 담김
		System.out.println("temp => "+ temp);
		System.out.println("list1 => " + list1);
		System.out.println();
		
		//데이터 삭제하기
		list1.remove(0);//인덱스값
		System.out.println("첫번째 데이터 삭제 후 =>"+list1);
		
		list1.remove("bbb");//값
		System.out.println("bbb삭제후 =>" + list1);
		System.out.println();
		
		list1.remove(new Integer (111));//int 타입 값을 삭제 하고 싶은경우 new Integer(int 값) 적어야함
		System.out.println("111 삭제 :"+list1.remove(new Integer (111)));
		System.out.println("list1 => " + list1);
		System.out.println();
	}
}

 

결과 화면1

 

 

package kr.or.ddit.basic;

import java.util.ArrayList;
import java.util.List;

public class T01ArrayListTest {
	public static void main(String[] args) {
		//제너릭 이용하여 선언하기 :리스트안에 타입을 한정 지움
		List<String> list2 = new ArrayList<String>();
		list2.add("AAA");
		list2.add("BBB");
		list2.add("CCC");
		list2.add("DDD");
		list2.add("EEE");
		
		System.out.println("list2 => " + list2);
		System.out.println();
		
		//cotains(비교객체) => 리스트에 '비교객체'가 있으면 true, 없으면 false 반환됨.
		System.out.println("DDD가 존재하는지 => " + list2.contains("DDD"));
		System.out.println("ZZZ가 존재하는지 => " + list2.contains("ZZZ"));
		
		//indexOf(비교객체) => 리스트에서 '비교객체'가 존재하는 index 정보를 반환함. 존재하지않으면 -1 반환됨
		System.out.println("DDD의 index 값 : " + list2.indexOf("DDD"));
		System.out.println("ZZZ의 index 값 : " + list2.indexOf("ZZZ"));
		System.out.println("-----------------------------------------------\n");
		
		System.out.println(list2);
		System.out.println(list2.size()); 
		System.out.println();
		// ArrayList 삭제 처리에 대하여...
		for (int i = 0; i < list2.size(); i++) {
			list2.remove(i);
			System.out.println("i :" + i);
		}
		System.out.println("삭제후 List2 => " + list2);
		
	}
	//stack  L(ast)I(n)F(irst)O(ut)
	//Queue F(irst) i(n) F(irst) O(ut) ex) 은행 대기줄
}

 

결과 화면2

 

 

 

LinkedList

 

: 각 노드가 '데이터'와 '포인터'를 가지고 한 줄로 연결되어 잇는 방식으로 저장하는 자료구조

 

- 종류

Stack : 후입선출(LIFO)의 자료구조

Queue : 선입선출(FIFO)의 자료구조

 

 

  • Stack
사용법 뜻
push(저장할 값) 데이터 추가
pop() 데이터 가져오기
데이터를 꺼내온 후 해당 데이터를 삭제함

 

package kr.or.ddit.basic;

import java.util.LinkedList;

public class T02LinkedListTest {

	public static void main(String[] args) {
		/*
		 *  Stack => 후입선출(LIFO)의 자료구조
		 *  Queue => 선입선출(FIFO)의 자료구조
		 */
		
		LinkedList<String> stack = new LinkedList<String>();
		
		/*
		 * stack 방식으로 처리하기 위한 메서드
		 * 1) 데이터 추가 : push (저장할 값)
		 * 2) 데이터 꺼내기 : pop() => 데이터를 꺼내온 후 해당 데이터를 삭제한다.
		 */
		stack.push("홍길동");
		stack.push("일지매");
		stack.push("변학도");
		stack.push("강김찬");
		System.out.println("현재 stack 값들 : " + stack);//현재 stack 값들 : [강김찬, 변학도, 일지매, 홍길동]
		
		String data = stack.pop();
		System.out.println("꺼내온 데이터 :" + data);//꺼내온 데이터 :강김찬
		System.out.println("꺼내온 데이터 : " + stack.pop());//꺼내온 데이너 : 변학도
		System.out.println("현재 stack 값들 : " + stack);
		
		stack.push("성춘향");
		System.out.println("현재 stack 값들 :" + stack);
		System.out.println("꺼내온 데이터" + stack.pop());
		
		System.out.println("==========================================");
		System.out.println();
	}
}

 

결과 화면3

 

 

  • Queue
사용법 뜻
offer(저장할 값) 데이터 추가
poll() 데이터 가져오기
데이터를 꺼내온 후 해당 데이터를 삭제함

 

package kr.or.ddit.basic;

import java.util.LinkedList;

public class T02LinkedListTest {

	public static void main(String[] args) {
		/*
		 *  Stack => 후입선출(LIFO)의 자료구조
		 *  Queue => 선입선출(FIFO)의 자료구조
		 */
		
		LinkedList<String> queue = new LinkedList<String>();
		/*
		 * Queue 방식으로 동작하게 하기 위한 메서드
		 * 1) 데이터 추가 : offer(저장할 값)
		 * 2) 데이터 꺼내기 : poll() => 데이터를 꺼내온 후 데이터는 삭제된다.
		 */
		
		queue.offer("홍길동");
		queue.offer("일지매");
		queue.offer("변학도");
		queue.offer("강김찬");
		
		System.out.println("현재 queue 값들 : "+ queue);
		
		String temp = queue.poll();
		System.out.println("꺼내온 데이터" + temp);
		System.out.println("꺼내온 데이터 : "+ queue.poll());
		System.out.println("현재 queue 값들 : "+queue);
		
		if(queue.offer("성춘향")) {
			System.out.println("신규등록 데이터 : 성춘향");
		}
		System.out.println("현재 queue 값들 :"+ queue);
		System.out.println("꺼내온 데이터 : "+ queue.poll());
	}
}

 

결과 화면4

 

 

 

인스턴스 메소드

 

: static 메소드가 아닌 메소드

 

class Car {
    boolean door;                       // 인스턴스 변수
    void openDoor() {                   // 인스턴스 메소드
        door = true;
    }

    static void toggleDoor(boolean d) { // 클래스 메소드
        return !d;
    }
}

 

 

 

ListSort

 

 

  • 데이터 섞기
사용법 뜻
Collections.sort() String 타입 오름차순으로 정렬
Collections.shuffle() 데이터 섞기
T1.compareTo( T2 ) 두개(T1, T2)의 값을 비교하여 int 값으로 반환 (T1은 객체여야 함)
compare( T1, T2 )
 T1과 T2를 비교하여 T1이 크면 1, T1이 작으면 -1를 반환
implements Comparator<String> 외부에 별도로 정렬 기준을 구현하고 싶을 때 사용

 

package kr.or.ddit.basic;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class T03LIstSortTest {
	//인스턴스 메소드
	//인스턴스(객체) 만들고 메소드 호출이 가능
	//장점 : 인스턴스 별로 기능 만들수 있음
	
	//Interface Comparable<T> : String 포함
	//Compare(T,T)

	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		
		list.add("일지매");
		list.add("홍길동");
		list.add("성춘향");
		list.add("변학도");
		list.add("이순신");
		
		System.out.println("정렬 전 :" + list);
		
		/*
		 * 클래스 메서드 , static 메서드 : 객체 생성 없이 호출 가능 , 주로 유틸기능 사용
		 * 정렬은 Collections.sort() 메서드를 이용하여 정렬한다.
		 * 정렬은 기본적으로 '오름차순'정렬을 수행한다.
		 */
		
		Collections.sort(list); //오름차순으로 정렬하기
		System.out.println("정렬 후 :" + list);
		
		Collections.shuffle(list);//섞기 처리
		
		System.out.println("섞기 후 :" + list);
		
		Collections.sort(list, new Desc());
		//Desc 객체 생성
		
		System.out.println("외부정렬자를 이용한 정렬 후 :" + list);
	}
}

// Comparator는 외부에 별도로 정렬 기준을 구현하고 싶을 때 사용
class Desc implements Comparator<String>{ //나만의 방식으로 하고 싶을때

	@Override//comparable 타입이면 override 반드시 있어야한다.
	public int compare(String str1, String str2) {
		/*
		 * compare() 메서드의 반환값을 결정하는 방법
		 * 
		 * -오름차순 정렬일 경우...
		 * => 앞의 값이 크면 양수, 값틍면 0, 뒤의 값이 크면 음수를 반환하도록 구현한다.
		 */
		return str1.compareTo(str2) *-1;//str1, str2 비교 내림차순을 하고 싶으면 *-1 해아함
	}
	
}

 

결과 화면5

 

 

package kr.or.ddit.basic;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class T04ListSortTest {
	public static void main(String[] args) {
		List<Member> memList = new ArrayList<Member>();
		memList.add(new Member(1, "홍길동","010-1111-1111"));
		memList.add(new Member(5, "변학도","010-2222-1111"));
		memList.add(new Member(9, "성충향","010-3333-1111"));
		memList.add(new Member(3, "이순신","010-4444-1111"));
		memList.add(new Member(6, "강감찬","010-5555-1111"));
		memList.add(new Member(2, "일지매","010-5555-1111"));
		
		System.out.println("정렬전 :");
		for (Member m : memList) {
			System.out.println(m);
		}
		System.out.println("--------------------------------------------");
		
		Collections.sort(memList);// 정렬하기
		
		System.out.println("회원이름 오름차순 정렬 후: :");
		for (Member m : memList) {
			System.out.println(m);
		}
		
		Collections.shuffle(memList);//회원정보 섞기
		System.out.println("섞은 후: :");
		for (Member m : memList) {
			System.out.println(m);
		}
		
		Collections.sort(memList, new SortNumDesc());
		System.out.println("회원번호 내림차순 정렬 후: :");
		for (Member m : memList) {
			System.out.println(m);
		}
		
		
	}

}

//회원번호의 내림차순으로 정렬되도록 외부정렬자 클래스 구현
class SortNumDesc implements Comparator<Member>{

	@Override
	public int compare(Member mem1, Member mem2) {
		//방법1
		if(mem1.getNum() > mem2.getNum()) {
			return -1;//내림차순
		} else if(mem1.getNum() == mem2.getNum()) {
			return 0;
		} else {
			return 1;
		}
	
		//방법2
		//return new Integer(mem1.getNum()).compareTo(mem2.getNum()) * -1; //내림차순으로 하기 위해서 *-1 해줌

		//방법3
//		return Integer.compare(mem1.getNum(), mem2.getNum()) * -1;
	}
	
}



//회원이름을 기준으로 오름차순 정렬이 되도록 구현하기
class Member implements Comparable<Member> { //Vo
	private  int num; 
	private  String name; 
	private  String tel;
	
	//생성자 생성
	public Member(int num, String name, String tel) {
		super();
		this.num = num;
		this.name = name;
		this.tel = tel;
	}
	//getter setter
	public int getNum() {
		return num;
	}

	public void setNum(int num) {
		this.num = num;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getTel() {
		return tel;
	}

	public void setTel(String tel) {
		this.tel = tel;
	}
	
	//toString
	@Override
	public String toString() {
		return "Member [num=" + num + ", name=" + name + ", tel=" + tel + "]";
	}
	@Override //정렬을 적절하게 해줌
	public int compareTo(Member mem) {//파라미터 하나만 있음 /나 자신이랑 비교해서
		
		return this.getName().compareTo(mem.getName());
	} 
}

 

결과 화면6

 

 

 

TIP

 

  • extends와 implements 차이
extends implements
상속
하나만 상속 다중 상속 가능
오버라이딩 (즉 부모의 메소드를 그대로 사용) 할 필요 없음 반드시 오버라이딩(재정의) 해야함

 

 

반응형

'자바' 카테고리의 다른 글

[Java 고급] 2장 Hash Set, Tree Set  (1) 2024.01.27
[Java 고급] 1.5장 Test  (0) 2024.01.27
[Java 초급] 28장 MVC 패턴6 : 영화 예매  (0) 2024.01.10
[Java 초급] 27장 MVC 패턴5 : 게시판2  (0) 2024.01.09
[Java 초급] 26장 MVC 패턴4 : 도서 대여 시스템  (1) 2024.01.08

티스토리툴바