티스토리 뷰
1. Operator 함수적 인터페이스 ( p. 697 )
- 매개 값과 리턴 값이 모두 있는 추상 메소드를 가진다.
- 주로 매개 값을 연산하고, 그 결과를 리턴하는 경우에 사용한다. ( y = f(x) )
- 매개 변수의 타입과 수에 따라서 분류한다.
- 종류 예시 :
- BinaryOperator<T> : 2(T, U)개를 연산한 후에, R로 리턴해라.
- UnaryOperator<T> : 1개(T)를 연산한 후에, R로 리턴해라.
- 이 경우 매개변수 T만이 적혀 있는데, 그 이유는 이 2개의 인터페이스는 BiFunction<T,U,R>과 Function<T,R>의 하위 인터페이스이기 때문이다.
2. Predicate 함수적 인터페이스 ( p. 699 )
- 매개 값을 조사해서 true 또는 false를 리턴할 때 사용한다.
- 예시 :
- 인터페이스 명 : Predicate<T>
- 추상 메소드 : boolean test ( 조사할 대상T t )
3. 자바 컬렉션 프레임워크 ( JCF ) **
- 객체를 수집하고 저장하는 것
- 불특정 다수의 객체를 저장하기 힘들다는 점과 객체를 저장하려면 어디가 비어 있는지 확인해야 한다는 배열의 한계점을 극복하기 위해서 나타났다.
- Java.util 패키지에 포함되어 있다.
- 객체들을 효율적으로 추가, 삭제, 검색할 수 있도록 제공되는 컬렉션 라이브러리
- 인터페이스를 통해서 정형화된 방법으로 다양한 컬렉션 클래스를 이용한다.
4. 컬렉션 프레임 워크의 주요 인터페이스
- 인터 페이스의 분류 :
- 1 ) Collection 계열 ( 성질 구분하기 )
- (1) List : 1.순서를 유지하고 저장한다. 2. 중복저장이 가능하다. ( 배열과 비슷 )
- Ex. ArrayList, Vector, LinkedList
- (2) Set : 1.순서를 유지하지 않고 저장한다. 2.중복저장이 안된다.
- Ex. HashSet, TreeSet
- 2 ) Map 계열 : 1.키와 값이 쌍으로(key = value) 저장된다. 2.키는 중복저장이 안된다.
- Ex. HashMap, Hashtable, TreeMap, Properties
5. List 컬렉션
- 특징 : 1) 인덱스로 관리한다. 2) 중복해서 객체(참조타입)를 저장할 수 있다.
- 구현 클래스 : ArrayList, Vector, LinkedList
- 객체와 List계열 컬렉션 모두 힙영역에 저장된다.
- 주요 메소드 : 객체 추가(add), 객체 검색, 객체 삭제(remove)
- 1 ) ArrayList : 초기용량으로 10이 지정되지만, 저장용량을 초과한 객체들이 들어오게 되면 자동적으로 늘어난다. ( 고정도 가능하다. )
- 2 ) Vector : 복수의 스레드가 동시에 Vector에 접근해 객체를 추가하거나 삭제하더라도 스레드에 안전하다. ( 스레드 동기화 )
- + List <E> list = new Vector <E>( );
- 3 ) LinkedList : 인접한 참조를 링크해서 체인처럼 관리하게 된다.
- 특정 인덱스에서 객체를 제거하거나 추가하게 되면 바로 앞/뒤 링크만 변경되는 거지, 앞으로 댕겨지거나 밀리지 않아 좋은 성능을 낸다.
- 빈번한 객체의 삽입과 삭제가 일어나는 곳에서는 ArrayList보다 좋은 성능을 낸다.
- + List <E> list = new LinkedList<E>( );
6. Set 컬렉션
- 특징 : 1. 수학의 집합에 비유된다. 2. 저장순서가 유지되지 않는다. 3. 객체를 중복으로 저장할 수 없다. 4. 하나의 null만 저장할 수 있다. ( null도 값이다. )
- 구현 클래스 : HashSet, LinkedHashSet, TreeSet
- 1 ) HashSet : 동일 객체 및 동등 객체는 중복 저장하지 않는데, 동등 객체인지 판단하는 방법은 HashCode에서 1차로 확인한 후에 equals로 2차로 동등 객체인지를 확인한다.
더보기
01. Operator 함수적 인터페이스
package operator;
import java.util.function.IntBinaryOperator;
public class OperatorExample { // Operator 함수적 인터페이스 (***)
public static int [] scores = { 92, 95, 87 }; // 배열 생성
public static int maxOrMin(IntBinaryOperator operator) { // 다형성 1 - IntBinaryOperator가 부모 operator는 자식
// int applyAsInt(int left, int right);
int result = scores[0]; // 첫번째 원소의 값을 임시 결과로 지정
for (int score : scores) { // 배열의 원소를 차례대로 순회
result = operator.applyAsInt(result, score); // 추상메소드 호출 ( 다형성2 ) - result에 비교 후의 값을 저장
}// enhanced for
return result;
} // maxOrMin
// ===========================================================================================
public static void main(String[] args) {
// 1. 최대값 얻기
// int applyAsInt(int left, int right);
int max = maxOrMin(
(a,b) -> {
if ( a >= b) return a;
else return b;
} //람다식 : 최대값을 가지는 원소를 추출하는 익명구현객체 생성
);
System.out.println("1. Max(최대값) : " + max);
// ===========================================================================================
// 2. 최소값 얻기
// int applyAsInt(int left, int right);
int min = maxOrMin (
(a,b) -> {
if( a <= b ) return a;
else return b;
} // 람다식 : 최소값을 가지는 원소를 추출하는 익명구현객체 생성
);
System.out.println("2. Min(최소값) : " + min);
// ===========================================================================================
// 출력 :
// 1. Max(최대값) : 95
// 2. Min(최소값) : 87
}// main
} // end class더보기
02. Predicate 함수적 인터페이스
package predicate;
import lombok.AllArgsConstructor;
import lombok.Getter;
@AllArgsConstructor // 모든 필드를 가지는 생성자 생성
public class Student {
private String name;
@Getter private String sex;
@Getter private int score;
} // end classpackage predicate;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
// 표준 함수적 인터페이스 ( Consumer, Supplier, Function, Operator, Predicate )에 선언된 추상 메소드는
// 특정 비지니스 로직을 염두하고 만든 추상메소드가 아니다. (***)
public class PredicateExample { // Predicate 함수적 인터페이스
private static List<Student> list = Arrays.asList( // Student 객체를 넣는 목록 생성
new Student("홍길동","남자",90),
new Student("김순희","여자",90),
new Student("김자바","남자",95),
new Student("박한나","여자",92)
); // list
public static double avg (Predicate<Student> predicate) { // Student 객체를 test 해라!
// boolean test(T t);
int count = 0, sum =0;
for(Student student : list) {
if(predicate.test(student)) {
count++; // 조건에 부합하는 학생 수 가 몇 명인지 count한다.
sum += student.getScore(); // 조건에 부합한 점수의 합을 구한다.
} // if
} // enhanced for
return (double) sum / count; // 조건에 맞는 평균 구하기!!
} // avg
public static void main(String [] args) {
double maleAvg = PredicateExample.avg ( t -> t.getSex().equals("남자"));
System.out.println("1. 남자 평균 점수 : " + maleAvg);
// ============================================================
double femaleAvg = PredicateExample.avg ( t -> t.getSex().equals("여자"));
System.out.println("2. 여자 평균 점수 : " + femaleAvg);
} // main
} // end class더보기
03. ArrayList
package array_list;
import java.util.ArrayList;
import java.util.List;
public class ArrayListExample { // List 컬렉션 - ArrayList
// list : 1. 순서보장(인덱스 번호 사용하여 조작) 2. 중복허용 3. 빈번한 추가/삭제가 적어야만 효율적이다. (****)
public static void main(String[] args) {
// Lvalue(부모타입) = Rvalue(자식타입, 구현 클래스) (**)
List<String> list = new ArrayList<String>(); // 다형성
// List<String> list = new ArrayList<>(); // 자바 8부터는 이렇게 작성해도 괜찮다.
// ==========================================
list.add("java");
list.add("JDBC");
list.add("Servlet/JSP");
list.add(2, "Database"); // add(index번호, String) < - - - 지정된 인덱스 번호에 String을 넣는다.
list.add("iBATIS");
// ==========================================
int size = list.size(); // list의 크기
System.out.println("총 객체 수 : " + size); // 출력 : 총 객체 수 : 5
System.out.println();
// ==========================================
String skill = list.get(2);
System.out.println("2 : " + skill); // 출력 : 2 : Database
System.out.println();
// ==========================================
for(int i=0; i<list.size(); i++) {
String str = list.get(i);
System.out.println( i+ " : " + str );
}// for - list의 인덱스번호 순서대로 출력한다.
// 이를 통해서 인덱스 번호를 통해 입력하게 되면, 다른 요소들의 순서가 1개씩 밀린다는 것을 알 수 있다.
// 이렇게 되면 대용량의 데이터를 다룰 때 효율적이지 않기 때문에 List를 사용할 때는 많은 변경을 사용하면 안된다!!!
System.out.println();
// 출력 :
// 0 : java
// 1 : JDBC
// 2 : Database
// 3 : Servlet/JSP
// 4 : iBATIS
// ==========================================
for ( String str : list ) {
System.out.println(">> str : " + str);
} // enhanced for문으로 변경
// enhanced for문의 사용조건 : " : " 뒤에 오는 것이 Iterable 인테페이스의 구현객체이어야 한다.
System.out.println();
// ==========================================
// List 요소 삭제 (**)
list.remove(2);
list.remove(2); // 같은 인덱스 번호를 삭제한다고 작성하였어도, 이미 위에서 2번째가 삭제되었기에 변경후 다른 요소를 삭제하게 된다.
list.remove("iBATIS"); // 요소 객체를 지정하여 삭제도 가능하다.
// ==========================================
for(int i=0; i<list.size(); i++) {
String str = list.get(i);
System.out.println( i+ " : " + str );
} // for - 삭제 후 요소들 확인
// 출력 :
// 0 : java
// 1 : JDBC
} // main
} // end class더보기
04. ArrayAsList
package array_list;
import java.util.Arrays;
import java.util.List;
public class ArrayAsListExample {
public static void main(String[] args) {
List <String> list1 = Arrays.asList("홍길동","신용권","김자바"); // 다형성1
// List <String> list1 = Arrays.<String>asList("홍길동","신용권","김자바"); // 생략 전 버전
System.out.println("list : " + list1); // 출력 : list : [홍길동, 신용권, 김자바]
for(String name : list1) {
System.out.println(name);
} // enhanced for
// ============================================
List <Integer> list2 = Arrays.asList(1, 2, 3); // 다형성1, Auto-boxing
// Int타입인 1, 2, 3이 들어갈 수 있는 이유는 Integer은 Int의 wrapper 타입에기에 자동 boxing된다.
for(int value : list2) {
System.out.println(value);
} // enhanced for
} // main
} // end class더보기
05. Vector
package vector;
import lombok.AllArgsConstructor;
import lombok.ToString;
@ToString
@AllArgsConstructor // 모든 필드를 매개변수로 갖는 생성자 생성
public class Board {
String subject;
String content;
String writer;
} // end classpackage vector;
import java.util.List;
import java.util.Vector;
import java.util.function.Consumer;
public class VectorExample {
public static void main(String[] args) {
List<Board> list = new Vector< >( ); // < > : 타입추론 연산자
list.add(new Board("제목1","내용1","글쓴이1")); // 0
list.add(new Board("제목2","내용2","글쓴이2")); // 1
list.add(new Board("제목3","내용3","글쓴이3")); // 2
list.add(new Board("제목4","내용4","글쓴이4")); // 3
list.add(new Board("제목5","내용5","글쓴이5")); // 4
// =================================================
list.remove(2); // 중간 요소를 삭제 - > 당겨지는
list.remove(3);
// =================================================
for(int i = 0; i<list.size(); i++) {
Board board = list.get(i);
System.out.println(board.subject + "\t" + board.content + "\t" + board.writer);
}// for
// 출력 :
// 제목1 내용1 글쓴이1
// 제목2 내용2 글쓴이2
// 제목4 내용4 글쓴이4
System.out.println();
// =================================================
for ( Board board : list) {
System.out.println(board.subject + "\t" + board.content + "\t" + board.writer);
} // enhanced for
System.out.println();
// =================================================
// Consumer 인터페이스 버전 - 컨트롤 해서 인터페이스를 확인하자!! (*****)
list.forEach(new Consumer<Board>() {
@Override
public void accept(Board t) {
System.out.println(t.subject + "\t" + t.content + "\t" + t.writer);
} // accept
} ); // for each - Consumer 인터페이스
System.out.println();
// =================================================
// 람다식 버전 (*****)
list.forEach( t -> System.out.println(t.subject + "\t" + t.content + "\t" + t.writer ) ); // for each
System.out.println();
// =================================================
// ToString 활용 (*****)
list.forEach(t -> System.out.println(t));
System.out.println();
// 출력 :
// Board(subject=제목1, content=내용1, writer=글쓴이1)
// Board(subject=제목2, content=내용2, writer=글쓴이2)
// Board(subject=제목4, content=내용4, writer=글쓴이4)
// =================================================
// for each는 자동으로 enhanced for을 해준다!! (****)
} // main
} // end class더보기
06. Linked List
package linked_list;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class LinkedListExample {
public static void main(String [] args) {
List<String> list1 = new ArrayList<>();
List<String> list2 = new LinkedList<>(); // (***)
// ====================================================
long startTime;
long endTime;
// ====================================================
// 컴퓨터의 시행 시간을 측정하는 방법 (***) - ArrayList의 시간
startTime = System.nanoTime(); // 10억 분의 1초로 정확도로 현재시간을 반환
for (int i=0; i<10000; i++) {
list1.add(0,String.valueOf(i));
} //for
endTime = System.nanoTime();
System.out.println("ArrayList 걸린시간 : " + ( endTime - startTime) + " ns"); // 출력 : ArrayList 걸린시간 : 6377700 ns
// ====================================================
// 컴퓨터의 시행 시간을 측정하는 방법 (***) - LinkedList의 시간
startTime = System.nanoTime();
for (int i=0; i<10000; i++) {
list2.add(0,String.valueOf(i));
} //for
endTime = System.nanoTime();
System.out.println("LinkedList 걸린시간 : " + ( endTime - startTime) + " ns"); // 출력 : LinkedList 걸린시간 : 2498700 ns
// ====================================================
// 이를 통해서 요소를 빈번하게 추가하는데 있어서는 LinkedList가 유리한 것을 알 수 있다. (**)
} // main
} // end class더보기
07. Hash Set
package hash_set;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
@EqualsAndHashCode
@AllArgsConstructor
public class Member extends Object { // HashCode - 중복값 확인
// Set계열과 Map계열의 키는 중복 값을 허용하지 않기에 값이 들어가 있는지 확인해야 한다.
public String name;
public int age;
// ===========================================
// 아래의 코드는 @EqualsAndHashCode가 대체할 수 있다!!(******)
// @Override
// public boolean equals(Object obj) { // 2. equals - 다시 한번 이름과 나이가 같은지 확인한다.
//
// if( obj instanceof Member) {
// Member member = (Member) obj;
// return member.name.equals(name) && (member.age == age);
// } else {
// return false;
// } // if - else
//
// } // equals
//
// @Override
// public int hashCode() {
// return name.hashCode() + age;
// }// 1. hashCode - 이름과 나이를 붙여서 유니크한 값(OID)을 가지게 한다.
} // end classpackage hash_set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class HashExample1 {
public static void main(String [] args) {
Set <String> set = new HashSet<String>();
set.add("JAVA");
set.add("JDBC");
set.add("Servlet/JSP");
set.add("Java");
set.add("iBATIS");
int size = set.size();
System.out.println(" 총 객체수 : " + size);
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
String element = iterator.next();
System.out.println("\t" + element);
} // while
set.remove("JDBC");
set.remove("iBATIS");
System.out.println("삭제 후 총 객체 수 : " + set.size());
for(String element : set) {
System.out.println("\t" + element);
} // for
set.clear();
if(set.isEmpty()) {System.out.println("비어있습니당");}
} // main
} // end class728x90
'KH 정보교육원 [ Java ]' 카테고리의 다른 글
| KH 23일차 - 컬렉션 프레임워크 및 IO (0) | 2022.03.30 |
|---|---|
| KH 22일차 - 컬렉션 프레임워크 (0) | 2022.03.29 |
| KH 20일차 - 람다식과 함수적 인터페이 (0) | 2022.03.26 |
| KH 19일차 - 제네릭 타입 (0) | 2022.03.25 |
| KH 18일차 - 예외처리코드 및 제네릭 (0) | 2022.03.24 |
댓글