<div id="readability-page-1" class="page"><div id="dkContent" role="main">

					

					<p>
						<h2><span>Kim-Baek 개발자 이야기</span></h2>
					</p>

					           
               
	


	
		
		<div>
			<p><strong><a href="/category/%EA%B0%9C%EB%B0%9C/java%20basic">개발/java basic</a></strong></p><h3>자바에서 코틀린 - 6장 자바에서 코틀린 컬렉션으로</h3>
			<p><span>김백개발자
                           <span></span>2023. 4. 17. 07:36
			
		</span>
		</p></div>

		<div><p data-ke-size="size16">자바의 컬렉션은 가변이다. 이 때문에 발생하는 문제를 먼저 살펴본다</p>
<p data-ke-size="size16">6.1</p>
<pre><code>package travelator;

public class Suffering {

    public static int sufferScoreFor(List&lt;Journey&gt; route) {
        Location start = getDepartsFrom(route);
        List&lt;Journey&gt; longestJourneys = longestJourneysIn(route, 3);
        return sufferScore(longestJourneys, start);
    }

}
</code></pre>
<ul data-ke-list-type="disc">
<li>start 가 별게 없어서 인라인 한다. (6.2)</li>
</ul>
<p data-ke-size="size16">6.2</p>
<pre><code>public static int sufferScoreFor(List&lt;Journey&gt; route) {
        List&lt;Journey&gt; longestJourneys = longestJourneysIn(route, 3);
        return sufferScore(longestJourneys, getDepartsFrom(route));
    }
</code></pre>
<ul data-ke-list-type="disc">
<li>이렇게 하고 난 뒤 문제가 발생한다.</li>
</ul>
<p data-ke-size="size16">6.3</p>
<pre><code>package travelator;

import java.util.List;

public class Routes {

    public static Location getDepartsFrom(List&lt;Journey&gt; route) {
        return route.get(0).getDepartsFrom();
    }

}
</code></pre>
<ul data-ke-list-type="disc">
<li>위처럼 수정한 후, 출발 로케이션을 찾는 곳에서 버그 발생</li>
</ul>
<p data-ke-size="size16">6.4</p>
<pre><code>public static List&lt;Journey&gt; longestJourneysIn(
        List&lt;Journey&gt; journeys,
        int limit
    ) {
        journeys.sort(comparing(Journey::getDuration).reversed()); // &lt;1&gt;
        var actualLimit = Math.min(journeys.size(), limit);
        return journeys.subList(0, actualLimit);
    }
</code></pre>
<ul data-ke-list-type="disc">
<li>longestJourneysIn 에서 Sort 가 순서를 바꿔버렸다.</li>
<li>Collections.unmodifiableList() 를 썼으면?
<ul data-ke-list-type="disc">
<li>실행 시점에 확인이 가능
<ul data-ke-list-type="disc">
<li>UnsupportedOperationException 에러가 났을 것이다.</li>
</ul>
</li>
<li>래핑을 하는 것이기 때문에 원본리스트를 변경할 수 있다면 역시나 문제가 생길 수 있음.</li>
</ul>
</li>
</ul>
<blockquote data-ke-style="style1">
<p data-ke-size="size16"><b>공유된 컬렉션을 변경하지 말라</b></p>
</blockquote>
<ul data-ke-list-type="disc">
<li>다른 코드에서 공유되는 컬렉션이 있으면 불변 컬렉션으로 취급하라</li>
<li>불변이 아닐지라도 이 원칙을 적용해라</li>
<li>생성하되 변경하지 말라. ( <b>전략</b> )</li>
<li>자바 컬렉션
<ul data-ke-list-type="disc">
<li>가변</li>
</ul>
</li>
<li>스칼라
<ul data-ke-list-type="disc">
<li>불변 컬렉션 ( 자바와 쓰기 위해서 컬렉션 복사 필요 )</li>
</ul>
</li>
<li>코틀린
<ul data-ke-list-type="disc">
<li>자바의 컬렉션 인터페이스에서 상태를 변경하는 메소드 제거
<ul data-ke-list-type="disc">
<li>List&lt;E&gt; , Collection&lt;E&gt;</li>
<li>상태 변경을 위해서, 위의 인터페이스를 확장한 MutableCollection&lt;E&gt;, MutableList&lt;E&gt;</li>
</ul>
</li>
</ul>
</li>
<li>코틀린의 불변 List / MutableList 에 자바의 List 를 대입해 사용된다.
<ul data-ke-list-type="disc">
<li>문제는 불변 값인 List에 가변 리스트가 들어가 값이 변경될 수 있다는 것.</li>
</ul>
<pre><code>val aMutableList = mutableListOf("0","1")
val aList: List&lt;String&gt; = aMutableList //코틀린에서 List 는 불변

