T01~ T04 24.1.20 List&Link

T01 ArrayList

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);
		
		//get() 이용하여 데이터 가져오기
		System.out.println("1번째 자료 :" + list1.get(0));
		
		//데이터 끼워넣기(인덱스값,값)
		list1.add(0,"zzz");
		System.out.println("zzz 추가후 ... list1 => "+ list1);
		
		//데이터 변경하기(인덱스값, 값)
		String temp = (String) list1.set(0, "yyy");
		System.out.println("temp => "+ temp);
		System.out.println("list1 => " + list1);
		
		//데이터 삭제하기
		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)));
		
		//제너릭 이용하여 선언하기 :리스트안에 타입을 한정 지움
		List<String> list2 = new ArrayList<String>();
		list2.add("AAA");
		list2.add("BBB");
		list2.add("CCC");
		list2.add("DDD");
		list2.add("EEE");
		
		//cotains(비교객체) => 리스트에 '비교객체'가 있으면 true, 없으면 false 반환됨.
		System.out.println(list2.contains("DDD"));
		System.out.println(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("-----------------------------------------------");
		
		System.out.println(list2);
		// ArrayList 삭제 처리에 대하여...
		for (int i = 0; i < list2.size(); i++) {
			list2.remove(i);
			System.out.println("i :" + i);
		}
		System.out.println("삭제후 List2 => " + list2);
		
	}

 

T02 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();
		
		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());
	
	}

}

 

 

T03 ListSort

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

	}

}


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 해아함
	}
	
}

 

 

T04ListSort

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());
	} 
	
}