Mengapa Java berpikir bahwa produk semua angka dari 10 hingga 99 adalah 0?

131

Blok kode berikut memberikan output sebagai 0.

public class HelloWorld{

    public static void main(String []args){
        int product = 1;
        for (int i = 10; i <= 99; i++) {
            product *= i;
        }
        System.out.println(product);
    }
}

Tolong bisakah seseorang menjelaskan mengapa ini terjadi?

java integer integer-overflow

— Aniruddha Sarkar
sumber

106

Kemungkinan besar Anda memiliki integer overflow.

— TheLostMind

68

Jika Anda mempertimbangkan faktor utama dalam produk, Anda akan 2muncul sekitar 90 kali. Itu berarti Anda akan memerlukan variabel dengan setidaknya 90 bit untuk mendapatkan output yang tidak nol. 32 dan 64 keduanya kurang dari 90. Untuk menghitung bilangan bulat yang lebih besar dari kata-kata asli, Anda harus menggunakan kelas bilangan bulat besar apa pun yang tersedia dalam bahasa pilihan Anda.

— kasperd

62

Secara teknis, ini adalah produk angka dari 10 hingga 98.

— AShelly

45

Apa? Mengapa pertanyaan ini ditutup sebagai duplikat dari pertanyaan yang sedang ditutup sebagai duplikat dari pertanyaan ini ?

— Salman A

82

Punya 99 masalah dan 2147483648 bukan 1.

— glenatron

425

Inilah yang dilakukan program pada setiap langkah:

          1 * 10 =          10
         10 * 11 =         110
        110 * 12 =        1320
       1320 * 13 =       17160
      17160 * 14 =      240240
     240240 * 15 =     3603600
    3603600 * 16 =    57657600
   57657600 * 17 =   980179200
  980179200 * 18 =   463356416
  463356416 * 19 =   213837312
  213837312 * 20 =   -18221056
  -18221056 * 21 =  -382642176
 -382642176 * 22 =   171806720
  171806720 * 23 =  -343412736
 -343412736 * 24 =   348028928
  348028928 * 25 =   110788608
  110788608 * 26 = -1414463488
-1414463488 * 27 =   464191488
  464191488 * 28 =   112459776
  112459776 * 29 = -1033633792
-1033633792 * 30 =  -944242688
 -944242688 * 31 =   793247744
  793247744 * 32 =  -385875968
 -385875968 * 33 =   150994944
  150994944 * 34 =   838860800
  838860800 * 35 =  -704643072
 -704643072 * 36 =   402653184
  402653184 * 37 =  2013265920
 2013265920 * 38 =  -805306368
 -805306368 * 39 = -1342177280
-1342177280 * 40 = -2147483648
-2147483648 * 41 = -2147483648
-2147483648 * 42 =           0
          0 * 43 =           0
          0 * 44 =           0
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
          0 * 97 =           0
          0 * 98 =           0

Perhatikan bahwa pada beberapa langkah, hasil perkalian dalam jumlah yang lebih kecil (980179200 * 18 = 463356416) atau tanda yang salah (213837312 * 20 = -18221056), menunjukkan bahwa ada bilangan bulat bilangan bulat. Tapi dari mana nol berasal? Baca terus.

Perlu diingat bahwa inttipe data adalah 32-bit yang ditandatangani , integer pelengkap dua , berikut adalah penjelasan dari setiap langkah:

Operation         Result(1)     Binary Representation(2)                                           Result(3)
----------------  ------------  -----------------------------------------------------------------  ------------
          1 * 10            10                                                               1010            10
         10 * 11           110                                                            1101110           110
        110 * 12          1320                                                        10100101000          1320
       1320 * 13         17160                                                    100001100001000         17160
      17160 * 14        240240                                                 111010101001110000        240240
     240240 * 15       3603600                                             1101101111110010010000       3603600
    3603600 * 16      57657600                                         11011011111100100100000000      57657600
   57657600 * 17     980179200                                     111010011011000101100100000000     980179200
  980179200 * 18   17643225600                               100 00011011100111100100001000000000     463356416
  463356416 * 19    8803771904                                10 00001100101111101110011000000000     213837312
  213837312 * 20    4276746240                                   11111110111010011111100000000000     -18221056
  -18221056 * 21    -382642176  11111111111111111111111111111111 11101001001100010101100000000000    -382642176
 -382642176 * 22   -8418127872  11111111111111111111111111111110 00001010001111011001000000000000     171806720
  171806720 * 23    3951554560                                   11101011100001111111000000000000    -343412736
 -343412736 * 24   -8241905664  11111111111111111111111111111110 00010100101111101000000000000000     348028928
  348028928 * 25    8700723200                                10 00000110100110101000000000000000     110788608
  110788608 * 26    2880503808                                   10101011101100010000000000000000   -1414463488
