Thanks for the PR @sergeevik. Have you run some benchmarks on this? I suspect that there won't be much impact since the JVM does a lot of these optimizations already.

@aeberhart Benchmarks are a complex thing. I tried them on simple examples and stumbled upon many JVM optimizations (due to the simplicity of the scenarios).

This is more of a general practice (my experience).

Regarding strings and creating new strings by appending to chars, the JVM might optimize them, but there's no point in waiting for JIT to notice.

String appending in a loop is never optimized by JIT.

Regex compilation is useful because JIT doesn't do it itself. The JVM might cache some things, but not much.

For example look at the Signature.validate method

jetbrains performance alanytics show memmory allocation
biggest on 'match.split' 5GB

deep into String split

4.8 GB by 'pattern.split'

deep into Pattern.split

3.94 on matcher invoke

deep into mather call

2.56 on compile invoke

But we split by empty string. wich mean just get char array. If replace this logic on Pattern.compile we save 50% RAM. If replace this by toCharArray save 100% RAM

less gc call

just example. I try collect more preformance check on my data.

In my case. i try two version
first without my changes. max used RAM 5.5 GB

second with my changes. max used RAM 4.1

seems it's no diff on result used RAM when all data calculated but defferent use
and this less gc activity

But I'm starting to doubt the usefulness of using String.valueOf for char ;

    public static String valueOf(char c) {
        if (COMPACT_STRINGS && StringLatin1.canEncode(c)) {
            return new String(StringLatin1.toBytes(c), LATIN1);
        }
        return new String(StringUTF16.toBytes(c), UTF16);
    }

it seems like it doesn't create fewer objects. So, I'll make a couple of changes and run some more measurements.

Hi @aeberhart, I removed my the String.valueOf s—they're probably pointless.

I left the StringBuilder in the loop because it's still not optimized by the JIT.

Also left the regex as constants.

Removed the string handling in the signature calculation and reworked it to use characters (since it's essentially handling characters, but it creates extra strings).