자바 8지도, 필터 및 스트림을 스칼라로 변환하는 방법은 무엇입니까?

Question

나는 scala에 상응하는 java를 scala로 바꾸어서 이해하려고 노력하는 것이 매우 익숙해 져서 더 나은 이해를 얻는다.

자바 8지도, 필터 및 스트림을 스칼라로 변환하는 방법은 무엇입니까?

public Set<String> getValidUsages(String itemId, long sNo, Date timeOfAccess) {              
    Set<String> itemSet = Sets.newHashSet();                         
    TestWindows testWindows = items.get(itemId).getTestWindows();               

    final boolean isTV = existsEligibleTestWindow(testWindows.getTV(), timeOfAccess);          
    if (isTV) {                                
     itemSet.add(TV);                            
    } else {                                  
     final boolean isCableUseable = existsEligibleTestWindow(testWindows.getCableUse(), timeOfAccess);       
     final boolean isWifi = existsEligibleTestWindow(testWindows.getWifi(), timeOfAccess);        
     if (isCableUseable || isWifi) {                          
      itemSet.add(MOVIE);                           
     }                                  
    }                                   

    if (testWindows.getUsageIds() != null) {                       
     itemSet.addAll(testWindows.getUsageIds()                      
       .entrySet()                              
       .stream()                              
       .filter(entry -> existsEligibleTestWindow(entry.getValue(), timeOfAccess))            
       .map(Map.Entry::getKey)                           
       .collect(Collectors.toSet()));                         
    }                                   

    return itemSet;                                
}                                    

private boolean existsEligibleTestWindow(List<TestWindow> windows, Date timeOfAccess) {           
    if (windows != null) {                              
     return windows.stream()                             
       .filter(w -> withinDateRange(timeOfAccess, w))                     
       .findAny()                              
       .isPresent();                             
    }                                   
    return false;                                
}                                    

private boolean withinDateRange(Date toCheck, TestWindow window) {                  
    return toCheck.after(window.getStartTime()) && toCheck.before(window.getEndTime());               
} 

내가 시도 :

은 내가 스칼라로 변환하려고 다음과 같은 자바 (8) 코드를

def withinDateRange(toCheck: Date, window: TestWindow): Boolean = { 
    toCheck.after(window.getStartTime) && toCheck.before(window.getEndTime) 
    } 


    def getValidUsages(itemId: String, sNo: Long, timeOfAccess: Date): Set[String] = { 
    var itemSet = Sets.newHashSet() 
    val testWindows = items.value(itemId).getTestWindows 
    val isTV = existsEligibleTestWindow(testWindows.get(0).getTV, timeOfAccess) 
    if (isTV) { 
     itemSet += TV 
    } else { 
     val isCableUseable = existsEligibleTestWindow(testWindows.get(0).getCableUse, timeOfAccess) 
     val isWifi = existsEligibleTestWindow(testWindows.get(0).getWifi, timeOfAccess) 
     if (isCableUseable || isWifi) { 
     itemSet += MOVIE 
     } 
    } 
    if (testWindows.get(0).getUsageIds != null) { 
     itemSet.addAll(testWindows.get(0).getUsageIds.entrySet().stream() 
     .filter((x) => existsEligibleTestWindow(x._2, timeOfAccess)).map(x => Map.Entry._1) 
     .collect(Collectors.toSet())) 
    } 
    itemSet 
    } 


    def existsEligibleConsumptionWindow(windows: List[ConsumptionWindow], timeOfAccess: Date): Boolean = { 
if (windows != null) { 
    return windows.exists((x) => withinDateRange(timeOfAccess, x)) 
} 
false 
} 

그러나 필터 스트림을하는 동안 오류가 발생. 어떤 사람이 방향을 지시 할 수 있습니까? 어떤 참조? 나는 getValidUsages에 오류가 점점 오전 :

compile error “cannot resolve reference project with such signature 

Answer 1

