Considering the String class' length method returns an int, the maximum length that would be returned by the method would be Integer.MAX_VALUE, which is 2^31 - 1 (or approximately 2 billion.)

In terms of lengths and indexing of arrays, (such as char[], which is probably the way the internal data representation is implemented for Strings), Chapter 10: Arrays of The Java Language Specification, Java SE 7 Edition says the following:

The variables contained in an array have no names; instead they are referenced by array access expressions that use nonnegative integer index values. These variables are called the components of the array. If an array has n components, we say n is the length of the array; the components of the array are referenced using integer indices from 0 to n - 1, inclusive.

Furthermore, the indexing must be by int values, as mentioned in Section 10.4:

Arrays must be indexed by int values;

Therefore, it appears that the limit is indeed 2^31 - 1, as that is the maximum value for a nonnegative int value.

However, there probably are going to be other limitations, such as the maximum allocatable size for an array.

You can also use String.format("%3.3s", "abcdefgh"). The first digit is the minimum length (the string will be left padded if it's shorter), the second digit is the maxiumum length and the string will be truncated if it's longer. So

System.out.printf("'%3.3s' '%3.3s'", "abcdefgh", "a");

will produce

'abc' '  a'

(you can remove quotes, obviously).

Some other answers have claimed that "There is no way to limit Strings in java to a certain finite number through inbuilt features", and suggested rolling ones own. However, Java EE validations API is meant for just this. An example:

import javax.validation.constraints.Size;

public class Person {
      @Size(max = 6)
      private String username;
}

Further info on how to use Validation API, see this thread for example. Hibernate validator is the reference implementation (usage).

In short, when annotating an object as @Valid, validations done in annotations will be enforced.

Not taking the comma and the ellipses into account when calculating the resulting string length and instead setting the max length to 250 is an ugly hack. The code is also a bit buggy, because if the first error message happens to be 250 characters long, you only get ellipses in the result even though there would have been room for the error message, a comma and ellipses.

You should create a method for calculating the result length if a string was appended.

private int calculateResultingLength(String str) {
    int result = stringBuilder.length();
    if (result > 0) {
        result += 1; // Account for a comma.
    }
    if (errorsDropped) {
        result += ELLIPSES.length();
    }
    result += str.length();

    return result;
}

The second isFull check in checkAndAppend is redundant because you already do that check in the append method and checkAndAppend is private. The isFull is now also misleading, because it tells that an error was dropped. The next error might be shorter and fit into the string. I rename it to errorsDropped.

public void append(String str) {
    if (calculateResultingLength(str) >= MAX_CAP) {
        errorsDropped = true;
    } else {
        performAppend(str);
    }
}

The isFirst field is redundant. You know the append is the first one if the stringBuilder is empty:

private void performAppend(String str) {
    if (stringBuilder.length() > 0) {
        stringBuilder.append(",");
    }
    stringBuilder.append(str);
}

The performAppend method became a bit pointless now. You could just write:

public void append(String str) {
    if (calculateResultingLength(str) >= MAX_CAP) {
        errorsDropped = true;
        return;
    }

    if (stringBuilder.length() > 0) {
        stringBuilder.append(",");
    }
    stringBuilder.append(str);
}

The MAX_CAP and ELLIPSES are named as if they were constants but they are variables. They should be static and final. Also, no need to abbreviate here.

private static final int MAX_CAPACITY = 255;
private static final String ELLIPSES = "...";

Can anyone confirm if this is indeed a limitation of Java?

Yes. There is an implementation limit of 65535 on the length of a string literal¹. It is not stated in the JLS, but it is implied by the structure of the class file; see JVM Spec 4.4.7 and note that the string length field is 'u2' ... which means a 16 bit unsigned integer.

Note that a String object can have up to 2^31 - 1 characters. The 2^16 -1 limit is actually for string-valued constant expressions; e.g. string literals or concatenations of literals that are embedded in the source code of a Java program.

If you want to a String that represents the first million digits of Pi, then it would be better to read the characters from a file in the filesystem, or a resource on the classpath.

^{1 - This limit is actually on the number of bytes in the (modified) UTF-8 representation of the String. If the string consists of characters in the range 0x01 to 0x7f, then each byte represents a single character. Otherwise, a character can require up to 6 bytes.}

A common question you could have searched for but I going to answer it again anyway.

Is there any limit for the number of characters that I can assign?

Its Integer.MAX_VALUE or 2^31-1 or about 2 billion. You are more likely to have memory problems before getting to this size. e.g. You need 4 GB for the String and 4 GB to create it.

I am assigning the user input to this string xx. 70% of the times people give only one word. some times they give a big sentence so want to know is that ok?

I suspect all the works of J K Rowling would fit into one string.

or is there any better java practices?

I suggest you keep things as simple as possible. Assigning a String reference is about simple as it gets.