Android topics — 13: אותו חוזה, שני מבני נתונים

package com.example.topics;

import java.util.Locale;
import java.util.Objects;

/** An immutable book whose identity is its normalized code. */
public final class Book {
    public final String code;
    public final String title;

    /**
     * Creates immutable identity from a trimmed, locale-independent uppercase code.
     *
     * @param code nonblank identifier to normalize
     * @param title non-null display title, which is not part of identity
     * @throws IllegalArgumentException if code is null or blank
     * @throws NullPointerException if title is null
     */
    public Book(String code, String title) {
        if (code == null || code.trim().isEmpty()) {
            throw new IllegalArgumentException("Book code is required");
        }
        // Machine identity must not change with the phone's display language.
        this.code = code.trim().toUpperCase(Locale.ROOT);
        this.title = Objects.requireNonNull(title, "title");
    }

    /**
     * Compares normalized book identity, ignoring display title.
     *
     * @param other object to compare, possibly null or another type
     * @return true for the same normalized code
     */
    @Override
    public boolean equals(Object other) {
        if (this == other) return true;
        if (!(other instanceof Book)) return false;
        return code.equals(((Book) other).code);
    }

    /**
     * Hashes exactly the identity fields used by equals.
     *
     * @return equal hash values for equal books; collisions can still occur
     */
    @Override
    public int hashCode() {
        return code.hashCode();
    }
}

package com.example.topics;

/** Operations shared by catalogs with different storage structures. */
public interface Catalog<T> {
    /**
     * Adds one non-null unique item.
     *
     * @param item item to store
     * @throws DuplicateItemException if an equal item is already present
     * @throws NullPointerException if item is null
     */
    void add(T item);
    /**
     * Tests membership using the equality contract of the item type.
     *
     * @param item lookup identity
     * @return whether an equal item is present
     */
    boolean contains(T item);
    /**
     * Counts unique stored items.
     *
     * @return current catalog size
     */
    int size();
}

package com.example.topics;

/** A duplicate is a recoverable user action, not a crash. */
public final class DuplicateItemException extends IllegalArgumentException {
    /**
     * Describes a rejected duplicate insertion that leaves the catalog unchanged.
     */
    public DuplicateItemException() {
        super("This book code already exists");
    }
}

package com.example.topics;

import java.util.Objects;

/** Shares the add contract while leaving storage to subclasses. */
public abstract class AbstractCatalog<T> implements Catalog<T> {
    /**
     * Enforces the shared insertion policy before delegating storage to a subclass.
     *
     * @param item non-null item to insert
     * @throws NullPointerException if item is null
     * @throws DuplicateItemException if an equal item is already stored
     */
    @Override
    public final void add(T item) {
        Objects.requireNonNull(item, "item");
        if (contains(item)) {
            throw new DuplicateItemException();
        }
        // Dispatch to the subclass only after the shared contract is satisfied.
        insert(item);
    }

    /**
     * Stores an item after the base add method has validated its insertion.
     *
     * @param item validated item to store; this method does not repeat the policy
     */
    protected abstract void insert(T item);
}

package com.example.topics;

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

/** Linear search; lastChecks makes the work visible. */
public final class ListCatalog<T> extends AbstractCatalog<T> {
    private final List<T> items = new ArrayList<>();
    private int lastChecks;

    /**
     * Tests membership according to item equality in this storage implementation.
     *
     * @param item identity to search for
     * @return whether an equal item is stored
     */
    @Override
    public boolean contains(T item) {
        lastChecks = 0;
        for (T candidate : items) {
            lastChecks++;
            if (Objects.equals(candidate, item)) return true;
        }
        return false;
    }

    /**
     * Stores an item after the base add method has validated its insertion.
     *
     * @param item validated item to store; this method does not repeat the policy
     */
    @Override
    protected void insert(T item) {
        items.add(item);
    }

    /**
     * Counts stored unique items.
     *
     * @return current number of stored items
     */
    @Override
    public int size() {
        return items.size();
    }

    /**
     * Reports comparisons made by the most recent List membership check.
     *
     * @return comparison count, not elapsed time or HashSet work
     */
    public int getLastChecks() {
        return lastChecks;
    }
}

package com.example.topics;

import java.util.HashSet;
import java.util.Set;

