Longueur de la chaîne sans utiliser la méthode length ()

Comment puis-je trouver la longueur d'une Chaîne sans l'aide de la length() méthode de la classe String?

40
- str.toCharArray().length devrait fonctionner.
- Ou que diriez-vous:
  
  str.lastIndexOf("")
  
  Même, probablement, s'exécute en temps constant 🙂
- Un autre
```
Matcher m = Pattern.compile("$").matcher(str);
m.find();
int length = m.end();
```
- L'une des plus stupides solutions: str.split("").length - 1
- Est-ce de la triche: new StringBuilder(str).length()? 🙂

Puisque personne ne l'a posté la coquine porte arrière de façon encore:

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

😉

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

10

Vous pouvez utiliser une boucle pour vérifier chaque position de caractère et attraper le IndexOutOfBoundsException quand vous passez le dernier caractère. Mais pourquoi?
```
public int slowLength(String myString) {
    int i = 0;
    try {
        while (true) {
            myString.charAt(i);
            i++;
        }
    } catch (IndexOutOfBoundsException e) {
       return i;
    }
}
```
Note: Ceci est très la mauvaise programmation de la pratique et très inefficace.

Vous pouvez utiliser la réflexion pour examiner les variables internes dans le String classe, plus précisément count.
8

Juste pour compléter cela avec le plus stupide de la méthode, je peux venir avec: Générer tous les possible des chaînes de longueur 1, l'utilisation est égale à comparer à la chaîne d'origine; si elles sont égales, la longueur de la chaîne est 1. Si aucune chaîne correspond à, de générer tous les possible des chaînes de longueur 2, de les comparer, pour la longueur de la chaîne 2. Etc. Continuer jusqu'à ce que vous trouver la longueur de la chaîne ou de l'univers se termine, ce qui arrive en premier.

essayer de code ci-dessous

    public static int Length(String str) {
    str = str + '    public static int Length(String str) {
str = str + '\0';
int count = 0;
for (int i = 0; str.charAt(i) != '\0'; i++) {
count++;
}
return count;
}
';
    int count = 0;

    for (int i = 0; str.charAt(i) != '    public static int Length(String str) {
str = str + '\0';
int count = 0;
for (int i = 0; str.charAt(i) != '\0'; i++) {
count++;
}
return count;
}
'; i++) {
        count++;
    }

    return count;
    }

4

Pour les demi-meilleures méthodes ont été affichés, et il n'y a rien de mieux que String#longueur...

Rediriger Système.un FileOutputStream, l'utilisation du Système..print (pas println()!) pour imprimer la corde et obtenir la taille du fichier, ce qui est égal à la longueur de la chaîne. N'oubliez pas de restaurer le Système.après la mesure.

😉

Caché longueur() utilisation:

    String s = "foobar";

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

Voici une autre façon:

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

Dans le même esprit (bien que beaucoup moins efficace):

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

Ou encore:

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

C'est un programme complet qui vous permet de compiler et de l'exécuter.

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]!='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;
}
}
';i++)
                k++;
        }
        catch(Exception e){
        }
        return k;
    }

}

2

Juste pour être complet (et ce n'est pas du tout recommandé):
```
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");
}
```
Cela fonctionne parce qu'un char est un code UTF-16 de l'unité, et str.length() retourne le nombre de ces unités de code. Chaque code UTF-16 unité occupe 2 octets, donc on divise par 2. En outre, il n'y a pas de marque d'ordre d'octet écrit avec de l'UTF-16BE.
2

Nous pouvons itérer à travers la chaîne comme un tableau de caractères, et à compter de cette façon (beaucoup plus terre-à-terre façon de faire):
```
String s = "foo"
char arr[]=s.toCharArray();
int len = 0;
for(char single : arr){
  len++;
}
```
À l'aide de la "foreach" version de la boucle for

Encore plus lent

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

Ou même plus lent,

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

Très agréable solutions. Voici un peu plus.

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

Ici est une version récursive:

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

Et encore plus

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

Comment ai-je pu oublier un qui fonctionne réellement dans un délai raisonnable? (Chaîne de caractères#longueur est toujours préférable.)

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

Vous devez vous connecter pour publier un commentaire.