Stream.collect with StringBuilder works but Custom class is not working

    // S#1. stream works with StringBuilder 
System.out.println( 
Stream.of("a", "b", "c", "d", "ef", "ghi", "j")
.collect(StringBuilder::new,
StringBuilder::append,
StringBuilder::append)
.toString()
);
// S#2. stream works fine with Int 
// my custom class that conforms to arg types of collect method
// method signature: collect(Supplier, accumulator, combiner)
Int anInt = new Int();
System.out.println(
Stream.of("a", "b", "c", "d", "ef", "ghi", "j")
.collect(() -> anInt, Int::accumulator, Int::combiner)
.total
);
class Int {
int total;
static void accumulator(Int result, String str) { result.total += str.length(); }
static void combiner(Int a, Int b) { a.total += b.total; }
}
// S#3. compiler error with Int2 
// custom class I created which has method accumulator(String) similar to StringBuidler append(String)
// StringBuilder::append (used as above in S#1)
Int2 int2 = new Int2();
System.out.println(
Stream.of("a", "b", "c", "d", "ef", "ghi", "j")
.collect(() -> int2, int2::accumulator, int2::combiner)
);
class Int2 {
void accumulator(String s) {}
void combiner(Int2 b) {}
}

But I am wondering how StringBuilder version code compiles, whereas S#3 (Int2 version) doesn't.
StringBuilder extends from CharSequence, AbstractStringBuilder classes. Is it working because of this hierarchy relationship which something lacks on my custom class (Int2)

Much appreciated your help.

Compare the way that you are using the StringBuilder methods, with the way that you are using your Int2 methods:

.collect(StringBuilder::new,
StringBuilder::append,
StringBuilder::append)
.collect(
() -> int2, 
int2::accumulator, 
int2::combiner)

Clearly, they are in different forms. int2::accumulator refers to the accumulator method on a specific instance of Int2 called int2. StringBuilder::append however, refers to the append method. These are different kinds of method references. For more info about the different kinds of method references, see "Kinds of Method References" in this page.

You should instead use:

.collect(
Int2::new, 
Int2::accumulator, 
Int2::combiner)

int2::accumulator is known as a "Reference to an Instance Method of a Particular Object" in the docs, and it refers to a method that takes a String and returns void, so it can be passed into a Consumer<String>. However, collect expects BiConsumer<Int2, String> as the second argument.

Because Int2::accumulator does not refer to a specific instance of Int2. It is known as a "Reference to an Instance Method of an Arbitrary Object of a Particular Type" in the docs. It represents a function that accepts an instance of Int2 as its first parameter, in addition to the other parameters that accumulator normally accepts. This is why you can pass in Int2::accumulator instead. A similar explanation can be applied for Int2::combiner.

This goes without saying, but your methods are empty, so it won't do anything at runtime.