Generics (제너릭)
제너릭스는 JDK 1.5 에서의 가장 큰 변화 중 하나로 다양한 타입의 객체를 다루는 메소드나, 컬랙션 클래스에 컴파일시의 Type check 를 해주는 기능이다.
객체의 타입을 컴파일시에 해주기 때문에 객체의 타입 안정성을 높이고 형변환의 번거로움이 줄어든다.
ArrayList와 같은 컬렉션 클래스는 다양한 종류의 객체를 담을 수 있긴하지만 보통 한 종류의 객체를 담는 경우가 많다.
그런데도 꺼낼때마다 타입을 체크하고 형변환 하는 것은 불편하다.
제너릭스는
1. 타입의 안정성을 제공한다.
2. 타입 체크와 형변환을 생략할 수 있음으로 코드가 간결해진다.
자바에서 제너릭이란 데이터 타입을 일반화한다(generalize)는 것을 의미한다.
제너릭은 클래스나 메소드에서 사용할 내부 데이터 타입을 컴파일시에 미리 지정하는 방법이다.
이렇게 컴파일시에 미리 타입검사(type check)를 수행하면 다음과 같은 장점을 가진다.
1.클래스나 메소드 내부에서 사용되는 객체의 타입 안정성을 높일 수 있다.
2. 반환값에 대한 타입변환 및 타입 검사에 들어가는 노력을 줄일 수 있다.
JDK 1.5 이전에서는 여러 타입을 사용하는 대부분의 클래스나 메소드에서 인수나 반환값으로 Object 타입을 사용했다.
하지만 이경우에는 반환된 Object 객체를 다시 원하는 타입으로 타입변환 해야하며,
이때 오류가 발생할 가능성도 존재한다.
하지만 JDK 1.5부터 도입된 제네릭을 사용하면 컴파일 시에 미리 타입이 정해지므로,
타입검사나 타입변환과 같은 번거로운 작업을 생략할 수 있게 된다.
- 제너릭의 제거 시기 -
자바코드에서 선언되고 자용된 제네릭 타입은 컴파일시 컴파일러에 의해 자동으로 검사되어 타입변환된다.
그리고나서 코드내의 모든 제너릭 타입은 제거되어, 컴파일된 class 파일에는 어떠한 제너릭 타입도 포함되지 않게 된다.
이런식으로 동작하는 이유는 제네릭을 사용하지 않는 코드와의 호환성을 유지하기 위해서 이다.
제네릭은 다룰 객체 타입을 미리 명시해 줌으로써 형변환 하지 않아도 되게하는 것이다.
제네릭은 참조형타입(reference type), 간단히 말해서 Type을 의미하는 T를 사용한다.
어떠한 참조형 타입도 가능하다는 뜻이다.
뿐만아니라 요소를 의미하는 'E' = element, 'K' = key , 'V' = value도 사용된다.
이들은 기호의 종류만 다를 뿐 '임의의 참조형 타입'을 의미한다는 것은 모두 같다.
기존의 다양한 종류의 타입을 다루는 메소드의 매개변수나 리턴타입으로 object타입의 참조변수를 많이 사용했고
그로인해 형변환이 불가피했지만 이젠 object 타입 대신 원하는 타입을 지정하기만 하면 된다.
제너릭은 클래스 내부에서 지정하는 것이 아닌 외부에서 사용자에 의해 지정되는 것을 의미한다.
한마디로 특정(Specific) 타입을 미리 지정해주는 것이 아닌 필요에 의해 지정할 수 있도록 하는
일반(Generic) 타입이라는것이다.
형식
< >
Collection(컬렉션)
자바에서는 많은 수의 다양한 페키지(Java API)를 제공하여 개발자들이 자바 어플리케이션을 쉽게 개발할 수 있도록 도와준다.
Collection Framework( 컬렉션 프레임워크)
: 다수의 데이터를 쉽게 처리할 수 있는 표준화된 방법을 제공하는 클레스
형식화 클레스
: 데이터를 표준화된 형식으로 출력하는데 도움을 주는 클레스
: 컬렉션 프레임 워크란 데이터 군을 저장하는(Vector와 같은) 클래스들을 표준화한 설계를 뜻한다.
Collection은 다수의 데이터 즉 데이터 그룹을, Framework은 표준화된 프로그래밍 방식을 의미한다.
Java API 문서에서는 컬렉션 프레임웍을 데이터 군을 다루고 표현하기 위한 단일화 된 구조라고 정의하고 있다.
자바에서 컬렉션프래임워크란 다수의 데이터를 쉽고 효과적으로 처리할 수 있는
표준화된 방법을 제공하는 클래스의 집합을 의미한다.
즉, 데이터를 저장하는 자료구조와 데이터를 처리하는 알고르짐을 구조화하여 클래스로 구현해 놓은 것이다.
이러한 컬랙선 프래임워크는 자바의 인터페이스를 사용하여 구현된다.
컬렉션 프레임웍의 핵심 인터페이스
Collection
| | Map
List Set
:List 와 Set을 구현한 컬렉션 클래스들은 서로 공통점이 많아 공통된 부분을 다시 뽑아 Collection인터페이스를 정의할 수 있었지만 Map 인터페이스는 이들과는 전혀 다른 형태로 컬렉션(데이터군)을 다루기 때문에 같은 상속 계층도에 포함되지 못하였다.
| 인터페이스 | 특징 |
| List | 순서가 있는 데이터의 집합, 데이터 중복을 허용한다. (예) 대기자 명단 클래스 >> ArrayList, LinkedList, Stack, Vector ... |
| Set | 순서가 없는 데이터의 집합, 데이터의 중복을 허용하지 않는다. (예) 양의 정수의 집합, 소수의 집합 클래스>> HashSet, TreeSet |
| Map | Key와 Value의 쌍(Pair)으로 이루어진 데이터의 집합 순서는 유지되지 않으며, 키는 중복을 허용하지 않고 값은 중복을 허용한다. (예) 우편번호, 지역번호(전화번호) 클래스 >> HashMap, TreeMap, HashTable, Properties |
Vector와 ArrayList
: Vector 와 ArrayList 는 컬렉션 프레임웍에서 가장 많이 사용되는 컬랙션 클래스 이다.
이들은 List 인터페이스를 구현하기 때문에 데이터의 저장순서가 유지되고 중복을 허용한다는 공통적인 특징을 갖는다.
ArrayList는 기존의 Vector를 개선한 것으로 Vector와 구현원리와 기능적인 측면에서 동일하다고 할 수 있다.
| 공통점 | 차이점 |
| List인터페이스를 구현한다. 저장 순서가 유지되고 중복을 허용한다. 데이터의 저장공간으로 배열을 사용한다. |
Vector는 멀티스레드에 대한 동기화가 되어있지만 ArrayList는 되어있지 않다. |
🟢 Vector
문법들
| v.setSize(i) | size를 i로 조정함. 만약 i보다 사이즈가 컷다면 뒤의 값을 절삭 |
| v.trimToSize | 공백제거, size에 맞게 용량을 줄여줌 |
| Enumeration enu = vv.elements(); while (enu.hasMoreElements()) { System.out.println(enu.nextElement() + " "); } |
벡터속에 있는 값을 뽑아오는 방법 |
| v.add("자바"); / v.addElement( new Double(1.23)); | v에 값 추가하는법 |
| v.removeElement(i) | v의 값을 지우는 방법i번째 인덱스 값을 지움 |
| v.removeElement(v.lastIndexof("t")) | 인덱스번호 뒤에서부터 찾아서 t라는 애를 찾아서 지우겠다 |
| v.size | v안에 몇개의 값이 들어있는지를 알려줌 |
| v.capacity() | v의 용량을 반환함 |
| v.removeAllElements(); | 모든객체 제거, 빈공간이된다. |
| Vector v = new Vector(3,5) | 기본용량은 3인 v가 생성되고 용량이 커질때한번에 5씩커짐 |
package ja_0727;
import java.util.Vector;
public class Vector_1 {
public static void main(String[] args) {
Vector<String> vv = new Vector<String>(5); // capacity가 5인vector
// <String> : String 타입만 받겠다고 허용하는것
// 원래는 모든 타입을 받을 수 있는데 제너릭을 통해 String타입으로 한정한것
vv.add("1");
vv.add("2");
vv.add("3");
vv.add("4");
vv.add("5");
vv.add("6");// 자동으로 공간이 늘어남
print(vv);
vv.trimToSize();// 빈공간을 없앤다 용량과 크기가 같아진다.
System.out.println("==============================66");
print(vv);
vv.ensureCapacity(7); // 용량 7추가 즉 용량이 12가됨 ensure : 보장하다.
// Vector의 용량이 최소한 minCapacity가 되도록한다.
// 최소 7개가 들어갈수있도록 보장해야함으로 원래의 사이즈의 2배인 12가 된다.
System.out.println("==============================77");
print(vv);
System.out.println("==============================88");
vv.add("1");
vv.add("2");
vv.add("3");
vv.add("4");
vv.add("5");
vv.add("6");
vv.add("7");
vv.add("8");
print(vv);
vv.setSize(8);
vv.clear();// Vector을 비운다
System.out.println("================================");
print(vv);
}
private static void print(Vector vv) {
System.out.println(vv);
System.out.println("vv.size : " + vv.size());
System.out.println("vv.capacity : " + vv.capacity());
}
}
capacity : 수용력, 용량
trim : 다듬다, 손질하다.
trimToSize( ) :
Capacity와 Size를 같게 만드는 명령어
정확하게 표현하면, Capacity와 Size가 동일한 새로운 인스턴스를 만들어서 원소의 내용을 복사합니다.
ensureCapacity( ) :
예를들어 ensureCapacity(6) 이라고 한다면 최소한 6개가 들어갈 size는 보장하라는 의미.
해당 Vector의 Capacity가 6 이상이면 아무 일이 일어나지 않지만 그렇지 않으면 원래의 Vector의 크기의 2배인
새로운 공간을 생성해서 원래의 것을 복사한다.
setSize( ) :
setSize(7) 메소드는 ensureCapacity() 메소드처럼 Capacity가 7 이상이라면 아무 일이 일어나지 않는다. 하지만 그렇지 않을 때 동작하는 방식은 조금 다르다. Vector는 Capacity가 부족할 경우 자동적으로 기존의 Capacity를 2배 늘린 새로운 인스턴스를 생성합니다. 즉, 현재 Capacity가 6인 상태에서 setSize(7) 메소드를 호출한다면 Capacity가 6의 2배인 12가 되는 것입니다.
clear( ) :size 는 0이 되고 capacity는 그대로 유지된다.
package ja_0727;
import java.util.Date;
import java.util.Enumeration;
import java.util.Vector;
public class Vector_2 {
public static void main(String[] args) {
int i;
Date date = new Date();
Vector vv = new Vector(3, 5); // 기본사이즈는3으로 주고 capacity 5씩증가하겠다는말
// 모든타입을 함께 담을 수 있다.
// addElement , add 모두 추가하는건데 요즘은 add를 많이씀
vv.addElement("Java");
vv.add(new Double(56.7));
vv.addElement(date);
System.out.println("=======3개의 객체 추가=======");
System.out.println("size 11 : " + vv.size() + ", capacity : " + vv.capacity());
System.out.println("=========================");
for (int j = 0; j < 10; j++) {
vv.add(new Integer(j + 1));
}
vv.add("korea");
System.out.println("=======10개의 객체 추가=======");
System.out.println("size 22 : " + vv.size() + ", capacity : " + vv.capacity());
// 5씩증가하니까 18이됨
System.out.println("---------Vector 내용 출력-----------");
Enumeration enu = vv.elements(); // Enumeration : 열거형
// 벡터속에 들어있는 값을 뽑아오는 방법
while (enu.hasMoreElements()) {
System.out.println(enu.nextElement() + " ");
}
System.out.println("============객체 포함 확인============");
if (vv.contains("Java")) {
System.out.println("Java 문자열 포함됨");
} else {
System.out.println("Java 문자열 포함 안~됨");
}
System.out.println("56.7 객체 위치 : " + vv.indexOf(new Double(56.7)));
// 만약 -1출력되면 객체가 없다는 뜻
System.out.println("\n 입력시간 : " + vv.get(vv.indexOf(date)));
// date 객체 삭제
vv.removeElementAt(vv.lastIndexOf(date)); // 뒤에서부터 date를 지워주겠다.
for (int j = 0; j < vv.size(); j += 3) {
vv.removeElementAt(j);
// j값을 인덱스 0,3,6,...번째에있는 것을 지워주겠다.
}
vv.setElementAt("seoul", 2); // 인덱스 2번째위치에 korea 문자열 추가
enu = vv.elements();
while (enu.hasMoreElements()) {
System.out.println(enu.nextElement() + " ");
}
System.out.println("\n size : " + vv.size() + "capacity :" + vv.capacity());
vv.trimToSize(); // 공백제거
System.out.println("\n size : " + vv.size() + "capacity :" + vv.capacity());
vv.setSize(3); // 크기를 3로 조정
enu = vv.elements();
while (enu.hasMoreElements()) {
System.out.println(enu.nextElement() + " ");
}
vv.removeAllElements(); // 모든객체 제거
System.out.println("\n size : " + vv.size() + "capacity :" + vv.capacity());
}
}
 |
 |
