比较两个列表中的元素

Question

我从两家不同的书店得到了两本书的书单。这些标题可以是相同的，但它们的书写方式不同，例如“例如”-“例如”，正如你所看到的，它们是相等的，但一点也不一样。

这就是为什么我编写的流将purify元素(它将删除列表中的空格和特殊字母)，并使它们相等，所以流之后两者看起来都像"forexmaple“，因此它们现在是相等的。

private List<String> purifyListOfTitles(List<Book> listToPurify) {
        return listToPurify
                .stream()
                .map(Book::getTitle)
                .map(title -> title.replaceAll("[^A-Za-z]+", ""))
                .collect(Collectors.toList());
    }

问题是..。我想得到一个地图，将包括原始标题和图书出现次数(最多2次，默认1)。我编写了算法，比较两个标题，并从第一个书店添加标题到地图，但我必须从第二个添加，但不知道如何才能得到这个标题。

说清楚..。

我在比较第一家书店的标题和第二家书店的每个标题，如果是相等的，那么我将添加+1，如果循环结束，我将从第一家书店添加这个迭代标题，并添加次数。但是，如果第二家书店的书名只有一次出现，那又是怎么回事？我知道来自第一家书店的迭代标题索引，所以我可以使用.get(i)方法从原始列表中获得这个标题(带有未纯化的标题)，但是我不知道第二个书店的迭代标题的索引以获得原始标题。

我看到的唯一的解决方案是，先把then和第二个标题进行比较，然后再将标题与第一家书店的每个标题进行比较，但这不是最佳的解决方案。或者不知怎么的不净化列表。

总之，我只有在地图标题从第一家书店，我如何添加标题从第二家书店被省略。我想要地图中的原始标题(例如，净化是房子大，但原来的是房子-是大的)！，我是比较纯化列表和添加原始标题。

全班：

package bookstore.scraper.rankingsystem;

import bookstore.scraper.Bookstore;
import bookstore.scraper.book.Book;
import bookstore.scraper.book.scrapingtypeservice.CategorizedBookService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.toMap;

@Slf4j
@Component
public class CategorizedBooksRankingService {

    private final CategorizedBookService categorizedBookService;

    @Autowired
    public CategorizedBooksRankingService(CategorizedBookService categorizedBookService) {
        this.categorizedBookService = categorizedBookService;
    }

    public Map<String, Integer> getRankingForCategory(String category) {
        Map<Bookstore, List<Book>> bookstoreWith15CategorizedBooks = chooseGetterImplementationByCategory(category);

        List<Book> merlinBooks = bookstoreWith15CategorizedBooks.get(Bookstore.MERLIN);
        List<Book> empikBooks = bookstoreWith15CategorizedBooks.get(Bookstore.EMPIK);

        List<String> purifiedMerlinBookTitles = purifyListOfTitles(merlinBooks);
        List<String> purifiedEmpikBookTitles = purifyListOfTitles(empikBooks);

        Map<String, Integer> bookTitleWithOccurrencesNumber =
                prepareTitleAndOccurrencesMap(merlinBooks, empikBooks, purifiedMerlinBookTitles, purifiedEmpikBookTitles);

        return getSortedLinkedHashMappedByValue(bookTitleWithOccurrencesNumber);
    }

    private Map<String, Integer> prepareTitleAndOccurrencesMap(List<Book> merlinBooks, List<Book> empikBooks, List<String> purifiedMerlinBookTitles, List<String> purifiedEmpikBookTitles) {
        Map<String, Integer> bookTitleWithOccurrencesNumber = new LinkedHashMap<>();

        int occurrencesOfIteratedBook;
        String iteratedMerlinTitle;

        for (int i = 0; i < purifiedMerlinBookTitles.size(); i++) {
            occurrencesOfIteratedBook = 1;
            iteratedMerlinTitle = purifiedMerlinBookTitles.get(i);
            for (String iteratedEmpikTitle : purifiedEmpikBookTitles) {

                if (iteratedMerlinTitle.equals(iteratedEmpikTitle))
                    occurrencesOfIteratedBook++;
            }
            bookTitleWithOccurrencesNumber.put(merlinBooks.get(i).getTitle(), occurrencesOfIteratedBook);
            //how to add to bookTitleWithOccurrencesNumber map book titles from second bookstore that are not equal to any of title
        }
        return bookTitleWithOccurrencesNumber;
    }

    private List<String> purifyListOfTitles(List<Book> listToPurify) {
        return listToPurify
                .stream()
                .map(Book::getTitle)
                .map(title -> title.replaceAll("[^A-Za-z]+", ""))
                .collect(Collectors.toList());
    }

    private Map<String, Integer> getSortedLinkedHashMappedByValue(Map<String, Integer> mapToSort) {
        return mapToSort.entrySet()
                .stream()
                .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
                .collect(
                        toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2,
                                LinkedHashMap::new));
    }

    private Map<Bookstore, List<Book>> chooseGetterImplementationByCategory(String category) {
        if (category.equals("crimes"))
            return categorizedBookService.get15BooksFromCrimeCategory();
        if (category.equals("romances"))
            return categorizedBookService.get15BooksFromRomanceCategory();
        if (category.equals("fantasies"))
            return categorizedBookService.get15BooksFromFantasyCategory();
        if (category.equals("guides"))
            return categorizedBookService.get15BooksFromGuidesCategory();
        if (category.equals("biographies"))
            return categorizedBookService.get15BooksFromBiographiesCategory();
        else {
            log.error(category + " is invalid category");
            throw new IllegalArgumentException();
        }
    }
}

示例：