-1414463488 * 27  -38190514176  11111111111111111111111111110111 00011011101010110000000000000000     464191488
  464191488 * 28   12997361664                                11 00000110101101000000000000000000     112459776
  112459776 * 29    3261333504                                   11000010011001000000000000000000   -1033633792
-1033633792 * 30  -31009013760  11111111111111111111111111111000 11000111101110000000000000000000    -944242688
 -944242688 * 31  -29271523328  11111111111111111111111111111001 00101111010010000000000000000000     793247744
  793247744 * 32   25383927808                               101 11101001000000000000000000000000    -385875968
 -385875968 * 33  -12733906944  11111111111111111111111111111101 00001001000000000000000000000000     150994944
  150994944 * 34    5133828096                                 1 00110010000000000000000000000000     838860800
  838860800 * 35   29360128000                               110 11010110000000000000000000000000    -704643072
 -704643072 * 36  -25367150592  11111111111111111111111111111010 00011000000000000000000000000000     402653184
  402653184 * 37   14898167808                                11 01111000000000000000000000000000    2013265920
 2013265920 * 38   76504104960                             10001 11010000000000000000000000000000    -805306368
 -805306368 * 39  -31406948352  11111111111111111111111111111000 10110000000000000000000000000000   -1342177280
-1342177280 * 40  -53687091200  11111111111111111111111111110011 10000000000000000000000000000000   -2147483648
-2147483648 * 41  -88046829568  11111111111111111111111111101011 10000000000000000000000000000000   -2147483648
-2147483648 * 42  -90194313216  11111111111111111111111111101011 00000000000000000000000000000000             0
          0 * 43             0                                                                  0             0
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
          0 * 98             0                                                                  0             0

adalah hasil yang benar
adalah representasi internal dari hasilnya (64 bit digunakan untuk ilustrasi)
adalah hasil yang diwakili oleh komplemen dua dari 32 bit yang lebih rendah

Kita tahu bahwa mengalikan angka dengan angka genap:

menggeser bit ke kiri dan menambahkan nol bit ke kanan
menghasilkan angka genap

Jadi pada dasarnya program Anda mengalikan angka genap dengan angka lain berulang kali yang nol bit hasil mulai dari kanan.

PS: Jika penggandaan hanya melibatkan angka ganjil maka hasilnya tidak akan menjadi nol.

— Salman A
sumber

15

Representasi Hex adalah yang membantu saya memahami apa yang terjadi di sini. Terima kasih telah mengklarifikasi!

1

Ya, akan lebih instruktif jika Anda memodifikasi program Anda untuk juga mencetak nilai hex dalam daftar panjang.

— Hot Licks

4

Jawaban ini benar tetapi ada begitu banyak kekacauan. Lima baris terakhir adalah inti dari itu, dan tidak ada tempat yang benar-benar menggambarkan di mana tepatnya bagaimana hal itu terjadi. (Tapi orang bisa memecahkannya dari meja raksasa.)

— Rex Kerr

6

Dengan kata lain, Anda mengakumulasikan faktor 2. Beberapa angka memberi Anda beberapa faktor 2 semuanya sendiri, seperti 12, 16, dan 20. Setiap faktor 2 akan menggeser semua bit dari semua hasil Anda berikutnya, meninggalkan nol sebagai placeholder. Setelah Anda bergeser ke kanan 32 kali, Anda hanya memiliki 32 angka nol.

— Tertarik

2

Efek serupa juga dapat dilihat pada basis 10. Cobalah mengalikan serangkaian bilangan bulat berurutan, setiap kali Anda mengalikan dengan angka yang dapat dibagi dengan 10, Anda menambahkan setidaknya satu nol ke akhir produk, dan tidak mungkin untuk menghapus nol itu dari produk dengan perkalian bilangan bulat. Pada titik tertentu, semua digit ke-terkecil ke-nol akan diisi dengan nol dan jika Anda melakukan aritmatika ke modulo 10 ** m (yang memiliki efek memangkas segala sesuatu kecuali ke-ke-ke-ke-10), maka akhirnya akan berubah menjadi nol. Begitu juga dengan pangkalan lainnya.

