String length without using length() method in java

Question

How can i find the string length without using the length() method in java

Answer 1

• str.toCharArray().length should work.

• Or how about:

  str.lastIndexOf("")

  Probably even runs in constant time :)

• Another one

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

• One of the dumbest solutions: str.split("").length - 1

• Is this cheating: new StringBuilder(str).length()? :-)

Answer 2

You can use a loop to check every character position and catch the IndexOutOfBoundsException when you pass the last character. But why?

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

Note: This is very bad programming practice and very inefficient.

You can use reflection to examine the internal variables in the String class, specifically count.

Answer 3

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

Answer 4

Hidden length() usage:

    String s = "foobar";

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

Answer 5

Since nobody's posted the naughty back door way yet:

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

Even more slower one

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

Or even slower,

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

Answer 7

Just for completeness (and this is not at all recommended):

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

This works because a char is a UTF-16 code unit, and str.length() returns the number of such code units. Each UTF-16 code unit takes up 2 bytes, so we divide by 2. Additionally, there is no byte order mark written with UTF-16BE.

Answer 8

For the semi-best methods have been posted and there's nothing better then String#length...

Redirect System.out to a FileOutputStream, use System.out.print (not println()!) to print the string and get the file size - this is equal to the string length. Don't forget to restore System.out after the measurement.

;-)

Answer 9

This is a fool's errand.

Answer 10

Very nice solutions. Here are some more.

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

Here is a recursive version:

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

And still more

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

How could I forget one that actually works in a reasonable time? (String#length is still preferred.)

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 11

Just to complete this with the most stupid method I can come up with: Generate all possible strings of length 1, use equals to compare them to the original string; if they are equal, the string length is 1. If no string matches, generate all possible strings of length 2, compare them, for string length 2. Etc. Continue until you find the string length or the universe ends, whatever happens first.

Answer 12

Here's another way:

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

In the same spirit (although much less efficient):

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

Or even:

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