Strings and Methods — Optimize the Code¶

public class Main {
    public static String buildCSV(String[] words) {
        StringBuilder sb = new StringBuilder(words.length * 8); // pre-sized estimate
        for (int i = 0; i < words.length; i++) {
            if (i > 0) {
                sb.append(',');
            }
            sb.append(words[i]);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        String[] words = new String[10_000];
        for (int i = 0; i < words.length; i++) {
            words[i] = "word" + i;
        }

        long start = System.nanoTime();
        String csv = buildCSV(words);
        long elapsed = (System.nanoTime() - start) / 1_000_000;
        System.out.println("Length: " + csv.length() + " in " + elapsed + " ms");
    }
}

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static String[] deduplicateStrings(String[] input) {
        Map<String, String> pool = new HashMap<>(256); // pre-sized for expected uniques
        String[] result = new String[input.length];
        for (int i = 0; i < input.length; i++) {
            String canonical = pool.get(input[i]);
            if (canonical == null) {
                pool.put(input[i], input[i]);
                canonical = input[i];
            }
            result[i] = canonical;
        }
        return result;
    }

    public static void main(String[] args) {
        String[] data = new String[500_000];
        for (int i = 0; i < data.length; i++) {
            data[i] = "category_" + (i % 100);
        }

        long start = System.nanoTime();
        String[] deduped = deduplicateStrings(data);
        long elapsed = (System.nanoTime() - start) / 1_000_000;
        System.out.println("Deduped: " + deduped.length + " in " + elapsed + " ms");
    }
}

import java.util.regex.Pattern;

public class Main {
    // Pattern compiled once and reused — Pattern is thread-safe
    private static final Pattern EMAIL_PATTERN =
            Pattern.compile("^[\\w.+-]+@[\\w.-]+\\.[a-zA-Z]{2,}$");

    public static int countValidEmails(String[] emails) {
        int count = 0;
        for (String email : emails) {
            if (EMAIL_PATTERN.matcher(email).matches()) {
                count++;
            }
        }
        return count;
    }

    public static void main(String[] args) {
        String[] emails = new String[100_000];
        for (int i = 0; i < emails.length; i++) {
            emails[i] = (i % 3 == 0) ? "user" + i + "@example.com" : "invalid-" + i;
        }

        long start = System.nanoTime();
        int valid = countValidEmails(emails);
        long elapsed = (System.nanoTime() - start) / 1_000_000;
        System.out.println("Valid: " + valid + " in " + elapsed + " ms");
    }
}

public class Main {
    public static String[] generateLogEntries(int count) {
        String[] entries = new String[count];
        StringBuilder sb = new StringBuilder(64); // reuse across iterations
        for (int i = 0; i < count; i++) {
            sb.setLength(0); // clear without reallocating
            sb.append('[');
            appendPadded(sb, i % 10000, 4);
            sb.append("] INFO: Processed item ")
              .append(i)
              .append(" with status ")
              .append((i % 2 == 0) ? "OK" : "FAIL");
            entries[i] = sb.toString();
        }
        return entries;
    }

    private static void appendPadded(StringBuilder sb, int value, int width) {
        String numStr = Integer.toString(value);
        for (int i = numStr.length(); i < width; i++) {
            sb.append('0');
        }
        sb.append(numStr);
    }

    public static void main(String[] args) {
        long start = System.nanoTime();
        String[] logs = generateLogEntries(100_000);
        long elapsed = (System.nanoTime() - start) / 1_000_000;
        System.out.println("Generated " + logs.length + " entries in " + elapsed + " ms");
        System.out.println("Sample: " + logs[0]);
    }
}

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static List<String> extractIds(String[] logLines) {
        List<String> ids = new ArrayList<>(logLines.length); // pre-sized
        for (String line : logLines) {
            // new String() ensures a compact, independent copy of the substring
            ids.add(new String(line.substring(0, 8)));
        }
        return ids;
    }

    public static void main(String[] args) {
        // Build log lines without String.format
        String[] logLines = new String[100_000];
        StringBuilder sb = new StringBuilder(500);
        String padding = "X".repeat(492);
        for (int i = 0; i < logLines.length; i++) {
            sb.setLength(0);
            appendPadded(sb, i, 8);
            sb.append(padding);
            logLines[i] = sb.toString();
        }

        long beforeMem = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        List<String> ids = extractIds(logLines);
        logLines = null;
        System.gc();
        long afterMem = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();

        System.out.println("IDs extracted: " + ids.size());
        System.out.println("Memory used: " + (afterMem - beforeMem) / 1024 + " KB");
    }

    private static void appendPadded(StringBuilder sb, int value, int width) {
        String numStr = Integer.toString(value);
        for (int i = numStr.length(); i < width; i++) {
            sb.append('0');
        }
        sb.append(numStr);
    }
}

public class Main {
    // Use an enum to represent the fixed set of statuses
    enum Status { ACTIVE, INACTIVE, PENDING, DELETED }

    public static int countByStatus(Status[] records, Status target) {
        int count = 0;
        for (Status record : records) {
            if (record == target) { // identity comparison — single CPU instruction
                count++;
            }
        }
        return count;
    }

