Koleksiyonların İçi — ArrayList, LinkedList ve Iterator

1
public class LruCache<K, V> extends LinkedHashMap<K, V> {
2

3
    private final int capacity;
4

5
    public LruCache(int capacity) {
6
        super(16, 0.75f, true);        // accessOrder = true: get() moves an entry to the end
7
        this.capacity = capacity;
8
    }
9

10
    @Override
11
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
12
        return size() > capacity;      // evict the least recently used entry after each put
13
    }
14
    // Not thread-safe: wrap it, or use Caffeine when several threads share it.
15
}

1
public class Choices {
2

3
    // The final size is known: allocate once instead of growing (copying) repeatedly.
4
    static List<Statement> statementsFor(List<Account> accounts) {
5
        List<Statement> result = new ArrayList<>(accounts.size());
6
        for (Account account : accounts) result.add(Statement.of(account));
7
        return result;
8
    }
9

10
    // ArrayDeque: a contiguous ring buffer. Faster than LinkedList as a queue or a stack,
11
    // and without a node object per element.
12
    static Deque<PendingAuthorization> pendingAuthorizations() {
13
        return new ArrayDeque<>();
14
    }
15

16
    // EnumMap: an array indexed by ordinal. No hashing, iteration in declaration order.
17
    static Map<TransferStatus, Integer> countByStatus(List<Transfer> transfers) {
18
        Map<TransferStatus, Integer> counts = new EnumMap<>(TransferStatus.class);
19
        for (Transfer transfer : transfers) counts.merge(transfer.status(), 1, Integer::sum);
20
        return counts;
21
    }
22
}

1
// A tiered deposit product: the annual rate depends on the balance tier.
2
// The rates here are illustrative; the real table comes from the treasury.
3
public class InterestTiers {
4

5
    // Sorted by key: floor/ceiling/subMap in O(log n), which a HashMap cannot do.
6
    private final NavigableMap<BigDecimal, BigDecimal> tiers = new TreeMap<>(Map.of(
7
            new BigDecimal("0"), new BigDecimal("0.30"),
8
            new BigDecimal("100000"), new BigDecimal("0.38"),
9
            new BigDecimal("1000000"), new BigDecimal("0.42")));
10

11
    public BigDecimal rateFor(BigDecimal balance) {
12
        return tiers.floorEntry(balance).getValue();     // greatest threshold <= balance
13
    }
14

15
    public SortedMap<BigDecimal, BigDecimal> from(BigDecimal min) {
16
        return tiers.tailMap(min, true);
17
    }
18
}

1
public class Iteration {
2

3
    // Reversed card transactions must not appear on the statement.
4
    static void removeReversedBroken(List<CardTransaction> txs) {
5
        for (CardTransaction tx : txs) {
6
            if (tx.status() == TxStatus.REVERSED) {
7
                txs.remove(tx);          // ConcurrentModificationException on the next iteration step
8
            }
9
        }
10
    }
11

12
    static void removeReversed(List<CardTransaction> txs) {
13
        txs.removeIf(tx -> tx.status() == TxStatus.REVERSED);   // one pass, no CME
14
    }
15
}

1
public class Main {
2

3
    public static void main(String[] args) {
4
        // Recipient-name lookups while the customer types an IBAN: recent ones stay hot.
5
        var names = new LruCache<String, String>(2);
6
        names.put("TR11", "Ayşe Y.");
7
        names.put("TR22", "Mehmet K.");
8
        names.get("TR11");              // TR11 is now the most recent
9
        names.put("TR33", "Can D.");    // evicts TR22, the least recently used
10
        System.out.println(names.keySet());                           // [TR11, TR33]
11

12
        var tiers = new InterestTiers();
13
        System.out.println(tiers.rateFor(new BigDecimal("250000")));   // 0.38
14
        System.out.println(tiers.rateFor(new BigDecimal("1000000")));  // 0.42
15
    }
16
}