반응형

Consumer는 1개의 Type T 인자를 받고 리턴 값이 없는 함수형 인터페이스입니다.

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

}

Example 1 : Consumer

Consumer는 Lambda 표현식으로 구현할 수 있습니다. accept() 호출과 함께 인자를 전달하면 구현된 내용이 수행됩니다.

import java.util.function.Consumer;

public class ConsumerExample1 {

    public static void main(String[] args) {
        Consumer<String> consumer = s -> System.out.println(s.toUpperCase());

        consumer.accept("hello world");
    }
}

Output:

HELLO WORLD

Example 2 : Primitive Consumer

Java는 Primitive type에 대한 Consumer 클래스를 제공합니다. IntConsumer 외에 DoubleConsumer, LongConsumer가 있습니다.

import java.util.function.IntConsumer;

public class ConsumerExample2 {

    public static void main(String[] args) {
        IntConsumer consumer = n -> System.out.println(n * 100);

        consumer.accept(5);

        consumer.accept(10);
    }
}

Output:

500
1000

Example 3 : List.forEach()

List.forEach()는 인자로 Consumer를 받습니다.

다음과 같이 Consumer를 이용하여 List의 모든 아이템들을 출력할 수 있습니다.

 

Output:

APPLE
KIWI
ORANGE

Example 4 : andThen()

andThen()은 Consumer들을 연결해주는 Chaining 메소드입니다.

아래 코드에서 addNumber.andThen(printList).accept(fruits)를 호출하면 addNumber()가 수행된 이후에 printList()가 수행됩니다. 두개의 메소드로 전달되는 인자는 fruits로, 동일한 객체가 전달됩니다.

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerExample4 {

    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("apple", "kiwi", "orange");

        Consumer<List<String>> addNumber = list -> {
            for (int i = 0; i < list.size(); i++) {
                list.set(i, (i + 1) + ". " + list.get(i));
            }
        };

        Consumer<List<String>> printList = list -> {
            for (String fruit : list) {
                System.out.println(fruit);
            }
        };

        addNumber.andThen(printList).accept(fruits);
    }
}

Output:

1. apple
2. kiwi
3. orange

실제로 andThen()은 아래처럼 구현되어있습니다.

// Consumer.java
public interface Consumer<T> {
  ...
  default Consumer<T> andThen(Consumer<? super T> after) {
      Objects.requireNonNull(after);
      return (T t) -> { accept(t); after.accept(t); };
  }
}

Example 5 : 함수의 인자로 Consumer 전달 (Higher Order Function)

다음과 같이 Consumer를 인자로 받는 함수를 정의할 수 있습니다.

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerExample5 {

    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("apple", "kiwi", "orange");

        Consumer<String> printFruit = fruit -> System.out.println("I like " + fruit);

        forEach(fruits, printFruit);
    }

    static <T> void forEach(List<T> list, Consumer<T> consumer) {
        for (T t : list) {
            consumer.accept(t);
        }
    }

}

Output:

I like apple
I like kiwi
I like orange

 

 

ref : https://codechacha.com/ko/java8-consumer-example/

반응형
반응형

 

그림 1은 런타임 라이브러리 종속 항목을 가진 앱을 보여줍니다. 앱 코드를 검사하는 동안 R8은 MainActivity.class 진입점에서 foo(), faz(), bar() 메서드에 연결할 수 있다고 판단합니다. 그러나 런타임에 OkayApi.class 클래스 또는 baz() 메서드가 앱에서 전혀 사용되지 않으며 R8은 앱을 축소할 때 이 코드를 삭제합니다.

 

\

R8은 프로젝트의 R8 구성 파일 -keep 규칙을 이용하여 진입점을 결정합니다. 즉, keep 규칙은 앱을 축소할 때 R8이 삭제하면 안 되는 클래스를 지정하고 R8은 이 클래스를 앱의 진입점으로 사용할 수 있다고 간주합니다. Android Gradle 플러그인과 AAPT2는 앱의 활동, 보기 및 서비스와 같이 대부분의 앱 프로젝트에서 필요한 keep 규칙을 자동으로 생성합니다. 그러나 추가적인 keep 규칙을 사용하여 이 기본 동작을 맞춤설정해야 하는 경우 유지할 코드를 맞춤설정하는 방법에 관한 섹션을 참조하세요.