— Lie Ryan

70

Multiplikasi komputer benar-benar terjadi modulo 2 ^ 32. Setelah Anda mengumpulkan cukup kekuatan dua di multiplicand, maka semua nilai akan menjadi 0.

Di sini kita memiliki semua angka genap dalam seri, bersama dengan kekuatan maksimum dua yang membagi angka, dan kekuatan kumulatif dua

num   max2  total
10    2     1
12    4     3
14    2     4
16    16    8
18    2     9
20    4    11
22    2    12
24    8    15
26    2    16
28    4    18
30    2    19
32    32   24
34    2    25
36    4    27
38    2    28
40    8    31
42    2    32

Produk hingga 42 sama dengan x * 2 ^ 32 = 0 (mod 2 ^ 32). Urutan kekuatan dua terkait dengan kode Gray (antara lain), dan muncul sebagai https://oeis.org/A001511 .

EDIT: untuk melihat mengapa tanggapan lain terhadap pertanyaan ini tidak lengkap, pertimbangkan fakta bahwa program yang sama, terbatas hanya pada bilangan bulat ganjil, tidak akan konvergen ke 0, meskipun semua meluap.

— pengguna295691
sumber

Yay! Akhirnya, jawaban yang benar. Orang harus lebih memperhatikan jawaban ini!

— Rex Kerr

Ini satu-satunya jawaban yang benar. Yang lainnya tidak menjelaskan alasannya .

— Olivier Grégoire

5

@ OlivierGrégoire Saya tidak setuju; Saya pikir jawaban yang diterima benar dan memberikan penjelasan yang sangat bagus. Yang ini lebih langsung.

— David Z

1

Saya harap lebih banyak orang melihat jawaban ini. Penyebab utama disebutkan di sini!

— lanpa

1

@ DavidZ: Setuju; jawaban yang diterima sebagian besar benar - posting saya tidak benar-benar membahas "mengapa" dari kalimat pembuka saya. Tetapi penutupan jawaban yang diterima adalah hal yang paling dekat dengan jawaban untuk "mengapa nol", tetapi itu tidak menjelaskan "mengapa 42" - hanya ada 16 angka genap antara 10 dan 42

— user295691

34

Itu terlihat seperti integer overflow .

Lihatlah ini

BigDecimal product=new BigDecimal(1);
for(int i=10;i<99;i++){
    product=product.multiply(new BigDecimal(i));
}
System.out.println(product);

Keluaran:

25977982938941930515945176761070443325092850981258133993315252362474391176210383043658995147728530422794328291965962468114563072000000000000000000000

Output tidak lagi menjadi intnilai. Maka Anda akan mendapatkan nilai yang salah karena melimpah.

Jika meluap, itu akan kembali ke nilai minimum dan berlanjut dari sana. Jika underflow, kembali ke nilai maksimum dan berlanjut dari sana.

Info lebih lanjut

Edit .

Mari kita ubah kode Anda sebagai berikut

int product = 1;
for (int i = 10; i < 99; i++) {
   product *= i;
   System.out.println(product);
}

Keluarkan:

10
110
1320
17160
240240
3603600
57657600
980179200
463356416
213837312
-18221056
-382642176
171806720
-343412736
348028928
110788608
-1414463488
464191488
112459776
-1033633792
-944242688
793247744
-385875968
150994944
838860800
-704643072
402653184
2013265920
-805306368
-1342177280
-2147483648
-2147483648>>>binary representation is 11111111111111111111111111101011 10000000000000000000000000000000 
 0 >>> here binary representation will become 11111111111111111111111111101011 00000000000000000000000000000000 
 ----
 0

— Ruchira Gayan Ranaweera
sumber

22

Itu karena integer overflow. Ketika Anda mengalikan banyak angka genap, angka biner mendapat banyak angka nol. Ketika Anda memiliki lebih dari 32 angka nol di belakangnya, angka intitu berguling ke 0.

