[즐거운자바] #8

by

54. 제네릭과 컬렉션 프레임

public class ObjectBox {
	private Object object;
    
    public void set(Object obj) {
    	this.object = obj;
    }
    
    public Object get() {
    	return this.object;
    }
}
public class ObjectBoxMain {
	public static void mian(String() args) {
    	ObjectBox box = new ObjectBox;
        
        box.set("kim");
        String str = (String)box.get();
        System.out.println(str.toUpperCase()); // KIM 출력 
        
        box.set(new Integer(5));
        Integer i = (Integer)box.get();
        System.out.println(i.intValue());
    }
}

//object 타입을 가질수 있기 때문에 object 후손들을 넣었다가 꺼낼수 있다.

 단, 꺼낼때 원래 type으로 바꿔줘야 한다.

ObjectBox는 모든 개체를 저장하고 모든 개체를 검색할 수 있습니다.

꺼내어 사용할 때 원래의 형태로 변환하는 번거로운 과정이 필요하다.

GenericBox

public class GenericBox<T> {
	private T t;
    
    public void set(T obj) {
    	this.t = obj;
    }
    
    public T get() {
    	return this.t;
    }
}

불확정 T 유형 수신

'추천 관련글, 
public class GenericBoxMain {
    public static void main(String() args) {
        GenericBox<String> genericBox = new GenericBox<>();

        genericBox.set("kim");
        String str = genericBox.get();
        System.out.println(str.toUpperCase());

        GenericBox<Integer> intBox = new GenericBox<>();

        intBox.set(new Integer(5));
        Integer intValue = intBox.get();
        System.out.println(intValue);

        GenericBox<String> objBox = new GenericBox<>();

        objBox.set("hello");
        String str2 = (String)objBox.get();
        System.out.println(str);
    }
}

GenericBox

T는 제네릭과 관련된 부분입니다.

제네릭은 클래스 이름 뒤나 메서드의 반환 유형 앞에 놓일 수 있습니다.

부분 T라는 일반 유형을 선언하는 것을 의미합니다.

T는 type의 약자이기 때문에 일반적으로 사용되는 문자이지만 반드시 T를 사용할 필요는 없습니다.

T 대신 E 또는 D와 같은 단어를 사용할 수도 있습니다.

제네릭 의약품의 이점

특정 유형만 사용하도록 강제할 수 있습니다.

유형 강제는 잘못된 유형의 값이 컴파일 타임에 저장되는 것을 방지합니다.

컬렉션 프레임

Java Collections Framework라고 하는 Collection API는 Java 2에서 추가된 데이터 구조 클래스 패키지를 말합니다.

데이터를 다루기 위한 필수적인 클래스들의 모음으로 JAVA 프로그래머들은 그것들에 익숙해야 합니다.


반복자: 모든 것을 가져오는 것을 나타내는 인터페이스

수집: 모든 것을 얻기 위해 반복자에 의존

목록: 객체를 저장하기 위한 인터페이스, 순서를 기억하기 위한 인터페이스.

집합: 중복을 허용하지 않고 동일한 데이터의 한 요소만 기억하는 데이터 구조입니다.

Map : 키와 값으로 구성된 데이터 구조, 저장시 push(key, vaule)로 저장

java.uitl.Collection 인터페이스

컬렉션 프레임워크에서 가장 기본적인 인터페이스입니다.

이 인터페이스는 주문을 저장하지 않고 중복을 허용하여 데이터를 처리하기 위해 만들어졌습니다.

java.uitl.List 인터페이스

이 인터페이스는 순서가 중요한 데이터를 다룰 때 사용됩니다.

Collection에서 상속하면 add(), size() 및 iterator() 메서드를 사용할 수 있습니다.

인터페이스는 순서가 알려져 있다고 가정하기 때문에 특정 순서로 저장된 데이터를 검색할 수 있는 get(int) 메서드가 있습니다.

java.uitl.Set 인터페이스

이 인터페이스는 중복되지 않은 데이터를 처리할 때 사용됩니다.

중복 금지는 동일한 값을 저장할 수 없음을 의미합니다.

즉, 동일한 값을 여러 번 추가해도 마지막 값만 저장됩니다.

Set 인터페이스에 저장된 객체는 Object의 equals() 및 hashCode() 메서드를 재정의해야 합니다.

java.uitl.Iterator 인터페이스

데이터 구조에서 문자를 추출하는 데 사용되는 인터페이스입니다.

Iterator 패턴을 구현합니다.

java.uitl.Map 인터페이스

키와 값을 함께 저장하기 위해 만든 인터페이스입니다.

동일한 키 값으로 하나의 값만 저장할 수 있습니다.

제네릭을 사용하지 않고 ArrayList 사용 

import java.util.ArrayList;

public class ListExam01 {
	public static void main(String() args) {
    	//자료구조 객체들은 제네릭을 사용하지 않으면 Object 타입을 저장한다.

 
        
        ArrayList list = new ArrayList();
        list.add("kim");
        list.add("lee");
        list.add("hong");
        
        String str1 = (String)list.get(0);
        String str2 = (String)list.get(1);
        String str3 = (String)list.get(2);
        
        System.out.println(srt1);
        System.out.println(srt2);
        System.out.println(srt3);
    }
}

