Her biri için Java 8 akışından ayrılma veya geri dönüş?

Kullanırken harici bir yineleme aşırı Iterablebiz kullanım breakya da returnhazır her bir döngü olarak geliştirilmiş den:

for (SomeObject obj : someObjects) {
   if (some_condition_met) {
      break; // or return obj
   }
}

Nasıl breakya returnda dahili yinelemeyi aşağıdaki gibi bir Java 8 lambda ifadesinde kullanarak yapabiliriz :

someObjects.forEach(obj -> {
   //what to do here?
})

Buna ihtiyacınız varsa kullanmamalısınız forEach, ancak akışlarda bulunan diğer yöntemlerden birini kullanmalısınız ; hangisi, hedefinizin ne olduğuna bağlıdır.

Örneğin, bu döngünün amacı bazı yüklemlerle eşleşen ilk öğeyi bulmaksa:

Optional<SomeObject> result =
    someObjects.stream().filter(obj -> some_condition_met).findFirst();

(Not: Bu, tüm koleksiyonu yinelemez, çünkü akışlar tembel olarak değerlendirilir - koşulla eşleşen ilk nesnede durur).

Koleksiyonda koşulun geçerli olduğu bir öğe olup olmadığını öğrenmek istiyorsanız, şunları kullanabilirsiniz anyMatch:

boolean result = someObjects.stream().anyMatch(obj -> some_condition_met);

Bu ise mümkün Iterable.forEach()(ancak güvenilir olan Stream.forEach()). Solüsyon hoş değil, ama bir mümkün.

UYARI : İş mantığını kontrol etmek için değil, yalnızca uygulamasının gerçekleşmesi sırasında ortaya çıkan istisnai bir durumu ele almak için kullanmalısınız forEach(). Bir kaynağın aniden erişilebilir olması gibi, işlenen nesnelerden biri bir sözleşmeyi ihlal ediyor (örneğin sözleşme, akıştaki tüm öğelerin nulldeğil, aniden ve beklenmedik bir şekilde bunlardan biri olması gerektiğini söylüyor null) vb.

İçin belgelere göre Iterable.forEach():

Tüm öğeler işleninceye veya eylem bir istisna Iterable atana kadar verilen her eylem için verilen eylemi gerçekleştirir ... Eylem tarafından atılan istisnalar arayana aktarılır.

Böylece, iç döngüyü derhal kıracak bir istisna atarsınız.

Kod böyle bir şey olacak - Sevdim diyemem ama işe yarıyor. Kendi sınıfınızı BreakExceptionyaratırsınız RuntimeException.

try {
    someObjects.forEach(obj -> {
        // some useful code here
        if(some_exceptional_condition_met) {
            throw new BreakException();
       }
    }
}
catch (BreakException e) {
    // here you know that your condition has been met at least once
}

O Bildirimi try...catcholduğu değil doğrusu etrafında bütün etrafında lambda ifadesi, ancak forEach()yöntem. Daha görünür hale getirmek için, kodu daha net gösteren aşağıdaki transkripsiyonuna bakın:

Consumer<? super SomeObject> action = obj -> {
    // some useful code here
    if(some_exceptional_condition_met) {
        throw new BreakException();
    }
});

try {
    someObjects.forEach(action);
}
catch (BreakException e) {
    // here you know that your condition has been met at least once
}

Bir lambdadaki geri dönüş, her biri için bir süreye eşittir, ancak bir mola eşdeğeri yoktur. Devam etmek için bir dönüş yapabilirsiniz:

someObjects.forEach(obj -> {
   if (some_condition_met) {
      return;
   }
})

Aşağıda bir projede kullandığım çözümü bulacaksınız. Bunun yerine forEachsadece şunu kullanın allMatch:

someObjects.allMatch(obj -> {
    return !some_condition_met;
});