대신 앱 리소스의 크기를 줄이는 데만 관심이 있다면 리소스 축소 방법에 관한 섹션을 참조하세요.

 

 

 

유지할 코드 맞춤설정

대부분의 상황에서는 기본 ProGuard 규칙 파일(proguard-android- optimize.txt)만 있으면 R8을 이용하여 미사용 코드를 삭제할 수 있습니다. 그러나 R8에서 정확하게 분석하기 어려운 상황도 있으며 실제로 앱에서 사용하는 코드를 삭제하는 경우도 발생할 수 있습니다. 다음은 코드를 잘못 삭제할 수 있는 몇 가지 예입니다.

  • 앱이 자바 네이티브 인터페이스(JNI)에서 메서드를 호출하는 경우
  • 앱이 런타임에 리플랙션 등을 사용하여 코드를 찾는 경우

앱을 테스트하면 잘못된 코드 삭제로 인한 오류가 나타나지만 삭제된 코드 보고서를 생성하여 삭제된 코드를 검사할 수도 있습니다.

오류를 수정하고 R8이 특정 코드를 유지하도록 하려면 ProGuard 규칙 파일에 -keep 줄을 추가합니다. 예:

 
-keep public class MyClass

또는 유지하려는 코드에 @Keep 주석을 추가할 수 있습니다. @Keep을 클래스에 추가하면 전체 클래스가 그대로 유지됩니다. 이 주석을 메서드나 필드에 추가하면 메서드/필드 및 그 이름뿐만 아니라 클래스 이름도 그대로 유지됩니다. 참고로 이 주석은 축소 사용 방법에 관한 섹션에 설명한 대로 AndroidX 주석 라이브러리를 사용하고 Android Gradle 플러그인과 함께 패키징된 ProGuard 규칙 파일을 포함할 때만 사용할 수 있습니다.

-keep 옵션을 사용하려면 고려해야 하는 사항이 많습니다. 규칙 파일을 맞춤설정하는 방법에 관한 자세한 정보는 ProGuard 설명서를 참조하세요. 문제 해결 섹션에서는 코드를 제거할 때 발생할 수 있는 다른 일반적인 문제를 간략히 설명합니다.

 

 

 

ref : https://developer.android.com/studio/build/shrink-code?hl=ko

반응형

'프로그래밍(Programming) > Java' 카테고리의 다른 글

Java : Consumer  (0) 2022.01.12
스트림 변환 메서드들 표  (0) 2021.12.31
interface default 키워드로 메소드 구현하기  (0) 2021.12.30
[Java] Comparable, comparator  (0) 2021.12.15
[Java] Collection , Map, Tree  (0) 2021.12.15
반응형

 

 

ref : https://www.youtube.com/watch?v=VUh_t_j9qjE&list=PLW2UjW795-f6xWA2_MUhEVgPauhGl3xIp&index=171

반응형

'프로그래밍(Programming) > Java' 카테고리의 다른 글

Java : Consumer  (0) 2022.01.12
Java @Keep (Android )  (0) 2022.01.03
interface default 키워드로 메소드 구현하기  (0) 2021.12.30
[Java] Comparable, comparator  (0) 2021.12.15
[Java] Collection , Map, Tree  (0) 2021.12.15
반응형

인터페이스의 default method

인터페이스의 default 메소드

JAVA 8이 등장하면서 interface에 대한 정의가 몇 가지 변경되었다.

default메소드

  • 인터페이스가 default키워드로 선언되면 메소드가 구현될 수 있다. 또한 이를 구현하는 클래스는 default메소드를 오버라이딩 할 수 있다.
    public interface Calculator {
        public int plus(int i, int j);
        public int multiple(int i, int j);
        default int exec(int i, int j){      //default로 선언함으로 메소드를 구현할 수 있다.
            return i + j;
        }
    }

    //Calculator인터페이스를 구현한 MyCalculator클래스
    public class MyCalculator implements Calculator {

        @Override
        public int plus(int i, int j) {
            return i + j;
        }

        @Override
        public int multiple(int i, int j) {
            return i * j;
        }
    }

    public class MyCalculatorExam {
        public static void main(String[] args){
            Calculator cal = new MyCalculator();
            int value = cal.exec(5, 10);
            System.out.println(value);
        }
    }
  • 인터페이스가 변경이 되면, 인터페이스를 구현하는 모든 클래스들이 해당 메소드를 구현해야 하는 문제가 있다. 이런 문제를 해결하기 위하여 인터페이스에 메소드를 구현해 놓을 수 있도록 하였다.

