Java 8'de birden çok boş denetim

Birden fazla boş kontrol için biraz çirkin olan aşağıdaki koda sahibim.

String s = null;

if (str1 != null) {
    s = str1;
} else if (str2 != null) {
    s = str2;
} else if (str3 != null) {
    s = str3;
} else {
    s = str4;
}

Bu yüzden Optional.ofNullableaşağıdaki gibi kullanmayı denedim , ancak birinin kodumu okuyup okumadığını anlamak hala zor. Java 8'de bunu yapmak için en iyi yaklaşım nedir.

String s = Optional.ofNullable(str1)
                   .orElse(Optional.ofNullable(str2)
                                   .orElse(Optional.ofNullable(str3)
                                                   .orElse(str4)));

Java 9'da Optional.ofNullableile kullanabiliriz OR, Ama Java8'de başka bir yaklaşım var mı?

Bunu şu şekilde yapabilirsiniz:

String s = Stream.of(str1, str2, str3)
    .filter(Objects::nonNull)
    .findFirst()
    .orElse(str4);

Üçlü koşullu operatör nasıl olur?

String s = 
    str1 != null ? str1 : 
    str2 != null ? str2 : 
    str3 != null ? str3 : str4
;

Ayrıca bir döngü de kullanabilirsiniz:

String[] strings = {str1, str2, str3, str4};
for(String str : strings) {
    s = str;
    if(s != null) break;
}

Mevcut cevaplar güzel, ancak bunu gerçekten bir yardımcı yönteme koymalısınız:

public static Optional<String> firstNonNull(String... strings) {
    return Arrays.stream(strings)
            .filter(Objects::nonNull)
            .findFirst();
}

Bu yöntem yıllardır benim Utilsınıfımda, kodu daha temiz hale getiriyor:

String s = firstNonNull(str1, str2, str3).orElse(str4);

Hatta jenerik bile yapabilirsiniz:

@SafeVarargs
public static <T> Optional<T> firstNonNull(T... objects) {
    return Arrays.stream(objects)
            .filter(Objects::nonNull)
            .findFirst();
}

// Use
Student student = firstNonNull(student1, student2, student3).orElseGet(Student::new);

Yardımcı bir işlev kullanıyorum, şunun gibi

T firstNonNull<T>(T v0, T... vs) {
  if(v0 != null)
    return v0;
  for(T x : vs) {
    if (x != null) 
      return x;
  }
  return null;
}

O zaman bu tür bir kod şu şekilde yazılabilir:

String s = firstNonNull(str1, str2, str3, str4);

İstediğiniz kadar elemana uygulanabilecek bir çözüm şunlar olabilir:

Stream.of(str1, str2, str3, str4)
      .filter(Object::nonNull)
      .findFirst()
      .orElseThrow(IllegalArgumentException::new)

Aşağıdaki gibi bir çözüm hayal edebilirsiniz, ancak ilki non nullitytüm unsurları sağlar

Stream.of(str1, str2, str3).....orElse(str4)

Ayrıca tüm Dizeleri bir String dizisi içinde toplayabilir, ardından atandıktan sonra döngüyü kontrol etmek ve kırmak için bir for döngüsü yapabilirsiniz. S1, s2, s3, s4'ün tümünün Dizeler olduğunu varsayarsak.

String[] arrayOfStrings = {s1, s2, s3};


s = s4;

for (String value : arrayOfStrings) {
    if (value != null) { 
        s = value;
        break;
    }
}

Hiçbiri atanmamışsa varsayılan olarak s4 olarak atılacak şekilde düzenlendi.

Yönteme dayalı ve basit.

String getNonNull(String def, String ...strings) {
    for(int i=0; i<strings.length; i++)
        if(strings[i] != null)
             return s[i];
    return def;
}

Ve şu şekilde kullanın:

String s = getNonNull(str4, str1, str2, str3);

Dizilerle yapmak basit ve güzel görünüyor.

Apache Commons Lang 3 kullanıyorsanız, şu şekilde yazılabilir:

String s = ObjectUtils.firstNonNull(str1, str2, str3, str4);

ObjectUtils.firstNonNull(T...)Bu cevaptan kullanımı alınmıştır . İlgili soruda farklı yaklaşımlar da sunulmuştur .