Untuk membantu Anda memvisualisasikan ini, berikut adalah perkalian dalam hex yang dihitung pada tipe angka yang tidak akan meluap. Lihat bagaimana nol trailing tumbuh perlahan, dan perhatikan bahwa intterdiri dari 8 digit hex terakhir. Setelah dikalikan dengan 42 (0x2A), semua 32 bit intadalah nol!

                                     1 (int: 00000001) * 0A =
                                     A (int: 0000000A) * 0B =
                                    6E (int: 0000006E) * 0C =
                                   528 (int: 00000528) * 0D =
                                  4308 (int: 00004308) * 0E =
                                 3AA70 (int: 0003AA70) * 0F =
                                36FC90 (int: 0036FC90) * 10 =
                               36FC900 (int: 036FC900) * 11 =
                              3A6C5900 (int: 3A6C5900) * 12 =
                             41B9E4200 (int: 1B9E4200) * 13 =
                            4E0CBEE600 (int: 0CBEE600) * 14 =
                           618FEE9F800 (int: FEE9F800) * 15 =
                          800CE9315800 (int: E9315800) * 16 =
                         B011C0A3D9000 (int: 0A3D9000) * 17 =
                        FD1984EB87F000 (int: EB87F000) * 18 =
                      17BA647614BE8000 (int: 14BE8000) * 19 =
                     25133CF88069A8000 (int: 069A8000) * 1A =
                    3C3F4313D0ABB10000 (int: ABB10000) * 1B =
                   65AAC1317021BAB0000 (int: 1BAB0000) * 1C =
                  B1EAD216843B06B40000 (int: 06B40000) * 1D =
                142799CC8CFAAFC2640000 (int: C2640000) * 1E =
               25CA405F8856098C7B80000 (int: C7B80000) * 1F =
              4937DCB91826B2802F480000 (int: 2F480000) * 20 =
             926FB972304D65005E9000000 (int: E9000000) * 21 =
           12E066E7B839FA050C309000000 (int: 09000000) * 22 =
          281CDAAC677B334AB9E732000000 (int: 32000000) * 23 =
         57BF1E59225D803376A9BD6000000 (int: D6000000) * 24 =
        C56E04488D526073CAFDEA18000000 (int: 18000000) * 25 =
      1C88E69E7C6CE7F0BC56B2D578000000 (int: 78000000) * 26 =
     43C523B86782A6DBBF4DE8BAFD0000000 (int: D0000000) * 27 =
    A53087117C4E76B7A24DE747C8B0000000 (int: B0000000) * 28 =
  19CF951ABB6C428CB15C2C23375B80000000 (int: 80000000) * 29 =
 4223EE1480456A88867C311A3DDA780000000 (int: 80000000) * 2A =
AD9E50F5D0B637A6610600E4E25D7B00000000 (int: 00000000)

— Tim S.
sumber

1

Ini sedikit menyesatkan. Sementara itu tidak benar menunjukkan mengapa itu menjadi nol, setiap nilai disimpan dalam int 32-bit setelah perkalian, sehingga harus dipotong setelah setiap langkah. Cara Anda menulis jawaban Anda menyiratkan bahwa itu tidak terpotong sampai loop for berakhir. Akan lebih baik jika Anda hanya menunjukkan 8 digit terakhir untuk setiap langkah.

— RyNo

@KamikazeScotsman Saya telah memperbaiki jawaban saya berdasarkan saran Anda. Nol redundan yang lebih sedikit, visibilitas int 32-bit lebih banyak.

— Tim S.

1

+1 untuk menunjukkan nilai aktual vs nilai 32-bit pada setiap tahap, menyoroti bahwa nilai tersebut sedang terpotong ...

— kwah

14

Di suatu tempat di tengah Anda dapatkan 0sebagai produk. Jadi, seluruh produk Anda adalah 0.

Dalam kasus Anda:

for (int i = 10; i < 99; i++) {
    if (product < Integer.MAX_VALUE)
        System.out.println(product);
    product *= i;
}
// System.out.println(product);

System.out.println(-2147483648 * EvenValueOfi); // --> this is the culprit (Credits : Kocko's answer )