static메소드

    public interface Calculator {
        public int plus(int i, int j);
        public int multiple(int i, int j);
        default int exec(int i, int j){
            return i + j;
        }
        public static int exec2(int i, int j){   //static 메소드 
            return i * j;
        }
    }

    //인터페이스에서 정의한 static메소드는 반드시 인터페이스명.메소드 형식으로 호출해야한다.  

    public class MyCalculatorExam {
        public static void main(String[] args){
            Calculator cal = new MyCalculator();
            int value = cal.exec(5, 10);
            System.out.println(value);

            int value2 = Calculator.exec2(5, 10);  //static메소드 호출 
            System.out.println(value2);
        }
    }
  • 인터페이스에 static 메소드를 선언함으로써, 인터페이스를 이용하여 간단한 기능을 가지는 유틸리티성 인터페이스를 만들 수 있게 되었다.

 

 

ref : https://programmers.co.kr/learn/courses/5/lessons/241

반응형

'프로그래밍(Programming) > Java' 카테고리의 다른 글

Java @Keep (Android )  (0) 2022.01.03
스트림 변환 메서드들 표  (0) 2021.12.31
[Java] Comparable, comparator  (0) 2021.12.15
[Java] Collection , Map, Tree  (0) 2021.12.15
RMI 개념, 분산 시스템이란  (0) 2012.10.31
반응형

 

 

 

TreeSet 에서  비교 클래슬를 생성자에서 받을때는 Comparable 을 상속받은 클래스는 불가하고

Comparator 를 상속받은 클래스를 생성자에 Functor 식으로 넣어서 비교기준으로 삼는 것은 가능하다

class TestCopmp implements Comparator {

    public int a;

    @Override
    public int compare(Object o1, Object o2) {
        return ((Test)o1).a - ((Test)o2).a;
    }
}

 

Set set = new TreeSet( new TestCopmp() );

마치 C++ 에서 Fuctor 를 만든것 처럼 끝 어미도 tor 이다, 사용법도 유사하다 볼수 있다

Comparator 는 sort 시에도 정렬 기준으로 던져줄수 있는 Fuctor 다

 

 

 

위 처럼 생성자에 넣는 것이 아닌 클래스 자체에 비교 함수를 override 하는 방법이 있는데 그것이 Comparable 이다

class Test implements Comparable {
    public int a;

    @Override
    public int compareTo(Object o) {
        return a - ((Test)o).a;
    }
}
//원소 추가함과 동시에 정렬됨
Set set = new TreeSet();

for (int i=0; set.size() < 6;++i)
{
    int nm = (int)(Math.random()* 45) + 1;
    Test ss= new Test();
    ss.a = nm;

    set.add(ss);

}

 

 위 처럼 하면 가능 하지만 Test 클래스가 Comparator 를 상속을 받는것은 가능하나
 객체간의 비교로 사용용도로 사용되진 못한다, 사용하면 크래쉬 (Comparable 로 캐스팅 하지 못한다는 에러 발생)

Exception in thread "main" java.lang.ClassCastException: class Test cannot be cast to 
class java.lang.Comparable (Test is in unnamed module of loader 'app'; 
java.lang.Comparable is in module java.base of loader 'bootstrap')

	at java.base/java.util.TreeMap.compare(TreeMap.java:1563)
	at java.base/java.util.TreeMap.addEntryToEmptyMap(TreeMap.java:768)
	at java.base/java.util.TreeMap.put(TreeMap.java:777)
	at java.base/java.util.TreeMap.put(TreeMap.java:534)
	at java.base/java.util.TreeSet.add(TreeSet.java:255)
	at comp.main(comp.java:98)

 

 

 

 

 

 

[Comparable 의 사용 예시]

import java.util.*;

//하나의 자바 소스 파일에 작성된 클래스 중 오직 한 클래스만 public으로 선언할 수 있습니다.

