Basics of OOP — Optimize the Code¶

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;

public class Main {
    static class PriceFormatter {
        private final DecimalFormat format = new DecimalFormat("#,##0.00");

        String format(double price) {
            return "$" + format.format(price);
        }
    }

    public static void main(String[] args) {
        double[] prices = new double[100_000];
        for (int i = 0; i < prices.length; i++) {
            prices[i] = Math.random() * 10000;
        }

        List<String> result = new ArrayList<>(prices.length);
        long start = System.nanoTime();

        // Reuse a single formatter instance
        PriceFormatter formatter = new PriceFormatter();
        for (double price : prices) {
            result.add(formatter.format(price));
        }

        long elapsed = System.nanoTime() - start;
        System.out.println("Formatted " + result.size() + " prices");
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

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

public class Main {
    static class Person {
        String name;
        int age;

        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString() {
            return name + "(" + age + ")";
        }
    }

    static String formatAll(List<Person> people) {
        StringJoiner sj = new StringJoiner(", ", "[", "]");
        for (Person p : people) {
            sj.add(p.toString());
        }
        return sj.toString();
    }

    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        for (int i = 0; i < 10_000; i++) {
            people.add(new Person("Person" + i, 20 + (i % 50)));
        }

        long start = System.nanoTime();
        String output = formatAll(people);
        long elapsed = System.nanoTime() - start;

        System.out.println("Length: " + output.length());
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

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

public class Main {
    static class Point {
        double x, y; // Primitive types — no boxing

        Point(double x, double y) {
            this.x = x;
            this.y = y;
        }

        double distanceTo(Point other) {
            double dx = this.x - other.x;
            double dy = this.y - other.y;
            return Math.sqrt(dx * dx + dy * dy);
        }
    }

    public static void main(String[] args) {
        List<Point> points = new ArrayList<>();
        for (int i = 0; i < 100_000; i++) {
            points.add(new Point(Math.random() * 1000, Math.random() * 1000));
        }

        long start = System.nanoTime();

        double totalDistance = 0.0; // primitive accumulator
        for (int i = 1; i < points.size(); i++) {
            totalDistance += points.get(i - 1).distanceTo(points.get(i));
        }

        long elapsed = System.nanoTime() - start;
        System.out.println("Total distance: " + String.format("%.2f", totalDistance));
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

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

public class Main {
    static class ImmutableConfig {
        private final List<String> settings;

        ImmutableConfig(List<String> settings) {
            // Defensive copy only once, then wrap as unmodifiable
            this.settings = Collections.unmodifiableList(new ArrayList<>(settings));
        }

        // Return the unmodifiable view — no copy needed
        List<String> getSettings() {
            return settings;
        }

        // Direct index access — no list copy
        String getSetting(int index) {
            return settings.get(index);
        }
    }

    public static void main(String[] args) {
        List<String> initial = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            initial.add("setting." + i + "=value" + i);
        }

        ImmutableConfig config = new ImmutableConfig(initial);

        long start = System.nanoTime();
        String result = "";
        for (int i = 0; i < 100_000; i++) {
            result = config.getSetting(i % 1000);
        }
        long elapsed = System.nanoTime() - start;

        System.out.println("Last setting: " + result);
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

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

public class Main {
    static class DatabaseConnection {
        private Map<String, String> cache;
        private String connectionString;
        private boolean connected;

        DatabaseConnection(String connectionString) {
            this.connectionString = connectionString;
            // No expensive work in constructor
        }

        private void ensureConnected() {
            if (!connected) {
                this.cache = new HashMap<>();
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                for (int i = 0; i < 10_000; i++) {
                    cache.put("key" + i, "value" + i);
                }
                this.connected = true;
            }
        }

        String getConnectionString() {
            return connectionString; // No initialization needed for metadata
        }

        String query(String key) {
            ensureConnected(); // Initialize only when first query is made
            return cache.get(key);
        }
    }

    public static void main(String[] args) {
        long start = System.nanoTime();

        DatabaseConnection db = new DatabaseConnection("jdbc:mysql://localhost/test");
        System.out.println("Connection: " + db.getConnectionString());

        long elapsed = System.nanoTime() - start;
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

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

public class Main {
    static class Settings {
        private final Map<String, String> values;

        Settings() {
            this.values = Collections.emptyMap();
        }

        private Settings(Map<String, String> values) {
            // No copy — trusts the caller (private constructor)
            this.values = Collections.unmodifiableMap(values);
        }

        Settings set(String key, String value) {
            Map<String, String> copy = new HashMap<>(this.values);
            copy.put(key, value);
            return new Settings(copy); // single copy, not double
        }

        String get(String key) {
            return values.getOrDefault(key, "N/A");
        }

        int size() {
            return values.size();
        }

        // Builder for bulk updates — avoids repeated copying
        static class Builder {
            private final Map<String, String> values;

            Builder(Settings base) {
                this.values = new HashMap<>(base.values);
            }

            Builder set(String key, String value) {
                values.put(key, value);
                return this;
            }

            Settings build() {
                return new Settings(values);
            }
        }
    }

    public static void main(String[] args) {
        long start = System.nanoTime();

        Settings.Builder builder = new Settings.Builder(new Settings());
        for (int i = 0; i < 50_000; i++) {
            builder.set("key" + (i % 100), "value" + i);
        }
        Settings settings = builder.build();

        long elapsed = System.nanoTime() - start;
        System.out.println("Settings size: " + settings.size());
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

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

public class Main {
    // Record class — compact, JVM-optimized value semantics
    record Money(long cents, String currency) {
        // Use long cents instead of double to avoid floating-point issues
        // equals, hashCode, toString auto-generated via invokedynamic
    }

    public static void main(String[] args) {
        Map<Money, String> descriptions = new HashMap<>();
        long start = System.nanoTime();

        for (int i = 0; i < 100_000; i++) {
            Money m = new Money(i % 1000, "USD");
            descriptions.put(m, "payment-" + i);
        }

        long elapsed = System.nanoTime() - start;
        System.out.println("Map size: " + descriptions.size());
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import java.io.ByteArrayInputStream;

public class Main {
    // ThreadLocal pool — one DocumentBuilder per thread, reused
    private static final ThreadLocal<DocumentBuilder> BUILDER_POOL =
        ThreadLocal.withInitial(() -> {
            try {
                return DocumentBuilderFactory.newInstance().newDocumentBuilder();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });

    static String parseTitle(String xml) throws Exception {
        DocumentBuilder builder = BUILDER_POOL.get();
        builder.reset(); // Reset state for reuse
        Document doc = builder.parse(new ByteArrayInputStream(xml.getBytes()));
        return doc.getDocumentElement().getTagName();
    }

    public static void main(String[] args) throws Exception {
        String xml = "<book><title>Java</title></book>";

        long start = System.nanoTime();
        String result = "";
        for (int i = 0; i < 10_000; i++) {
            result = parseTitle(xml);
        }
        long elapsed = System.nanoTime() - start;

        System.out.println("Tag: " + result);
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

public class Main {
    static class CompositeKey {
        private final String[] parts;
        private final int cachedHash; // Computed once, cached forever

        CompositeKey(String... parts) {
            this.parts = parts.clone();
            this.cachedHash = Arrays.hashCode(this.parts); // Compute once
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            CompositeKey that = (CompositeKey) o;
            // Fast path: if hashes differ, objects are definitely not equal
            if (this.cachedHash != that.cachedHash) return false;
            return Arrays.equals(parts, that.parts);
        }

        @Override
        public int hashCode() {
            return cachedHash; // O(1) — just return the cached value
        }
    }

    public static void main(String[] args) {
        CompositeKey[] keys = new CompositeKey[10_000];
        for (int i = 0; i < keys.length; i++) {
            String[] parts = new String[20];
            for (int j = 0; j < 20; j++) {
                parts[j] = "part" + j + "_" + (i % 500);
            }
            keys[i] = new CompositeKey(parts);
        }

        Map<CompositeKey, Integer> map = new HashMap<>();
        long start = System.nanoTime();

        for (int i = 0; i < keys.length; i++) {
            map.put(keys[i], i);
        }
        long sum = 0;
        for (CompositeKey key : keys) {
            sum += map.get(key);
        }

        long elapsed = System.nanoTime() - start;
        System.out.println("Sum: " + sum);
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}