O/P :
1
10
110
1320
17160
240240
3603600
57657600
980179200
463356416
213837312
-18221056
-382642176
171806720
-343412736
348028928
110788608
-1414463488
464191488
112459776
-1033633792
-944242688
793247744
-385875968
150994944
838860800
-704643072
402653184
2013265920
-805306368
-1342177280  --> Multiplying this and the current value of `i` will also give -2147483648 (INT overflow)
-2147483648  --> Multiplying this and the current value of `i` will also give -2147483648 (INT overflow)

-2147483648  ->  Multiplying this and the current value of 'i' will give 0 (INT overflow)
0
0
0

Setiap kali Anda mengalikan nilai saat ini idengan angka yang Anda dapatkan 0sebagai output.

— TheLostMind
sumber

@KickButtowski - Lipat gandakan angka .. Anda akan tahu mengapa: P

— TheLostMind

@KickButtowski - 0 dikalikan dengan angka lain akan terus menghasilkan 0 selamanya setelah overflow mengembalikan 0 pada titik mana pun.

— Tuan Moose

Saya lakukan tetapi saya pikir Anda harus lebih informatif sehingga orang lain dapat belajar juga

— Kick Buttowski

@KickButtowski - memperbarui jawabannya. Periksa bagian OP.

— TheLostMind

8

@KickButtowski: Itu karena pembungkus overflow terjadi pada kekuatan dua. Pada dasarnya, OP menghitung {10 x 11 x 12 x ... x 98} modulo 2 ^ 32. Karena kelipatan 2 muncul lebih dari 32 kali dalam produk itu, hasilnya adalah nol.

— ruakh

12

Karena banyak dari titik jawaban yang ada untuk rincian implementasi Java dan hasil debug, mari kita lihat matematika di balik perkalian biner untuk benar-benar menjawab alasannya.

Komentar @kasperd mengarah ke arah yang benar. Misalkan Anda tidak memperbanyak secara langsung dengan angka tetapi dengan faktor prima dari angka itu sebagai gantinya. Dari banyak angka akan memiliki 2 sebagai faktor utama. Dalam biner ini sama dengan shift kiri. Dengan komutatif kita dapat mengalikan dengan faktor prima dari 2 terlebih dahulu. Itu artinya kita hanya melakukan shift kiri.

Ketika melihat aturan perkalian biner, satu-satunya kasus di mana 1 akan menghasilkan posisi digit tertentu adalah ketika kedua nilai operan adalah satu.

Jadi efek dari pergeseran kiri adalah bahwa posisi bit terendah dari 1 ketika lebih jauh mengalikan hasilnya meningkat.

Karena integer hanya berisi bit urutan terendah, mereka semua akan ditetapkan ke 0 ketika faktor prima 2 cukup sering ditandai dalam hasilnya.

Perhatikan bahwa representasi komplemen dua tidak menarik untuk analisis ini, karena tanda hasil multiplikasi dapat dihitung secara independen dari angka yang dihasilkan. Itu berarti jika nilai meluap dan menjadi negatif, bit urutan terendah direpresentasikan sebagai 1, tetapi selama penggandaan mereka diperlakukan lagi sebagai 0.

— SpaceTrucker
sumber

7

Jika saya menjalankan kode ini What I get all -

          1 * 10 =          10
         10 * 11 =         110
        110 * 12 =        1320
       1320 * 13 =       17160
      17160 * 14 =      240240
     240240 * 15 =     3603600
    3603600 * 16 =    57657600
   57657600 * 17 =   980179200
  980179200 * 18 =   463356416 <- Integer Overflow (17643225600)
  463356416 * 19 =   213837312
  213837312 * 20 =   -18221056
  -18221056 * 21 =  -382642176
 -382642176 * 22 =   171806720
  171806720 * 23 =  -343412736
 -343412736 * 24 =   348028928
  348028928 * 25 =   110788608
  110788608 * 26 = -1414463488
-1414463488 * 27 =   464191488
  464191488 * 28 =   112459776
  112459776 * 29 = -1033633792
-1033633792 * 30 =  -944242688
 -944242688 * 31 =   793247744
  793247744 * 32 =  -385875968
 -385875968 * 33 =   150994944
  150994944 * 34 =   838860800
  838860800 * 35 =  -704643072
 -704643072 * 36 =   402653184
  402653184 * 37 =  2013265920
 2013265920 * 38 =  -805306368
 -805306368 * 39 = -1342177280
-1342177280 * 40 = -2147483648
-2147483648 * 41 = -2147483648
-2147483648 * 42 =           0 <- produce 0 
          0 * 43 =           0