Book a = new Book.BookBuilder().withTitle("To - jest haha").build();
        Book b = new Book.BookBuilder().withTitle("Bubu").build();
        Book c = new Book.BookBuilder().withTitle("Kiki").build();
        Book d = new Book.BookBuilder().withTitle("sza . la").build();

        Book e = new Book.BookBuilder().withTitle("Tojest haha").build();
        Book f = new Book.BookBuilder().withTitle("bam").build();
        Book g = new Book.BookBuilder().withTitle("zzz").build();
        Book h = new Book.BookBuilder().withTitle("szaLa").build();


        List<Book> list1 = new ArrayList<>();
        list1.add(a);
        list1.add(b);
        list1.add(c);
        list1.add(d);

        List<Book> list2 = new ArrayList<>();
        list2.add(e);
        list2.add(f);
        list2.add(g);
        list2.add(h);

        Map<String,Long> z = countBooksByTitle(list1,list2);

Z map包含：{sza . la =2, Bubu=1, zzz=1, Kiki=1, bam=1, To - jest haha =2}

Answer 1

我有两份名单 ..。 我想要一张地图，其中包括书的标题和出现的次数。

您可以这样做，这是一个单一的流链：

private Map<String, Long> countBooksByTitle(List<Book> list1, List<Book> list2) {
    return Stream.concat(list1.stream(), list2.stream())
            .map(book -> book.getTitle().replaceAll("[^A-Za-z]+", ""))
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
}

注意，理论上，如果一个列表有两个或多个不同的书籍，标题映射到相同的紧凑型文本，那么理论上的计数可能大于2。因为你只保留字母，所以Streams for dummies 1和Streams for dummies 2可以算作两本名为Streamsfordummies的书。

更新

若要保留原始标题，请创建一个helper类，该类通过纯化的标题进行比较，但保留原始标题，然后首先使用类构建映射，然后将其展开到原始标题。

在下面的代码中，对纯化进行了修改，以保留数字，并在保留字母的同时消除重音，例如bé -> be，而问题代码将消除字母bé -> b。这样，bé和bä就不会相提并论。

因为计数代码无论如何都是映射键/值对，所以值也从Long映射到Integer，只是为了表明它可以完成。生成的映射也已被修改为按标题排序。

帮助者阶级

public final class PurifiedTitle implements Comparable<PurifiedTitle> {
    private final String original;
    private final String purified;
    public PurifiedTitle(String title) {
        this.original = title;
        // Purified string has only lowercase letters and digits,
        // with no accents on the letters
        this.purified = Normalizer.normalize(title, Normalizer.Form.NFD)
                .replaceAll("\\P{Alnum}+", "")
                .toLowerCase(Locale.US);
    }
    @Override
    public String toString() {
        return this.original;
    }
    @Override
    public int compareTo(PurifiedTitle that) {
        return this.purified.compareTo(that.purified);
    }
    @Override
    public boolean equals(Object obj) {
        if (! (obj instanceof PurifiedTitle))
            return false;
        PurifiedTitle that = (PurifiedTitle) obj;
        return this.purified.equals(that.purified);
    }
    @Override
    public int hashCode() {
        return this.purified.hashCode();
    }
}

更新计数法

private static Map<String, Integer> countBooksByTitle(List<Book> list1, List<Book> list2) {
    Collator collator = Collator.getInstance(Locale.US);
    collator.setStrength(Collator.PRIMARY);
    return Stream.concat(list1.stream(), list2.stream())
            .collect(Collectors.groupingBy(book -> new PurifiedTitle(book.getTitle()),
                                           Collectors.counting()))
            .entrySet().stream()
            .collect(Collectors.toMap(e -> e.getKey().toString(),
                                      e -> e.getValue().intValue(),
                                      Integer::sum,
                                      () -> new TreeMap<>(collator)));
}

测试

List<Book> list1 = Arrays.asList(
        new Book("To - jest haha"),
        new Book("Bubû"),
        new Book("Kiki"),
        new Book("bam 2"),
        new Book("sza . lä"));
List<Book> list2 = Arrays.asList(
        new Book("Tojest haha"),
        new Book("bam 1"),
        new Book("zzz"),
        new Book("száLa"));
System.out.println(countBooksByTitle(list1, list2));

输出

{bam 1=1, bam 2=1, Bubû=1, Kiki=1, sza . lä=2, To - jest haha=2, zzz=1}

Answer 2

可能的解决方案，对您的算法影响最小:您可以从第二个列表中删除标题，只要它们与第一个列表中的标题匹配。

这样做，第二个列表将只包含不匹配的书后的for循环。然后，您可以将所有这些元素添加到映射中，其出现率为1。

您应该使用迭代器来浏览列表和删除项。

    for (int i = 0; i < purifiedMerlinBookTitles.size(); i++) {
        occurrencesOfIteratedBook = 1;
        iteratedMerlinTitle = purifiedMerlinBookTitles.get(i);
        Iterator<String> it = purifiedEmpikBookTitles.iterator();
        while (it.hasNext()) {
            String iteratedEmpikTitle = it.next();
            if (iteratedMerlinTitle.equals(iteratedEmpikTitle)) {
                occurrencesOfIteratedBook++;
                it.remove();
            }
        }
        bookTitleWithOccurrencesNumber.put(merlinBooks.get(i).getTitle(), occurrencesOfIteratedBook);
    }
    // At this time purifiedEmpikBookTitles contains only unmatched titles
    purifiedEmpikBookTitles.forEach(title -> bookTitleWithOccurrencesNumber.put(title, 1));
    return bookTitleWithOccurrencesNumber;
}