41일차 java 연산(2023-02-20)

Generic : 타입을 컴파일 시점에 결정

[Eclipse 연습]

[계산]
package Generic;
class Person2<T, K> {
	T name;
	K age;

	public void set(T name, K age) {
		this.name = name;
		this.age = age;
	}

	@Override
	public String toString() {
		return "출력: " + name + " " + age + "세 입니다.";
	}
}

public class Test2 {
	public static void main(String[] args) {
		Person2<String, Integer> p = new Person2<String, Integer>();
		p.set("홍길동", 25);
		System.out.println(p); // 출력 : 홍길동 25 세 입니다.
	}
}

[결과값]
출력: 홍길동 25세 입니다.

---

[계산]
package Generic;
class Apple2 {
	public String toString() {
		return "이것은 사과 입니다";
	}
}

class Orange2 {
	public String toString() {
		return "이것은 오렌지 입니다";
	}
}

class Box2<\T> {
  public T o;
  public void set(T o) {
  this.o = o;
  }

	public T get() {
		return o;
	}
}
public class Test3 {
	public static void main(String[] args) {
		Box2<\Apple2> aBox = new Box2<\Apple2>(); // T를 Apple로 결정
		Box2<\Orange2> oBox = new Box2<\Orange2>(); // T를 Orange로 결정

		aBox.set(new Apple2()); // 사과를 상자에 담는다.
		oBox.set(new Orange2()); // 오렌지를 상자에 담는다.

		Apple2 ap = aBox.get(); // 사과를 꺼내는데 형 변환 하지 않는다.
		Orange2 og = oBox.get(); // 오렌지를 꺼내는데 형 변환 하지 않는다.

		System.out.println(ap); // 출력 : 이것은 사과 입니다.
		System.out.println(og); // 출력 : 이것은 오렌지 입니다.
	}
}

[결과값]
이것은 사과 입니다
이것은 오렌지 입니다

---

[컬렉션 프레임워크]

컬렉션 프레임워크 : 데이터를 좀 더 손쉽게 다룰 수 있게 만들어준 객체
자료구조 및 알고리즘을 구현해 놓은 일종의 라이브러리! 제네릭 기반으로 구현이 되어 있다.
구현하는 인터페이스에 따라 사용방법과 특성이 결정된다.
컬렉션 프레임워크의 골격에 해당하는 인터페이스들 : 셋리큐맵
・Set<E>
・List<E>
・Queue<E>
・Map<K, V>

[List<\E>]

순서가 있는 데이터의 집합으로 데이터의 중복을 허용한다.
・ArrayList<E>(조회 많이하면) : 배열 기반 자료구조, 배열을 이용하여 인스턴스 저장
유리한 작업 :

[ArrayList<E>의 단점]
・저장 공간을 늘리는 과정에서 시간이 비교적 많이 소요된다.
・인스턴스의 삭제 과정에서 많은 연산이 필요할 수 있다. 따라서 느릴 수 있다.

[ArrayList<E>의 장점]
・저장된 인스턴스의 참조가 빠르다.
→배열 형식이기에 1004번지를 찾고 싶으면 1000번지에서 1004번지까지 멈추지 않고 찾는다.

・LinkedList<E>(수정 많이하면) : 리스트 기반 자료구조, 리스트를 구성하여 인스턴스 저장(링크 연결)
유리한 작업 : 입력과 삭제가 빈번한 작업 insert(추가), delete(참조끊기)

[LinkedList<E>의 단점]
・저장된 인스턴스의 참조 과정이 배열에 비해 복잡하다. 따라서 느릴 수 있다.

[LinkedList<E>의 장점]
・저장 공간을 늘리는 과정이 간단하다.
・저장된 인스턴스의 삭제 과정이 단순하다.

[ArrayList]

[ArrayList<\E> 계산]
// 배열처럼 크기를 지정하지 않아도 자동으로 추가 됨.
// 검증되어 있는 객체
// 배열 기반 자료구조이지만 공간의 확보 및 확장은 ArrayList 인스턴스가 스스로 처리한다.
package CollectionF;

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

public class ArrayListTest {
	public static void main(String[] args) {
		List<\String> list = new ArrayList<>(); // 컬렉션 인스턴스 생성

// 컬렉션 인스턴스에 문자열 인스턴스 저장
		list.add("Toy");
		list.add("Box");
		list.add("Robot");

		// 저장된 문자열 인스턴스의 참조
		for (int i = 0; i < list.size(); i++)
			System.out.print(list.get(i) + '\t');
		System.out.println();

		list.remove(0); // 첫 번째 인스턴스 삭제

// 첫 번째 인스턴스 삭제 후 나머지 인스턴스들을 참조
		for (int i = 0; i < list.size(); i++)
			System.out.print(list.get(i) + '\t');
		System.out.println();
	}
}

[결과값]
Toy	Box	Robot	
Box	Robot

---

[LinkedList]

[LinkedList<\E> 계산]
package CollectionF;

import java.util.LinkedList;
import java.util.List;

public class LinkedListTest {
	public static void main(String[] args) {
		List<\String> list = new LinkedList<>(); // 컬렉션 인스턴스 생성

//컬렉션 인스턴스에 문자열 인스턴스 저장
		list.add("Toy");
		list.add("Box");
		list.add("Robot");

		// 저장된 문자열 인스턴스의 참조
		for (int i = 0; i < list.size(); i++) // list.size() = 3
			System.out.print(list.get(i) + '\t'); // list.get(0) = Toy | list.get(1) = Box
		System.out.println();

		list.remove(0); // 첫 번째 인스턴스 삭제

//첫 번째 인스턴스 삭제 후 나머지 인스턴스들을 참조
		for (int i = 0; i < list.size(); i++)
			System.out.print(list.get(i) + '\t');
		System.out.println();
	}
}

[결과값]
Toy	Box	Robot	
Box	Robot

---

[LinkedList<\E> 계산]
public class LinkedListTest {
	public static void main(String[] args) {

		TestLinkedList l1 = new TestLinkedList();
		l1.num = 1;

		TestLinkedList l2 = new TestLinkedList();
		l2.num = 2;

		l1.linked = l2;

---

[iterator : 반복자]

Toy	Box	Robot

list 객체에서 list.iterator(); itr.hasNext();를 하면
Toy로 화살표를 옮기고, 다음 사용할 수 있는 토큰이 더 있으면 다음 토큰을 불러와서 화살표를 옆으로 옮긴다.(Box)

[iterator 계산]
package CollectionF;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class IteratorTest {
	public static void main(String[] args) {
		List<String> list = new LinkedList<>();

		list.add("Toy");
		list.add("Box");
		list.add("Robot");

		for (int i = 0; i < list.size(); i++)
			System.out.print(list.get(i) + '\t');
		System.out.println();

		for (String word : list)
			System.out.print(word + '\t');
		System.out.println();

		for (Iterator<String> itr = list.iterator(); itr.hasNext();)
			System.out.print(itr.next() + '\t');
		System.out.println();

// Iterator<String> itr = list.iterator(); // 반복자 획득, itr이 지팡이를 참조한다.
// 반복자를 이용한 순차적 참조
//		while (itr.hasNext()) { // next 메소드가 반환할 대상이 있다면,
//			str = itr.next(); // next 메소드를 호출한다.
//		}
	}
}

[결과값]
Toy	Box	Robot	
Toy	Box	Robot	
Toy	Box	Robot	

---