मैं सरणी को दिए गए खंड आकार में विभाजित करने का प्रयास कर रहा हूं। मैं एक समाधान लेकर आया हूं लेकिन क्या इसे और अधिक सरल बनाया जा सकता है।

सरणी और खंड आकार को देखते हुए। मुझे वांछित आउटपुट उत्पन्न करना है
सरणी = [1,2,3,4,5]

खंड आकार = 1
वांछित आउटपुट [1] [2] [3] [4] [5]

मैंने क्या प्रयास किया है:

मैंने IntStream का उपयोग करने का प्रयास किया है

जावा

public static List<int[]> chunk(int[] input, int chunkSize) {
        return IntStream.iterate(0, i -> i + chunkSize)
                .limit((long) Math.ceil((double) input.length / chunkSize))
                .mapToObj(j -> Arrays.copyOfRange(input, j, j + chunkSize > input.length ? input.length : j + chunkSize))
                .collect(Collectors.toList());//how to fix this line error on new
    }

फ़ंक्शन कॉल मैं मुख्य विधि में इस प्रकार कर रहा हूं:
सूची सूची = खंड (मूल, विभाजन आकार);
list.forEach(splitArray -> System.out.println(Arrays.toString(splitArray)));

समाधान 1
समाधान 2

समाधान 1

इसे करने के कई तरीके हो सकते हैं. यदि जगह की कोई समस्या नहीं है तो मैं पसंद करूंगा Arrays.copyOfRange()

इसमें, copyOfRange() मूल सरणी के समान प्रकार की एक नई सरणी बनाता है, और मूल सरणी की निर्दिष्ट सीमा के आइटम को एक नई सरणी में शामिल करता है।

वाक्य – विन्यास:

जावा

public static T[] copyOfRange(T[] original, int from, int to)

// original – the array from which a range is to be copied
// from – the initial index of the range to be copied, inclusive
// to – the final index of the range to be copied, exclusive

अधिक जानकारी: Java.util.Arrays.copyOfRange() विधि[^]

उदाहरण उपयोग:

जावा

int[] arr1 = new int[] {15, 10, 45, 55};
int chunk = 2; // provided as input
for(int i=0; i<arr1.length; i+=chunk){
    System.out.println(Arrays.toString(Arrays.copyOfRange(arr1, i, Math.min(arr1.length,i+chunk))));
}

समाधान 2

/********************************************* *****************************
जीडीबी ऑनलाइन में आपका स्वागत है।
दुनिया में कहीं से भी ऑनलाइन कोड, संकलन, चलाएँ और डिबग करें।
******************************************** *****************************/
आयात java.util.*;

कक्षा मुख्य
{
सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग)[] तर्क) {
int यहाँ[] मूल = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10};
पूर्णांक विभाजन आकार = 3;

/* अपेक्षित उत्पादन
[0, 1, 2]
[3, 4, 5]
[6, 7, 8]
[9]

सूची सूची = स्प्लिटअरे (मूल, स्प्लिटसाइज़);
list.forEach(splitArray -> System.out.println(Arrays.toString(splitArray)));
}

सार्वजनिक स्थैतिक सूची स्प्लिटअरे(int[] सरणी, पूर्णांक विभाजन आकार) {
int k=0;
ArrayList परिणाम=नया ArrayList();
int यहाँ[] एआर = शून्य;
int लंबाई=सरणी.लंबाई;
पूर्णांक आकार=स्प्लिटआकार;
for(int i=0;i “arr=’नया’ int[size];
“` }
“`अरे[k]= “सरणी[i];
“के++;
“`>=विभाजन आकार || i==array.length-1 ){
क=0;
परिणाम.जोड़ें(arr);
लंबाई=लंबाई-विभाजितआकार;
यदि(लंबाई

समाधान 1

समाधान 2

コメント