Strings and Methods — Senior Level¶

public interface TextProcessor {
    // ✅ Accept CharSequence — works with String, StringBuilder, etc.
    CharSequence process(CharSequence input);

    // ❌ Avoid — forces callers to convert to String
    // String process(String input);
}

public class HtmlEscaper implements TextProcessor {
    private static final Map<Character, String> ESCAPES = Map.of(
        '<', "&lt;", '>', "&gt;", '&', "&amp;", '"', "&quot;"
    );

    @Override
    public CharSequence process(CharSequence input) {
        StringBuilder result = null;
        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            String escape = ESCAPES.get(c);
            if (escape != null) {
                if (result == null) {
                    result = new StringBuilder(input.length() + 16);
                    result.append(input, 0, i);
                }
                result.append(escape);
            } else if (result != null) {
                result.append(c);
            }
        }
        return result != null ? result : input; // Return original if no escaping needed
    }
}

public class StringBuilderPool {
    private static final ThreadLocal<StringBuilder> POOL =
        ThreadLocal.withInitial(() -> new StringBuilder(256));

    public static StringBuilder acquire() {
        StringBuilder sb = POOL.get();
        sb.setLength(0); // reset without deallocating
        return sb;
    }

    // Usage
    public static String buildMessage(String user, String action, long timestamp) {
        StringBuilder sb = acquire();
        sb.append('[').append(timestamp).append("] ")
          .append(user).append(": ").append(action);
        return sb.toString();
    }
}

import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 5, time = 1)
@Fork(2)
@State(Scope.Benchmark)
public class StringConcatBenchmark {

    @Param({"10", "100", "1000"})
    int count;

    @Benchmark
    public String plusOperator() {
        String result = "";
        for (int i = 0; i < count; i++) result += "x";
        return result;
    }

    @Benchmark
    public String stringBuilder() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < count; i++) sb.append("x");
        return sb.toString();
    }

    @Benchmark
    public String stringBuilderSized() {
        StringBuilder sb = new StringBuilder(count);
        for (int i = 0; i < count; i++) sb.append("x");
        return sb.toString();
    }

    @Benchmark
    public String stringJoin() {
        String[] arr = new String[count];
        java.util.Arrays.fill(arr, "x");
        return String.join("", arr);
    }

    @Benchmark
    public String charArrayDirect() {
        char[] chars = new char[count];
        java.util.Arrays.fill(chars, 'x');
        return new String(chars);
    }
}

@Benchmark
public String internNew() {
    return new String("test_" + counter++).intern();
}

@Benchmark
public String internExisting() {
    return "test_fixed".intern(); // already in pool
}

@Benchmark
public String noIntern() {
    return new String("test_" + counter++);
}

import java.util.concurrent.ConcurrentHashMap;

public class StringRegistry {
    private final ConcurrentHashMap<String, String> registry = new ConcurrentHashMap<>(256);

    public String canonicalize(String input) {
        if (input == null) return null;
        return registry.computeIfAbsent(input, k -> k);
    }

    public int size() { return registry.size(); }

    public void clear() { registry.clear(); }

    // Usage for high-cardinality fields with repetition
    private static final StringRegistry STATUS_REGISTRY = new StringRegistry();

    public static String normalizeStatus(String rawStatus) {
        return STATUS_REGISTRY.canonicalize(rawStatus.toUpperCase());
    }
}

import java.nio.CharBuffer;

public class ZeroCopyParser {

    public static void parseCsv(CharSequence line, java.util.function.BiConsumer<Integer, CharSequence> fieldHandler) {
        int fieldIndex = 0;
        int start = 0;
        for (int i = 0; i <= line.length(); i++) {
            if (i == line.length() || line.charAt(i) == ',') {
                // subSequence returns a VIEW — no copy
                fieldHandler.accept(fieldIndex, line.subSequence(start, i));
                fieldIndex++;
                start = i + 1;
            }
        }
    }

    public static void main(String[] args) {
        CharBuffer line = CharBuffer.wrap("Alice,30,NYC,Engineer");
        parseCsv(line, (index, value) ->
            System.out.printf("Field %d: %s%n", index, value));
    }
}

public sealed interface Rope permits Rope.Leaf, Rope.Branch {

    int length();
    char charAt(int index);
    Rope concat(Rope other);
    Rope substring(int start, int end);

    record Leaf(String value) implements Rope {
        public int length() { return value.length(); }
        public char charAt(int index) { return value.charAt(index); }
        public Rope concat(Rope other) { return new Branch(this, other); }
        public Rope substring(int start, int end) {
            return new Leaf(value.substring(start, end));
        }
    }

    record Branch(Rope left, Rope right) implements Rope {
        public int length() { return left.length() + right.length(); }
        public char charAt(int index) {
            int leftLen = left.length();
            return index < leftLen ? left.charAt(index) : right.charAt(index - leftLen);
        }
        public Rope concat(Rope other) { return new Branch(this, other); }
        public Rope substring(int start, int end) {
            int leftLen = left.length();
            if (end <= leftLen) return left.substring(start, end);
            if (start >= leftLen) return right.substring(start - leftLen, end - leftLen);
            return left.substring(start, leftLen).concat(right.substring(0, end - leftLen));
        }
    }

    static Rope of(String s) { return new Leaf(s); }
}

// ❌ Race condition — reference assignment is not atomic
private String cachedValue;

public String getValue() {
    if (cachedValue == null) {
        cachedValue = computeExpensiveString(); // multiple threads may compute
    }
    return cachedValue;
}

// ✅ Thread-safe with volatile
private volatile String cachedValue;

// ✅ Or use AtomicReference for CAS
private final AtomicReference<String> cachedValue = new AtomicReference<>();

public String getValue() {
    String result = cachedValue.get();
    if (result == null) {
        result = computeExpensiveString();
        cachedValue.compareAndSet(null, result);
        result = cachedValue.get(); // may be different thread's result
    }
    return result;
}

// ❌ StringBuffer is synchronized but SLOW for contended access
StringBuffer shared = new StringBuffer();
// Multiple threads appending...

// ✅ Collect per-thread and merge
List<String> perThreadResults = Collections.synchronizedList(new ArrayList<>());
// Each thread builds locally with StringBuilder, adds result to list
// Then join: String.join("", perThreadResults)

// ✅✅ Best — parallel stream with joining collector
String result = IntStream.range(0, 1000)
    .parallel()
    .mapToObj(i -> processItem(i))
    .collect(Collectors.joining());

// ❌ String built regardless of log level
log.debug("Processing user " + user.getId() + " with request " + request.toString());

// ✅ Parameterized logging — string built only if DEBUG is enabled
log.debug("Processing user {} with request {}", user.getId(), request);

// ✅ Lazy evaluation for expensive toString()
log.debug("Complex state: {}", (Supplier<String>) () -> computeExpensiveDebugString());