¿Cómo comprobar si una cadena contiene dos caracteres de asterisco?

Question

Tenemos una entrada de cadena y los siguientes combinaciones son válidos (por ejemplo sunday, *sunday*, sun*day*, *sun*day, su*nda*y) Si contiene un solo asterisco, entonces es una mala entrada.

Por lo tanto, dada la entrada anterior, ¿cómo puedo verificar para ver si la cadena contiene múltiples asteriscos.

Answer 1

Usted podría utilizar String.matches con una expresión regular:

"^.*(?:\\*.*){2}$" 

Si desea exactamente dos asteriscos:

"^[^*]*(?:\\*[^*]*){2}$" 

aunque para esta tarea podría ser más simple sólo para iterar sobre la cadena y contar los asteriscos.

Answer 2

Al menos dos maneras:

• expresiones regulares

  String regex = ".*\\*.*\\*.*"; 
  boolean valid = input.matches(regex); 
  

• bucle

  int asterisks = 0; 
  for (int i = 0; i < input.length(); i ++) { 
      if (input.charAt(i) == '*') { 
       asterisks++; 
      } 
  } 
  

Answer 3

int asterisk1 = input.indexOf('*'); 
boolean hasTowAsterisks = asterisk1 != -1 && input.indexOf('*', asterisk1+1) != -1; 

Editar: esta solución supone que el requisito era "tiene al menos dos asteriscos".

Answer 4

boolean hasTwoAsteriks(String str) { 
int i; 
if((i = str.indexOf("*")) != -1) { 
    if ((i = str.indexOf("*", i+1)) != -1) 
    return true; 
return false; 
}

Answer 5

Aquí es una alternativa no de expresiones regulares que funciona con cualquier cadena literal:

public static boolean containsNoneOrTwo(String haystack, String needle) { 
    int index = haystack.indexOf(needle); 
    return (index == -1) || 
     haystack.indexOf(needle, index+1) == haystack.lastIndexOf(needle); 
} 

En esencia, el algoritmo es:

containsNoneOrTwo(haystack, needle) 
    = haystack contains no needle OR 
     haystack's second needle is also its last 

Answer 6

Para completar (aunque se han dado varias respuestas buenas, Me gusta Mark's y Joachim's best), aquí hay dos versiones basadas en String.split(regex) y String.split(regex, limit):

(Edición, corrección de errores :)

boolean containsAtLeastTwoAsterisks = ("_" + myString + "_").split("\\*", 3).length == 3; 

boolean containsExactlyTwoAsterisks = ("_" + myString + "_").split("\\*").length == 3; 

---

me escribió a little benchmark basado en nuestras respuestas (lo sé, los puntos de referencia no significan mucho, pero son diversión, y el mío es probablemente una mierda, lo sé .) de todos modos, aquí están los resultados de un análisis de la muestra:

********************************************************************************* 

Testing strings with one or less asterisk 

Processor: bhups 
Finished. Duration: 40 ms, errors: 0 

Processor: Bozho (loop version) 
Finished. Duration: 33 ms, errors: 0 

Processor: Bozho (regex version) 
Finished. Duration: 806 ms, errors: 0 

Processor: Joachim Sauer 
Finished. Duration: 24 ms, errors: 0 <-- winner 

Processor: Mark Byers 
Finished. Duration: 1068 ms, errors: 0 

Processor: seanizer 
Finished. Duration: 408 ms, errors: 0 

********************************************************************************* 

Testing strings with exactly two asterisks 

Processor: bhups 
Finished. Duration: 14 ms, errors: 0 <-- winner 

Processor: Bozho (loop version) 
Finished. Duration: 21 ms, errors: 0 

Processor: Bozho (regex version) 
Finished. Duration: 693 ms, errors: 0 

Processor: Joachim Sauer 
Finished. Duration: 14 ms, errors: 0 <-- winner 

Processor: Mark Byers 
Finished. Duration: 491 ms, errors: 0 

Processor: seanizer 
Finished. Duration: 340 ms, errors: 0 

********************************************************************************* 

Testing strings with more than two asterisks (not all processors will be included) 

Skipping processor bhups 

Processor: Bozho (loop version) 
Finished. Duration: 63 ms, errors: 0 <-- winner 

Skipping processor Bozho (regex version) 

Skipping processor Joachim Sauer 

Processor: Mark Byers 
Finished. Duration: 1555 ms, errors: 0 

Processor: seanizer 
Finished. Duration: 860 ms, errors: 0 

parece que no expresiones regulares es mucho más rápido que la expresión regular. Eso es lo que esperarías, supongo.

EDITAR: solucionó el ganador incorrecto. lo siento, joachim