Konstruktory

Konstruktor BigInteger(byte[] val)

Załóżmy, że mamy liczbę 1682151.
W systemie dwójkowym będzie to liczba 3-bajtowa: “000110011010101011100111”;
Liczbę możemy podzielić na trzy bajty: “00011001”, “10101010”, “11100111”.
Po przekształceniu do intów będą to liczby: 25, 170, 231.
Po przekształceniu w bajty (kod uzupełnień do 2) będą to bajty: 25, -86, -25.
To oznacza, że liczba 1682151 zapisana jako tablica bajtów będzie wyglądała tak: [25, -86, -25].
W klasie BigInt01 podstawiamy tę tablicę do konstruktora i konstruujemy liczbę BigInteger:

        byte[] b1 = {25,-86,-25};
        Util.print(b1);
        BigInteger big1 = new BigInteger(b1);
        Util.print(big1);

Po uruchomieniu klasy na konsoli otrzymamy:

[25, -86, -25]
1682151

Konstruktor BigInteger(byte[] val, int off, int len)

Konstruktor pozwala na utworzenie liczby BigInteger z danych tablicy val.
off – oznacza przesunięcie indeksu
len – oznacza liczbę odczytywanych bajtów

Ten konstruktor (znany od Java 9) działa nieprawidłowo.

Kod przedstawiony (BigInt02) poniżej:

        byte[] b1 = {25, -86, -25};
        Util.print(b1);
        BigInteger big1 = new BigInteger(b1, 0, 3);
        Util.print(big1);
        BigInteger big2 = new BigInteger(b1, 0, 1);
        Util.print(big2);
        BigInteger big3 = new BigInteger(b1, 1, 1);
        Util.print(big3);
        BigInteger big4 = new BigInteger(b1, 2, 1);
        Util.print(big4);

po uruchomieniu pokazuje:

[25, -86, -25]
1682151
25
-86
-25

Zgodnie z wyjaśnieniami przy konstruktorze BigInteger(byte[] val) powinniśmy otrzymać:
1682151
25
170
231

Konstruktor BigInteger(int signum, byte[] magnitude)

Ten konstruktor przekształca układ signum - magnitude (znak liczby – liczba bez znaku) w liczbę BigInteger.
Znak (signum) może być równy:

  • 1 dla liczb dodatnich
  • -1 dla ujemnych
  • 0 nie jest dozwolone
  • Magnitude może być liczbą 7-bitową, a zatem liczbą od 0 do 127. Signum określa jej znak.
    Po uruchomieniu klasy BigInt03:

            byte[] b1 = {25,-86,-25};
            BigInteger a = new BigInteger(1, b1);
            Util.print(a);
    

    na konsoli otrzymujemy:

    1682151
    

    Konstruktor BigInteger(int signum, byte[] magnitude, int off, int len)

    Ten konstruktor pozwala zamienić układ signum – magnitude (znak – liczba bez znaku) na liczbę BigInteger.
    off – oznacza przesunięcie indeksu
    len – oznacza liczbę bajtów
    Znak (signum) może być równy:

    • 1 dla liczb dodatnich
    • -1 dla ujemnych
    • 0 nie jest dozwolone
    • Magnitude może być liczbą 7-bitową, a zatem liczbą od 0 do 127. Signum określa jej znak.
      Po uruchomieniu klasy BigInt04:

              byte[] b1 = {25, -86, -25};
              Util.print(b1);
              BigInteger big1 = new BigInteger(1,b1, 0, 3);
              Util.print(big1);
              BigInteger big2 = new BigInteger(1,b1, 0, 1);
              Util.print(big2);
              BigInteger big3 = new BigInteger(1,b1, 1, 1);
              Util.print(big3);
              BigInteger big4 = new BigInteger(1,b1, 2, 1);
              Util.print(big4);
      

      na konsoli zobaczymy:

      [25, -86, -25]
      1682151
      25
      170
      231
      

      Konstruktor BigInteger(int numBits, Random random)

      Tworzy losową liczbę BigInteger, z przedziału zamkniętego <0, 2numBits-1>
      Uruchamiamy klasę BigInt05:

              BigInteger a = new BigInteger(16, new Random());
              Util.print(a);
      

      Na konsoli otrzymujemy:

      22009
      

      Komentarz: Liczba powinna być w zakresie <0, 65535>.

      Konstruktor BigInteger(int bitLength, int certainty, Random random)

      Tworzy losową, dodatnią liczbę BigInteger o długości bitLength, która jest prawdopodobnie pierwsza, z pewnością certainty.
      Najlepiej jest, gdy liczba bitLength jest podzielna przez 8.
      certainty oznacza liczbę iteracji pętli sprawdzającej pierwszość liczby. Sensowne są liczby 100 lub większe.
      Uruchamiamy klasę BigInt06:

           BigInteger a = new BigInteger(24, 1000, new Random());
           Util.print(a);       
      

      Na konsoli otrzymujemy:

      14226001
      

      Konstruktor BigInteger(String val)

      Przekształca string val w systemie dziesiętnym na BigInteger.
      Uruchamiamy klasę BigInt07:

           BigInteger a = new BigInteger("24");
           Util.print(a);
      

      Na konsoli otrzymamy:

      24
      

      Konstruktor BigInteger(String val, int radix)

      Przekształca string val w systemie radix na BigInteger.
      Uruchamiamy klasę BigInt08:

          BigInteger a = new BigInteger("10111101", 2);
          Util.print(a);    
      

      Na konsoli otrzymamy:

      189
      

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *