জাভা: আমি কীভাবে একাধিক ছোট অ্যারেলিস্টে একটি অ্যারেলিস্ট বিভক্ত করতে পারি?

Question

একই আকারের (= 10) একাধিক অ্যারেলিস্টে আমি কীভাবে একটি অ্যারেলিস্ট (আকার = 1000) বিভক্ত করতে পারি?

ArrayList<Integer> results;

Comments

আপনার কি ভিউ বা নতুন সংগ্রহের প্রয়োজন?

— xuesheng

জাভা 8: stackoverflow.com/a/51837311/1216775

— akhil_mittal

Answer 1

তুমি ব্যবহার করতে পার subList(int fromIndex, int toIndex) মূল তালিকার একটি অংশের মতামত পেতে ।

এপিআই থেকে:

সুনির্দিষ্ট মধ্যে এই তালিকার অংশের একটি দৃশ্য প্রদান করে fromIndex , অন্তর্ভুক্ত এবং toIndex, একচেটিয়া । (যদি fromIndexএবং toIndexএটি সমান হয় তবে প্রত্যাশিত তালিকাটি খালি) প্রত্যাবর্তিত তালিকা এই তালিকার দ্বারা সমর্থিত alচ্ছিক তালিকার সমস্ত ক্রিয়াকলাপ সমর্থন করে।

উদাহরণ:

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!)

Answer 2

আপনি আপনার প্রকল্পে পেয়ারা গ্রন্থাগার যুক্ত করতে পারেন এবং তালিকা.বিভাজন পদ্ধতিটি ব্যবহার করতে পারেন , যেমন

List<Integer> bigList = ...
List<List<Integer>> smallerLists = Lists.partition(bigList, 10);

Comments

উত্সের তালিকাটি সংশোধন করুন, সাবলিস্টগুলির মধ্য দিয়ে লুপ করার সময় আপনি একযোগে ব্যতিক্রম পাবেন, কারণ জাভা ডক পরিসংখ্যান: বাহ্যিক তালিকাটি পরিবর্তনযোগ্য নয়, তবে উত্স তালিকার সর্বশেষ অবস্থা প্রতিফলিত করে। অভ্যন্তরীণ তালিকাগুলি হ'ল মূল তালিকার সাবলিস্ট ভিউ। এটি

— জুনচেন লিউ

Answer 3

অ্যাপাচি কমন্স সংগ্রহ 4 এর ক্লাসে একটি বিভাজন পদ্ধতি রয়েছে ListUtils। এখানে কিভাবে এটা কাজ করে:

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

int targetSize = 100;
List<Integer> largeList = ...
List<List<Integer>> output = ListUtils.partition(largeList, targetSize);

Answer 4

পলিজেনুব্রিকেন্টস দ্বারা সরবরাহ করা উত্তর প্রদত্ত আকারের উপর ভিত্তি করে একটি অ্যারে বিভক্ত করে। আমি এমন কোডের সন্ধান করছিলাম যা একটি অ্যারেটিকে একটি নির্দিষ্ট সংখ্যক অংশে বিভক্ত করবে। কোডটিতে আমি যে পরিবর্তনটি করেছি তা এখানে:

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;
}

আশা করি এটি কাউকে সাহায্য করবে।

Answer 5

এটি আমার পক্ষে কাজ করে