//Comparable 상속받아 정렬 기준을 만들수 있다
class Player implements Comparable<Player>
{
    private String name;
    private int score;

    public int getScore(){ return score; }

    @Override
    public int compareTo(Player o) {
        return o.getScore() - this.getScore();
    }

    public Player(String name, int score)
    {
        this.name = name;
        this.score = score;
    }
}

public class comp {

    public static void main(String[] args)
    {
        List<Player> players = new ArrayList<>();
        players.add(new Player("Alice", 899));
        players.add(new Player("Bob", 982));
        players.add(new Player("Chloe", 1090));
        players.add(new Player("Dale", 982));
        players.add(new Player("Eric", 1018));

        //이때 Comparable 이 사용됨
       주석 제거하면 Comparable 가 작동하여 정렬된다
        //Collections.sort(players);


        //comparator 를 통해 클래스 밖에서 정렬 기준을 다르게 하여 정렬 할수 있다
        Comparator<Player> comparator = new Comparator<Player>() {
            @Override
            public int compare(Player a, Player b)
            {
                return a.getScore() - b.getScore();
            }
        };

        //Collection<Integer> sdf = new LinkedList<>();
        Collections.sort(players, comparator);


    }

}

 

 

 

 

 

Comparable 인터페이스

객체의 정렬 기준을 정의하는 첫번째 방법은 정렬 대상 클래스를 자바에서 기본적으로 제공하고 있는 Comparable 인터페이스를 구현하도록 변경하는 것입니다. 이를 적용하면 Player 클래스는 다음과 같이 수정됩니다.

public class Player implements Comparable<Player> {
    // Fields, Getters, Setters 생략

    @Override
    public int compareTo(Player o) {
        return o.getScore() - getScore();
    }
}

Comparable 인터페이스의 compareTo() 메서드를 통해 인자로 넘어온 같은 타입의 다른 객체와 대소 비교가 가능합니다. 메서드를 호출하는 객체가 인자로 넘어온 객체보다 작을 경우에는 음수를 리턴하고, 크기가 동일하다면 0, 클 경우에는 양수를 리턴해야합니다.

게이머 랭키 페이지의 경우 높은 점수 순으로 내림 차순 정렬을 원하기 때문에, 인자로 넘어온 게이머의 점수에서 메서드를 호출하는 게이머의 점수를 빼면 됩니다. 예를 들어 인자로 넘어온 게이머의 점수가 982이고 compareTo() 메서드를 호출하는 객체의 점수가 1018이라면, compareTo() 메서드는 음수(982-1018)를 리턴하게 되며, 이는 곧 메서드를 호출하는 게미머가 인자로 넘어온 게이머보다 작다는 것을 의미합니다. 다시 말해, 메서드를 호출를 호출하는 메서드가 점수가 더 크지만, 객체 자체 비교에서는 인자로 넘어온 게이머보다 작은 객체가 됩니다.

 

Collections.sort(players);
System.out.println(players); // [Player(name=Chloe, score=1090), Player(name=Eric, score=1018), Player(name=Bob, score=982), Player(name=Dale, score=982), Player(name=Alice, score=899)]

 

 

이제 Collections.sort() 메서드에는 Comparable 인터페이스를 구현한 Comparable 타입의 Player 객체의 리스트가 인자로 넘어가기 때문에 더 이상 컴파일 에러가 발생하지 않습니다. 정렬 후 게이머 리스트를 출력해보면 원하는 바와 같이 점수가 제일 높은 Chloe 가 리스트의 맨 앞으로 위치하고, 점수가 제일 낮은 Alice 가 리스트의 맨 뒤에 위치하게 됩니다.

 

 

 

Comparator 객체 사용

만약 정렬 대상 클래스의 코드를 직접 수정할 수 없는 경우에는 어떻게 객체의 정렬 기준을 정의할 수 있을까요? 또는 정렬 하고자 하는 객체에 이미 존재하고 있는 정렬 기준과 다른 정렬 기준으로 정렬을 하고 싶을 때는 어떻게 해야할까요?

