Cómo comprobar si un elemento en una matriz de cadena está vacía?

¿Cómo puedo comprobar si un elemento en una matriz de cadena está vacía? Este es mi ejemplo de matriz:

private static String correct[] = new String[5];
    static {
        correct[1] = "some texT";
        correct[2] = "some texT3";
        correct[4] = "some texT2";
}

Puedo asignar null al resto de elementos, pero quiero encontrar una mejor manera de hacer esto.
He encontrado isEmpty, pero sólo está disponible en la API de 9 y superiores.

if(correct[0].length() > 0)
me da un NPE.
if(correct[0] != null también.

5 Kommentare

  1. 5

    Has probado el «obvio»:

    if(correct[0] != null && correct[0].length() > 0) {
       //it is not null and it is not empty
    }
    • He intentado sólo if(correct[0] != null) pero me da NPE
    • Luego correct es null, no sus elementos.
  2. 1

    Sólo tienes que comparar a null, que es el valor predeterminado para una matriz de algún tipo de objeto.

    if (correct[0] != null && correct[0].length() > 0)

    La && operador sólo evaluar el lado derecho si el lado izquierdo es true, es decir, correct[0] no null y no lanzar una NullPointerException.

  3. 1

    Si usted está tratando de comprobar si un determinado elemento en una posición específica está vacía (no sólo diferente de null, pero a partir de "" demasiado), la presentación de soluciones no será suficiente.

    Java tiene un montón de maneras de hacer esto. Veamos algunos de ellos:

    1. Usted puede convertir la matriz en una List (utilizando Matrices del asList método) y la verificación de las condiciones a través de contains() método:

      import java.util.*;
      
      public class Test1 {
      
        private static boolean method1_UsingArrays(String[] array) {
         return Arrays.asList(array).contains(null) 
                  || Arrays.asList(array).contains("");
        }
      }
    2. También es posible utilizar Colecciones de la discontinuo método, para comprobar si dos colecciones tienen elementos en común o no:

      import java.util.*;
      
      public class Test2 {      
      
        private static String[] nullAndEmpty = {"", null};
      
        private static boolean method2_UsingCollectionsDisjoint(String[] array) {
         //disjoint returns true if the two specified collections have no elements in common.
         return !Collections.disjoint( //
           Arrays.asList(array), //
           Arrays.asList(nullAndEmpty) //
         );
        }
      
      }
    3. Si usted es capaz de utilizar Java 8 (mi opción favorita), es posible hacer uso de la nueva Flujos de API.

      import java.util.stream.*;
      import java.util.*;
      
      public class Test3 {
      
        private static boolean method3_UsingJava8Streams(String[] array) {
         return Stream.of(array).anyMatch(x -> x == null || "".equals(x));
        }
      
      }

      Comparación con las otras opciones, esto es aún más fácil de manejar en caso de que usted necesita para trim cada uno de sus cadenas (o llame a cualquiera de los otros String‘s métodos):

      Stream.of(array).anyMatch(x -> x == null || "".equals(x.trim()));

    A continuación, puede llamar fácilmente y prueba de ellos:

    public static void main(String[] args) {
      //Ok tests
      String[] ok = {"a", "b", "c"};
    
      System.out.println("Method 1 (Arrays - contains): " + method1_UsingArrays(ok)); //false
      System.out.println("Method 2 (Disjoint): " + method2_UsingCollectionsDisjoint(ok)); //false
      System.out.println("Method 3 (Java 8 Streams): " + method3_UsingJava8Streams(ok)); //false
    
      System.out.println("-------------------------------");
    
      //Nok tests
      String[] nok = {"a", null, "c"};
    
      System.out.println("Method 1 (Arrays - contains): " + method1_UsingArrays(nok)); //true
      System.out.println("Method 2 (Disjoint): " + method2_UsingCollectionsDisjoint(nok)); //true
      System.out.println("Method 3 (Java 8 Streams): " + method3_UsingJava8Streams(nok)); //true
    
      //Nok tests
      String[] nok2 = {"a", "", "c"};
    
      System.out.println("Method 1 (Arrays - contains): " + method1_UsingArrays(nok2)); //true
      System.out.println("Method 2 (Disjoint): " + method2_UsingCollectionsDisjoint(nok2)); //true
      System.out.println("Method 3 (Java 8 Streams): " + method3_UsingJava8Streams(nok2)); //true
    }
  4. 0

    Bien si usted no puede utilizar isEmpty intente utilizar la Matriz.Contiene(null) o intentar este pequeño bucle

    for(int i = 0;i<=Array.length;i++){
      if(array[i] > 0 && array[i] != null){
         //yay its not null
      }
    }
  5. 0

    Similares a las de la versión donde el número de argumentos podría ser más grande

    if (Arrays.asList(new String[] {productId, productTitle, imageName, productPrice}).contains(null)) {
            return null;
    }

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea