Beemo 개발 블로그

카카오 sdk v2 굳이 자바로 사용하기 -2 (카카오 링크 메시지)

Beemo_ — Sat, 20 Feb 2021 13:44:33 +0900

[개발/Android] - 카카오 sdk v2 굳이 자바로 사용하기 -1 (카카오 로그인)

전 포스팅 로그인에 이어서 카카오 메시지 보내는 방법을 자바 코드로 작성하였습니다.

1. kotlin으로 카카오 링크 메시지 보내기

class KakaoLink {

    companion object {
        @JvmStatic
        val instance by lazy { KakaoUtil() }
    }
    fun kakaoLink(context : Context) {

        val defaultFeed = FeedTemplate(
                content = Content(
                        title = "타이틀",
                        description = "메시지 내용",
                        imageUrl = "이미지 경로",
                        link = Link(
                                webUrl = "웹 링크",
                                mobileWebUrl = "모바일 링크"
                                androidExecParams = mapOf("1" to "안드로이드 폰 링크"),
                                iosExecParams = mapOf("1" to "ios 폰 링크")
                        )
                )
        )
        LinkClient.instance.defaultTemplate(context, defaultFeed) { linkResult, error ->
            if (error != null) {
                Log.e("TAG", "카카오링크 보내기 실패", error)
            }
            else if (linkResult != null) {
                context.startActivity(linkResult.intent)

                // 카카오링크 보내기에 성공했지만 아래 경고 메시지가 존재할 경우 일부 컨텐츠가 정상 동작하지 않을 수 있습니다.
                Log.w("TAG", "Warning Msg: ${linkResult.warningMsg}")
                Log.w("TAG", "Argument Msg: ${linkResult.argumentMsg}")
            }
        }
    }
}

2. Java로 카카오 링크 메시지 보내기

public class TestKakaoMsg {

    public void kakaoLink(Context context) {
        /**
         * new Link() : 파라미터 순서대로 webLink, mobileLink, androidLink, iosLink
         */
        FeedTemplate feedTemplate = new FeedTemplate(new Content("title","imageUrl",    //메시지 제목, 이미지 url
                new Link("https://www.naver.com"),"description",                    //메시지 링크, 메시지 설명
                300,300));                                                     //이미지 사이즈

        LinkClient.getInstance().defaultTemplate(context, feedTemplate,null,new Function2<LinkResult, Throwable,Unit>() {
            @Override
            public Unit invoke(LinkResult linkResult, Throwable throwable) {
                if (throwable != null) {
                    Log.e("TAG", "카카오링크 보내기 실패", throwable);
                }
                else if (linkResult != null) {
                    context.startActivity(linkResult.getIntent());

                    // 카카오링크 보내기에 성공했지만 아래 경고 메시지가 존재할 경우 일부 컨텐츠가 정상 동작하지 않을 수 있습니다.
                    Log.w("TAG", "Warning Msg: "+ linkResult.getWarningMsg());
                    Log.w("TAG", "Argument Msg: "+ linkResult.getArgumentMsg());
                }
                return null;
            }
        });
    }
    
}

카카오 sdk v2 굳이 자바로 사용하기 -1 (카카오 로그인)

Beemo_ — Sat, 20 Feb 2021 13:38:03 +0900

[개발/Android] - 카카오 sdk v2 굳이 자바로 사용하기 -2 (카카오 링크 메시지)

카카오 sdk v2는 코틀린으로 가이드가 나와있습니다.

하지만 굳이, 아니면 어쩔 수 없이 자바로 해야되는 분들을 위해 자바로 사용하는 방법을 공유합니다.

sdk init, 앱 등록, 키발급 같은 내용은 생략합니다.

1. kotlin으로 카카오 로그인하기

- Login 코드

class KakaoLogin
{
    interface IKLoginResult
    {
        fun onKakaoLoginResult(user: User?)
    }
    var user:User? = null
    var listener:IKLoginResult? = null

