I'm memiliki masalah menemukan jumlah dari semua bilangan bulat dalam sebuah array dalam Java. Aku tidak bisa menemukan apapun metode yang berguna dalam Matematika
untuk kelas ini.
Di [tag:Jawa-8] anda dapat menggunakan stream:
int[] a = {10,20,30,40,50};
int sum = IntStream.of(a).sum();
System.out.println("The sum is " + sum);
Output:
Jumlah tersebut adalah 150.
It's dalam paket jawa.util.stream
import java.util.stream.*;
Jika anda're menggunakan Java 8, Array
hotel ini menyediakan aliran(int[] array)
metode yang mengembalikan berurutan IntStream
dengan yang ditentukan int
hotel. Hal ini juga telah kelebihan beban untuk double
dan panjang
array.
int [] arr = {1,2,3,4};
int sum = Arrays.stream(arr).sum(); //prints 10
Hal ini juga menyediakan metode
aliran(int[] array, int startInclusive, int endExclusive)
yang memungkinkan anda untuk mengambil kisaran tertentu dari array (yang dapat berguna) :
int sum = Arrays.stream(new int []{1,2,3,4}, 0, 2).sum(); //prints 3
Akhirnya, hal ini dapat mengambil sebuah array dari tipe T
. Jadi anda dapat per contoh memiliki String
yang berisi angka-angka sebagai input dan jika anda ingin jumlah mereka hanya melakukan :
int sum = Arrays.stream("1 2 3 4".split("\\s+")).mapToInt(Integer::parseInt).sum();
Ini adalah salah satu dari mereka hal-hal sederhana yang doesn't (AFAIK) ada dalam standar Java API. It's cukup mudah untuk menulis anda sendiri.
Jawaban yang lain baik-baik saja, tapi di sini's dengan beberapa untuk masing-masing gula sintaksis.
int someArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int sum = 0;
for (int i : someArray)
sum += i;
Juga, contoh array penjumlahan bahkan ditunjukkan dalam Spesifikasi Bahasa Jawa 7. Contoh dari Bagian 10.4 - Array Akses.
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);
}
}
Anda dapat't. Bahasa-bahasa lain yang memiliki beberapa metode untuk ini seperti array_sum() di PHP, tapi Jawa doesn't.
Hanya..
int[] numbers = {1,2,3,4};
int sum = 0;
for( int i : numbers) {
sum += i;
}
System.out.println(sum);
Satu-satunya point yang saya tambahkan untuk solusi sebelumnya adalah bahwa saya akan menggunakan yang lama untuk mengumpulkan total untuk menghindari overflow nilai.
int[] someArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, Integer.MAX_VALUE};
long sum = 0;
for (int i : someArray)
sum += i;
Di Java 8
Kode:
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());
Output:
The summation of array is 15
Another way to find summation :15
Penjelasan:
Di Java 8
, anda dapat menggunakan konsep pengurangan untuk melakukan itu.
IMHO fungsi sum tampaknya cocok untuk memperpanjang Susunan kelas di mana isi, sort, search, copy, & sama dengan hidup. Ada banyak berguna metode bersembunyi di javadocs jadi itu adalah pertanyaan yang wajar ketika port Fortran ke jawa untuk bertanya sebelum bergulir kita sendiri metode penolong. Pencarian melalui besar javadoc indeks "sum", "tambahkan" dan kata kunci lain yang mungkin anda pikirkan. Anda mungkin menduga pasti seseorang telah melakukan ini untuk tipe primitif int, float, double, Integer, Float, Double? Tidak peduli seberapa sederhana, itu selalu baik untuk memeriksa. Menjaga kode sesederhana mungkin dan don't menemukan kembali roda.
Saya suka metode ini secara pribadi. Kode saya gaya ini sedikit aneh.
public static int sumOf(int... integers) {
int total = 0;
for (int i = 0; i < integers.length; total += integers[i++]);
return total;
}
Cukup mudah untuk menggunakan kode:
int[] numbers = { 1, 2, 3, 4, 5 };
sumOf(1);
sumOf(1, 2, 3);
sumOf(numbers);
Anda harus roll anda sendiri. Anda mulai dengan jumlah 0. Kemudian anda mempertimbangkan untuk setiap bilangan bulat dalam array, menambahkannya ke total. Kemudian ketika anda're keluar dari bilangan bulat, anda memiliki jumlah yang.
Jika tidak ada bilangan bulat, maka total adalah 0.
Ada dua hal yang harus belajar dari latihan ini :
Anda perlu untuk iterate melalui elemen-elemen dari array entah bagaimana - anda dapat melakukan ini dengan for loop atau while loop. Anda perlu untuk menyimpan hasil penjumlahan di akumulator. Untuk ini, anda perlu membuat sebuah variabel.
int accumulator = 0;
for(int i = 0; i < myArray.length; i++) {
accumulator += myArray[i];
}
Anda dapat membuat kode anda terlihat lebih baik seperti ini:
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;
}
Ada sum() metode underscore-jawa perpustakaan.
Contoh kode:
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
}
}
Itu tergantung. Berapa banyak angka yang anda menambahkan? Pengujian banyak saran di atas:
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);
}
}
Saya menemukan, menggunakan 8 inti, 16 G Ubuntu18 mesin, loop tercepat untuk nilai yang lebih kecil dan paralel untuk yang lebih besar. Tapi tentu saja itu akan tergantung pada perangkat keras anda're menjalankan:
------
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
Sedikit terkejut melihat Tidak ada jawaban atas menganggap hal itu bisa menjadi beberapa kali lebih cepat menggunakan benang kolam renang. Di sini, paralel
menggunakan fork-join thread renang dan secara otomatis memutus aliran di beberapa bagian dan menjalankannya secara paralel dan kemudian bergabung. Jika anda hanya ingat baris kode berikut anda dapat menggunakannya di banyak tempat.
Jadi penghargaan sebagai yang tercepat pendek dan manis code pergi -
int[] nums = {1,2,3};
int sum = Arrays.stream(nums).parallel().reduce(0, (a,b)-> a+b);
Katakanlah anda ingin melakukan jumlah ' kotak
, maka Array.stream(nums).paralel().peta(x->x*x).mengurangi(0, (a,b)-> a+b). Idenya adalah anda masih dapat melakukan reduce , tanpa peta .
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
}
}