제네릭과 함께 ArrayList 사용 

import java.util.ArrayList;

public class ListExam02 {
	public static void main(String() args) {        
        ArrayList<String> list = new ArrayList<>();
        list.add("kim");
        list.add("lee");
        list.add("hong");
        
        String str1 = list.get(0);
        String str2 = list.get(1);
        String str3 = list.get(2);
        
        System.out.println(srt1);
        System.out.println(srt2);
        System.out.println(srt3);
    }
}

컬렉션 반복자(&I)

import java.util.ArrayList;
import java.util.Colleciton;
import java.util.Iterator;

public class ListExam03 {
    public static void main(String() args) {        
        Collection<String> collection = new ArrayList<>();
        collection.add("kim");
        collection.add("lee");
        collection.add("hong");

        System.out.println(collection.size());

        Iterator<String> iter = collection.iterator();
        whiel (iter.hasNext()) {
            String str = iter.next();
            System.out.println(str);
        }
    }
}

목록

import java.util.ArrayList;

public class ListExam02 {
	public static void main(String() args) {
    	// 앞에는 인터페이스 타입 뒤에는 인터페이스를 구현하고 있는 인스턴스로 작성!
 
        List<String> list = new ArrayList<>();
        list.add("kim");
        list.add("lee");
        list.add("hong");
        
        String str1 = list.get(0);
        String str2 = list.get(1);
        String str3 = list.get(2);
        
        System.out.println(srt1);
        System.out.println(srt2);
        System.out.println(srt3);
    }
}

인터페이스를 사용하여 프로그램 작성 -> 참조 유형을 인터페이스로 사용하십시오.

클래스를 사용할 때 인터페이스를 사용하는 것이 객체지향적입니다.

프로그램을 만들 때 먼저 인터페이스 선언!

문장

import java.util.*

public class SetExam {
    public static void main(String() args) {        
        Set<String> set = new HashSet<>();
        set.add("hello");
        set.add("hi");
        set.add("hong");

        Iterator<String> iter = set.iterator();
        
        whiel (iter.hasNext()) {
            String str = iter.next();
            System.out.println(str);
        }
    }
}
import java.util.*

public class SetExam2 {
    public static void main(String() args) {
    	Set<MyData> mySet = new HashSet<>;
        
        mySet.add(new MyData("kim", 500));
        mySet.add(new MyData("lee", 200));
        mySet.add(new MyData("hong", 700));
        
        Iterator<MyData> iter = mySet.iterator();
        whiel (iter.hasNext()) {
            NySet mySet = iter.next();
            System.out.println(mySet);
        }
    }
}

class MyData {
	private String name; 
    private int value;
    
    pulbic MyData(String name, int value) {
    	this.name = name;
        this.value = value;
    }
    
    public String getName() {
    	return name;
    }
    
    public int getValue() {
    	return value;
    }
    
    @Override
    pulbic boolean equals(Object o) {
    	if (this == o) return treu;
        if (o == null || getClass() !
= o.getClass()) return false;
        MyData myData = (MyData) o;
        return value == myData.value && Objects.equals(name, myData.name);
    }
    
    @Override
    public int hashCode() {
    	return Objects.hash(name, value);
    }
    
    @Override
    public String toString() {
    	return "MyData{" + 
        		"name="" + name + "\'' +
                ", value = " + value +
                '}';
    }
}

**hash라는 알고리즘이 나타나면 개체의 hashCode 및 equals 메서드를 재정의해야 합니다.

지도

import java.util.Map;

public class MapExam {
	public static void main (String() args) {
    	Map<String, String> map = new Map<>():
        
        map.put("k1", "hello");
        map.put("k2", "hi");
        map.put("k3", "안녕");
        
        System.put.println(map.get("k1"));
        System.put.println(map.get("k2"));
        System.put.println(map.get("k3"));
    }
}

맵의 키도 고유한 값을 가져야 하므로 해시 알고리즘을 사용하여 키를 저장합니다.

hashCode를 동일하게 구현해야 합니다.

키 값이 같으면 기존 키 값을 덮어씁니다.

import java.util.Map;

public class MapExam2 {
	public static void main (String() args) {
    	Map<String, String> map = new Map<>():
        
        map.put("k1", "hello");
        map.put("k2", "hi");
        map.put("k3", "안녕");
        
        set<String> keySet = map.keySet();
        Iterator<String> iterator = keySet.iterator();
        while(interator.hashNext()) {
        	String key = interator.next();
            String value = map.get(key)        
	        System.put.println(key + ":" + value);
        }
    }
}

모든 키가 캡처될 때 데이터 구조 설정

반복자를 사용하여 데이터 집합에서 모든 것을 가져옵니다.

지도에서 값을 검색하려면 키를 사용하여 값을 검색합니다.

정렬 

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

public class SortExam {
	public static void main (String() args) {
    	List<String> list = new ArrayList<>():
        
        liist.add("kim");
        liist.add("lee");
        liist.add("hong");
        
        Collections.sort(list);
        
        for (int i = 0; i < list.size(); i++) {
        	System.out.println(list.get(i));
        }
    }
}