java - রহম - জাভা প্রোগ্রামিং বই pdf free



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

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

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

ArrayList<Integer> results;

Answer #1

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

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


Answer #2

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

Answer #3

আপনি আপনার প্রোজেক্টে Guava লাইব্রেরি যোগ করতে পারেন এবং Lists.partition পদ্ধতি ব্যবহার করতে পারেন, যেমন

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

Answer #4

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

এটি করার সবচেয়ে সহজ (পড়াশোনার অযোগ্য) উপায় এই রকম:

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 #5

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

প্রধানত আপনি sublist ব্যবহার করতে পারেন। আরো বিস্তারিত এখানে: subList

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


Answer #6

এটা আমার জন্য কাজ করে

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

Answer #7

যদি আপনি 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;
}

Answer #8

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

Answer #9
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++;
}




arraylist