Comment puis-je prendre un Java Ensemble de taille X et briser en X/Y de Jeux?

J'ai un Java Jeu (plus précisément HashSet). Supposons qu'il a une taille de 10k. Comment puis-je diviser en 5 Sets chacun de taille 2k?

Boucle, le comte, insérer.
Est-il une règle spécifique que vous souhaitez utiliser lors de la distribution des éléments dans ces 5 sous-ensembles?
Aucune règle spécifique n'est nécessaire. Je pourrais faire comme nhahtdh suggéré. J'ai pensé que j'étais juste donnant sur une lib appel comme une Liste.sous-liste
C'est ce que la JavaDoc est: List, Collections, Arrays, Set...

OriginalL'auteur James | 2013-05-08

  1. 7

    Cette méthode permettra de séparer les éléments de l'ensemble, de sorte que le premier ensemble contient les 2000 premiers, le deuxième contient les 2000, etc.

    public static <T> List<Set<T>> split(Set<T> original, int count) {
    //Create a list of sets to return.
    ArrayList<Set<T>> result = new ArrayList<Set<T>>(count);

    //Create an iterator for the original set.
    Iterator<T> it = original.iterator();

    //Calculate the required number of elements for each set.
    int each = original.size() / count;

    //Create each new set.
    for (int i = 0; i < count; i++) {
        HashSet<T> s = new HashSet<T>(original.size() / count + 1);
        result.add(s);
        for (int j = 0; j < each && it.hasNext(); j++) {
            s.add(it.next());
        }
    }
    return result;
}

//As example, in your code...

Set<Integer> originalSet = new HashSet<Integer>();
//[fill the set...]
List<Set<Integer>> splitSets = split(originalSet, 5);
Set<Integer> first = splitSets.get(0); //etc.
    j.ajouter(il.next()) => s.ajouter(il.next()); je pense que oui
    En effet!
    Dans le cas de 5 éléments étant divisé à la page 2 éléments, votre code donne 2 pages avec 2 éléments. Le dernier est perdu. Donc i < count => i <= count

    OriginalL'auteur wchargin

  2. 16

    Goyave a des bibliothèques pour partition Itérable classes. Le Iterables est une classe utilitaire qui a des méthodes statiques pour la partition Itérable classes. La valeur de retour est un objet iterable listes si. Le code montre comment le faire.

    Set<Integer> myIntSet = new HashSet<Integer>();
//fill the set
Iterable<List<Integer>> lists = Iterables.partition(myIntSet, SIZE_EACH_PARTITION);

    OriginalL'auteur user2327870

  3. 0

    Itérer sur l'ensemble de la série, et ajouter les 2000 premiers éléments d'un premier ensemble de nouveau, le 2ème à 2000 éléments de la 2e nouvel ensemble, etc.

    OriginalL'auteur Tom

  4. 0

    Si vous ne souhaitez pas écrire par votre propre ont un coup d'oeil à goyave. Les Listes de classe ont une méthode de partition(Liste, int) pour séparer une liste en plusieurs listes à la taille spécifiée.
    Voir Goyave Listes

    OriginalL'auteur mszalbach

  5. 0

    J'ai écrit quelque chose qui ne le découpage de l'ensemble.

    Il utilise intermédiaire des tableaux et des Listes.

    Il utilise les Tableaux.asList et les Tableaux.copyOfRange méthodes.

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


public class SetSplitTest {
    //define and initialize set
    private static Set<Integer> largeSet;
    static {
        largeSet  = new HashSet<Integer>();

        for (int i = 0; i < 10000; i++) {
            largeSet.add(i);
        }
    }


    public static void main() {
        System.out.println(largeSet);
        int amountOfSets = 5; //amount of subsets wanted
        Set<Integer>[] subsets = new Set[amountOfSets]; //array holding the subsets

        Integer[] largesetarray =  largeSet.toArray(new Integer[largeSet.size()]);

        for (int i = 1; i <= amountOfSets; i++) {
            int fromIndex = (i-1) * largeSet.size() / amountOfSets;
            int toIndex = i * largeSet.size() / amountOfSets - 1; 
            Set<Integer> subHashSet = new HashSet<Integer>();
            subHashSet.addAll(Arrays.asList(Arrays.copyOfRange(largesetarray, fromIndex, toIndex)));

            subsets[i - 1] = subHashSet;
        }

        for (Set<Integer> subset : subsets) {
            System.out.println(subset);
        }
    }
}

    Ce certainement pas la solution la plus élégante, mais c'est le mieux que je pouvais penser à l'arrêt le moment de ne pas vouloir de la boucle de la jeux de vous-même.

    OriginalL'auteur stefaan dutry