try this

public void delete(StringBuilder sb, String s) {
    int start = sb.indexOf(s);
    if(start < 0)
        return;

    sb.delete(start, start + s.length());
}

If you want to remove characters from a String I recommend you to use Regex. This is an example to replace with empty strings the characters that you need to remove:

public static String cleanWhitPattern(String sample, String , String regex) {

    if (sample != null && regex != null) {
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(sample);

        if (matcher.find()) {
            return matcher.replaceAll("");
        }

        return sample;
    }

    return null;
}

Now, you simply call this method with your required pattern:

System.out.print(cleanWithPattern("I don't know this", "o*"));

And your output should be this:

I dn't knw this

There are basically two alternatives, using setLength(0) to reset the StringBuilder or creating a new one in each iteration. Both can have pros and cons depending on the usage.

If you know the expected capacity of the StringBuilder beforehand, creating a new one each time should be just as fast as setting a new length. It will also help the garbage collector, since each StringBuilder will be relatively short-lived and the gc is optimized for that.

When you don't know the capacity, reusing the same StringBuilder might be faster. Each time you exceed the capacity when appending, a new backing array has to be allocated and the previous content has to be copied. By reusing the same StringBuilder, it will reach the needed capacity after some iterations and there won't be any copying thereafter.

Another simple solution¹ is:

sb.setLength(sb.length() - 1);

A more complicated solution:

The above solution assumes that sb.length() > 0 ... i.e. there is a "last character" to remove. If you can't make that assumption, and/or you can't deal with the exception that would ensue if the assumption is incorrect, then check the StringBuilder's length first; e.g.

// Readable version
if (sb.length() > 0) {
   sb.setLength(sb.length() - 1);
}

or

// Concise but harder-to-read version of the above.
sb.setLength(Math.max(sb.length() - 1, 0));

^{1 - Be aware that these solutions for removing the last "character" from a String are not Unicode-safe. (Indeed, I don't think any of the solutions presented in other answers are either.) The problem is that codepoints outside of the BMP are represented in a String by a pair of char values. If the last codepoint in a String is (say) an emoji codepoint, then removing the last char will remove half of the codepoint.}

I agree with Micheal Borgwardt's answer but there is an opportunity for elaboration. The approach you see here is not only useful but also consistent with most the APIs you will find in Java and many other languages. The association with 0-based indexing is more clear if you think about the standard old-style for-loop: for (int i = 0; i < end; i++). These days we tend to favor for-each style constructs but this is how a lot of code is written. Note the while condition, it's based on and exclusive end with a < instead of a <=. When you are writing a lot of loops like this, it's helpful to use a similar construct each time.

But to really understand the bigger picture on this, I think it helps to look at a different kind of problem: time intervals. Let's imagine I want to tell if something happened today, in the morning. If I structure this as an inclusive end, I then have a problem of figuring out what the last time possibly could be. That means I need to know the smallest resolution of the clock. Is it seconds, milliseconds, microseconds, nanoseconds? Let's say I think seconds is good enough. So I say 'less than or equal to 11:59'. Does that work if it happened at 11:59 and 30 seconds? Well, I'll check whether "the minute of the day was less than or equal to 11:59". Or I could just say "less than noon" which is a lot more elegant and tends to be more robust.

Or consider date periods. How do I know if two date periods are adjacent i.e. that there is no gap in between? If I used an exclusive end, it's trivial. I just check that the (exclusive) end on the first period is equal to or after the (inclusive) start of the second. If I use an inclusive end, now I have to get out a calendar and figure out if the day after September 30th is October 1st. And does March 1st follow Feb 28? What year is it? Divide that by 4 unless we are talking about the last year of the century but don't forget that the year 2000 is the exception to the exception. There are strategies to solve that kind of thing but the easiest is to convert the inclusive end to exclusive.

There is no immediate way to do this. I suggest you append each substring to a List or even to a Stack, and pop whatever you don't need out of your data structure. When you are totally sure about what to present in your StringBuilder, start appending to it by running through your Collection and putting each substring into your final StringBuilder.