/**
* 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()-1 : 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);

Comments

প্লিজ নোট করুন এটিতে একটি বাগ রয়েছে যা এটি ডেটার শেষ সেটটিকে উপেক্ষা করে। প্রাক্তন 201 এর 100 টি ভাগে ভাঙা 100,100,1 এর পরিবর্তে 100,100,0 এ ফিরে আসবে

— এএপি

Answer 6

জাভা 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]]

Comments

@ i_am_zero কী একাধিক শর্ত প্রয়োগ করা সম্ভব (তৃতীয় স্থিতিশীল পদ্ধতি) যাতে আপনি একাধিক তালিকা তৈরি করতে পারেন [[1,2,3,4], [5,6,7,8,9], [10,11,12 , 13,14]] শর্তাবলীতে: i <5, 5 <= i <10, i> = 10

— gooornik07

@ gooornik07 একটি স্ট্রিমটি একবার ব্যবহার করা যেতে পারে।

— akhil_mittal

Answer 7

আমি অনুমান করছি যে সমস্যাটি আপনার মধ্যে রয়েছে 100 টি অ্যারেলিস্টের নামকরণ এবং সেগুলি জনবসতি নিয়ে। আপনি অ্যারেলিস্টগুলির একটি অ্যারে তৈরি করতে পারেন এবং লুপ ব্যবহার করে তাদের প্রত্যেককে পপুলেট করতে পারেন।

এটি করার সহজতম (মূup়ভাবে পড়ার) উপায়টি এরকম:

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));
    } 

Answer 8

একটি অনুরূপ প্রশ্ন এখানে আলোচনা করা হয়েছিল, জাভা: একটি তালিকা দুটি উপ-তালিকায় বিভক্ত?

প্রধানত আপনি সাবলিস্ট ব্যবহার করতে পারেন। আরও বিশদ এখানে: সাবলিস্ট

ইনডেক্স, ইনক্লুসিভ এবং টু ইন্ডেক্সের মধ্যে এই তালিকার অংশটির একটি ভিউ প্রদান করে exclusive (যদি ইনডেক্স এবং টু ইন্ডেক্স সমান হয় তবে প্রত্যাশিত তালিকাটি খালি রয়েছে)) ফিরে আসা তালিকাটি এই তালিকাটি সমর্থন করে, সুতরাং প্রত্যাবর্তিত তালিকার পরিবর্তনগুলি এই তালিকায় প্রতিফলিত হয় এবং তদ্বিপরীত। প্রত্যাবর্তিত তালিকা এই তালিকার দ্বারা সমর্থিত সমস্ত alচ্ছিক তালিকার ক্রিয়াকে সমর্থন করে ...

Answer 9

private ArrayList<List<String>> chunkArrayList(ArrayList<String> arrayToChunk, int chunkSize) {
    ArrayList<List<String>> chunkList = new ArrayList<>();
    int guide = arrayToChunk.size();
    int index = 0;
    int tale = chunkSize;
    while (tale < arrayToChunk.size()){
            chunkList.add(arrayToChunk.subList(index, tale));
            guide = guide - chunkSize;
            index = index + chunkSize;
            tale = tale + chunkSize;
    }
    if (guide >0) {
       chunkList.add(arrayToChunk.subList(index, index + guide));
    }
    Log.i("Chunked Array: " , chunkList.toString());
    return chunkList;
}

উদাহরণ

    ArrayList<String> test = new ArrayList<>();
    for (int i=1; i<=1000; i++){
        test.add(String.valueOf(i));
    }

    chunkArrayList(test,10);

আউটপুট

নির্বাচিত :: [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [11, 12, 13, 14, 15, 16, 17, 18, 19, 20], [21 , 22, 23, 24, 25, 26, 27, 28, 29, 30], [31, 32, 33, 34, 35, 36, 37, 38, 39, 40], [41, 42, 43, 44 , 45, 46, 47, 48, 49, 50], [51, 52, 53, 54, 55, 56, 57, 58, 59, 60], [61, 62, 63, 64, 65, 66, 67 , 68, 69, 70], [71, 72, 73, 74, 75, 76, 77, 78, 79, 80], [81, 82, 83, 84, 85, 86, 87, 88, 89, 90 ], [91, 92, 93, 94, 95, 96, 97, 98, 99, 100], .........

আপনি আপনার লগ দেখতে পাবেন

Answer 10

আপনি গ্রহণটি সংগ্রহchunk থেকে পদ্ধতিটি ব্যবহার করতে পারেন :

ArrayList<Integer> list = new ArrayList<>(Interval.oneTo(1000));
RichIterable<RichIterable<Integer>> chunks = Iterate.chunk(list, 10);
Verify.assertSize(100, chunks);

chunkপদ্ধতির কয়েকটি উদাহরণ এই জোন নিবন্ধেও অন্তর্ভুক্ত ছিল।

দ্রষ্টব্য: আমি গ্রহগ্রাহ সংগ্রহের প্রতিশ্রুতিবদ্ধ।

Answer 11

একটি নতুন তালিকা তৈরি করুন এবং একটি নতুন সাবলিস্ট তৈরি করতে অ্যাডএল পদ্ধতিটি ব্যবহার করে উত্স তালিকার সাবলিস্ট ভিউ যুক্ত করুন তালিকা নতুন তালিকা
= নতুন অ্যারেলিস্ট (); newList.addAll (উত্সলিস্ট.সুবলিস্ট (startIndex, endIndex));

Answer 12

আপনি ফাংশনাল জাভা গ্রন্থাগারও ব্যবহার করতে পারেন - এর জন্য partitionপদ্ধতি রয়েছে List। এই lib এর নিজস্ব সংগ্রহের ধরণ রয়েছে, আপনি এগুলি জাভা সংগ্রহগুলিতে পিছনে পিছনে রূপান্তর করতে পারেন।

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);

Comments

এটি কি আপনার তালিকাটিকে 2 তালিকাগুলিতে বা প্রতি তালিকায় 2 মানগুলিতে বিভক্ত করছে? উদাহরণস্বরূপ, যদি আপনার প্রাথমিক তালিকাটি 10 ​​উপাদান থাকে তবে এটি 2 এর 5 বা 5 তালিকার 2 টি তালিকা উপস্থাপন করতে পারে

— jDub9

@ jDub9 এটি প্রশ্নের হিসাবে যেমনটি প্রয়োজন তেমন কাজ করে। 10 উপাদানের জন্য এটা 2. 5 তালিকা ফেরৎ github.com/functionaljava/functionaljava/blob/...

— মিখাইল Golubtsov

Answer 13

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++;
}

Answer 14

যদি আপনি এপাচি কমন্স লাইব্রেরি আমদানি করতে না চান তবে এই সাধারণ কোডটি ব্যবহার করে দেখুন:

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;
}

Comments

@ জাফর: আমি একইরকমটি চাই তবে ২০ টি উপাদান মুদ্রণ লোড করার পরে আবার আমাকে পরবর্তী ২০ টি উপাদান এবং আরও কিছু লোড করতে হবে। সুতরাং দয়া করে এটির জন্য আমাকে পরামর্শ দিন।

— বসন্ত

হাই @vantha দুঃখিত আমি আপনার অনুরোধ তাড়াতাড়ি দেখিনি, আপনি তা করেছেন নাকি এখনও করেন নি?

— বি.এ.এফ.এফ.আর

Answer 15

কেবল পরিষ্কার করে বলতে গেলে, এটিকে আরও পরীক্ষা করতে হবে ...

public class Splitter {

public static <T> List<List<T>> splitList(List<T> listTobeSplit, int size) {
    List<List<T>> sublists= new LinkedList<>();
    if(listTobeSplit.size()>size) {
    int counter=0;
    boolean lastListadded=false;

    List<T> subList=new LinkedList<>();

    for(T t: listTobeSplit) {           
         if (counter==0) {               
             subList =new LinkedList<>();
             subList.add(t);
             counter++;
             lastListadded=false;
         }
         else if(counter>0 && counter<size-1) {
             subList.add(t);
             counter++;
         }
         else {
             lastListadded=true;
             subList.add(t);
             sublists.add(subList);
             counter=0;
         }              
    }
    if(lastListadded==false)
        sublists.add(subList);      
    }
    else {
        sublists.add(listTobeSplit);
    }
    log.debug("sublists: "+sublists);
    return sublists;
 }
}

Answer 16

    **Divide a list to lists of n size**

    import java.util.AbstractList;
    import java.util.ArrayList;
    import java.util.List;

    public final class PartitionUtil<T> extends AbstractList<List<T>> {

        private final List<T> list;
        private final int chunkSize;

        private PartitionUtil(List<T> list, int chunkSize) {
            this.list = new ArrayList<>(list);
            this.chunkSize = chunkSize;
        }

        public static <T> PartitionUtil<T> ofSize(List<T> list, int chunkSize) {
            return new PartitionUtil<>(list, chunkSize);
        }

        @Override
        public List<T> get(int index) {
            int start = index * chunkSize;
            int end = Math.min(start + chunkSize, list.size());

            if (start > end) {
                throw new IndexOutOfBoundsException("Index " + index + " is out of the list range <0," + (size() - 1) + ">");
            }

            return new ArrayList<>(list.subList(start, end));
        }

        @Override
        public int size() {
            return (int) Math.ceil((double) list.size() / (double) chunkSize);
        }
    }





Function call : 
              List<List<String>> containerNumChunks = PartitionUtil.ofSize(list, 999)

আরও বিশদ: https://e.printstacktrace.blog/divide-a-list-to-lists-of-n-size-in- জাভা-8/

Answer 17

আপনি নিজের তালিকাটি ভাগ করে নিচ্ছেন এমন আকারের আকারটি আপনার জানা দরকার। বলুন যে আপনার একটি তালিকা রয়েছে 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());
        }
    }