이 때 필요한 것이 바로 Comparable 인터페이스와 이름이 유사한 Comparator 인터페이스입니다. Comparator 인터페이스의 구현체를 Arrays.sort()나 Collections.sort()와 같은 정렬 메서드의 추가 인자로 넘기면 정렬 기준을 누락된 클래스의 객체나 기존 정렬 기준을 무시하고 새로운 정렬 기준으로 객체를 정렬할 수 있습니다.

 

 

Comparator<Player> comparator = new Comparator<Player>() {
    @Override
    public int compare(Player a, Player b) {
        return b.getScore() - a.getScore();
    }
};

Collections.sort(players, comparator);
System.out.println(players); // [Player(name=Chloe, score=1090), Player(name=Eric, score=1018), Player(name=Bob, score=982), Player(name=Dale, score=982), Player(name=Alice, score=899)]

 

 

 

위 코드는 Comparator 객체를 Collections.sort() 메서드의 두번째 인자로 넘겨서 이전 섹션과 동일한 정렬 결과를 만들어 내고 있습니다. 이렇게 Comparator 객체를를 인자로 넘기면, 정렬 대상 객체가 Comparable 인터페이스를 구현 여부와 상관없이, 넘어온 Comparator 구현체의 compare() 메서드 기준으로 정렬을 수행합니다. compare() 메서드는 비교 대상 2 개의 객체를 인자를 차례로 인자로 받습니다. 첫번째 인자가 두번째 인자보다 작다면 음수, 같다면 0, 크다면 양수를 리턴하면 됩니다.

 

 

람다 함수로 대체

Comparator 객체는 메서드가 하나 뿐인 함수형 인터페이스를 구현하기 때문에 람다 함수로 대체가 가능합니다.

 

 

Collections.sort(players, (a, b) -> b.getScore() - a.getScore());
System.out.println(players); // [Player(name=Chloe, score=1090), Player(name=Eric, score=1018), Player(name=Bob, score=982), Player(name=Dale, score=982), Player(name=Alice, score=899)]

 

 

 

 

Stream 으로 정렬

Stream 클래스의 sorted() 메서드도 Comparator 객체를 인자로 받아 정렬을 해줍니다. 스트림을 사용하면 위에서 살펴본 배열과 리스트의 정렬과 달리 기존 객체의 순서를 변경하지 않고, 새롭게 정렬된 객체를 생성하고자 할 때 사용됩니다.

 

List<Player> sortedPlayers = players.stream()
        .sorted((a, b) -> b.getScore() - a.getScore())
        .collect(Collectors.toList());
System.out.println(sortedPlayers); // [Player(name=Chloe, score=1090), Player(name=Eric, score=1018), Player(name=Bob, score=982), Player(name=Dale, score=982), Player(name=Alice, score=899)]

 

 

 

ref : https://www.javastudypoint.com/2019/03/comparable-vs-comparator-in-java.html

ref : https://www.daleseo.com/java-comparable-comparator/

ref :https://server-engineer.tistory.com/808

반응형
반응형

JAVA에서 기본적인 자료 구조를 제공하기 위한 환경을 JAVA Collection Framework라고 한다.

다음은 JAVA Collection Framework의 상속 기본 구조이다.

 

 

 

 

 

  1.  Collection 인터페이스를 상속받아 List와 Set 인터페이스가 된다. List는 순서가 있는 Collection, 그리고 List는 Data 중복을 허락한다. 하지만 Set은 순서의 의미가 없으며 Data를 중복해서 포함할 수 없다.
  2. Collection
  • List 인터페이스의 특징
    • 순서가 있는 Collection.(이 순서는 삽입된 순서를 의미한다.)
    • Data를 중복해서 포함할 수 있다.
    • Stack의 특징
      • Data의 삽입과 추출이 후입선출(Last-In First-Out) 구조로 되어 있다.
      • push() method : Data 삽입할 때 사용
      • pop() method : Data 추출할 때 사용
      • peek() method : 추출할 Data를 삭제하지 않고 Data만을 가져 올 때 사용
      • search() method : Stack으로부터 Data를 검색할 때 사용
    • Vector의 특징
      • 자동으로 동기화를 보장해준다.
      • ArrayList에 동기화가 보장되도록 최적화한 클래스이다.
      • JAVA 5.0 이 후로는 AutoBoxing/AutoUnBoxing을 지원한다.
        • AutoBoxing이란? 기본 Data 타입을 Wrapper 클래스형의 객체로 자동으로 변환해주는 기능. AutoUnBoxing은 AutoBoxing의 반대 개념
        • JAVA 1.4까지
