ejemplo - Condición de SQL IN en Java

java collection hashset

Question

Tengo varias condiciones para verificar como se muestra a continuación,

if(pouch.getStatus().equals("Finalized") || pouch.getStatus().equals("Ready") 
  || pouch.getStatus().equals("Checkout") || pouch.getStatus().equals("Confirmed")
  || pouch.getStatus().equals("Book") || pouch.getStatus().equals("Started")
  || pouch.getStatus().equals("Inital") || pouch.getStatus().equals("Close")) {
        // Body
}

¿Hay alguna manera fácil de verificar las condiciones anteriores similares a las condiciones de SQL IN , para que el código parezca más simple?

Answer 1

Aquí está el ejemplo completo

public class InConditionJava {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        String[] arr = { "Finalized", "Ready", "Checkout" };
        checkData(arr);
    }

    private static void checkData(String[] arr) {
        Set<String> names = new HashSet<String>(Arrays.asList(arr));

        System.out.println("AS Checkout is there in our arr is should return True>>" + names.contains("Checkout")); // true
        System.out.println(names.contains("Book")); // false
    }

}

Answer 2

Creo que si usas el condicional "switch", el código se lee mejor:

switch (pouch.getStatus()) {
            case "Finalized":
            case "Ready":
            case "Checkout":
            case "Confirmed":
            case "Book":
            case "Started":
            case "Inital":
            case "Close":
                // your code
                break;
        }

Answer 3

Debajo de un fragmento puede ayudarte.

 String status = "COMPLETED";
 List<String> statusList = new ArrayList<>(Arrays.asList("COMPLETED","INPROGRESS"));
 if(statusList.contains(status)){
     // do your stuff
 }

Answer 4

Echemos un vistazo sobre SQL in características

SQL WHERE IN devuelve valores que coinciden con los valores de una lista

Así que usaría una colección, que se implementa desde la Collection<E> y tenía el método contains , simplificando la instrucción if .

contiene (Objeto o) Devuelve verdadero si este conjunto contiene el elemento especificado.

contains efecto es muy similar a SQL in .

1.add sus múltiples condiciones en la colección, que se implementa desde la Collection<E>

Set<String> dict = new HashSet<String>();
dict.add("Finalized");
dict.add("Ready");
dict.add("Checkout");
dict.add("Confirmed");
dict.add("Book");
dict.add("Started");
dict.add("Inital");
dict.add("Close");

2.using utiliza para verificar el valor de entrada si existe en la colección.

if (dict.contains(pouch.getStatus()))
{
     // do your logic
}

Answer 5

El uso de Arrays.asList y luego el uso de los contains podría ser la mejor manera, al menos en mi caso.

if(Arrays.asList("Finalized", "Ready", "Checkout", "Confirmed", 
    "Book", "Started", "Inital", "Close").contains(pouch.getStatus())) {

   // Body
}

Answer 6

Esta es otra forma de inicializar la Lista en una línea con todos los estados, y luego verificar si la lista contiene el estado dado.

// Java 9 way of initializing List with one line        
List<String> statuses = List.of("Finalized", "Ready", "Checkout", "Confirmed",
    "Book", "Started", "Inital", "Close");
if (statuses.contains(pouch.getStatus())) {
  // Body
}

Answer 7

Para este escenario en particular, creo que es un buen candidato para una enum simple como esta:

public enum PouchStatus {
    FINALIZED, READY, CHECKOUT, CONFIRMED, BOOK, STARTED, INITIAL, CLOSE
}

Uso:

if(PouchStatus.valueOf(pouch.getStatus().toUpperCase()) != null) {
}

También puede mover esta lógica de desinfección de cadena dentro de un método estático en la enumeración, que se vería así:

public enum PouchStatus {
    FINALIZED, READY, CHECKOUT, CONFIRMED, BOOK, STARTED, INITIAL, CLOSE

    public static PouchStatus fromDescription(String desc) {
        return Arrays.stream(PouchStatus.values()).filter(e -> e.name().equalsIgnoreCase(desc)).findFirst().orElse(null);
    }
}

Uso:

if (PouchStatus.fromDescription(pouch.getStatus()) != null) {
}

Como nota final, si el objeto Pouch proviene de ORM (por ejemplo, hibernate / jpa), puede asignar estos valores a los elementos de enumeración correspondientes en la asignación de entidades (pouc.getStatus () ya devolvería un objeto PouchStatus en lugar de un Cuerda).

Answer 8

Puede crear una función personalizada:

static boolean inCondition(String var, String... ins) {
    for (String in : ins) {
        if (in.equals(var)) return true;
    }

    return false;
}

y luego usarlo de esta manera:

public static void main(String[] args) {
    String pouch = "Ready";
    if (inCondition(pouch, "Finalized", "Ready", "Checkout" ... )) {
        // do something
    }
}

Answer 9

Puede crear una matriz de todos los estados y luego verificar si pouch.getStatus () está en esa lista o no.

 public String[] statusArray = new String[]{  "Finalized", "Ready","Checkout","Confirmed",  "Book",  "Started", "Inital", "Close"};

if( Arrays.asList(statusArray).contains(pouch.getStatus())){
 //do something 
}

Answer 10

Puedes usar las matches métodos que están disponibles en String clase String ,

if(pouch.getStatus().matches("Finalized|Ready|Checkout|Confirmed|Book|Started|Inital|Close")){
   //your implementation goes here
}

Answer 11

SQL IN puede devolver más de un resultado, pero en su pregunta, si se cumple una condición, la operación terminará y volverá.

Puede crear una enumeración para mantener todas sus condiciones como se muestra a continuación.

Suponiendo que tu clase de bolsa es esto.

public class Pouch {

    private final String status;

    public Pouch(final String status) {
        this.status = status;
    }

    public String getStatus() {
        return status;
    }
}

Aquí está su enumeración con el estado de la bolsa.

public enum  PouchEnum {
   Finalized, Ready, Checkout, Confirmed, Book, Started, Inital, Close
}

y verifique su condición como se muestra a continuación.

if (PouchEnum.valueOf(pouch.getStatus()) != null) {
        // Do some stuff
}

Para hacerlo más limpio, puede usar EnumUtils de apache commons-lang3; esto hace que su código sea más limpio como se muestra a continuación.

if (EnumUtils.isValidEnum(PouchEnum.class, pouch.getStatus())) {
        // Do some stuff
}

Espero que esto ayude a que su código sea más limpio.

Answer 12

Ya hay muchas opciones aquí, pero también podría usar Stream para esta tarea, si la versión del JDK que está utilizando es> = 8:

String status = pouch.getStatus();
if (Stream.of(
        "Finalized",
        "Ready",
        "Checkout",
        "Confirmed",
        "Book",
        "Started",
        "Inital",
        "Close")
        .anyMatch(status::equals)) {
    // Body
}

La desventaja de este método, en comparación con la Collection#contains , es que debe asegurarse de que pouch.getStatus() no sea nulo, de lo contrario obtendrá una NullPointerException .

Answer 13

List<String> listOfInputs = new ArrayList<String>();
// add elements in listOfInputs...  
boolean isAvailable = listOfInputs.contains(pouch.getStatus());