У мене виникають проблеми з пошуком суми всіх цілих чисел у масиві на Java. Я не можу знайти для цього жодного корисного методу в Math
класі.
У мене виникають проблеми з пошуком суми всіх цілих чисел у масиві на Java. Я не можу знайти для цього жодного корисного методу в Math
класі.
Відповіді:
В java-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();
Якщо ви використовуєте Java 8, Arrays
клас надає stream(int[] array)
метод, який повертає послідовний IntStream
із зазначеним int
масивом. Він також був перевантажений double
і long
масиви.
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();
Це одна з тих простих речей, яких немає (AFAIK) у стандартному Java API. Досить просто написати своє.
Інші відповіді ідеально чудові, але ось одна із синтаксичним цукром на кожний.
int someArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int sum = 0;
for (int i : someArray)
sum += i;
Також приклад підсумовування масиву навіть показаний у специфікації мови Java 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);
}
}
Ви не можете. В інших мовах є такі методи, як array_sum () в PHP, але Java не робить.
Просто ..
int[] numbers = {1,2,3,4};
int sum = 0;
for( int i : numbers) {
sum += i;
}
System.out.println(sum);
Єдиний момент, який я хотів би додати до попередніх рішень, - це те, що я використовую довгий час, щоб накопичити загальну суму, щоб уникнути переповнення значення.
int[] someArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, Integer.MAX_VALUE};
long sum = 0;
for (int i : someArray)
sum += i;
В 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 сума може здатися гарною для розширення класу Arrays, де живуть заповнення, сортування, пошук, копіювання та дорівнювання. Є багато зручних методів, які ховаються в javadocs, тому це справедливо питання, коли переносити Fortran в Java, щоб запитати, перш ніж прокати наш власний помічник. Шукайте через величезний індекс javadoc для "суми", "додати" та будь-якого іншого ключового слова, про яке ви могли б придумати. Ви можете підозрювати, що хтось уже зробив це для примітивних типів int, float, double, Integer, Float, Double? Як би не було просто, це завжди добре перевірити. Зберігайте код максимально простим і не вигадуйте колесо.
Мені подобається цей метод особисто. Мій стиль коду трохи дивний.
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);
З цієї вправи можна дізнатися дві речі:
Потрібно якось перебрати елементи масиву - це можна зробити за допомогою циклу for або циклу. Потрібно зберігати результат підсумовування в акумуляторі. Для цього вам потрібно створити змінну.
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-ядерну машину Ubuntu18 16 G, цикл був найшвидшим для менших значень і паралельним для більших. Але, звичайно, це залежатиме від обладнання, яке ви працюєте:
------
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
Існує метод sum () у підкреслювальній ява- бібліотеці.
Приклад коду:
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
використовується пул потоків fork-join і автоматично розбиває потік на кілька частин і запускає їх паралельно, а потім об'єднує. Якщо ви просто пам'ятаєте наступний рядок коду, ви можете використовувати його у багатьох місцях.
Тож нагорода за найшвидший короткий та солодкий код -
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);
}
}
Станом на Java 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;
});
Повернути або надрукувати суму.