Am'm a avea o problemă în a găsi suma tuturor numerelor întregi într-o matrice în Java. Eu nu pot găsi nici o metodă utilă în "Matematica" pentru clasa asta.
În [tag:Java-8] puteți utiliza fluxuri:
int[] a = {10,20,30,40,50};
int sum = IntStream.of(a).sum();
System.out.println("The sum is " + sum);
Ieșire:
Suma este de 150.
L's în pachetul java.util.stream`
import java.util.stream.*;
Daca're folosind Java 8, Tablouri
clasă oferă o flux(int[] array)
metodă care returnează un secvențiale IntStream
cu cele specificate int
matrice. Acesta a fost, de asemenea, supraîncărcat pentru "dublu" și "lung" tablouri.
int [] arr = {1,2,3,4};
int sum = Arrays.stream(arr).sum(); //prints 10
Acesta oferă, de asemenea, o metodă
flux(int[] matrice, int startInclusive, int endExclusive)
, care permite să ia un interval specificat de matrice (care pot fi utile) :
int sum = Arrays.stream(new int []{1,2,3,4}, 0, 2).sum(); //prints 3
În cele din urmă, se poate lua o matrice de tip "T". Astfel încât să puteți, de exemplu, au un "String", care conține numere ca intrare și, dacă doriți să le rezuma doar face :
int sum = Arrays.stream("1 2 3 4".split("\\s+")).mapToInt(Integer::parseInt).sum();
Acesta este unul din acele lucruri simple care nu't (AFAIK) există în standardul Java API. L's destul de ușor de a scrie propriul.
Alte răspunsuri sunt perfect în regulă, dar aici's unul cu ceva pentru fiecare sintactică de zahăr.
int someArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int sum = 0;
for (int i : someArray)
sum += i;
De asemenea, un exemplu de matrice de însumare este chiar a a arătat în Java 7 Limba caietul de sarcini. Exemplul este de la Secțiunea 10.4 - Matrice de Acces.
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);
}
}
Singurul punct pe care aș adăuga la soluțiile anterioare este că mi-ar folosi un timp să se acumuleze în total, pentru a evita orice revărsare de valoare.
int[] someArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, Integer.MAX_VALUE};
long sum = 0;
for (int i : someArray)
sum += i;
În Java 8`
**Cod:
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());
Ieșire:
The summation of array is 15
Another way to find summation :15
Explicație:
În Java 8`, puteți utiliza concept de reducere a face dvs. plus.
IMHO o funcție de sumă ar părea o alegere bună pentru a prelungi durata de Tablouri de clasă unde se umple, sortare, căutare, copia, & egal live. Există o mulțime de îndemână metode de a ascunde în javadocs așa că este o întrebare corectă atunci când portarea Fortran pentru java pentru a cere înainte de rulare propria noastra metoda de ajutor. Cauta prin mare javadoc index pentru "sum", "adăugați" și orice alte cuvinte cheie s-ar putea gândi. S-ar putea bănui, cu siguranță, cineva a făcut deja acest lucru pentru tipuri primitive int, float, double, Integer, Float, Double? Nu contează cât de simplă, este întotdeauna bine să verificați. Păstrați codul cât mai simplu posibil și don't reinventeze roata.
Îmi place această metodă personal. Codul meu stil este un pic ciudat.
public static int sumOf(int... integers) {
int total = 0;
for (int i = 0; i < integers.length; total += integers[i++]);
return total;
}
Destul de ușor de utilizat în cod:
int[] numbers = { 1, 2, 3, 4, 5 };
sumOf(1);
sumOf(1, 2, 3);
sumOf(numbers);
Trebuie să se rostogolească ta. Începe cu un total de 0. Apoi ia în considerare pentru fiecare număr întreg în matrice, adăugați-l la un total. Atunci când te're de numere întregi, aveți suma.
Dacă nu există numere întregi, atunci totalul este de 0.
Există două lucruri de învățat din acest exercițiu :
Ai nevoie pentru a itera prin elementele de matrice într - un fel- puteți face acest lucru cu o buclă sau o buclă în timp. Aveți nevoie pentru a stoca rezultatul însumării într-un acumulator. Pentru aceasta, aveți nevoie pentru a crea o variabilă.
int accumulator = 0;
for(int i = 0; i < myArray.length; i++) {
accumulator += myArray[i];
}
Puteți face codul arata mai bine ca asta:
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;
}
Nu este o suma() metoda în subliniere-java biblioteca.
Exemplu de cod:
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
}
}
Depinde. Câte numere sunt mai adăuga și tu? Am testat multe din sugestiile de mai sus:
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);
}
}
Am găsit, folosind un 8 core, 16 G Ubuntu18 mașină, bucla fost cel mai rapid, pentru valori mai mici și paralel pentru mai mari. Dar, desigur, aceasta va depinde de hardware-ul tine're de funcționare:
------
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
Un pic surprins să văd Nici unul din raspunsurile de mai sus consideră că pot fi de mai multe ori mai repede folosind un thread pool. Aici, "paralel" folosește o furculiță-alăturați-vă thread pool și rupe în mod automat flux în mai multe părți și a alerga-le în paralel și apoi îmbinați. Dacă vă amintiți doar următoarea linie de cod, puteți folosi mai multe locuri.
Astfel, premiul pentru cel mai scurt și dulce codul duce la ...
int[] nums = {1,2,3};
int sum = Arrays.stream(nums).parallel().reduce(0, (a,b)-> a+b);
Să spunem că vrei să faci sumă de pătrate , atunci Tablouri.stream(nums).paralel().harta(x->x*x).reduce(0, (a,b)-> a+b). Ideea este, puteți efectua încă reduce , fără hartă .
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
}
}