    public static void main(String[] args) {
        Status[] records = new Status[1_000_000];
        Status[] pool = Status.values();
        for (int i = 0; i < records.length; i++) {
            records[i] = pool[i % 4]; // reuses same enum constants — zero allocation
        }

        long start = System.nanoTime();
        int active = countByStatus(records, Status.ACTIVE);
        long elapsed = (System.nanoTime() - start) / 1_000_000;
        System.out.println("Active: " + active + " in " + elapsed + " ms");
    }
}

public class Main {
    public static String[][] parseCSV(String[] lines) {
        String[][] result = new String[lines.length][];
        for (int i = 0; i < lines.length; i++) {
            result[i] = splitByComma(lines[i]);
        }
        return result;
    }

    // Manual split using indexOf — avoids regex and intermediate ArrayList
    private static String[] splitByComma(String line) {
        // Count commas first to pre-size the array
        int count = 1;
        int idx = 0;
        while ((idx = line.indexOf(',', idx)) != -1) {
            count++;
            idx++;
        }

        String[] parts = new String[count];
        int start = 0;
        for (int i = 0; i < count - 1; i++) {
            int end = line.indexOf(',', start);
            parts[i] = line.substring(start, end);
            start = end + 1;
        }
        parts[count - 1] = line.substring(start);
        return parts;
    }

    public static void main(String[] args) {
        String[] lines = new String[100_000];
        for (int i = 0; i < lines.length; i++) {
            lines[i] = "field1_" + i + ",field2_" + i + ",field3_" + i + ",field4_" + i;
        }

        long start = System.nanoTime();
        String[][] parsed = parseCSV(lines);
        long elapsed = (System.nanoTime() - start) / 1_000_000;
        System.out.println("Parsed " + parsed.length + " lines in " + elapsed + " ms");
        System.out.println("Sample: " + java.util.Arrays.toString(parsed[0]));
    }
}

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.Arrays;
import java.util.Base64;

public class Main {
    private static final byte[] SALT = "SALT_".getBytes(StandardCharsets.UTF_8);
    private static final byte[] PEPPER = "_PEPPER".getBytes(StandardCharsets.UTF_8);

    public static String hashPassword(char[] password) {
        try {
            // Convert char[] to byte[] directly — no String intermediary
            byte[] passBytes = new byte[password.length * 3]; // UTF-8 worst case
            int len = 0;
            for (char c : password) {
                if (c < 0x80) {
                    passBytes[len++] = (byte) c;
                } else if (c < 0x800) {
                    passBytes[len++] = (byte) (0xC0 | (c >> 6));
                    passBytes[len++] = (byte) (0x80 | (c & 0x3F));
                } else {
                    passBytes[len++] = (byte) (0xE0 | (c >> 12));
                    passBytes[len++] = (byte) (0x80 | ((c >> 6) & 0x3F));
                    passBytes[len++] = (byte) (0x80 | (c & 0x3F));
                }
            }

            MessageDigest md = MessageDigest.getInstance("SHA-256");
            md.update(SALT);
            md.update(passBytes, 0, len);
            md.update(PEPPER);
            byte[] hash = md.digest();

            // Zero out sensitive data immediately
            Arrays.fill(passBytes, (byte) 0);
            Arrays.fill(password, '\0');

            return Base64.getEncoder().encodeToString(hash);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        char[][] passwords = new char[50_000][];
        for (int i = 0; i < passwords.length; i++) {
            passwords[i] = ("P@ssw0rd_" + i + "!secure").toCharArray();
        }

        long start = System.nanoTime();
        String[] hashes = new String[passwords.length];
        for (int i = 0; i < passwords.length; i++) {
            hashes[i] = hashPassword(passwords[i]);
        }
        long elapsed = (System.nanoTime() - start) / 1_000_000;
        System.out.println("Hashed " + hashes.length + " passwords in " + elapsed + " ms");
        System.out.println("Sample: " + hashes[0]);
    }
}

public class Main {
    // Template split into constant segments at compile time
    private static final String PART1 = "<html><body><h1>Hello, ";
    private static final String PART2 = "!</h1><p>Your order #";
    private static final String PART3 = " has been confirmed.</p><p>Confirmation sent to: ";
    private static final String PART4 = "</p><p>Thank you for shopping with us.</p></body></html>";

    public static String[] generateEmails(String[] names, String[] emails, int[] orderIds) {
        String[] results = new String[names.length];
        // Estimate: fixed parts ~130 chars + variable ~40 chars = ~170
        StringBuilder sb = new StringBuilder(180);
        for (int i = 0; i < names.length; i++) {
            sb.setLength(0);
            sb.append(PART1).append(names[i])
              .append(PART2).append(orderIds[i])
              .append(PART3).append(emails[i])
              .append(PART4);
            results[i] = sb.toString();
        }
        return results;
    }

    public static void main(String[] args) {
        int count = 50_000;
        String[] names = new String[count];
        String[] emails = new String[count];
        int[] orderIds = new int[count];
        for (int i = 0; i < count; i++) {
            names[i] = "User" + i;
            emails[i] = "user" + i + "@example.com";
            orderIds[i] = 10000 + i;
        }

        long start = System.nanoTime();
        String[] results = generateEmails(names, emails, orderIds);
        long elapsed = (System.nanoTime() - start) / 1_000_000;
        System.out.println("Generated " + results.length + " emails in " + elapsed + " ms");
        System.out.println("Sample length: " + results[0].length());
    }
}