Penyebab Integer Overflow -

980179200 * 18 =   463356416 (should be 17643225600)

17643225600 : 10000011011100111100100001000000000 <-Actual
MAX_Integer :     1111111111111111111111111111111
463356416   :     0011011100111100100001000000000 <- 32 bit Integer

Menghasilkan 0 penyebab -

-2147483648 * 42 =           0 (should be -90194313216)

-90194313216: 1010100000000000000000000000000000000 <- Actual
MAX_Integer :       1111111111111111111111111111111
0           :      00000000000000000000000000000000 <- 32 bit Integer

— Subhrajyoti Majumder
sumber

6

Akhirnya, perhitungan meluap, dan akhirnya meluap itu menghasilkan produk nol; itu terjadi ketika product == -2147483648dan i == 42. Coba kode ini untuk memverifikasi sendiri (atau jalankan kode di sini ):

import java.math.BigInteger;

class Ideone {
    public static void main (String[] args) throws java.lang.Exception {
        System.out.println("Result: " + (-2147483648 * 42));
    }
}

Begitu nol, tentu saja tetap nol. Berikut beberapa kode yang akan menghasilkan hasil yang lebih akurat (Anda dapat menjalankan kode di sini ):

import java.math.BigInteger;

class Ideone {
    public static void main (String[] args) throws java.lang.Exception {
        BigInteger p = BigInteger.valueOf(1);
        BigInteger start = BigInteger.valueOf(10);
        BigInteger end = BigInteger.valueOf(99);
        for(BigInteger i = start; i.compareTo(end) < 0; i = i.add(BigInteger.ONE)){
            p = p.multiply(i);
            System.out.println("p: " + p);
        }
        System.out.println("\nProduct: " + p);
    }
}

— Trevor
sumber

Itu meluap (dalam arti kata yang tepat) jauh sebelum iterasi ke-42 - pada 19 sudah meluap, karena f (19) <f (18)

— user295691

Ya, tetapi overflow tidak menyebabkan atau menghasilkan produk nol hingga iterasi ke-42.

— Trevor

Saya kira apa yang saya maksudkan adalah bahwa Anda tidak membahas "mengapa" - mengapa produk kumulatif akan pernah melewati 0? Jawaban Tim S. memberikan beberapa indikasi mengapa, tetapi jawaban sebenarnya terletak pada aritmatika modular.

— user295691

Pertanyaannya tidak menanyakan mengapa produk melewati nol. Ia bertanya mengapa kode menghasilkan nol. Dengan kata lain, saya pikir OP lebih tertarik pada dinamika bahasa Jawa daripada aritmatika modular, tapi mungkin saya salah. Ini bukan pertama kalinya saya salah menafsirkan pertanyaan seseorang.

— Trevor

misalnya, jika program ini mengambil produk dari semua angka ganjil dari 11 menjadi 99, maka itu tidak akan mencapai nol. Jawaban Anda sebenarnya tidak membahas mengapa ini bisa terjadi.

— user295691

1

Ini adalah integer overflow.

Tipe data int adalah 4 byte, atau 32 bit. Oleh karena itu, angka yang lebih besar dari 2 ^ (32 - 1) - 1 (2.147.483.647) tidak dapat disimpan dalam tipe data ini. Nilai numerik Anda akan salah.

Untuk jumlah yang sangat besar, Anda ingin mengimpor dan menggunakan kelas java.math.BigInteger:

BigInteger product = BigInteger.ONE;
for (long i = 10; i < 99; i++) 
    product = product.multiply(BigInteger.valueOf(i));
System.out.println(product.toString());

CATATAN: Untuk nilai numerik yang masih terlalu besar untuk tipe data int, tetapi cukup kecil untuk muat dalam 8 byte (nilai absolut kurang dari atau sama dengan 2 ^ (64 - 1) - 1), Anda mungkin harus menggunakan longprimitif.

Masalah praktik HackerRank (www.hackerrank.com), seperti bagian praktik Algoritma, ( https://www.hackerrank.com/domains/algorithms/warmup ) mencakup beberapa pertanyaan besar yang sangat bagus yang memberikan praktik bagus tentang cara pikirkan tipe data yang tepat untuk digunakan.

— La-comadreja
sumber