    // 로그인 callback 구성
    val callback: (OAuthToken?, Throwable?) -> Unit = { token, error ->

        if (error != null) {
            Log.e("TAG", "로그인 실패", error)
            if(listener != null)
                listener!!.onKakaoLoginResult(null)
        }
        else if (token != null)
        {
            Log.i("TAG", "로그인 성공 ${token.accessToken}")

            UserApiClient.instance.me { user, error ->

                if (error != null)
                {
                    Log.e("TAG", "사용자 정보 요청 실패", error)
                }
                else if (user != null)
                {
                    Log.i("TAG", "사용자 정보 요청 성공" +
                            "\n회원번호: ${user.id}" +
                            "\n이메일: ${user.kakaoAccount?.email}" +
                            "\n닉네임: ${user.kakaoAccount?.profile?.nickname}" +
                            "\n프로필사진: ${user.kakaoAccount?.profile?.thumbnailImageUrl}")

                    this.user = user

                    if(listener != null)
                        listener!!.onKakaoLoginResult(user)
                }
            }
        }
    }
    fun login(context: Context)
    {
        // 카카오톡이 설치되어 있으면 카카오톡으로 로그인, 아니면 카카오계정으로 로그인
        if (LoginClient.instance.isKakaoTalkLoginAvailable(context))
            LoginClient.instance.loginWithKakaoTalk(context, callback = callback)
        else
            LoginClient.instance.loginWithKakaoAccount(context, callback = callback)
    }
 
	//로그아웃
    fun onLink() {
        UserApiClient.instance.unlink { error ->
            if (error != null) {
                Log.e("TAG", "연결 끊기 실패", error)
            }
            else {
                Log.i("TAG", "연결 끊기 성공. SDK에서 토큰 삭제 됨")

            }
        }
    }

    companion object {
        @JvmStatic
        val instance by lazy { KakaoLogin() }
    }
}

- activity 코드

class TestKakaoActivityKotlin : AppCompatActivity(), KakaoLogin.IKLoginResult  {

    override fun onCreate(savedInstanceState: Bundle?, persistentState: PersistableBundle?) {
        super.onCreate(savedInstanceState, persistentState)
        setContentView(R.layout.activity_main)
        kakaoLogin()
    }
    private fun kakaoLogin() {
        KakaoLogin.instance.listener = this
        KakaoLogin.instance.login(this)
    }
    override fun onKakaoLoginResult(user: User?) {
        //콜백메서드
    }
    
}

2. Java로 카카오 로그인하기

- Login 코드

public class TestKakaoLogin {

    interface IKLoginResult{
        void onKakaoLoginResult(User user);
    }
    private static TestKakaoLogin testKakaoLogin = new TestKakaoLogin();
    IKLoginResult listener;
    public void setListener(IKLoginResult listener){
        this.listener = listener;
    }
    public static TestKakaoLogin getInstance() {
        return testKakaoLogin;
    }
    private TestKakaoLogin() {
        if (testKakaoLogin != null)
            throw new AssertionError();
    }
    private Function2<OAuthToken, Throwable, Unit> callback = new Function2<OAuthToken, Throwable, Unit> () {
        @Override
        public Unit invoke(OAuthToken oAuthToken, Throwable throwable) {

            if (throwable != null) {
                Log.e("error",throwable.getLocalizedMessage());
            } else if (oAuthToken != null) {
                Log.i("success", "로그인 성공");
                UserApiClient.getInstance().me(new Function2<User, Throwable, Unit>() {
                    @Override
                    public Unit invoke(User user, Throwable throwable) {
                        if (user != null) {
                            listener.onKakaoLoginResult(user);

                        }
                        return null;
                    }
                });
            }
            return null;
        }
    };
    public void login(Context context) {
        if (LoginClient.getInstance().isKakaoTalkLoginAvailable(context)) {
            LoginClient.getInstance().loginWithKakaoTalk(context, callback);
        }
    }
}

- activity 코드

public class TestKakaoActivity extends AppCompatActivity implements TestKakaoLogin.IKLoginResult {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        kakaoLogin();

    }
    private void kakaoLogin() {
        TestKakaoLogin.getInstance().setListener(this);
        TestKakaoLogin.getInstance().login(this);
    }
    @Override
    public void onKakaoLoginResult(User user) {
        //콜백메서드
    }
}

자바 tcp/ip 소켓통신

