Longitud de la cadena sin usar el método de longitud()

Question

¿Cómo puedo encontrar la longitud de una cadena sin usar el método length() de la clase String?

Answer 1

• str.toCharArray().length debería funcionar.

• O qué tal:

  str.lastIndexOf("")

  probablemente aún se ejecuta en un tiempo constante :)

• Otro

  Matcher m = Pattern.compile("$").matcher(str); 
  m.find(); 
  int length = m.end(); 
  

• Una de las soluciones más tontas: str.split("").length - 1

• ¿Es esto hacer trampa: new StringBuilder(str).length()? :-)

Answer 2

Usted puede utilizar un bucle para comprobar cada posición de carácter y coger el IndexOutOfBoundsException cuando se pasa el último carácter. ¿Pero por qué?

public int slowLength(String myString) { 
    int i = 0; 
    try { 
     while (true) { 
      myString.charAt(i); 
      i++; 
     } 
    } catch (IndexOutOfBoundsException e) { 
     return i; 
    } 
} 

Nota: Esto es muy mala práctica de programación y muy ineficiente.

Puede usar la reflexión para examinar las variables internas en la clase String, específicamente count.

Answer 3

String blah = "HellO"; 
int count = 0; 
for (char c : blah.toCharArray()) { 
    count++; 
} 
System.out.println("blah's length: " + count); 

Answer 4

longitud Oculto() Uso:

String s = "foobar"; 

    int i = 0; 
    for(char c: s.toCharArray()) 
    { 
     i++; 
    } 

Answer 5

Dado que nadie ha publicado la puerta trasera traviesa manera aún:

public int getLength(String arg) { 
    Field count = String.class.getDeclaredField("count"); 
    count.setAccessible(true); //may throw security exception in "real" environment 
    return count.getInt(arg); 
} 

;)

Answer 6

Aún más lento uno

public int slowerLength(String myString) { 
String[] str = myString.split(""); 
int lol=0; 
for(String s:str){ 
    lol++; 
} 
return (lol-1) 
} 

O incluso más lento,

public int slowerLength(String myString) { 
String[] str = myString.split(""); 
int lol=0; 
for(String s:str){ 
    lol += s.toCharArray().length; 
} 
return lol 
} 

Answer 7

simplemente para la corrección (no y esto es en absoluto recomendable):

int length; 
try 
{ 
    length = str.getBytes("UTF-16BE").length/2 
} 
catch (UnsupportedEncodingException e) 
{ 
    throw new AssertionError("Cannot happen: UTF-16BE is always a supported encoding"); 
} 

Esto funciona porque un char es una unidad de código UTF-16, y str.length() retornos el número de tales unidades de código. Cada unidad de código UTF-16 ocupa 2 bytes, por lo que se divide por 2. Además, no hay una marca de orden de bytes escrita con UTF-16BE.

Answer 8

Para los mejores semi-métodos se han publicado y no hay nada mejor que Cadena # longitud ...

redirección System.out a un FileOutputStream, utilice System.out.print (no println()!) A imprima la cadena y obtenga el tamaño del archivo; esto es igual a la longitud de la cadena. No olvide restaurar System.out después de la medición.

;-)

Answer 9

Muy buenas soluciones. Aquí hay algunos más.

int length (String s) 
{ 
    int length = 0 ; 
    // iterate through all possible code points 
    for (int i = INTEGER . MIN_VALUE ; i <= INTEGER . MAX_VALUE ; i ++) 
    { 
      // count the number of i's in the string 
      for (int next = s . indexOf (i , next) + 1 ; next != -1 ; next = s . indexOf (i , next) + 1) 
      { 
       length ++ ; 
      } 
    } 
    return (length) ; 
} 

Aquí está una versión recursiva:

int length (String s) 
{ 
    int length = 0 ; 
    search : 
    for (int i = Integer . MIN_VALUE ; i <= Integer . MAX_VALUE ; i ++) 
    { 
      final int k = s . indexOf (i) ; 
      if (k != -1) 
      { 
       length = length (s . substring (0 , k)) + length (s . substring (k)) ; 
       break search ; 
      } 
    } 
    return (length) ; 
} 

y aún más

int length (String s) 
{ 
    int length ; 
    search ; 
    for (length = 0 ; true ; length ++) 
    { 
      int [ ] codePoints = new int [ length ] ; 
      for (each possible value of codePoints from {MIN_VALUE,MIN_VALUE,...} to {MAX_VALUE,MAX_VALUE,...}) 
      { 
       if (new String (codePoints) . equals (s)) { break search ; } 
      } 
    } 
} 

¿Cómo podría olvidar uno que realmente funciona en un tiempo razonable? (. Todavía se prefiere Cadena # longitud)

int length (String s) 
{ 
    String t = s . replaceAll ("." , "A") ; 
    int length ; 
    String r = "" ; 
    search : 
    for (r = "" , length = 0 ; true ; r += "A" , length ++) 
      { 
       if (r . equals (t)) 
       { 
        break search ; 
       } 
      } 
    return (length) ; 
} 

Answer 10

sólo para completar esto con el método más estúpida que puedo llegar a: generar todas las posibles cadenas de longitud 1, el uso es igual al compararlos con la cadena original; si son iguales, la longitud de la cadena es 1. Si ninguna cadena coincide, genere todas las cadenas posibles de longitud 2, compárelas, para longitud de cuerda 2. Etc. Continúe hasta que encuentre la longitud de la cuerda o el universo finalice, pase lo que pase primero.

Answer 11

Ésta es otra manera:

int length = 0; 
while (!str.equals("")) { 
    str = str.substring(1); 
    ++length; 
} 

En el mismo espíritu (aunque mucho menos eficiente):

String regex = "(?s)"; 
int length = 0; 
while (!str.matches(regex)) { 
    regex += "."; 
    ++length; 
} 

O incluso:

int length = 0; 
while (!str.matches("(?s).{" + length + "}")) { 
    ++length; 
} 

Answer 12

Este es un programa completo que puede compilar y ejecutarlo.

import java.util.Scanner; 

class Strlen{ 

    public static void main(String...args){ 
     Scanner sc = new Scanner(System.in); 
     System.out.print("\nEnter Your Name =>" +" "); 
     String ab = sc.nextLine(); 
     System.out.println("\nName Length is:" +len(ab)); 
    } 

    public static int len(String ab){ 
     char[] ac = ab.toCharArray(); 
     int i = 0, k = 0; 

     try{ 
      for(i=0,k=0;ac[i]!='\0';i++) 
       k++; 
     } 
     catch(Exception e){ 
     } 
     return k; 
    } 

} 

Answer 13

Podemos iterar a través de la cadena como una matriz de caracteres, y contar de esa manera (A mucho más a la tierra forma de hacerlo):

String s = "foo" 
char arr[]=s.toCharArray(); 
int len = 0; 
for(char single : arr){ 
    len++; 
} 

Usando el "foreach" versión de el intento de bucle

Answer 14

continuación código

public static int Length(String str) { 
    str = str + '\0'; 
    int count = 0; 

    for (int i = 0; str.charAt(i) != '\0'; i++) { 
     count++; 
    } 

    return count; 
    }