मुझे जावा में एक सरणी में सभी पूर्णांकों का योग खोजने में समस्या हो रही है। मुझे इसके लिए Math
कक्षा में कोई उपयोगी विधि नहीं मिल सकती है ।
मुझे जावा में एक सरणी में सभी पूर्णांकों का योग खोजने में समस्या हो रही है। मुझे इसके लिए Math
कक्षा में कोई उपयोगी विधि नहीं मिल सकती है ।
जवाबों:
में जावा-8 आप धाराओं का उपयोग कर सकते हैं:
int[] a = {10,20,30,40,50};
int sum = IntStream.of(a).sum();
System.out.println("The sum is " + sum);
आउटपुट:
योग 150 है।
यह पैकेज में है java.util.stream
import java.util.stream.*;
java.util.stream.DoubleStream.of(a).sum();
यदि आप जावा 8 का उपयोग कर रहे हैं, तो Arrays
कक्षा एक stream(int[] array)
विधि प्रदान करती है जो IntStream
निर्दिष्ट int
सरणी के साथ अनुक्रमिक रिटर्न देती है । यह भी double
और long
arrays के लिए अतिभारित किया गया है ।
int [] arr = {1,2,3,4};
int sum = Arrays.stream(arr).sum(); //prints 10
यह एक विधि भी प्रदान करता है
stream(int[] array, int startInclusive, int endExclusive)
जो आपको सरणी की एक निर्दिष्ट सीमा लेने की अनुमति देता है (जो उपयोगी हो सकता है):
int sum = Arrays.stream(new int []{1,2,3,4}, 0, 2).sum(); //prints 3
अंत में, यह प्रकार की एक सरणी ले सकता है T
। तो आप उदाहरण के लिए String
एक इनपुट के रूप में संख्याएँ शामिल कर सकते हैं और यदि आप उन्हें योग करना चाहते हैं तो बस करें:
int sum = Arrays.stream("1 2 3 4".split("\\s+")).mapToInt(Integer::parseInt).sum();
यह उन सरल चीजों में से एक है जो (जावा) जावा जावा मानक में मौजूद नहीं है। अपना लिखना काफी आसान है।
अन्य उत्तर पूरी तरह से ठीक हैं, लेकिन यहां प्रत्येक के लिए कुछ-एक वाक्यगत चीनी है।
int someArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int sum = 0;
for (int i : someArray)
sum += i;
इसके अलावा, सरणी योग का एक उदाहरण जावा 7 भाषा विनिर्देश में भी दिखाया गया है । इसका उदाहरण धारा 10.4 - ऐरे एक्सेस से है ।
class Gauss {
public static void main(String[] args) {
int[] ia = new int[101];
for (int i = 0; i < ia.length; i++) ia[i] = i;
int sum = 0;
for (int e : ia) sum += e;
System.out.println(sum);
}
}
आप नहीं कर सकते। अन्य भाषाओं में PHP में array_sum () जैसे कुछ तरीके हैं, लेकिन जावा नहीं है।
बस ..
int[] numbers = {1,2,3,4};
int sum = 0;
for( int i : numbers) {
sum += i;
}
System.out.println(sum);
में Java 8
कोड :
int[] array = new int[]{1,2,3,4,5};
int sum = IntStream.of(array).reduce( 0,(a, b) -> a + b);
System.out.println("The summation of array is " + sum);
System.out.println("Another way to find summation :" + IntStream.of(array).sum());
आउटपुट :
The summation of array is 15
Another way to find summation :15
स्पष्टीकरण :
में Java 8
, आप अपने जोड़ को करने के लिए कमी अवधारणा का उपयोग कर सकते हैं।
int sum = 0;
for (int i = 0; i < myArray.length; i++)
sum += myArray[i];
}
IMHO राशि फ़ंक्शन एरेस वर्ग को भरने के लिए एक अच्छा फिट प्रतीत होता है जहां भरना, सॉर्ट, खोज, प्रतिलिपि, और लाइव के बराबर है। जबड़े में छिपने के लिए बहुत सारे आसान तरीके हैं, इसलिए हमारी सहायक विधि को रोल करने से पहले फोरान को जावा में पोर्ट करते समय यह एक उचित प्रश्न है। "योग", "जोड़ें" और आपके द्वारा सोचा जा सकने वाले किसी भी अन्य कीवर्ड के लिए विशाल जावाडॉक इंडेक्स के माध्यम से खोजें। आपको निश्चित रूप से संदेह है कि किसी ने पहले से ही आदिम प्रकार के इंट, फ्लोट, डबल, इंटेगर, फ्लोट, डबल के लिए ऐसा किया है? कोई फर्क नहीं पड़ता कि यह कितना सरल है, हमेशा जांचना अच्छा होता है। कोड को यथासंभव सरल रखें और पहिया को सुदृढ़ न करें।
मुझे यह तरीका व्यक्तिगत रूप से पसंद है। मेरा कोड स्टाइल थोड़ा अजीब है।
public static int sumOf(int... integers) {
int total = 0;
for (int i = 0; i < integers.length; total += integers[i++]);
return total;
}
कोड में उपयोग करने के लिए बहुत आसान:
int[] numbers = { 1, 2, 3, 4, 5 };
sumOf(1);
sumOf(1, 2, 3);
sumOf(numbers);
इस अभ्यास से सीखने के लिए दो चीजें हैं:
आपको किसी तरह सरणी के तत्वों के माध्यम से पुनरावृति करने की आवश्यकता है - आप इसे लूप या थोड़ी देर के लूप के साथ कर सकते हैं। आपको एक संचयकर्ता में योग के परिणाम को संग्रहीत करने की आवश्यकता है। इसके लिए, आपको एक चर बनाने की आवश्यकता है।
int accumulator = 0;
for(int i = 0; i < myArray.length; i++) {
accumulator += myArray[i];
}
आप अपने कोड को इस तरह बेहतर बना सकते हैं:
public void someMethod(){
List<Integer> numbers = new ArrayList<Integer>();
numbers.addAll(db.findNumbers());
...
System.out.println("Result is " + sumOfNumbers(numbers));
}
private int sumOfNumbers(List<Integer> numbers){
int sum = 0;
for (Integer i : numbers){
sum += i;
}
return sum;
}
निर्भर करता है। आप कितने नंबर जोड़ रहे हैं? उपरोक्त सुझावों में से कई का परीक्षण:
import java.text.NumberFormat;
import java.util.Arrays;
import java.util.Locale;
public class Main {
public static final NumberFormat FORMAT = NumberFormat.getInstance(Locale.US);
public static long sumParallel(int[] array) {
final long start = System.nanoTime();
int sum = Arrays.stream(array).parallel().reduce(0,(a,b)-> a + b);
final long end = System.nanoTime();
System.out.println(sum);
return end - start;
}
public static long sumStream(int[] array) {
final long start = System.nanoTime();
int sum = Arrays.stream(array).reduce(0,(a,b)-> a + b);
final long end = System.nanoTime();
System.out.println(sum);
return end - start;
}
public static long sumLoop(int[] array) {
final long start = System.nanoTime();
int sum = 0;
for (int v: array) {
sum += v;
}
final long end = System.nanoTime();
System.out.println(sum);
return end - start;
}
public static long sumArray(int[] array) {
final long start = System.nanoTime();
int sum = Arrays.stream(array) .sum();
final long end = System.nanoTime();
System.out.println(sum);
return end - start;
}
public static long sumStat(int[] array) {
final long start = System.nanoTime();
int sum = 0;
final long end = System.nanoTime();
System.out.println(sum);
return end - start;
}
public static void test(int[] nums) {
System.out.println("------");
System.out.println(FORMAT.format(nums.length) + " numbers");
long p = sumParallel(nums);
System.out.println("parallel " + FORMAT.format(p));
long s = sumStream(nums);
System.out.println("stream " + FORMAT.format(s));
long ar = sumArray(nums);
System.out.println("arrays " + FORMAT.format(ar));
long lp = sumLoop(nums);
System.out.println("loop " + FORMAT.format(lp));
}
public static void testNumbers(int howmany) {
int[] nums = new int[howmany];
for (int i =0; i < nums.length;i++) {
nums[i] = (i + 1)%100;
}
test(nums);
}
public static void main(String[] args) {
testNumbers(3);
testNumbers(300);
testNumbers(3000);
testNumbers(30000);
testNumbers(300000);
testNumbers(3000000);
testNumbers(30000000);
testNumbers(300000000);
}
}
मैंने पाया, एक 8 कोर, 16 G Ubuntu18 मशीन का उपयोग करते हुए, लूप छोटे मूल्यों के लिए सबसे तेज़ था और बड़े के लिए समानांतर था। लेकिन निश्चित रूप से यह आपके द्वारा चलाए जा रहे हार्डवेयर पर निर्भर करेगा:
------
3 numbers
6
parallel 4,575,234
6
stream 209,849
6
arrays 251,173
6
loop 576
------
300 numbers
14850
parallel 671,428
14850
stream 73,469
14850
arrays 71,207
14850
loop 4,958
------
3,000 numbers
148500
parallel 393,112
148500
stream 306,240
148500
arrays 335,795
148500
loop 47,804
------
30,000 numbers
1485000
parallel 794,223
1485000
stream 1,046,927
1485000
arrays 366,400
1485000
loop 459,456
------
300,000 numbers
14850000
parallel 4,715,590
14850000
stream 1,369,509
14850000
arrays 1,296,287
14850000
loop 1,327,592
------
3,000,000 numbers
148500000
parallel 3,996,803
148500000
stream 13,426,933
148500000
arrays 13,228,364
148500000
loop 1,137,424
------
30,000,000 numbers
1485000000
parallel 32,894,414
1485000000
stream 131,924,691
1485000000
arrays 131,689,921
1485000000
loop 9,607,527
------
300,000,000 numbers
1965098112
parallel 338,552,816
1965098112
stream 1,318,649,742
1965098112
arrays 1,308,043,340
1965098112
loop 98,986,436
अंडरस्कोर-जावा लाइब्रेरी में एक योग () विधि है ।
कोड उदाहरण:
import com.github.underscore.lodash.U;
public class Main {
public static void main(String[] args) {
int sum = U.sum(java.util.Arrays.asList(1, 2, 3, 4));
System.out.println(sum);
// -> 10
}
}
नीचे तर्क का उपयोग करें:
static int sum()
{
int sum = 0; // initialize sum
int i;
// Iterate through all elements summing them up
for (i = 0; i < arr.length; i++)
sum += arr[i];
return sum;
}
class Addition {
public static void main() {
int arr[]={5,10,15,20,25,30}; //Declaration and Initialization of an Array
int sum=0; //To find the sum of array elements
for(int i:arr) {
sum += i;
}
System.out.println("The sum is :"+sum);//To display the sum
}
}
हम उपयोगकर्ता परिभाषित फ़ंक्शन का उपयोग कर सकते हैं। पहले शून्य के बराबर योग चर पर इनिशियलाइज़ करें। फिर सरणी को पीछे छोड़ें और योग को जोड़ दें। फिर योग चर को अपडेट करें।
सांकेतिक टुकड़ा :
import java.util.*;
import java.lang.*;
import java.io.*;
class Sum
{
public static int sum(int arr[])
{
int sum=0;
for(int i=0; i<arr.length; i++)
{
sum += arr[i];
}
return sum;
}
public static void main (String[] args)
{
int arr[] = {1, 2, 3, 4, 5};
int total = sum(arr);
System.out.printf("%d", total);
}
}
उपरोक्त उत्तरों में से कोई भी उत्तर देखकर कोई आश्चर्यचकित होता है कि यह थ्रेड पूल का उपयोग करके कई गुना तेज हो सकता है। यहां, parallel
एक कांटा-जुड़ने वाले थ्रेड पूल का उपयोग करता है और स्वचालित रूप से कई भागों में धारा को तोड़ता है और उन्हें समानांतर चलाता है और फिर विलय करता है। यदि आपको कोड की निम्न पंक्ति याद है तो आप इसे कई स्थानों पर उपयोग कर सकते हैं।
तो सबसे छोटे और मीठे कोड के लिए पुरस्कार जाता है -
int[] nums = {1,2,3};
int sum = Arrays.stream(nums).parallel().reduce(0, (a,b)-> a+b);
कहते हैं कि आप करना चाहते हैं sum of squares
, तो Arrays.stream (nums) .parallel ()। Map (x-> x * x) .reduce (0, (a, b) -> a + b)। आइडिया है कि आप अभी भी बिना नक्शे के कम कर सकते हैं।
public class Num1
{
public static void main ()
{
//Declaration and Initialization
int a[]={10,20,30,40,50}
//To find the sum of array elements
int sum=0;
for(int i=0;i<a.length;i++)
{
sum=sum+i;
}
//To display the sum
System.out.println("The sum is :"+sum);
}
}
public class AddDemo {
public static void main(String[] args) {
ArrayList <Integer>A = new ArrayList<Integer>();
Scanner S = new Scanner(System.in);
System.out.println("Enter the Numbers: ");
for(int i=0; i<5; i++){
A.add(S.nextInt());
}
System.out.println("You have entered: "+A);
int Sum = 0;
for(int i=0; i<A.size(); i++){
Sum = Sum + A.get(i);
}
System.out.println("The Sum of Entered List is: "+Sum);
}
}
जावा 8 के अनुसार लैम्बडा एक्सप्रेशन का उपयोग उपलब्ध हो गया है।
यह देखो:
int[] nums = /** Your Array **/;
कॉम्पैक्ट:
int sum = 0;
Arrays.asList(nums).stream().forEach(each -> {
sum += each;
});
पसंद करते हैं:
int sum = 0;
ArrayList<Integer> list = new ArrayList<Integer>();
for (int each : nums) { //refer back to original array
list.add(each); //there are faster operations…
}
list.stream().forEach(each -> {
sum += each;
});
वापसी या प्रिंट राशि।