Beemo_ — Sat, 6 Feb 2021 14:33:54 +0900

소켓 : 두 프로그램이 네트워크를 통해 서로 통신할 수 있도록 양쪽에 생성되는 링크의 단자

소켓이 연결되면 서로 다른 프로세스끼리 데이터를 전달할 수 있음

서버	클라이언트
socket()	socket()
bind()
listen()
	connect()
accept()

서버, 클라이언트는 각각 socket을 생성하고 서버는 bind에서 포트번호를 할당한다

그 후에 listen()을 호출하여 클라이언트의 접속을 기다린다.

클라이언트는 connect()를 통해 서버에 접속을 시도한다.

클라이언트 요청이 오면 accept() 함수를 호출에 연결한다.

소켓이 연결되면 recv() / send() 함수를 통해 데이터를 전달하고

마지막에 close()를 호출하여 소켓을 종료한다.

C프로그래밍에서는 socket() -> bind() -> listen() 함수를 코드에서 직접 호출해줘야 된다.

자바에서는 socket.accept() 메서드만 호출하면 Socket클래스 내부에서 socket() -> bind() -> listen()을 호출해준다.

간단한 소켓통신 예제

서버 Class

public class SocketServer {

    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(11111);

            Socket socket = serverSocket.accept();
            //socket -> bind -> listen socket 클래스 내부에 구현되어있음

            System.out.println("connect");
            OutputStream outputStream = socket.getOutputStream();
            for (int i = 0; i < 10; i++) {
                String sendString = "hello";
                outputStream.write(sendString.getBytes());
            }
            outputStream.write("exit".getBytes());
            serverSocket.close();
            socket.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

클라이언트 Class

public class SocketClient {

    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost",11111);
            InputStream inputStream = socket.getInputStream();
            while (true) {
                byte[] bytes = new byte[100];
                inputStream.read(bytes);
                String receive = new String(bytes);
                System.out.println(receive);
                if(receive.equals("exit")) {
                    break;
                }

            }
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

소켓통신으로 간단한 채팅만들기

서버 Class

public class SocketServer2 {

    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(11111);

            while(true) {
                Socket socket = serverSocket.accept();

                ReceiveClass receiveClass = new ReceiveClass();
                receiveClass.setSocket(socket);
                SendClass sendClass = new SendClass();
                sendClass.setSocket(socket);

                receiveClass.start();
                sendClass.start();
            }



        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

서버 ReceiveThread

public class ReceiveClass extends Thread {

    private Socket socket;
    @Override
    public void run() {
        super.run();

        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String receiveString;

            while(true) {
                receiveString = bufferedReader.readLine();
                if (receiveString == null) {
                    System.out.println("disconnect");
                    socket.close();
                    break;
                } else {
                    System.out.println("상대방 : " + receiveString);
                }
            }
            SocketServer2.main(null);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void setSocket(Socket socket) {
        this.socket = socket;
    }
}

서버 SendThread

public class SendClass extends Thread {