Ya devam edip etmeyeceğinizi belirten bir yöntem kullanmanız gerekir (bunun yerine mola verir) veya elbette çok çirkin bir yaklaşım olan bir istisna atmanız gerekir.

Böylece böyle bir forEachConditionalyöntem yazabilirsiniz :

public static <T> void forEachConditional(Iterable<T> source,
                                          Predicate<T> action) {
    for (T item : source) {
        if (!action.test(item)) {
            break;
        }
    }
}

Bunun yerine Predicate<T>, kendi işlevsel arayüzünüzü aynı genel yöntemle (a Tve geri dönen bir şey) tanımlamak isteyebilirsiniz, boolancak beklentiyi daha açık bir şekilde belirten isimlerle - Predicate<T>burada ideal değildir.

Java8 + rxjava kullanabilirsiniz .

//import java.util.stream.IntStream;
//import rx.Observable;

    IntStream intStream  = IntStream.range(1,10000000);
    Observable.from(() -> intStream.iterator())
            .takeWhile(n -> n < 10)
            .forEach(n-> System.out.println(n));

Paralel işlemlerinde maksimum performans için kullanımı findAny Findfirst benzerdir () ().

Optional<SomeObject> result =
    someObjects.stream().filter(obj -> some_condition_met).findAny();

Ancak kararlı bir sonuç isteniyorsa, bunun yerine findFirst () öğesini kullanın.

Ayrıca eşleşen desenlerin (anyMatch () / allMatch) yalnızca boole döndüreceğini, eşleşen nesneyi almayacağınızı unutmayın.

Aşağıdakilerle Java 9+ ile güncelleyin takeWhile:

MutableBoolean ongoing = MutableBoolean.of(true);
someobjects.stream()...takeWhile(t -> ongoing.value()).forEach(t -> {
    // doing something.
    if (...) { // want to break;
        ongoing.setFalse();
    }
});

Böyle bir şeyle başardım

  private void doSomething() {
            List<Action> actions = actionRepository.findAll();
            boolean actionHasFormFields = actions.stream().anyMatch(actionHasMyFieldsPredicate());
            if (actionHasFormFields){
                context.addError(someError);
            }
        }
    }

    private Predicate<Action> actionHasMyFieldsPredicate(){
        return action -> action.getMyField1() != null;
    }

Bunu bir peek (..) ve anyMatch (..) karışımı kullanarak elde edebilirsiniz.

Örneğinizi kullanma:

someObjects.stream().peek(obj -> {
   <your code here>
}).anyMatch(obj -> !<some_condition_met>);

Veya sadece genel bir util yöntemi yazın:

public static <T> void streamWhile(Stream<T> stream, Predicate<? super T> predicate, Consumer<? super T> consumer) {
    stream.peek(consumer).anyMatch(predicate.negate());
}

Ve sonra şu şekilde kullanın:

streamWhile(someObjects.stream(), obj -> <some_condition_met>, obj -> {
   <your code here>
});

Peki ya bu:

final BooleanWrapper condition = new BooleanWrapper();
someObjects.forEach(obj -> {
   if (condition.ok()) {
     // YOUR CODE to control
     condition.stop();
   }
});

BooleanWrapperAkışı kontrol etmek için uygulamanız gereken bir sınıf nerede .

int valueToMatch = 7;
Stream.of(1,2,3,4,5,6,7,8).anyMatch(val->{
   boolean isMatch = val == valueToMatch;
   if(isMatch) {
      /*Do whatever you want...*/
       System.out.println(val);
   }
   return isMatch;
});

Sadece eşleştiği yerde işlem yapar, ve eşleşmeden sonra iterasyonunu durdurur.

AnyMatch kullanmanızı öneririm. Misal:-

return someObjects.stream().anyMatch(obj -> 
    some_condition_met;
);

AnyMatch'i anlamak için bu gönderiye başvurabilirsiniz: - https://beginnersbook.com/2017/11/java-8-stream-anymatch-example/