Java: как я могу разделить ArrayList на несколько небольших ArrayLists?

Как я могу разделить ArrayList (size=1000) на несколько ArrayLists одного размера (=10)?



ArrayList<Integer> results;
611   13  

13 ответов:

можно использовать subList(int fromIndex, int toIndex) чтобы получить представление о части исходного списка.

из API:

возвращает представление части этого списка между указанными fromIndex включительно, и toIndex, эксклюзивных. (Если fromIndex и toIndex равны, возвращенный список пуст.) Возвращенный список подкрепляется этим списком, поэтому неструктурные изменения в возвращенном списке отражаются в этом списке, и наоборот. Возвращенный список поддерживает все дополнительные операции списка, поддерживаемые этим списком.

пример:

    List<Integer> numbers = new ArrayList<Integer>(
        Arrays.asList(5,3,1,2,9,5,0,7)
    );
    List<Integer> head = numbers.subList(0, 4);
    List<Integer> tail = numbers.subList(4, 8);
    System.out.println(head); // prints "[5, 3, 1, 2]"
    System.out.println(tail); // prints "[9, 5, 0, 7]"
    Collections.sort(head);
    System.out.println(numbers); // prints "[1, 2, 3, 5, 9, 5, 0, 7]"
    tail.add(-1);
    System.out.println(numbers); // prints "[1, 2, 3, 5, 9, 5, 0, 7, -1]"

Если вам нужно, чтобы эти нарезанные списки не были видом, то просто создайте новый List С subList. Вот пример объединения нескольких из этих вещей:

// chops a list into non-view sublists of length L
static <T> List<List<T>> chopped(List<T> list, final int L) {
    List<List<T>> parts = new ArrayList<List<T>>();
    final int N = list.size();
    for (int i = 0; i < N; i += L) {
        parts.add(new ArrayList<T>(
            list.subList(i, Math.min(N, i + L)))
        );
    }
    return parts;
}


List<Integer> numbers = Collections.unmodifiableList(
    Arrays.asList(5,3,1,2,9,5,0,7)
);
List<List<Integer>> parts = chopped(numbers, 3);
System.out.println(parts); // prints "[[5, 3, 1], [2, 9, 5], [0, 7]]"
parts.get(0).add(-1);
System.out.println(parts); // prints "[[5, 3, 1, -1], [2, 9, 5], [0, 7]]"
System.out.println(numbers); // prints "[5, 3, 1, 2, 9, 5, 0, 7]" (unmodified!)
272  
2010-05-24 10:31:42

вы можете добавить гуавы библиотека для вашего проекта и использовать списки.раздел метод, например,

List<Integer> bigList = ...
List<List<Integer>> smallerLists = Lists.partition(bigList, 10);
169  
2017-11-22 23:00:24

Apache Commons Collections 4 есть раздел метод ListUtils класса. Вот как это работает:

import org.apache.commons.collections4.ListUtils;
...

int targetSize = 100;
List<Integer> largeList = ...
List<List<Integer>> output = ListUtils.partition(largeList, targetSize);
46  
2017-08-22 23:00:41

ответ, предоставленный polygenelubricants разбивает массив на основе заданного размера. Я искал код, который разделил бы массив на заданное количество частей. Вот модификация, которую я сделал в коде:

public static <T>List<List<T>> chopIntoParts( final List<T> ls, final int iParts )
{
    final List<List<T>> lsParts = new ArrayList<List<T>>();
    final int iChunkSize = ls.size() / iParts;
    int iLeftOver = ls.size() % iParts;
    int iTake = iChunkSize;

    for( int i = 0, iT = ls.size(); i < iT; i += iTake )
    {
        if( iLeftOver > 0 )
        {
            iLeftOver--;

            iTake = iChunkSize + 1;
        }
        else
        {
            iTake = iChunkSize;
        }

        lsParts.add( new ArrayList<T>( ls.subList( i, Math.min( iT, i + iTake ) ) ) );
    }

    return lsParts;
}

надеюсь, что это поможет кому-то.

17  
2013-12-10 11:03:57

это работает для меня

/**
* Returns List of the List argument passed to this function with size = chunkSize
* 
* @param largeList input list to be portioned
* @param chunkSize maximum size of each partition
* @param <T> Generic type of the List
* @return A list of Lists which is portioned from the original list 
*/
public static  <T> List<List<T>> chunkList(List<T> list, int chunkSize) {
    if (chunkSize <= 0) {
        throw new IllegalArgumentException("Invalid chunk size: " + chunkSize);
    }
    List<List<T>> chunkList = new ArrayList<>(list.size() / chunkSize);
    for (int i = 0; i < list.size(); i += chunkSize) {
        chunkList.add(list.subList(i, i + chunkSize >= list.size() ? list.size() : i + chunkSize));
    }
    return chunkList;
}

например : 

List<Integer> stringList = new ArrayList<>();
stringList.add(0);
stringList.add(1);
stringList.add(2);
stringList.add(3);
stringList.add(4);
stringList.add(5);
stringList.add(6);
stringList.add(7);
stringList.add(8);
stringList.add(9);

List<List<Integer>> chunkList = getChunkList1(stringList, 2);
7  
2018-09-04 13:23:47

Я предполагаю, что проблема, с которой вы столкнулись, заключается в именовании 100 ArrayLists и их заполнении. Вы можете создать массив ArrayLists и заполнить каждый из них с помощью цикла.

самый простой (читай глупый) способ сделать это так:

ArrayList results = new ArrayList(1000);
    // populate results here
    for (int i = 0; i < 1000; i++) {
        results.add(i);
    }
    ArrayList[] resultGroups = new ArrayList[100];
    // initialize all your small ArrayList groups
    for (int i = 0; i < 100; i++) {
            resultGroups[i] = new ArrayList();
    }
    // put your results into those arrays
    for (int i = 0; i < 1000; i++) {
       resultGroups[i/10].add(results.get(i));
    }