    private Socket socket;
    @Override
    public void run() {
        super.run();

        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            PrintWriter printWriter = new PrintWriter(socket.getOutputStream());
            String sendString;
            while (true) {
                sendString = bufferedReader.readLine();
                printWriter.println(sendString);
                printWriter.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void setSocket(Socket socket) {
        this.socket = socket;
    }
}

클라이언트 Class

public class SocketClient {

    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost",11111);
            ReceiveClientClass receiveClientClass = new ReceiveClientClass();
            receiveClientClass.setSocket(socket);
            SendClientClass sendClientClass = new SendClientClass();
            sendClientClass.setSocket(socket);

            sendClientClass.start();
            receiveClientClass.start();


        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

클라이언트 ReceiveThread

public class ReceiveClientClass extends Thread {

    private Socket socket;
    @Override
    public void run() {
        super.run();

        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String receiveString;

            while(true) {
                receiveString = bufferedReader.readLine();
                System.out.println("상대방 : " + receiveString);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void setSocket(Socket socket) {
        this.socket = socket;
    }
}

클라이언드 SendThread

public class SendClientClass extends Thread {

    private Socket socket;
    @Override
    public void run() {
        super.run();

        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            PrintWriter printWriter = new PrintWriter(socket.getOutputStream());
            String sendString;
            while (true) {
                sendString = bufferedReader.readLine();
                if(sendString.equals("exit")) {
                    break;
                }
                printWriter.println(sendString);
                printWriter.flush();
            }
            bufferedReader.close();
            printWriter.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void setSocket(Socket socket) {
        this.socket = socket;
    }
}

Effective Java 3/E - 싱글턴을 만드는 방법

Beemo_ — Sat, 16 Jan 2021 13:42:46 +0900

싱글턴이란 인스턴스를 오직 하나만 생성할 수 있는 클래스

싱글턴을 만드는 3가지 방법

1. public static final 방식

public class Singleton {
    public static final Singleton INSTANCE = new Singleton();
    
    private Singleton() {}
    public void singletonMethod() {}
    
}

private 생성자는 public static final 필드의 Singleton.INSTANCE를 초기화 할 때 한 번만 호출

public이나 protected 생성작 없으므로 클래스가 초기화 될 때 만들어진 인스턴스가 전체 시스템에서 하나뿐임이 보장

예외적으로 권한이 있는 클라이언트는 AccessibleObject.setAccessible을 이용해 private 생성자를 호출 할 수 있음

2. 정적 팩터리 방식

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {}
    public static Singleton getInstance() {
        return INSTANCE;
    }
    public void singletonMethod() {}
}

api를 변경하지 않고도 싱글턴이 아니게 변경할 수 있다.

기타 다른 장점은 뒤에서..(아이템 30, 43, 44)

3. 열거 타입 방식

public enum Singleton {
    INSTANCE;

    public void singletonMethod() {}
}

public 필드 방식과 비슷하지만, 더 간결하고, 추가 노력 없이 직렬화할 수 있다.

리플렉션 공격에서도 제 2의 인스턴스가 생기는 일을 막아준다.

public class Singleton {
    public static final Singleton INSTANCE = new Singleton();

    private Singleton() {

    }
    public static Singleton getInstance() {
        return INSTANCE;
    }
    public void singletonMethod() {
        System.out.println("singletonMethod");
    }

    public static void main(String[] args) {
       // Singleton singleton = new Singleton();
        Class<? extends Singleton> cl = null;
        try {
            cl = (Class<? extends Singleton>) Class.forName("Singleton");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Constructor<? extends Singleton> constructor = null;
        try {
            constructor = cl.getDeclaredConstructor();
            Singleton singleton = constructor.newInstance();
            singleton.singletonMethod();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

    }
}

단, 만들려는 싱글턴이 Enum외의 클래스를 상속해야 한다면 이방법은 사용할 수 없다.

+ 클래스안에서 실수로 생성자를 호출하지 안하도록 막기

public class Singleton {
    public static final Singleton INSTANCE = new Singleton();

    private Singleton() {
        if (INSTANCE !=null)
            throw new AssertionError();
    }
    public static Singleton getInstance() {
        return INSTANCE;
    }
    public void singletonMethod() {}

    public static void main(String[] args) {
        Singleton singleton = new Singleton();
    }
}

Effective Java 3/E - 정적 팩터리 메서드

Beemo_ — Thu, 14 Jan 2021 16:48:17 +0900

클래스는 생성자와 별도로 정적 팩터리 메서드를 제공할 수 있다.

생성자보다 정적 팩터리 메서드가 좋은점

1. 이름을 가질 수 있다.

2. 호출될 때마다 인스턴스를 새로 생성하지는 않아도 된다.

3. 반환 타입의 하위 타입 객체를 반환할 수 있는 능력이 있다.

4. 입력 매개변수에 따라 매번 다른 클래스의 객체를 반환할 수 있다.

5. 정적 팩터리 메서드를 작성하는 시점에는 반환할 객체의 클래스가 존재하지 않아도 된다.

단점

1. 상속을 하려면 public이나 protected생성자가 필요하니 정적 팩터리 메서드만 제공하면 하위 클래스를 만들 수 없다.

2. 정척 팩터리 메서드는 프로그래머가 찾기 어렵다.

정적팩터리 메서드 명명방식

1. from : 매개변수를 하나 받아서 해당 타입의 인스턴스를 반환하는 형변환 메서드

2. of : 여러 매개변수를 받아 적합한 타입의 인스턴스를 반환하는 집계 메서드

3. valueOf : from과 of의 더 자세한 버전

4. instance or getInstance : (매개변수를 받는다면) 매개변수로 명시한 인스턴스를 반환하지만, 같은 인스턴스임을 보장하지는 않는다.

5. create or newInstance : instance 혹은 getInstance와 같지만, 매번 새로운 인스턴스를 생성해 반홤함을 보장한다.

6. getType : getInstance와 같으나, 생성할 클래스가 아닌 다른 클래스에 팩터리 메서드를 정의할 때 쓴다.

7. newType : newInstance와 같으나, 생성할 클래스가 아닌 다른 클래스에 팩터리 메서드를 정의할 때 쓴다.

8. type : getType과 newType의 간결한 버전

자바 스트림 -2

Beemo_ — Fri, 1 Jan 2021 23:59:57 +0900

스트림 최종연산 collect

collect() : 스트림의 최종연산, 매개변수로 컬렉터를 필요

Collector : 인터페이스, 컬렉터는 이 인터페이스를 구현

Collectors : 클래스, static메서드로 미리 작성된 컬렉터를 제공

스트림을 컬렉션과 배열로 변환 : toList(), toSet(), toMap(), toCollection(), to Array()

통계 : Counting(), summingInt(), averagingInt(), maxBy(), minBy()

리듀싱 : reducing()

문자열 결합 : joining(), joining(","), joining("," , "{" , "}");

그룹화와 분할 : groupingBy(), partitioningBy()

Collector 구현하기

public interface Collector<T, A, R> {
    Supplier<A> supplier();
    BiConsumer<A, T> accumulator();
    BinaryOperator<A> combiner();
    Function<A, R> finisher();
    Set<Characteristics> characteristics();
}

supplier() : 작업 결과를 저장할 공간을 제공

accumulator() : 스트림의 요소를 수집(collect)할 방법을 제공

combiner() : 두 저장공간을 병합할 방법을 제공

finisher() : 결과를 최종적으로 변환할 방법을 제공

characteristics() : 컬렉터가 수행하는 작업의 속성에 대한 정보를 제공

Characteristics.CONCURRENT : 병렬로 처리할 수 있는 작업

Characteristics.UNORDERED : 스트림의 요소의 순서가 유지될 필요가 없는 작업

Characteristics.IDENTITY_FINISH : finisher()가 항등 함수인 작업

자바 스트림 -1

Beemo_ — Sat, 26 Dec 2020 14:19:38 +0900

스트림?

- 데이터 소스를 추상화하고, 데이터를 다루는데 자주 사용되는 메서드들을 정의해 놓은 것

- 데이터 소스가 무엇이던 간에 같은 방식으로 다를 수 있게 해줌

- 코드의 재사용성이 높아짐

문자열 정렬, 출력

        String[] strings = {"data1", "data3", "data2"};
        List<String> stringList = Arrays.asList(strings);

        Arrays.sort(strings);
        Collections.sort(stringList);
        for(String string : strings) {
            System.out.println(string);
        }
        for(String string : stringList) {
            System.out.println(string);
        }
        
        Stream<String> stringStream = stringList.stream();
        Stream<String> stringStream2 = Arrays.stream(strings);

        stringStream.sorted().forEach(System.out::println);
        stringStream2.sorted().forEach(System.out::println);

스트림 특징

- 데이터 소스를 변경하지 않음

- 일회용

- 내부 반복으로 처리

스트림 연산

- 중간 연산 : 연산 결과(반환값)이 스트림인 연산

- 최종 연산 : 스트림의 요소를 소모하는 연산

stringStream.sorted().forEach(System.out::println);

에서 sorted()는 중간 연산, forEach는 최종 연산에 해당

- 중간 연산 종류

distinct() - 중복을 제거

filter() - 조건에 안 맞는 요소 제외

limit() - 스트림의 일부를 잘라냄

skip() - 스트림의 일부를 건너뜀

peek() - 스트림의 요소에 작업수행 (스트림의 중간 값을 확인하기에 좋음)

sorted() - 스트림의 요소를 정렬

map, flatMap - 스트림의 요소를 변환

- 최종 연산 종류

forEach(), forEachOrdered() - 각 요소에 지정된 작업 수행

count() - 스트림의 요소의 갯수 반환

max(), min() - 스트림의 최대, 최소 값을 반환

findAny(), findFirst() - 스트림의 요소 하나를 반환(any : 아무거나 1개, first : 첫 번째 요소)

allMatch(), anyMatch(), noneMatch() - 주어진 조건을 모든 요소가 만족시키는지, 만족시키지 않는지 확인

toArray() - 스트림의 모든 요소를 배열로 반환

reduce() - 스트림의 요소를 하나씩 줄여가면서 계산

collect() - 스트림 요소를 수집, 결과를 컬렉션에 담아 반환하는데 사용

- 스트림 연산은 최종 연산이 수행되기 전까지는 중간 연산을 수행하지 않는다(지연된 연산)

- 중간 연산을 호출 해도 어떤 작업이 수행되어야 하는지를 지정할 뿐 연산을 수행하진 않는다.

자바 람다식

Beemo_ — Sat, 19 Dec 2020 14:57:26 +0900

람다식?

- 메서드를 하나의 식으로 표현한 것

- 메서드의 이름과 반환값이 없어지므로, 익명함수라고도 함

람다식 작성법

반환타입 메서드이름 (매개변수) {

//내용

}

(매개변수) -> {

//내용

}

int add(int a, int b) {

return a + b;

}

(int a, int b) -> {

return a + b;

}

(a, b) -> a + b

함수형 인터페이스

Type t = (int a, int b) -> a + b;

interface Function {
    int add(int a, int b);
}

Function function = new Function() {
      @Override
      public int add(int a, int b) {
          return a + b;
      }
};
function.add(1,3);

interface LambdaInterface {
    int add(int a, int b);
}

LambdaInterface lambdaInterface = (int a, int b) -> {return a + b;};
lambdaInterface.add(1,3);

- 인터페이스를 통해 람다식을 다룸

- 람다식을 다루기 위한 인터페이스를 함수형 인터페이스 라고 함

- 함수형 인터페이스는 오직 하나의 추상 메서드만 정의 되어야 한다는 제약이 있음

@FunctionalInterface
interface LambdaInterface {
    int add(int a, int b);
}

- @FunctionalInterface 어노테이션을 선언하면 함수형 인터페이스의 제약에 맞게 정의하였는지 확인해줌

람다식의 외부 변수 참조

@FunctionalInterface
interface LambdaInterface {
    void method();
}

class Outer {
    int val = 10;

    class Inner {
        int val = 20;

        void method(int i) { //final
            int val = 30; //final
            Outer.this.val = 40;
            this.val = 30;
            //val = 20; - 에러
            //i = 40; - 에러
            LambdaInterface lambdaInterface = () -> {
                System.out.println("i : " + i);
                System.out.println("val : " + val);
                System.out.println("this.val : " + this.val);
                System.out.println("Outer.this.val : " + Outer.this.val);
            };
            lambdaInterface.method();
        }
    }
}

- 람다식내에서 참조하는 지역변수는 상수로 간주

- 외부변수들은 상수로 간주되지 않으므로 값의 변경이 가능

 void method(int i) { //final
            int val = 30; //final
            Outer.this.val = 40;
            this.val = 30;
            //val = 20; - 에러
            //i = 40; - 에러
            LambdaInterface lambdaInterface = (i) -> { //에러
                System.out.println("i : " + i);
                System.out.println("val : " + val);
                System.out.println("this.val : " + this.val);
                System.out.println("Outer.this.val : " + Outer.this.val);
            };
            lambdaInterface.method();
        }

- 외부 지역변수와 같은 이름의 람다식 매개변수는 허용되지 않음

java.util.function

Runnable runnable = () -> {}; // void run();
Supplier<String> supplier = () -> {return "string";}; //T get();
Consumer<String> consumer = (String t) -> {}; // void accept(T t);
Function<String, Integer> function = (String t) -> {return 5;}; // R apply(T t) : R은 반환 타입
Predicate<String> predicate = (String t) -> {return false;}; // boolean test(T t);

- java.util.function 패키지안에 미리 정의 된 함수형 인터페이스

- 매번 새로운 인터페이스를 정의 할 필요없이 해당 패키지의 인터페이스를 활용하는 게 좋음

- 메서드 이름의 통일

- 재사용성, 유지보수 측면에서 효율

BiPredicate<String, String> biPredicate = (String t, String u) -> {return false;}; 
//매개변수가 2개면 앞에 Bi가 붙은 interface사용

합성과 결합

합성

andThen, compose

 Function <String, Integer> f = (s) -> Integer.parseInt(s);
 Function <Integer, String> g = (i) -> Integer.toBinaryString(i);
 Function <String, String> h = f.andThen(g); //f 수행 후 g를 수행
 Function <Integer, Integer> h2 = g.andThen(f); //g 수행 후 f를 수행
        
 h = g.compose(f); //f 수행 후 g를 수행
 h2 = f.compose(g);//g 수행 후 f를 수행

결합

and, or, negate

Predicate<Integer> p = i-> i < 100;
Predicate<Integer> q = i-> i < 200;
Predicate<Integer> r = i-> i % 2 == 0;
Predicate<Integer> notP = p.negate(); // i >= 100
        
// 100 <= i && (i < 200 || i % 2 == 0) 
Predicate<Integer> result = notP.and(q.or(r));
System.out.println(result.test(150)); // true

프로그래머스 해시 - 베스트앨범

Beemo_ — Sat, 12 Dec 2020 13:55:27 +0900

해시문제 베스트 앨범

코드

class Solution {
    public int[] solution(String[] genres, int[] plays) {
        int[] answer = {};
        HashMap<String,PlayData> map = new HashMap<>();
        for (int i = 0; i < genres.length; i++) {
            PlayData playData;
            playData = new PlayData(i);
            playData.put(i, plays[i]);
            map.merge(genres[i], playData, PlayData::merge);
        }
        Iterator iterator = PlayData.sortByTotalValue(map).iterator();
        ArrayList<Integer> list = new ArrayList<>();

        while(iterator.hasNext()) {
            String temp = (String) iterator.next();
            HashMap<Integer, Integer> result = map.get(temp).getPlayList();
            Iterator playIterator = sortByValue(result).iterator();
            int i = 0;
            while(playIterator.hasNext() && i < 2) {
                i++;
                list.add((int)playIterator.next());
            }

        }
        answer = list.stream().mapToInt(i->i).toArray();

        return answer;
    }

    public static List sortByValue(HashMap allList) {

        List<Integer> list = new ArrayList();
        list.addAll(allList.keySet());
        Collections.sort(list,new Comparator() {
            public int compare(Object o1,Object o2) {
                Object v1 = allList.get(o1);
                Object v2 = allList.get(o2);
                return ((Comparable) v2).compareTo(v1);
            }

        });
        return list;

    }
}

class PlayData {
    private HashMap<Integer, Integer> allList = new HashMap<>();

    private int total = 0;
    int index;
    int plays;
    public PlayData(int index) {
        this.index = index;
    }
    public HashMap<Integer, Integer> getPlayList() {
        return allList;
    }
    public int getTotal() {
        return total;
    }
    public int[] getPlayInfo() {
        return new int[]{index, plays};
    }
    public void put(int index, int plays) {
        this.plays = plays;
        this.total += plays;
        allList.put(index, plays);
    }

    public static PlayData merge(PlayData playData, PlayData playData1) {

        int[] value = playData1.getPlayInfo();
        playData.put(value[0], value[1]);
        return playData;
    }
    public static List sortByTotalValue(HashMap allList) {

        List<Integer> list = new ArrayList();
        list.addAll(allList.keySet());
        Collections.sort(list,new Comparator() {
            public int compare(Object o1,Object o2) {
                Object v1 = ((PlayData)allList.get(o1)).getTotal();
                Object v2 = ((PlayData)allList.get(o2)).getTotal();
                return ((Comparable) v2).compareTo(v1);
            }
        });
        return list;
    }
}

코드 내용 요약

for (int i = 0; i < genres.length; i++) {
PlayData playData;
playData = new PlayData(i);
playData.put(i, plays[i]);
map.merge(genres[i], playData, PlayData::merge);
}

한 장르의 데이터를 맵에 넣기위해 PlayData 클래스를 만들어서 같은 장르를 인덱스별로 보관하기 위해 PlayData 클래스 내부에 allList라는 맵을 만들어주고 인덱스와 플레이 횟수를 저장해줌

public static PlayData merge(PlayData playData, PlayData playData1) {
int[] value = playData1.getPlayInfo();
playData.put(value[0], value[1]);
return playData;
}

map.merge를 사용해서 같은 장르의 앨범을 PlayData 안의 allList에 넣도록 해줌

public static List sortByTotalValue(HashMap allList) {
List<Integer> list = new ArrayList();
list.addAll(allList.keySet());
Collections.sort(list,new Comparator() {
public int compare(Object o1,Object o2) {
Object v1 = ((PlayData)allList.get(o1)).getTotal();
Object v2 = ((PlayData)allList.get(o2)).getTotal();
return ((Comparable) v2).compareTo(v1);
}
});
return list;
}

총 플레이 횟수를 기준으로 정렬시키기 위한 코드
list.addAll(allList.keySet()); 로 키값의 list를 리턴할 수 있도록 처리

public static List sortByValue(HashMap allList) {

List<Integer> list = new ArrayList();
list.addAll(allList.keySet());
Collections.sort(list,new Comparator() {
public int compare(Object o1,Object o2) {
Object v1 = allList.get(o1);
Object v2 = allList.get(o2);
return ((Comparable) v2).compareTo(v1);
}
});
return list;
}

같은 장르의 노래들을 플레이 수 순으로 정렬 후
while(playIterator.hasNext() && i < 2) {
i++;
list.add((int)playIterator.next());
}

최상위 곡 2개를 뽑아서 저장

answer = list.stream().mapToInt(i->i).toArray();

문제의 리턴형은 int형 배열이기 때문에 list를 int형 array로 바꾸는 mapToInt를 사용하여 변환

프로그래머스 DP - 등굣길

Beemo_ — Tue, 8 Dec 2020 15:29:41 +0900

동적계획법 등굣길 문제

코드

class Solution {
    public int solution(int m, int n, int[][] puddles) {
        int answer = 0;
        int[][] dp = new int[m+1][n+1];
        for (int[] puddle : puddles) {
            dp[puddle[0]][puddle[1]] = -1;
        }


        dp[1][0] = 1;
        for (int i = 1; i <= m; i++) {

            for (int j = 1; j <= n; j++) {
                if (dp[i][j] == -1) {
                    dp[i][j] = 0;
                } else {
                    dp[i][j] = (dp[i][j-1]+dp[i-1][j]) % 1000000007;
                }
            }
        }
        answer = dp[m][n];
        return answer;
    }
}

코드 내용 요약

int[][] dp = new int[m+1][n+1];
        for (int[] puddle : puddles) {
            dp[puddle[0]][puddle[1]] = -1;
        }

물웅덩이의 위치를 -1로 셋팅 그 외에는 0으로 셋팅(자바에서는 초기화와 동시에 배열값이 0으로 셋팅 된다.)

dp[1][0]

집의 시작지점은 1가지 길이기 때문에 1로 셋팅

for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
                if (dp[i][j] == -1) {
                    dp[i][j] = 0;
                } else {
                    dp[i][j] = (dp[i][j-1]+dp[i-1][j]) % 1000000007;
                }
            }
}

물웅덩이로 가는길 (dp[i][j] == -1) 은 갈 수 있는 길이 0가지 이므로 0으로 재 셋팅

그 외에는 해당 위치의 위와 왼쪽의 갈 수 있는 길의 갯 수 합이 해당 지점으로 가는 길의 갯수가 되므로 더함

문제에서 1000000007로 나눈 나머지 값을 저장 하라고 했으니 % 1000000007로 계산

dp[m][n]이 최종 목적지 까지 가는 길의 갯 수가 됨.