package ja_0727;
import java.util.Enumeration;
import java.util.Vector;
public class Vector_3 {
public static void main(String[] args) {
int kor, eng, math, total;
double avg;
String[] 이름 = { "강지수", "김동현", "김민석", "김민지", "김유진", "김창용", "김혜련", "김희진", "류현정", "박주선" };
int[] 국어 = { 56, 78, 34, 66, 90, 47, 88, 65, 78, 85 };
int[] 영어 = { 78, 49, 77, 89, 57, 89, 75, 88, 56, 64 };
int[] 수학 = { 85, 69, 88, 33, 56, 90, 55, 78, 66, 83 };
Vector vv = new Vector();
for (int i = 0; i < 10; i++) {
// 여러 종류의 자료형을 담을수 있다.
vv.add((String) 이름[i]);
vv.add(국어[i]);
vv.add(new Integer(영어[i]));
vv.add(new Integer(수학[i]));
}
System.out.println("===========학생 성적 조회 프로그램=============");
System.out.println("\n 이름\t국어\t영어\t수학\t총점\t평균");
//출력 Enumeration : 단계적인 묘사나 열거를의미 출력할때사용
Enumeration enu = vv.elements();
// vv.elements : vv의 요소들을 열거(나열)하겠다.
//Enumeration : 단계적인 묘사나 열거
while (enu.hasMoreElements()) {//enu에 값이 들어있다면
// nextElement로 뽑아와서 출력하겠다.
System.out.println("\n" + enu.nextElement());
kor = ((Integer) enu.nextElement()).intValue();
eng = ((Integer) enu.nextElement()).intValue();
math = ((Integer) enu.nextElement()).intValue();
//nextElement 리턴타입이 object이므로 Integer로 형변환하여 담는다.
total = kor + eng + math;
avg = total / 3.0;
System.out.print("\t" + kor + "\t" + eng + "\t" + math);
System.out.printf("\t %3d %5.1f", total, avg);
}
}
}
http://keepmind.net/java-collection-framework-1/?sfw=pass1658889585
[Java] Collection Framework 1 | KEEPMIND
이번 포스트부터 시작해서 앞으로 4개 정도의 포스트에서는 Collection Framework에 대해 다룰 예정입니다. Collection Framework는 Java의 자료구조라고 생각하시면 됩니다. 정확히는 다수의 데이터를 처리
keepmind.net
🟢 ArrayList
▷문법들
| list_name.subList(5,8); | 리스트의 인덱서 5이상 8미만까지를 가져오겠다는말 |
| ArrayList list_2 = new ArrayList(list_1.subList(1,4)) | list_1의 인덱스 1번이상 4번미만(1,2,3)을 가져와서 list_2에 담겠다는말 |
| 리스트이름.add( 내용) | 리스트에 다음의 내용을 추가하겠다는말 |
| list_1.containsAll(list_2) | list_1이 list_2의 모든 내용을 가지고 있으면 true반환 |
| list_1.retainAll(list_2 | list_1에서 list_2와 겹치는 부분만 남기고 나머지 삭제 |
| List a = new ArrayList(10) | 크기가 10인 (공간이 10인)리스트를 만들겠다는말 |
| list_1.get(i) | 리스트의 인덱스번호i인 공간에 담긴것을 반환함 |
| Collections.shuffle (list) | list의 값들이 셔플된다. |
| Collections.sort(list); | list의 값들을 정렬 |
package ja_0727;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
public class ArrayList_1 {
public static void main(String[] args) {
ArrayList<Integer> list_1 = new ArrayList<Integer>(10);
// int 형으로만 받겠다는말
list_1.add(5);
list_1.add(new Integer(4));
list_1.add(new Integer(3));
list_1.add(new Integer(2));
list_1.add(new Integer(0));
list_1.add(new Integer(1));
list_1.add(new Integer(3));
ArrayList list_2 = new ArrayList(list_1.subList(1, 4));
// list_1의 인덱스1이상4미만까지 가져와서 list_2에담겟다는말
print(list_1, list_2);
Collections.sort(list_1); // sort : 오름차순 정렬
Collections.sort(list_2);
print(list_1, list_2);
System.out.println("list_1.containsAll(list_2) : " + list_1.containsAll(list_2));
list_2.add("B");
list_2.add("C");
list_2.add("A");
System.out.println("list_1.containsAll(list_2) : " + list_1.containsAll(list_2));
print(list_1, list_2);
list_2.set(3, "Queen");
print(list_1, list_2);
// list_1에서 list_2와 겹치는 부분만 남기고 나머지 삭제 (retain : 유지하다, 간직하다)
System.out.println("list_1.retainAll(list_2) : " + list_1.retainAll(list_2));
print(list_1, list_2);
// liest_2에서 list_1에 포함된 객체들 삭제
for (int i = list_2.size() - 1; i >= 0; i--) {
if (list_1.contains(list_2.get(i))) {
list_2.remove(i);
}
}
print(list_1, list_2);
}
private static void print(ArrayList list_1, ArrayList list_2) {
System.out.println("list_1 : " + list_1);
System.out.println("list_2 : " + list_2);
System.out.println();
}
}
package ja_0727;
import java.util.ArrayList;
import java.util.List;
public class ArrayList_2 {
public static void main(String[] args) {
final int LIMIT = 10;
String source = "0123456789abcdefghijklmABCDEFG@#$%^&*()ZZZ";
int length = source.length();
List list = new ArrayList(length / LIMIT + 10);
//list는 10개씩 담을 공간이다. 10개씩 담고 남는 나머지를 담을 공간이 필요한데
//10으로 나눈 나머지는 10미만이므로 +10을 해주어서 공간을 넉넉하게 만들어줌
// 크기를 약간 여유있게 . +10은 몫이 떨어지고 나머지를 담을공간을 만든것
//10개씩 끊어서 list공간에 담아주는 작업
// (예) length : 23이면 0-10 10-20 20
for (int i = 0; i < length; i += LIMIT) { // i+=LIMIT : 즉 10개식 담겟다는말
if (i + LIMIT < length) {
list.add(source.substring(i, i + LIMIT));
//인덱스번호i이상부터i+LIMIT미만까지를 하나의 덩어리로 처리해서 list에 추가
} else {
list.add(source.substring(i)); // i부터 끝까지를 가져온다.
// 10개식 담고 남은 나머지들 담음
}
}
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
list = [0123456789, abcdefghij, klmABCDEFG, @#$%^&*()Z, ZZ]
Interator
: 컬렉션 프레임 웍에서는 컬렉션에 저장된 요소들을 읽어오는 방법을 표준화하여다.
컬랙션에 저장된 각 요소에 접근하는 기능을 가진 Interator 인터페이스를 정의하고 Collection 인터페이스에는 Interator를 반환하는 intorator() 메서드를 정의하고 있다.
interator( ) 는 collection 인터페이스에 적의된 메소드이므로 Collection인터페이스의 자손인 List, Set에도 포함되어있다.
| 메소드 | 설명 |
| boolean hasNext( ) | 읽어올 요소가 남아있는지 확인한다. 있으면 true / 없으면 false |
| Object next( ) | 다음 요소를 읽어온다. next()를 호출하기전에 hasNext()를 호출해서 읽어올 요소가 있는지 확인한다. |
| void remove( ) | next()로 읽어온 요소를 삭제한다. next()를 호출한 다음에 remove()를 호출한다. |
(예)
package ja_0728;
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayList_3 {
public static void main(String[] args) {
ArrayList<String> numbers = new ArrayList();
numbers.add("10");
numbers.add("20");
numbers.add("30");
numbers.add("40");
System.out.println("add(값)");
System.out.println(numbers);
numbers.add(1, "50");
System.out.println("\nadd(인덱스,값)");
System.out.println(numbers);
numbers.remove(2);
System.out.println("\nremove(인덱스)");
System.out.println(numbers);
System.out.println("\nget(인덱스)");
System.out.println(numbers.get(2));
System.out.println("\nsize()");
System.out.println(numbers.size());
System.out.println("\nindexOf()");
System.out.println(numbers.indexOf("45"));
// 열거형이 조금더 발달된 형태 (Iterator : 반복자)
Iterator<String> it = numbers.iterator();
System.out.println("\niterator");
while (it.hasNext()) {
String value = it.next();
// it을 위에서 <String>으로 받았기 때문에next()에서 리턴해주는 값이 String이므로 형변환할 필요 없다.
// 하지만 object타입으로 받았다면 (String)it.next()로 형변환해주어야함
if (value.equals("30")) {
it.remove(); // it 내부에서 지우는 것 아직 value는 30을가지고 있음
}
System.out.println(value); // value : 지우기전의 값을 가지고 있음
}
System.out.println(numbers);
//향상된 for문
System.out.println("\nfor each");
for (String value : numbers) {
System.out.println(value);
}
//for문 위의 것과 값은 동일하게 나온다.
System.out.println("\nfor");
for (int i = 0; i < numbers.size(); i++) {
System.out.println(numbers.get(i));
}
}
} |
 |
(예) - 성적표를 ArrayList로 출력하기
package ja_0728;
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayList_4 {
public static void main(String[] args) {
int kor, eng, math, total;
double avg;
String[] 이름 = { "강지수", "김동현", "김민석", "김민지", "김유진", "김창용", "김혜련", "김희진", "류현정", "박주선" };
int[] 국어 = { 56, 78, 34, 66, 90, 47, 88, 65, 78, 85 };
int[] 영어 = { 78, 49, 77, 89, 57, 89, 75, 88, 56, 64 };
int[] 수학 = { 85, 69, 88, 33, 56, 90, 55, 78, 66, 83 };
// Vector vv = new Vector();
ArrayList vv = new ArrayList();
for (int i = 0; i < 10; i++) {
// 여러 종류의 자료형을 담을수 있다.
vv.add((String) 이름[i]);
vv.add(국어[i]);
vv.add(new Integer(영어[i]));
vv.add(new Integer(수학[i]));
}
System.out.println("===========학생 성적 조회 프로그램=============");
System.out.println("\n 이름\t국어\t영어\t수학\t총점\t평균");
// Enumeration enu = vv.elements(); ArrayList는 제공하지 않는 기능
Iterator itt = vv.iterator();
while (itt.hasNext()) {
System.out.println("\n" + itt.next());
kor = ((Integer) itt.next()).intValue();
eng = ((Integer) itt.next()).intValue();
math = ((Integer) itt.next()).intValue();
total = kor + eng + math;
avg = total / 3.0;
System.out.print("\t" + kor + "\t" + eng + "\t" + math);
System.out.printf("\t %3d %5.1f", total, avg);
}
}
}
(예) ArrayList의 제너릭에 Class도 담을 수 있다.
package ja_0728;
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayList_5 {
public static void main(String[] args) {
// 제너릭에 클래스가 들어 올 수 있다.
ArrayList<Student_3> list = new ArrayList();
list.add(new Student_3("수 선 화", 1, 1));
list.add(new Student_3("백 합", 1, 2));
list.add(new Student_3("장 미", 1, 3));
list.add(new Student_3("코스모스", 2, 1));
list.add(new Student_3("해바라기", 2, 2));
list.add(new Student_3("데이지", 3, 1));
Iterator<Student_3> itt = list.iterator();
while (itt.hasNext()) {
Student_3 ss = itt.next();
System.out.println(ss.name + "\t" + ss.ban + "\t" + ss.noo + "\n");
}
System.out.println();
System.out.println();
for (Student_3 stu : list) {
System.out.println(stu.name + "\t" + stu.ban + "\t" + stu.noo + "\n");
}
System.out.println();
for (int i = 0; i < list.size(); i++) {
// Student_3 stt = list.get(i);
// System.out.println(stt.name); 위의 두줄로 적으나 아래의 한줄이나 같은결과 출력
System.out.println(list.get(i).name + "\t" + list.get(i).ban + "\t" + list.get(i).noo + "\n");
}
}
}
class Student_3 {
String name = "";
int ban;
int noo;
public Student_3(String name, int ban, int noo) {
this.name = name;
this.ban = ban;
this.noo = noo;
}
}
다음의 것이 세번 출력된다.
향상된 for문은 배열과 collection에서만 가능하다.
- comparable
package ja_0728;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
public class ArrayList_6 {
public static void main(String[] args) {
ArrayList<Student_4> list = new ArrayList();
list.add(new Student_4("백일 홍", 1, 1, 100, 90, 80));
list.add(new Student_4("해당 화", 1, 2, 67, 77, 83));
list.add(new Student_4("나팔 꽃", 1, 3, 79, 36, 56));
list.add(new Student_4("백일 홍", 1, 1, 100, 90, 80));
list.add(new Student_4("달맞이꽃", 1, 4, 66, 77, 88));
list.add(new Student_4("들국 화", 2, 1, 73, 52, 64));
list.add(new Student_4("패랭이꽃", 2, 2, 90, 27, 64));
list.add(new Student_4("코스모스", 3, 1, 78, 84, 34));
list.add(new Student_4("히야신스", 3, 2, 77, 59, 63));
Collections.sort(list); // 정렬
Iterator<Student_4> itt = list.iterator();
while (itt.hasNext()) {
Student_4 stt = itt.next();
System.out.println(stt);
}
}
}
class Student_4 implements Comparable<Student_4> { // comparable : 정렬을 위한 인터페이스
String name = "";
int ban = 0;
int no = 0;
int kor = 0;
int eng = 0;
int math = 0;
int total = 0;
public Student_4(String name, int ban, int no, int kor, int eng, int math) {
this.name = name;
this.ban = ban;
this.no = no;
this.kor = kor;
this.eng = eng;
this.math = math;
total = kor + eng + math;
}
public String toString() {
return name + "\t" + ban + "\t" + no + "\t" + kor + "\t" + eng + "\t" + math + "\t" + total;
}
//
// 객채의 정렬기준을 정의하는 것은 첫번째 방법은 정렬대상 클래스를 자바에서 기본적으로
// 제공하고 있는 Comparable 인터페이스를 구현하도록 변경하는 것이다.
// Comparable 인터페이스의 compareTo() 메소드를 통해 인자로 넘어온 같은 타입의 다른 객체와 대소비교가 가능하다.
// 메서드를 호출하는 객체가 인자로 넘어온 객체보다 작을경우 음수, 크기가 동일하면0, 클경우에는 양수를 리턴한다.
public int compareTo(Student_4 stt) {
return this.total - stt.total - this.total; // 내림차순
}
}
(vector의 형변환)
package ja_0728;
import java.util.Date;
import java.util.Enumeration;
import java.util.Vector;
public class Iterator_1 {
public static void main(String[] args) {
Vector list = new Vector();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
list.add(8);
list.add(9);
list.add(new Date());
list.add(45.899);
Enumeration enu = list.elements();
while (enu.hasMoreElements()) {
Object obj = enu.nextElement();
//Object로 받는다는 것은 모든 타입을 받겟다는 말
System.out.println(obj);
}
}
}같은것을 ArrayList로 표현한 것
package ja_0728;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
public class Iterator_1 {
public static void main(String[] args) {
// Vector list = new Vector();
ArrayList list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
list.add(8);
list.add(9);
list.add(new Date());
list.add(45.899);
// Enumeration enu = list.elements();
Iterator itt = list.iterator();
while (itt.hasNext()) {
Object obj = itt.next();
// Object로 받는다는 것은 모든 타입을 받겟다는 말
System.out.println(obj);
}
}
}(셔플)
package ja_0729;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Shuffle_1 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i <= 10; i++) {
list.add(i);
}
System.out.println("섞기전 : " + list);
Collections.shuffle(list);
System.out.println("섞은 후 : " + list);
}
}'KH > JAVA' 카테고리의 다른 글
| # 37 Set - HashSet, TreeSet (0) | 2022.07.28 |
|---|---|
| # 36 Calendar(달력) (0) | 2022.07.28 |
| # 34 Math.random( ) , Random Class (0) | 2022.07.27 |
| # 33 StringBuffer , StringTokenizer (0) | 2022.07.27 |
| # 32 String (0) | 2022.07.25 |