def getValidUsages(itemId: String, sNo: long, timeOfAcess: Date): Set[String] = { 
    var itemSet: Set[String] = Sets.newHashSet() 
    val testWindows: TestWindows = items.get(itemId).getTestWindows() 
    val isTV: Boolean = existsEligibleTestWindow(testWindows.getTV(), timeOfAccess) 

    isTV match { 
    case true => itemSet.add(TV) 
    case false => { 
     val isCableUseable: Boolean = existsEligibleTestWindow(testWindows.getCableUse(), timeOfAcess) 
     val isWifi: Boolean = existsEligibleTestWindow(testWindows.getWifi(), timeOfAccess) 
     if(isCableUseable || isWifi) { 
     itemSet.add(MOVIE) 
     } 
    } 
    } 

    if(testWindows.getUsageIds() != null) { 
    itemSet.addAll(testWindows.getUsageIds() 
       .stream. 
       .filter(entry => existsEligibleTestWindow(entry._2, timeOfAccess)) 
       .map(filteredData => Map.Entry._1) 
       .collect Collectors.toSet()) 
    } 
    itemSet 
} 

def existsEligibleTestWindow(windows: List[TestWindow], timeOfAcess: Date): Boolean = { 
    windows match { 
    case null => false 
    case _ => windows.stream.filter(data => withinDateRange(timeOfAcess), data).findAny().isPresent 
    } 
} 

행운을 빕니다 :)

Answer 2

이 내가 사용하는 형식 중 일부에 익숙하지 않은 생각 때문에 대답하기 다소 어렵다. 내가 추측하지만 같은 종류가 있습니다 다음 다음

trait Window { 
    def getStartTime: LocalDate 
    def getEndTime: LocalDate 
} 
trait TestWindows extends Window { 
    def getTV: List[Window] 
    def getCableUse: List[Window] 
    def getWifi: List[Window] 
    def getUsageIds: Map[String, List[Window]] 
} 

그냥이 할 수있는 : 아마도 일부 items 가치가 있었다 원래 코드에서

def withinDateRange(toCheck: LocalDate)(window: Window): Boolean = 
    window.getStartTime.isBefore(toCheck) && window.getEndTime.isAfter(toCheck) 

    // Nothing should ever be null in Scala. If it's possible you don't have any ConsumptionWindows you should either 
    // model it as an empty list or an Option[List[ConsumptionWindow]] 
    def existsEligibleTestWindow(windows: List[Window], 
           timeOfAccess: LocalDate): Boolean = 
    windows.exists(withinDateRange(timeOfAccess)) 


    def getValidUsages(testWindows: TestWindows, timeOfAccess: LocalDate): Set[String] = { 
    val isTV = existsEligibleTestWindow(testWindows.getTV, timeOfAccess) 
    val isCableUse = existsEligibleTestWindow(testWindows.getCableUse, timeOfAccess) 
    val isWifi = existsEligibleTestWindow(testWindows.getWifi, timeOfAccess) 
    val tvOrMovie: Option[String] = if (isTV) Some("TV") 
            else if (isCableUse || isWifi) Some("MOVIE") 
            else None 

    val byUsageId = testWindows.getUsageIds.collect { case (key, windows) if existsEligibleTestWindow(windows, timeOfAccess) => key }.toSet 

    tvOrMovie.toSet ++ byUsageId 
    } 

을하지만 위의 난 그냥 가정 당신은 getValidUsages 함수 외부에서 TestWindows testWindows = items.get(itemId).getTestWindows()을 수행합니다.

내 예는 전혀 자바 구조를 사용하고 단지 스칼라 코어 컬렉션을 사용하지 않습니다. 다른 주요 차이점은 필자가 생각하기에 조금 더 쉽게 따라갈 수 있고 일반적으로 더 안전한 데이터 구조를 사용한다는 것입니다. 노트의

일부 항목 : 1) 없음에라는 빈 세트의 Option.toSet 연산 결과. 2) withinDateRange 메소드에 사용 된 함수 currying의 예가 있습니다. 3) 필자는 원래의 형식이 무엇인지 잘 모르고 관련 부분을 추측해야했습니다.

Answer 3

문제는 스칼라의지도 & 필터 작업에 따라 동안 스칼라에서 자바 유형을 사용하는 것 같다. 이것은 문제가 있지만 목록/콜렉션을 Scala's collections으로 먼저 변환하면 (경고, 스칼라 유형은 기본적으로 불변), java의 stream() 메소드를 호출하지 않고도 맵/필터 연산을 사용할 수 있어야합니다.