/** Hash-based membership uses Book.equals and Book.hashCode. */
public final class SetCatalog<T> extends AbstractCatalog<T> {
    private final Set<T> items = new HashSet<>();

    /**
     * Tests membership according to item equality in this storage implementation.
     *
     * @param item identity to search for
     * @return whether an equal item is stored
     */
    @Override
    public boolean contains(T item) {
        return items.contains(item);
    }

    /**
     * Stores an item after the base add method has validated its insertion.
     *
     * @param item validated item to store; this method does not repeat the policy
     */
    @Override
    protected void insert(T item) {
        items.add(item);
    }

    /**
     * Counts stored unique items.
     *
     * @return current number of stored items
     */
    @Override
    public int size() {
        return items.size();
    }
}

package com.example.topics;

import org.junit.Test;
import static org.junit.Assert.*;

public final class CatalogTest {
    /**
     * Checks that normalized identity defines equality and the matching hash contract.
     */
    @Test
    public void normalizedCodeDefinesEqualityAndHash() {
        Book first = new Book(" b-40 ", "First title");
        Book sameCode = new Book("B-40", "Different title");
        assertEquals(first, sameCode);
        assertEquals(first.hashCode(), sameCode.hashCode());
    }

    /**
     * Checks shared membership behavior while exposing List's linear comparisons.
     */
    @Test
    public void listAndSetAgreeButListScansToLastItem() {
        ListCatalog<Book> list = new ListCatalog<>();
        SetCatalog<Book> set = new SetCatalog<>();
        for (int number = 1; number <= 40; number++) {
            Book book = new Book("B-" + number, "Book " + number);
            list.add(book);
            set.add(book);
        }
        Book last = new Book("b-40", "Lookup");
        assertTrue(list.contains(last));
        assertEquals(40, list.getLastChecks());
        assertTrue(set.contains(last));
        assertFalse(set.contains(new Book("B-99", "Missing")));
    }

    /**
     * Checks rejected operations leave the catalog size unchanged.
     */
    @Test
    public void duplicateAndBlankCodeAreRejectedWithoutChangingSize() {
        Catalog<Book> catalog = new SetCatalog<>();
        catalog.add(new Book("B-7", "Original"));
        try {
            catalog.add(new Book(" b-7 ", "Duplicate"));
            fail("DuplicateItemException expected");
        } catch (DuplicateItemException expected) {
            assertEquals(1, catalog.size());
        }
        try {
            new Book("  ", "Invalid");
            fail("IllegalArgumentException expected");
        } catch (IllegalArgumentException expected) {
            assertEquals(1, catalog.size());
        }
    }
}

private final ListCatalog<Book> listCatalog = new ListCatalog<>();
private final SetCatalog<Book> setCatalog = new SetCatalog<>();

for (int number = 1; number <= 40; number++) {
    String code = String.format(Locale.ROOT, "B-%02d", number);
    Book book = new Book(code, "Book " + number);
    listCatalog.add(book);
    setCatalog.add(book);
}
binding.addBook.setOnClickListener(view -> addBook());
binding.findBook.setOnClickListener(view -> findBook());

/**
 * Converts entered code into a Book and reports expected validation failures in the UI.
 */
private void addBook() {
    try {
        Book book = new Book(binding.bookCode.getText().toString(), "Student book");
        listCatalog.add(book);
        setCatalog.add(book);
        binding.result.setText(getString(R.string.added, book.code, listCatalog.size()));
    } catch (DuplicateItemException duplicate) {
        binding.result.setText(R.string.duplicate_book);
    } catch (IllegalArgumentException invalid) {
        binding.result.setText(R.string.code_required);
    }
}

/**
 * Runs the same membership query through both catalogs and displays List work.
 */
private void findBook() {
    try {
        Book query = new Book(binding.bookCode.getText().toString(), "Lookup");
        boolean inList = listCatalog.contains(query);
        int checks = listCatalog.getLastChecks();
        boolean inSet = setCatalog.contains(query);
        binding.result.setText(getString(R.string.lookup_result, query.code,
                inList ? getString(R.string.yes) : getString(R.string.no), checks,
                inSet ? getString(R.string.yes) : getString(R.string.no)));
    } catch (IllegalArgumentException invalid) {
        binding.result.setText(R.string.code_required);
    }
}