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 cannot limit the number of characters in a String. I think, in your usecase, the best solution would be to trim the string to the maximum size.
For Example:

String input = "123456789";
String result = input.substring(0, 4);
//result is: "1234" 

To ensure that you do not receive an IndexOutOfBoundsException when the input string is less than the expected length do the following instead:

input.substring(0, Math.min(MAX_CHAR, input.length()));

Math.min() will return the minimum of the two parameters.

You should be able to get a String of length

1. Integer.MAX_VALUE always 2,147,483,647 (2³¹ - 1)
   (Defined by the Java specification, the maximum size of an array, which the String class uses for internal storage)
   OR

2. Half your maximum heap size (since each character is two bytes) whichever is smaller.

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 = "...";