19

我的应用程序中有一个连续运行的线程，它由一个 HashSet 组成，用于存储应用程序内的所有符号。根据编写时的设计，在线程的 while true 条件下，它将不断迭代 HashSet，并为 HashSet 中包含的所有符号更新数据库。

HashSet 中可能存在的最大符号数约为 6000。我不想一次用所有 6000 个符号更新数据库，而是将此 HashSet 分成不同的子集，每个子​​集 500 个（12 组）并执行每个子集单独并在每个子集之后有一个线程睡眠 15 分钟，这样我可以减轻数据库的压力。

这是我的代码（示例代码片段）

如何将集合划分为更小的子集并处理（我已经看到了划分 ArrayList、TreeSet 的示例，但没有找到任何与 HashSet 相关的示例）

package com.ubsc.rewji.threads;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.PriorityBlockingQueue;

public class TaskerThread extends Thread {
    private PriorityBlockingQueue<String> priorityBlocking = new PriorityBlockingQueue<String>();
    String symbols[] = new String[] { "One", "Two", "Three", "Four" };
    Set<String> allSymbolsSet = Collections
            .synchronizedSet(new HashSet<String>(Arrays.asList(symbols)));

    public void addsymbols(String commaDelimSymbolsList) {
        if (commaDelimSymbolsList != null) {
            String[] symAr = commaDelimSymbolsList.split(",");
            for (int i = 0; i < symAr.length; i++) {
                priorityBlocking.add(symAr[i]);
            }
        }
    }

    public void run() {
        while (true) {
            try {
                while (priorityBlocking.peek() != null) {
                    String symbol = priorityBlocking.poll();
                    allSymbolsSet.add(symbol);
                }
                Iterator<String> ite = allSymbolsSet.iterator();
                System.out.println("=======================");
                while (ite.hasNext()) {
                    String symbol = ite.next();
                    if (symbol != null && symbol.trim().length() > 0) {
                        try {
                            updateDB(symbol);

                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void updateDB(String symbol) {
        System.out.println("THE SYMBOL BEING UPDATED IS" + "  " + symbol);
    }

    public static void main(String args[]) {
        TaskerThread taskThread = new TaskerThread();
        taskThread.start();

        String commaDelimSymbolsList = "ONVO,HJI,HYU,SD,F,SDF,ASA,TRET,TRE,JHG,RWE,XCX,WQE,KLJK,XCZ";
        taskThread.addsymbols(commaDelimSymbolsList);

    }

}
4

6 回答 6

75

与番石榴：

for (List<String> partition : Iterables.partition(yourSet, 500)) {
    // ... handle partition ...
}
于 2013-10-17T10:29:15.973 回答
12

做类似的事情

private static final int PARTITIONS_COUNT = 12;

List<Set<Type>> theSets = new ArrayList<Set<Type>>(PARTITIONS_COUNT);
for (int i = 0; i < PARTITIONS_COUNT; i++) {
    theSets.add(new HashSet<Type>());
}

int index = 0;
for (Type object : originalSet) {
    theSets.get(index++ % PARTITIONS_COUNT).add(object);
}

现在您已将 HashSet 划分originalSet为 12 个其他 HashSet。

于 2013-10-17T09:58:24.860 回答
3

我们可以使用以下方法来划分一个 Set。

我们将得到输出为 [a, b] [c, d] [e]`

private static List<Set<String>> partitionSet(Set<String> set, int     partitionSize)
{
    List<Set<String>> list = new ArrayList<>();
    int setSize = set.size();

    Iterator iterator = set.iterator();

    while(iterator.hasNext())
    {
        Set newSet = new HashSet();
        for(int j = 0; j < partitionSize && iterator.hasNext(); j++)
        {
            String s = (String)iterator.next();
            newSet.add(s);
        }
        list.add(newSet);
    }
    return list;
}

public static void main(String[] args)
{
    Set<String> set = new HashSet<>();
    set.add("a");
    set.add("b");
    set.add("c");
    set.add("d");
    set.add("e");

    int size = 2;
    List<Set<String>> list = partitionSet(set, 2);

    for(int i = 0; i < list.size(); i++)
    {
        Set<String> s = list.get(i);
        System.out.println(s);
    }
}
于 2017-04-06T18:28:47.247 回答
2

如果您不太担心空间复杂性，则可以以一种干净的方式这样做：

List<List<T>> partitionList = Lists.partition(new ArrayList<>(inputSet), PARTITION_SIZE);
List<Set<T>> partitionSet = partitionList.stream().map((Function<List<T>, HashSet>) HashSet::new).collect(Collectors.toList());
于 2021-05-10T09:20:14.870 回答
1

@Andrey_chaschev 的 Guava 解决方案似乎是最好的，但如果无法使用它，我相信以下内容会有所帮助

public static List<Set<String>> partition(Set<String> set, int chunk) {
        if(set == null || set.isEmpty() || chunk < 1)
            return new ArrayList<>();

        List<Set<String>> partitionedList = new ArrayList<>();
        double loopsize = Math.ceil((double) set.size() / (double) chunk);

        for(int i =0; i < loopsize; i++) {
            partitionedList.add(set.stream().skip((long)i * chunk).limit(chunk).collect(Collectors.toSet()));
        }

        return partitionedList;
    }
于 2019-12-16T12:45:07.580 回答
0

对于您的实际问题，一种非常简单的方法是按如下方式更改您的代码：

Iterator<String> ite = allSymbolsSet.iterator();
System.out.println("=======================");
int i = 500;
while ((--i > 0) && ite.hasNext()) {

一个通用的方法是使用迭代器在一个简单的循环中一个一个地取出元素：

int i = 500;
while ((--i > 0) && ite.hasNext()) {
  sublist.add(ite.next());
  ite.remove();
}
于 2013-10-17T10:03:43.510 回答