3  
2010-05-24 10:36:37

подобный вопрос обсуждался здесь,Java: разделить список на два подсписка?

в основном вы можете использовать подсписок. Подробнее здесь:подсписок

возвращает представление части этого списка между fromIndex, inclusive и toIndex, exclusive. (Если fromIndex и toIndex равны, возвращаемый список пуст.) Возвращенный список поддерживается этим списком, поэтому изменения в возвращенном списке отражаются в этом списке, и наоборот. Возвращенный список поддерживает все дополнительные операции списка, поддерживаемые этим списком...

3  
2017-05-23 14:54:59

создайте новый список и добавьте представление подсписка исходного списка с помощью метода addAll для создания нового подсписка
List newList = новый ArrayList(); newList.addAll(sourceList.подсписок (startIndex, endIndex));

2  
2016-08-26 07:16:06

вы также можете использовать FunctionalJava библиотеки -partition метод List. Эта библиотека имеет свои собственные типы коллекций, Вы можете конвертировать их в коллекции java туда и обратно.

import fj.data.List;

java.util.List<String> javaList = Arrays.asList("a", "b", "c", "d" );

List<String> fList = Java.<String>Collection_List().f(javaList);

List<List<String> partitions = fList.partition(2);
1  
2015-04-28 09:44:22 
import org.apache.commons.collections4.ListUtils;
ArrayList<Integer> mainList = .............;
List<List<Integer>> multipleLists = ListUtils.partition(mainList,100);
int i=1;
for (List<Integer> indexedList : multipleLists){
  System.out.println("Values in List "+i);
  for (Integer value : indexedList)
    System.out.println(value);
i++;
}
1  
2017-07-27 12:12:36

Если вы не хотите импортировать библиотеку Apache commons попробуйте этот простой код:

final static int MAX_ELEMENT = 20;

public static void main(final String[] args) {

    final List<String> list = new ArrayList<String>();

    for (int i = 1; i <= 161; i++) {
        list.add(String.valueOf(i));
        System.out.print("," + String.valueOf(i));
    }
    System.out.println("");
    System.out.println("### >>> ");
    final List<List<String>> result = splitList(list, MAX_ELEMENT);

    for (final List<String> entry : result) {
        System.out.println("------------------------");
        for (final String elm : entry) {
            System.out.println(elm);
        }
        System.out.println("------------------------");
    }

}

private static List<List<String>> splitList(final List<String> list, final int maxElement) {

    final List<List<String>> result = new ArrayList<List<String>>();

    final int div = list.size() / maxElement;

    System.out.println(div);

    for (int i = 0; i <= div; i++) {

        final int startIndex = i * maxElement;

        if (startIndex >= list.size()) {
            return result;
        }

        final int endIndex = (i + 1) * maxElement;

        if (endIndex < list.size()) {
            result.add(list.subList(startIndex, endIndex));
        } else {
            result.add(list.subList(startIndex, list.size()));
        }

    }

    return result;
}
0  
2016-11-22 13:19:44

вы должны знать размер куска, на который вы делите свой список. Скажем, у вас есть список 108 entries и вам нужен кусок размером 25. Таким образом, вы будете в конечном итоге с 5 lists:

  • 4, имеющей 25 entries каждая;
  • 1 (пятый), имеющего 8 elements.

код:

public static void main(String[] args) {

        List<Integer> list = new ArrayList<Integer>();
        for (int i=0; i<108; i++){
            list.add(i);
        }
        int size= list.size();
        int j=0;
                List< List<Integer> > splittedList = new ArrayList<List<Integer>>()  ;
                List<Integer> tempList = new ArrayList<Integer>();
        for(j=0;j<size;j++){
            tempList.add(list.get(j));
        if((j+1)%25==0){
            // chunk of 25 created and clearing tempList
            splittedList.add(tempList);
            tempList = null;
            //intializing it again for new chunk 
            tempList = new ArrayList<Integer>();
        }
        }
        if(size%25!=0){
            //adding the remaining enteries 
            splittedList.add(tempList);
        }
        for (int k=0;k<splittedList.size(); k++){
            //(k+1) because we started from k=0
            System.out.println("Chunk number: "+(k+1)+" has elements = "+splittedList.get(k).size());
        }
    }
0  
2017-11-10 12:27:33

Java 8

мы можем разделить список на основе некоторого размера или на основе условия. 

static Collection<List<Integer>> partitionIntegerListBasedOnSize(List<Integer> inputList, int size) {
        return inputList.stream()
                .collect(Collectors.groupingBy(s -> (s-1)/size))
                .values();
}
static <T> Collection<List<T>> partitionBasedOnSize(List<T> inputList, int size) {
        final AtomicInteger counter = new AtomicInteger(0);
        return inputList.stream()
                    .collect(Collectors.groupingBy(s -> counter.getAndIncrement()/size))
                    .values();
}
static <T> Collection<List<T>> partitionBasedOnCondition(List<T> inputList, Predicate<T> condition) {
        return inputList.stream().collect(Collectors.partitioningBy(s-> (condition.test(s)))).values();
}

тогда мы можем использовать их как:

final List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
System.out.println(partitionIntegerListBasedOnSize(list, 4));  // [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]]
System.out.println(partitionBasedOnSize(list, 4));  // [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]]
System.out.println(partitionBasedOnSize(list, 3));  // [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]
System.out.println(partitionBasedOnCondition(list, i -> i<6));  // [[6, 7, 8, 9, 10], [1, 2, 3, 4, 5]]
0  
2018-08-14 11:56:07

Comments

    Ничего не найдено.
Click here to cancel reply.