Nasıl java 8 harita, filtre ve akışları scala dönüştürmek için?

Question

Daha iyi anlayabilmek için, eşdeğer java'yı scala olarak değiştirerek anlamaya çalışmak için çok yeni bir deneyim yaşıyorum.

Java 8 harita, filtre ve akışları scala'ya nasıl dönüştürebilirim?

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());               
} 

Denedim:

ben Scala dönüştürmek çalışıyorum aşağıdaki java 8 koduna sahip

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 
} 

Ama filtre ve akış yaparken hata alıyorum. Direkt yöne bir nokta olabilir mi? Herhangi bir referans? Ben getValidUsages hatayı alıyorum:

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 
    } 
} 

İyi şanslar :)

Answer 2

Bu Kullanabileceğin türlerinden bazıları yabancıyım beri cevap vermek biraz zor. Sanırım Ama eğer gibi türleri vardır şu: o zaman

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]] 
} 

sadece bu yapabilirdi: muhtemelen bazı items değeri yoktu orijinal kodunda

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 
    } 

ama yukarıda sadece varsayalım getValidUsages işlevinin dışında TestWindows testWindows = items.get(itemId).getTestWindows() yaparsınız.

Örneğim, java yapılarını hiç kullanmıyor ve yalnızca scala çekirdek koleksiyonlarını kullanıyor. Diğer önemli fark, değişmez veri yapıları kullanmanın bence biraz daha kolay ve genel olarak daha güvenli olduğunu düşünüyorum.

Notun bazı öğeleri: 1) Option.toSet işlemi, bir Yok'a çağrıldığında boş bir kümeyle sonuçlanır. 2) withinDateRange yöntemi için kullanılan bir işlev körlemesi örneği vardır. 3) Orijinal tiplerinizin neler yaptığını ve ilgili parçalarda tahmin etmek zorunda olduğunu bilmiyorum.

Answer 3

Scala'nın haritasında & filtre işlemlerine bağlı olarak Scala'da Java türlerini kullandığınız gibi görünüyor. Bu kendi sorunlarına sahiptir, ancak listeyi/koleksiyonları önce bir Scala's collections dönüştürürseniz (uyarı, Scala türleri varsayılan olarak değişmezdir), o zaman harita/filtre işlemlerini java'nın stream() yöntemini çağırmak zorunda kalmadan kullanabilmeniz gerekir.