Vector v = new Vector();
v.addElement(new Integer(100));
  • JAVA 5.0이후
Vector v = new Vector();
v.addElement(100); // AutoBoxing 발생, 자동으로 Wrapper class인 Integer로 변경
  • addElement() method : Data를 삽입할 때 사용
  • elementAt() method : Data를 추출할 때 사용, Index에 해당하는 객체를 얻어냄
  • size() method : Vector 내에 존재하는 객체의 수를 얻어낼 대 사용
  • insertElementAt() method : Vector 내에 중간 삽입할 때 사용
  • setElementAt() method : Vector 내에 존재하는 Data를 수정할 때 사용
  • indexOf() method : Vector 내에 Data를 검색할 때 사용, Index를 반환
  • contains() method : Data의 존재 유무를 알기 위해 사용.
  • ArrayList의 특징
    • 동기화를 보장해주지 않는다.
    • 배열에 동적 메모리 증가 기능을 구현한 클래스이다.
    • 동기화 지원 방법 : List list = Collections.synchronizeList(new ArrayList(…));
    • add() method : Data 삽입할 때 사용
    • get(0 method : Data 추출할 때 사용
    • toArray() method : ArrayList로부터 배열 얻어낼 때 사용
    • contains() method : Data의 존재 유무를 알기 위해 사용
    • size() method : ArrayList의 요소 개수를 얻어낼 때 사용
  • Set 인터페이스의 특징
    • 집합적인 개념의 Collection
    • 순서의 의미가 없다.
    • Data를 중복해서 포함할 수 없다.
    • HashSet의 특징
      • add() method : Data 삽입할 때 사용
      • next() method : Data 추출할 때 사용
        • HashSet의 Data 추출은 Iterator을 이용하면 된다. Iterator는 Collection내의 모든 Data에 접근할 수 있는 특징이 있다. 그리고 Data의 마지막에 상관하지 않고 검색하기 위한 인터페이스이다. Set의 Iterator() method로 Iterator를 얻어 낼 수 있으며, Iterator의 hasNext() method를 이용해서 Data 끝을 만날 때까지 next() method를 호출해서 Data를 추출할 수 있다.
Iterator<String iter = set.iterator();
while(iter.hasNext()) {
String temp = iter.next();

System.out.print(temp + ", ");
}
  • remove() method : Data를 삭제할 때 사용
  • contains() method : Data의 포함여부를 알기 위해 사용
  • size() method : HashSet의 요소 개수를 얻어낼 때 사용
       
  1. Map
    List와 Set이 순서나 집합적인 개념의 인터페이스라면 Map은 검색의 개념이 가미된 인터페이스이다. Map 인터페이스는 데이터를 삽입할 때 Key와 Value의 형태로 삽입되며, Key를 이용해서 Value를 얻을 수 있다.
  • Hashtable, HashMap의 공통점
    • 내부적으로 모두 Hash 기법을 이용한다.
    • Map 인터페이스를 구현하고 있다.
    • Key와 Value를 이용해서 Data를 관리한다.
  • Hashtable, HashMap의 차이점
    • Hashtable은 동기화가 보장된다.
    • HashMap은 동기화가 보장되지 않는다.
    • HashMap의 동기화 지원 방법 : Map m = Collections.synchronizedMap(New HashMap(…));
  • Hashtable, HashMap과 HashSet과의 관계
    • Hashtable과 HashMap은 둘 다 Map 인터페이스를 구현하고 있다.
    • HashSet은 내부적으로 Hash기법을 사용하지만 Set인터페이스를 구현하고 있다.
  • HashMap
    • 객체 생성 : Map<String, Integer> map = new HashMap<String, Integer>();
    • put() method : Data 삽입할 때 사용
    • get() method : Data를 추출할 때 사용, argument값은 Key를 사용
  • Hashtable
    • 객체 생성 : Hashtable<String, Object> h = new Hashtable<String, Object>();
    • put() method : Data 삽입할 때 사용
    • get() method : Data를 추출할 때 사용, argument값은 Key를 사용

   

  1. Sorted
    Set과 Map 인터페이스를 상속받아 정렬 기능이 추가된 SortedSet과 SortedMap 인터페이스가 된다. 그리고 이들은 각각 TreeSet 클래스와 TreeMap 클래스로 구성된다. TreeSet과 TreeMap은 Set과 Map의 기능을 가지고 있으면서 정렬 기능이 가미되었다는 것이 특징이다.
  • Sorted를 지원하지 않는 클래스
    • HashSet, HashMap
  • Sorted를 지원하는 클래스
    • TreeSet, TreeMap
  • TreeMap
    • Key와 Value로 Data를 관리
    • Key를 기준으로 오름차순으로 정렬된다.
    • Map 인터페이스를 상속한 SortedMap 인터페이스를 구현한 클래스
  • TreeSet
    • Set 인터페이스를 상속한 SortedSet 인터페이스를 구현한 클래스
    • 데이터들이 자동으로 오름차순으로 정렬된다.
  • Comparator
    • TreeSet과 TreeMap은 사용자가 직접 정렬의 방식을 지정할 수 있다.
    • TreeSet과 TreeMap은 정렬을 위한 Comparator 인터페이스를 구현하면 된다.
    • TreeSet에 Data를 집어 넣으면 기본적으로 오름차순(Ascending) 정렬이 되지만 그것도 문자열이나 기본 데이터 타입과 같은 단순한 것에만 해당된다. 이에 사용자가 직접 비교법을 넣어주기 위해 사용하는 것이 Comparator 인터페이스이다.
    • Comparator의 구현 방법 : Comparator 내부에 compare() method를 구현하면 된다.
class Mycomparator<T> implements Comparator<T> {
public int compare(T o1, T o2) {
// 비교방법 구현
}
  • Comparator가 추가된 TreeSet의 생성
TreeSet<Score> tset = new TreeSet<Score>(new MyComparator<Score>());
  • Comparator가 추가된 TreeMap의 생성
TreeMap<Score, String> tset = new TreeMap<Score, String>(new MyComparator<Score>());
  • 일반적인 정렬기능의 사용
    • HashSet이나 HashMap을 정렬 기능이 지원되는 TreeSet이나 TreeMap으로 변환해서 사용
    • HashSet을 이용한 TreeSet 생성
Set<String> set = new HashSet<String>();
...
TreeSet<String> ts = new TreeSet<String>();
ts.addAll(set);
  • HashMap을 이용한 TreeMap 생성
Map<String, Integer> map = new HashMap<String, Integer>();
...
Map<String, Integer> sortedMap = new TreeMap<String, Integer>();
sortedMap.putAll(map);




ref : https://withwani.tistory.com/150

반응형
반응형

http://www.javastudy.co.kr/docs/getjava/rmi/1-rmi_con.htm

1. RMI 개념

1> 분산 시스템이란
RMI(Remote Method Invocation)을 이해하기 위해서는 분산시스템에 대한 기본적인 이해가 있어야 한다. 분산시스템이란 네트위크로 연결된 여러 대의 컴퓨터에 하나의 프로그램이 분산되어 실행되면서 마치 하나의 프로그램처럼 움직이는 시스템을 의미한다. 이는 실행하고자하는 프로그램 소스는 다른 컴퓨터에 있으나 이 소스를 마치 내 컴퓨터에 있는 것처럼 자유롭게 메서드를 호출 실행한다는 의미이다.
분산시스템이 가능하려면 여러 컴퓨터가 네트워크에 연결되어 있어야 한다. 이런 분산 시스템에서 널리 사용된 방식으로는 RPC (Remote Procedure Call)라는 기술이다. RPC는 네트워크에 연결되어 있는 다른 컴퓨터에 존재하는 함수를 사용자가 눈치채지 못하도록 실행해 줌으로써 분산시스템의 구현을 가능하게 했다. 그러나, RPC는 객체지향 개발개념을 구현하지는 않으며 단지 다른 컴퓨터에 저장되어 있는 순처적인 언어로 개발된 애플리케이션의 함수를 부를 수 있도록 해주는 역할을 할 따름이다. 대표적인 분산시스템으로 UNIX의 NFS (Network File System), AFS (Andrew File System), CODA 등이 있다.
자, 정리를 하자면,
  • 분산시스템이란 ?
    네트워크로 연결된 여러대의 컴퓨터에서 하나의 응용 프로그램이 여러곳에서 분산되어 실행되어 마치 하나의 프로그램이 실행되는 것처럼 보이도록하는 시스템
2> RMI(Remote Method Invocation) 란
살펴본 분산 시스템을 자바에서 지원해 주는 패키지가 rmi이다. 즉 RMI란 원격 메서드 호출로 네트워크상에서 떨어져 있는 객체의 메서드를 투명하게 호출하는 것을 말한다. 즉 네트워크로 연결된 다른 컴퓨터에 존재하는 메서드를 다른 컴퓨터에서 마치 내 컴퓨터에 있는 듯이 호출해서 사용하게끔 해주는 것이 바로 java.rmi 패키지이다.
여기서 네트워크상에 떨어져 있는 객체를 Remote객체(또는 원격객체)라 하고 이를 호출하는 것을 local 객체(또는 로컬 객체)라 한다.
RMI도 PRC와 마찬가지로 프로그래머가 소켓 통신에 대한 고려 없이 RMI관련 클래스만으로 프로그램을 작성하면 그외 모든 네트워크 관련 처리라든지 하는 여러 처리를 담당해 준다. 따라서 RMI를 이용하면 복잡한 소켓 프로그래밍 없이 네트워크 응용을 만들 수있다.
아직은 이해가 잘 안될 것이다. 당연한 것이므로 자학(?)하지 말고 다음으로 넘어가자.
3> RMI를 이용한 프로그램의 동작
그림을 보면 원격 컴퓨터에서 컴파일된 자바 소스 A가 존재한다면 로컬에서 자바 소스 B가 네트워크를 통해 A의 메서드를 호출한다. 이때 원격과 로컬 컴퓨터에는 둘다 자바가상머신이 존재해야 하며, 네트워크로 연결되어 있어야 한다.

반응형
반응형


가비지 콜렉션 S/W H/W

2010/05/26 08:42

복사http://skichase.blog.me/70086734516

가비지(Garbage)

프로그램에서 더이상 사용하지 않는 메모리 영역

가비지 콜렉션 (Garbage Collection)

프로그램에서 더이상 사용하지 않는 메모리 영역을 정리해서 프로그램의 다른부분에서 사용할 수 있게 하는 작업. 자바에서는 JVM이 가비지 콜렉션 작업을 자동으로 해준다.

Mark-Sweep 방식

일반적인 JVM이 가비지 콜렉션하는 방식으로, 객체에 메모리를 조사하여 객체를 참조하는 핸들이 있는 경우에는 체크하고, 객체 참조 핸들이 없는 경우에는 체크를 해제해서, 체크가 해제된 객체들을 정리하는 방식

가비지 콜렉션 작업은 우선순위가 낮은 쓰레드로 처리하여, 일반적으로 다른 스레드가 모두 수행된 후 가비지 콜렉션 작업이 수행된다.

메모리에 여유가 공간이 없어진 경우나, 프로그램에서 가비지 콜렉션작업을 강제로 수행하라고 지시하는 경우는 다른 스레드와 같이 수행된다.

프로그램에서 가비지 콜렉션작업을 강제로 수행하라고 지시하는 것은 작업 요청하는 것이, 가비지 콜렉션작업을 보장하는 것은 아니다.
예)
System.gc();
또는
Runtime.getRuntime().gc();

파일 닫기나 데이터베이스 닫기 같은 가베지 콜렉션이 일어날 때 같이 수행할 코드가 필요한 경우는 Object클래스에 finalize()를 오버라이딩해서 쓴다.

protected void finalize() throws Throwable

가비지 콜렉션 예제

public class Garbage

{

public static void main(String[] args)

{

int a = 120;
int b;
String c = "Traffic120";
String d = "JAVA GOOD";

b = a;
c = c + d;
d = c + d;
c = null;
// c는 가비지 콜렉션 대상이 된다.
// 가비지 콜렉션 작업이 어느 시점에서 이루어 지는지 보장할 수 없다.

System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
}

실행결과
120
120
null
Traffic120JAVA GOODJAVA GOOD

반응형

+ Recent posts