Lunghezza della stringa senza utilizzare il metodo length()

Question

Come posso trovare la lunghezza di una stringa senza utilizzare il metodo length() della classe String?

Answer 1

• str.toCharArray().length dovrebbe funzionare.

• O come circa:

  str.lastIndexOf("")

  Probabilmente funziona anche in tempo costante :)

• Un altro

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

• Una delle soluzioni più stupide: str.split("").length - 1

• E 'questo cheating: new StringBuilder(str).length()? :-)

Answer 2

È possibile utilizzare un ciclo per controllare ogni posizione del carattere e prendere il IndexOutOfBoundsException quando si passa l'ultimo carattere. Ma perché?

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

Nota: Questo è molto cattiva pratica di programmazione e molto inefficiente.

È possibile utilizzare la riflessione per esaminare le variabili interne nella classe String, in particolare count.

Answer 3

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

Answer 4

lunghezza nascosta() utilizzo:

String s = "foobar"; 

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

Answer 5

Dal momento che nessuno è così ancora pubblicato la porta sul retro giocherellona:

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

Ancora più lenta uno

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

O anche più 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

Solo per completezza (non e questo è affatto consigliato):

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"); 
} 

Questo funziona perché una char è un'unità di codice UTF-16, e str.length() rendimenti il numero di tali unità di codice. Ogni unità di codice UTF-16 occupa 2 byte, quindi divideremo per 2. Inoltre, non vi è alcun segno di ordine byte scritto con UTF-16BE.

Answer 8

Per i semi migliori-metodi sono stati pubblicati e non c'è niente di meglio quindi String # lunghezza ...

Redirect System.out ad un FileOutputStream, utilizzare System.out.print (non println()!) Per stampa la stringa e ottieni le dimensioni del file - questo è uguale alla lunghezza della stringa. Non dimenticare di ripristinare System.out dopo la misurazione.

;-)

Answer 9

Soluzioni molto carine. Eccone altri

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) ; 
} 

Ecco una versione ricorsiva:

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) ; 
} 

E ancora più

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 ; } 
      } 
    } 
} 

Come potrei dimenticare uno che funziona in realtà in un tempo ragionevole? (. String # lunghezza è ancora preferito)

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

Proprio per completare questo con il metodo più stupido che posso venire con: Genera tutte le possibili stringhe di lunghezza 1, l'uso è uguale per confrontarle con la stringa originale; se sono uguali, la lunghezza della stringa è 1. Se nessuna stringa corrisponde, genera tutte le stringhe possibili di lunghezza 2, confrontale, per la lunghezza della stringa 2. Ecc. Continua finché non trovi la lunghezza della stringa o l'universo finisce, qualunque cosa accada prima.

Answer 11

Ecco un altro modo:

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

Con lo stesso spirito (anche se molto meno efficiente):

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

O anche:

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

Answer 12

Questo è un programma completo che si può compilare ed eseguirlo.

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

Siamo in grado di scorrere la stringa come un array di caratteri, e contare in questo modo (A molto di più i piedi per terra modo di farlo):

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

Utilizzando la versione "foreach" di il ciclo for

Answer 14

prova sottostante codice

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

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

    return count; 
    }