aMutableList[0] = "123123"

assertEquals("0", aList[0] )
</code></pre>
<ul data-ke-list-type="disc">
<li>이걸 제대로 해결하려면 불변과 가변의 하위 타입 관계를 없애는 것이다.
<ul data-ke-list-type="disc">
<li>대신 StringBuilder / String 처럼 매번 복사를 해야한다.</li>
</ul>
</li>
<li>그런데 왜 코틀린은 이렇게 안했을까?
<ul data-ke-list-type="disc">
<li>“<b>공유된 컬렉션을 변경하지 말라” →</b> 이걸 지킨다면 안전할 것이라 생각</li>
<li>자바와의 상호 운영성을 가져가기 위해서.</li>
</ul>
</li>
</ul>
<pre><code>inline fun &lt;T, R&gt; Iterable&lt;T&gt;.map(transform: (T) -&gt; R): List&lt;R&gt; {
  val result = ArrayList&lt;R&gt;()
  for (item in this)
    result.add(transform(item))
  return result
}
</code></pre>
<ul data-ke-list-type="disc">
<li>코틀린 표준 라이브러리도 그런 식으로 설계가 되어 있다.</li>
</ul>
자바코드 고치기
<ul data-ke-list-type="disc">
<li>자바의 sort는 복사본을 정렬 후, 원본을 복사본에 일치시킨다. ( 가변 )</li>
<li>이걸 바꾸자</li>
</ul>
6.6</li>
<li>package travelator; public class Collections { @SuppressWarnings("unchecked") public static &lt;E&gt; List&lt;E&gt; sorted( Collection&lt;E&gt; collection, Comparator&lt;? super E&gt; by ) { var result = (E[]) collection.toArray(); // 새로운 어레이 리턴 Arrays.sort(result, by); return Arrays.asList(result); // Array. 를 리턴하는데 원소 추가삭제 불가 } }</li>
</ul>
<blockquote data-ke-style="style1">
<p data-ke-size="size16">•The returned array will be "safe" in that no references to it are maintained by this list. (In other words, this method must allocate a new array). The caller is thus free to modify the returned array.</p>
</blockquote>
<p data-ke-size="size16">6.7</p>
<pre><code>static List&lt;Journey&gt; longestJourneysIn(
        List&lt;Journey&gt; journeys,
        int limit
    ) {
        var actualLimit = Math.min(journeys.size(), limit);
        return sorted(
            journeys,
            comparing(Journey::getDuration).reversed()
        ).subList(0, actualLimit);
    }
</code></pre>
<ul data-ke-list-type="disc">
<li>우리가 새로 만든 sorted 사용
<ul data-ke-list-type="disc">
<li>불변!</li>
</ul>
</li>
</ul>
<p data-ke-size="size16">6.9</p>
<pre><code>public static int sufferScoreFor(List&lt;Journey&gt; route) {
        Location start = getDepartsFrom(route);
        List&lt;Journey&gt; longestJourneys = longestJourneysIn(route, 3);
        return sufferScore(longestJourneys, start);
    }

==========================================================

public static int sufferScoreFor(List&lt;Journey&gt; route) {
        return sufferScore(
            longestJourneysIn(route, 3),
            getDepartsFrom(route));
    }
</code></pre>
<ul data-ke-list-type="disc">
<li>이제 값이 불변이니 다시, 인라이닝 한다.</li>
</ul>
<p data-ke-size="size16">6.10</p>
<pre><code>public static List&lt;List&lt;Journey&gt;&gt; routesToShowFor(String itineraryId) {
        var routes = routesFor(itineraryId);
        removeUnbearableRoutes(routes);
        return routes;
    }

    private static void removeUnbearableRoutes(List&lt;List&lt;Journey&gt;&gt; routes) {
        routes.removeIf(route -&gt; sufferScoreFor(route) &gt; 10);
    }
</code></pre>
<ul data-ke-list-type="disc">
<li>removeUnbearableRoutes 는 void 를 리턴하면서, 내부에서 파라미터를 변경해버리는 구나… 를 알게 해준다.</li>
</ul>
<pre><code>private static List&lt;List&lt;Journey&gt;&gt; removeUnbearableRoutes
        (List&lt;List&lt;Journey&gt;&gt; routes
    ) {
        routes.removeIf(route -&gt; sufferScoreFor(route) &gt; 10);
        return routes;
    }

=============================================

private static List&lt;List&lt;Journey&gt;&gt; bearable
        (List&lt;List&lt;Journey&gt;&gt; routes
    ) {
        return routes.stream()
            .filter(route -&gt; sufferScoreFor(route) &lt;= 10)
            .collect(toUnmodifiableList());
    }
</code></pre>
<ul data-ke-list-type="disc">
<li>기존 값 변경이 아닌, 복사본을 리턴하도록 수정</li>
</ul>
<h2 data-ke-size="size26">이제 코틀린으로 변환</h2>
<pre><code>package travelator

import travelator.Collections.sorted
import travelator.Other.SOME_COMPLICATED_RESULT
import java.util.Comparator.comparing
import java.util.stream.Collectors

object Suffering {
    @JvmStatic
    fun sufferScoreFor(route: List&lt;Journey&gt;): Int {
        return sufferScore(
            longestJourneysIn(route, 3),
            Routes.getDepartsFrom(route)
        )
    }

    @JvmStatic
    fun longestJourneysIn(
        journeys: List&lt;Journey&gt;,
        limit: Int
    ): List&lt;Journey&gt; {
        val actualLimit = Math.min(journeys.size, limit)
        return sorted(
            journeys,
            comparing { obj: Journey -&gt; obj.duration }.reversed()
        ).subList(0, actualLimit)
    }

    fun routesToShowFor(itineraryId: String?): List&lt;List&lt;Journey&gt;&gt; {
        return bearable(Other.routesFor(itineraryId))
    }

    private fun bearable(routes: List&lt;List&lt;Journey&gt;&gt;): List&lt;List&lt;Journey&gt;&gt; {
        return routes.stream()
            .filter { route -&gt; sufferScoreFor(route) &lt;= 10 }
            .collect(Collectors.toUnmodifiableList())
    }

    private fun sufferScore(
        longestJourneys: List&lt;Journey&gt;,
        start: Location
    ): Int {
        return SOME_COMPLICATED_RESULT()
    } 
}
</code></pre>
<pre><code>@JvmStatic
    fun longestJourneysIn(
        journeys: List&lt;Journey&gt;,
        limit: Int
    ): List&lt;Journey&gt; {
        val actualLimit = Math.min(journeys.size, limit)
        return sorted(
            journeys,
            comparing { obj: Journey -&gt; obj.duration }.reversed()
        ).subList(0, actualLimit)
    }

======================================================

@JvmStatic
    fun longestJourneysIn(journeys: List&lt;Journey&gt;, limit: Int): List&lt;Journey&gt; =
        journeys.sortedByDescending { it.duration }.take(limit)

======================================================

// 확장함수
@JvmStatic
    fun List&lt;Journey&gt;.longestJourneys(limit: Int): List&lt;Journey&gt; =
        sortedByDescending { it.duration }.take(limit)
</code></pre>
<ul data-ke-list-type="disc">
<li>확장함수는 클래스에 새로운 함수를 추가하는 것.</li>
</ul>
<pre><code>@JvmStatic
    fun sufferScoreFor(route: List&lt;Journey&gt;): Int {
        return sufferScore(
            route.longestJourneys(limit = 3), // 확장함수 호출
            Routes.getDepartsFrom(route)
        )
    }
</code></pre>
<ul data-ke-list-type="disc">
<li>확장함수 호출하도록 수정한다.</li>
</ul>
<pre><code>private fun bearable(routes: List&lt;List&lt;Journey&gt;&gt;): List&lt;List&lt;Journey&gt;&gt; {
        return routes.stream()
            .filter { route -&gt; sufferScoreFor(route) &lt;= 10 }
            .collect(Collectors.toUnmodifiableList())
    }

======================================================

private fun bearable(routes: List&lt;List&lt;Journey&gt;&gt;): List&lt;List&lt;Journey&gt;&gt; =
        routes.filter { sufferScoreFor(it) &lt;= 10 }
</code></pre>
<ul data-ke-list-type="disc">
<li>list 가 filter 를 확장함수로 제공
<ul data-ke-list-type="disc">
<li>List 반환하기에 toUnmodifiableList 필요 없음</li>
</ul>
</li>
</ul></div>
		

		
			
		

		


	

               
           

					

					

					

					

					

					
				</div></div>

떠억상

자바의 컬렉션은 가변이다. 이 때문에 발생하는 문제를 먼저 살펴본다
6.1
package travelator;
public class Suffering {
    public static int sufferScoreFor(List<Journey> route) {
        Location start = getDepartsFrom(route);
        List<Journey> longestJourneys = longestJourneysIn(route, 3);
        return sufferScore(longestJourneys, start);
    }
}
start 가 별게 없어서 인라인 한다. (6.2)
6.2
public static int sufferScoreFor(List<Journey> route) {
        List<Journey> longestJourneys = longestJourneysIn(route, 3);
        return sufferScore(longestJourneys, getDepartsFrom(route));
    }
이렇게 하고 난 뒤 문제가 발생한다.
6.3
package travelator;
import java.util.List;
public class Routes {
    public static Location getDepartsFrom(List<Journey> route) {
        return route.get(0).getDepartsFrom();
    }
}
위처럼 수정한 후, 출발 로케이션을 찾는 곳에서 버그 발생
6.4
public static List<Journey> longestJourneysIn(
        List<Journey> journeys,
        int limit
    ) {
        journeys.sort(comparing(Journey::getDuration).reversed()); // <1>
        var actualLimit = Math.min(journeys.size(), limit);
        return journeys.subList(0, actualLimit);
    }
longestJourneysIn 에서 Sort 가 순서를 바꿔버렸다.
Collections.unmodifiableList() 를 썼으면?
실행 시점에 확인이 가능
UnsupportedOperationException 에러가 났을 것이다.
래핑을 하는 것이기 때문에 원본리스트를 변경할 수 있다면 역시나 문제가 생길 수 있음.
공유된 컬렉션을 변경하지 말라
다른 코드에서 공유되는 컬렉션이 있으면 불변 컬렉션으로 취급하라
불변이 아닐지라도 이 원칙을 적용해라
생성하되 변경하지 말라. ( 전략 )
자바 컬렉션
가변
스칼라
불변 컬렉션 ( 자바와 쓰기 위해서 컬렉션 복사 필요 )
코틀린
자바의 컬렉션 인터페이스에서 상태를 변경하는 메소드 제거
List<E> , Collection<E>
상태 변경을 위해서, 위의 인터페이스를 확장한 MutableCollection<E>, MutableList<E>
코틀린의 불변 List / MutableList 에 자바의 List 를 대입해 사용된다.
문제는 불변 값인 List에 가변 리스트가 들어가 값이 변경될 수 있다는 것.
val aMutableList = mutableListOf("0","1")
val aList: List<String> = aMutableList //코틀린에서 List 는 불변
aMutableList[0] = "123123"
assertEquals("0", aList[0] )
이걸 제대로 해결하려면 불변과 가변의 하위 타입 관계를 없애는 것이다.
대신 StringBuilder / String 처럼 매번 복사를 해야한다.
그런데 왜 코틀린은 이렇게 안했을까?
“공유된 컬렉션을 변경하지 말라” → 이걸 지킨다면 안전할 것이라 생각
자바와의 상호 운영성을 가져가기 위해서.
inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {
  val result = ArrayList<R>()
  for (item in this)
    result.add(transform(item))
  return result
}
코틀린 표준 라이브러리도 그런 식으로 설계가 되어 있다.
자바의 sort는 복사본을 정렬 후, 원본을 복사본에 일치시킨다. ( 가변 )
이걸 바꾸자
package travelator; public class Collections { @SuppressWarnings("unchecked") public static <E> List<E> sorted( Collection<E> collection, Comparator<? super E> by ) { var result = (E[]) collection.toArray(); // 새로운 어레이 리턴 Arrays.sort(result, by); return Arrays.asList(result); // Array. 를 리턴하는데 원소 추가삭제 불가 } }
•The returned array will be "safe" in that no references to it are maintained by this list. (In other words, this method must allocate a new array). The caller is thus free to modify the returned array.
6.7
static List<Journey> longestJourneysIn(
        List<Journey> journeys,
        int limit
    ) {
        var actualLimit = Math.min(journeys.size(), limit);
        return sorted(
            journeys,
            comparing(Journey::getDuration).reversed()
        ).subList(0, actualLimit);
    }
우리가 새로 만든 sorted 사용
불변!
6.9
public static int sufferScoreFor(List<Journey> route) {
        Location start = getDepartsFrom(route);
        List<Journey> longestJourneys = longestJourneysIn(route, 3);
        return sufferScore(longestJourneys, start);
    }
==========================================================
public static int sufferScoreFor(List<Journey> route) {
        return sufferScore(
            longestJourneysIn(route, 3),
            getDepartsFrom(route));
    }
이제 값이 불변이니 다시, 인라이닝 한다.
6.10
public static List<List<Journey>> routesToShowFor(String itineraryId) {
        var routes = routesFor(itineraryId);
        removeUnbearableRoutes(routes);
        return routes;
    }
    private static void removeUnbearableRoutes(List<List<Journey>> routes) {
        routes.removeIf(route -> sufferScoreFor(route) > 10);
    }
removeUnbearableRoutes 는 void 를 리턴하면서, 내부에서 파라미터를 변경해버리는 구나… 를 알게 해준다.
private static List<List<Journey>> removeUnbearableRoutes
        (List<List<Journey>> routes
    ) {
        routes.removeIf(route -> sufferScoreFor(route) > 10);
        return routes;
    }
=============================================
private static List<List<Journey>> bearable
        (List<List<Journey>> routes
    ) {
        return routes.stream()
            .filter(route -> sufferScoreFor(route) <= 10)
            .collect(toUnmodifiableList());
    }
기존 값 변경이 아닌, 복사본을 리턴하도록 수정
이제 코틀린으로 변환
package travelator
import travelator.Collections.sorted
import travelator.Other.SOME_COMPLICATED_RESULT
import java.util.Comparator.comparing
import java.util.stream.Collectors
object Suffering {
    @JvmStatic
    fun sufferScoreFor(route: List<Journey>): Int {
        return sufferScore(
            longestJourneysIn(route, 3),
            Routes.getDepartsFrom(route)
        )
    }
    @JvmStatic
    fun longestJourneysIn(
        journeys: List<Journey>,
        limit: Int
    ): List<Journey> {
        val actualLimit = Math.min(journeys.size, limit)
        return sorted(
            journeys,
            comparing { obj: Journey -> obj.duration }.reversed()
        ).subList(0, actualLimit)
    }
    fun routesToShowFor(itineraryId: String?): List<List<Journey>> {
        return bearable(Other.routesFor(itineraryId))
    }
    private fun bearable(routes: List<List<Journey>>): List<List<Journey>> {
        return routes.stream()
            .filter { route -> sufferScoreFor(route) <= 10 }
            .collect(Collectors.toUnmodifiableList())
    }
    private fun sufferScore(
        longestJourneys: List<Journey>,
        start: Location
    ): Int {
        return SOME_COMPLICATED_RESULT()
    } 
}
@JvmStatic
    fun longestJourneysIn(
        journeys: List<Journey>,
        limit: Int
    ): List<Journey> {
        val actualLimit = Math.min(journeys.size, limit)
        return sorted(
            journeys,
            comparing { obj: Journey -> obj.duration }.reversed()
        ).subList(0, actualLimit)
    }
======================================================
@JvmStatic
    fun longestJourneysIn(journeys: List<Journey>, limit: Int): List<Journey> =
        journeys.sortedByDescending { it.duration }.take(limit)
======================================================
// 확장함수
@JvmStatic
    fun List<Journey>.longestJourneys(limit: Int): List<Journey> =
        sortedByDescending { it.duration }.take(limit)
확장함수는 클래스에 새로운 함수를 추가하는 것.
@JvmStatic
    fun sufferScoreFor(route: List<Journey>): Int {
        return sufferScore(
            route.longestJourneys(limit = 3), // 확장함수 호출
            Routes.getDepartsFrom(route)
        )
    }
확장함수 호출하도록 수정한다.
private fun bearable(routes: List<List<Journey>>): List<List<Journey>> {
        return routes.stream()
            .filter { route -> sufferScoreFor(route) <= 10 }
            .collect(Collectors.toUnmodifiableList())
    }
======================================================
private fun bearable(routes: List<List<Journey>>): List<List<Journey>> =
        routes.filter { sufferScoreFor(it) <= 10 }
list 가 filter 를 확장함수로 제공
List 반환하기에 toUnmodifiableList 필요 없음

자바에서 코틀린 - 6장 자바에서 코틀린 컬렉션으로

댓글