BigIntegerの2つの構造方法を記録する

37978 ワード
Java 同前 API
BigIntegerの2つの構造方法を記録する
  • 構築方法:BigInteger(byte[]val)
  • まずこの構造方法がどのように結果を得たかを説明する:
  • 印刷結果から結論:
  • BigIntegerにおけるtoString(進数)法
  • 構築方法:BigInteger(int signum,byte[]magnitude)
  • まずこの構造方法がどのように結果を得たかを説明する:
    • -----------------------------------------------------------------------------------------------------------------------------------------------結論が分からない場合は、最初からゆっくりと見て、他の人の関連ドキュメントも調べます.以下はすべて個人の理解で、知識が限られていて、理解が間違っているかもしれません.参考にしてください--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    構築方法:BigInteger(byte[]val)
    構築方法:BigInteger(byte[]val)
    次のコードのコメントは、出力結果(結果:)、出力結果のバイナリ(BIN:)、バイト配列ごとに対応するバイナリをそれぞれ列挙し、比較し、出力結果の元のコードとtoString後の16進文字列を列挙しています.
    

        //    8 
        System.out.println(new BigInteger(new byte[]{11,22}).toString(16));  //  b16
        System.out.println(new BigInteger(new byte[]{11,22}));  //  2838
                                                                //BIN(2838):    0000 ‭1011 0001 0110‬
                                                                //BIN(11):      0000 1011
                                                                //BIN(22):                ‭0001 0110‬

                                                                //HEX:             0    b    1    6
                                                                //2838  ：     0000 ‭1011 0001 0110

        System.out.println(new BigInteger(new byte[]{-11,22}).toString(16));  //  -aea
        System.out.println(new BigInteger(new byte[]{-11,22})); //  -2794
                                                                //BIN(-2794):   1111 0101 0001 0110
                                                                //BIN(-11):     1111 0101
                                                                //BIN(22):                ‭0001 0110‬

                                                                //HEX:            -0    a    e    a
                                                                //-2794  ：    1000 ‭1010 1110 1010‬

        System.out.println(new BigInteger(new byte[]{-11,-22}).toString(16));  //  -a16
        System.out.println(new BigInteger(new byte[]{-11,-22}));//  -2582
                                                                //BIN(-2582):   1111 0101 1110 1010‬
                                                                //BIN(-11):     1111 0101
                                                                //BIN(-22):               1110 1010

                                                                //HEX:            -0    a    1    6
                                                                //-2582  ：    1000 ‭1010 0001 0110‬

        System.out.println(new BigInteger(new byte[]{11,-22}).toString(16));  //  bea
        System.out.println(new BigInteger(new byte[]{11,-22})); //  3050
                                                                //BIN(3050):    0000 ‭1011 1110 1010‬
                                                                //BIN(11):      0000 1011
                                                                //BIN(-22):               1110 1010

                                                                //HEX:             0    b    e    a
                                                                //-3050  ：    0000 ‭1011 1110 1010‬


        System.out.println(new BigInteger(new byte[]{-22,11}).toString(16));  //  -15f5
        System.out.println(new BigInteger(new byte[]{-22,11})); //  -5621
                                                                //BIN(-5621):   1110 1010 0000 1011
                                                                //BIN(-22):     1110 1010
                                                                //BIN(11):                0000 1011

                                                                //HEX:            -1    5    f    5
                                                                //-5621  ：    ‭1001 0101 1111 0101‬

    まず、この構造方法がどのように結果を得たかを説明します.
  • バイト配列を巡回し、各バイトのコンピュータバイナリ記憶値(正数が原符号、負数が補符号、1バイト8ビット)
    • を得る.
  • は、得られたすべてのバイトのバイナリを接合し、単一の新しいバイナリ
    • を形成する.
    印刷結果は次のようになります.
  • 構築方法パラメータバイト配列0のインデックス位置(第1ビット)のバイトが負であると、構築生成された新しい単一バイナリが負(符号数付きバイナリ最上位1)
    • となる.
  • 逆に、構築方法パラメータバイト配列0のインデックス位置(第1ビット)のバイトが正であると、構築生成された新しい単一バイナリが正(符号数付きバイナリ最上位0)
    • となる.
    BigIntegerでのtoString(進数)メソッド
    印刷結果によって(16進文字列に回転する)結論が得られます.
  • BigIntegerパッケージは正数であり、元のコードで格納されている場合、この数のバイナリを直接16進文字列
    • を求める.
  • BigIntegerパッケージは負数であり、符号化で格納されている場合は、まず原符号を求め、その後16進文字列(符号化の符号化が原符号であるか、符号化の演算逆演算に基づいて原符号を得る)
    • を求める.
  • が16進法に移行すると、最上位シンボルビット0は+(省略可能)に移行し、最上位シンボルビット1は-に移行し、残りのビットは対応16進法
        ：
      16  ，       16   ，             ，      ，
    BigInteger       toString​(int radix)  16   ，        ，     16         0000-0111，
     0H--6H,    ，    ！
    • に移行する.
    構築方法:BigInteger(int signum,byte[]magnitude)
    BigInteger​(int signum, byte[] magnitude) 
    

        System.out.println(new BigInteger(new byte[]{-11}));       //   -11
                                                                   //BIN(-11):     ‭1111 0101
                                                                   //BIN(-11):     1111 0101

        System.out.println(new BigInteger(1, new byte[]{-11}));    //   245
                                                                   //BIN(245):     ‭1111 0101
                                                                   //BIN(-11):     1111 0101

        System.out.println(new BigInteger(1, new byte[]{11, 22})); //   2838
                                                                   //BIN(2838):    0000 ‭1011 0001 0110‬
                                                                   //BIN(11):      0000 1011
                                                                   //BIN(22):                ‭0001 0110‬

        System.out.println(new BigInteger(1, new byte[]{-11, 22}));//   62742
                                                                   //BIN(62742):   ‭1111 0101 ‭0001 0110‬
                                                                   //BIN(-11):     1111 0101
                                                                   //BIN(22):                ‭0001 0110‬

        System.out.println(new BigInteger(1, new byte[]{11, -22}));//   3050
                                                                   //BIN(3050):    0000 ‭1011 1110 1010‬
                                                                   //BIN(11):      0000 1011
                                                                   //BIN(-22):               1110 1010

        System.out.println(new BigInteger(1, new byte[]{-11, -22}));//   62954
                                                                    //BIN(62954):   ‭1111 0101 1110 1010‬
                                                                    //BIN(-11):     1111 0101
                                                                    //BIN(-22):               1110 1010

        System.out.println(new BigInteger(1, new byte[]{-11, -22,-33,-44}));//   4125810644
                                                                            //BIN(62954):   ‭1111 0101 1110 1010 1101 1111 1101 0100‬
                                                                            //BIN(-11):     1111 0101
                                                                            //BIN(-22):               1110 1010
                                                                            //BIN(-33):                         1101 1111
                                                                            //BIN(-44):                                   1101 0100

    まず、この構造方法がどのように結果を得たかを説明します.
  • バイト配列を巡回し、各バイトのコンピュータバイナリ記憶値(正数が原符号、負数が補符号、1バイト8ビット)
    • を得る.
  • は、得られたすべてのバイトのバイナリを接合し、単一の新しいバイナリ
    • を形成する.
  • 最初のパラメータint signumが1の場合、BigIntegerパッケージを表すデジタルコンピュータに格納されたバイナリは正
    • である.
  • 最初のパラメータint signumが0の場合、BigIntegerパッケージを表す数は0
    • である.
  • 最初のパラメータInt signumが-1の場合、BigIntegerパッケージを表すデジタルコンピュータに格納されたバイナリは負の
    • である.
    どういう意味ですか.意味:つなぎ合わせて一連のバイナリを形成し、このバイナリの最高位は0,1の可能性がある.このとき、最初のパラメータが1である場合、このバイナリの最上位が0であっても、1であっても、このバイナリ列は正数のバイナリを表す.すなわち、この列のバイナリの最高位が0(例:0101 0001、この列のバイナリが元のコード)である場合、正数を表す.この列のバイナリの最上位が1(例:1001 0001、この列のバイナリは補符号)である場合、この列のバイナリは元の符号として処理される.上のコードの先行コードの比較を見てみましょう.
    
        System.out.println(new BigInteger(new byte[]{-11}));       //   -11
                                                                   //BIN(-11):     ‭1111 0101
                                                                   //BIN(-11):     1111 0101

        System.out.println(new BigInteger(1, new byte[]{-11}));    //   245
                                                                   //BIN(245):     ‭1111 0101
                                                                   //BIN(-11):     1111 0101
  • 第1行の印刷結果は-11であり、第2行の印刷結果は245であるが、それらのバイト配列パラメータはすべて{-11}であり、-11のバイナリはコンピュータにおいて補符号1111 0101である.
  • の1行目の構成方法では、このとき1111 0101という列のバイナリがビギンテーガーに補符号として封入されているので、印刷時には、補符号に基づいて原数-11を算出して印刷される.
  • の2行目の構成方法では、このとき1111 0101という列のバイナリがBigIntegerに原コードとしてカプセル化されているので、印刷時に1111 0101をそのまま原コードとしてその値を印刷する.

    • 最初のパラメータが0の場合、バイト配列の接合の結果は0にすぎず、次のコードでエラーが発生します.
    
//        System.out.println(new BigInteger(0, new byte[]{-11, -22}));//   java.lang.NumberFormatException: signum-magnitude mismatch
//        System.out.println(new BigInteger(0, new byte[]{-11}));	  //   java.lang.NumberFormatException: signum-magnitude mismatch
        System.out.println(new BigInteger(0, new byte[]{0,0}));         //   0
        System.out.println(new BigInteger(0, new byte[]{0}));           //   0
        System.out.println(new BigInteger(0, new byte[]{}));            //   0

    最初のパラメータが−1の場合、このバイナリの最上位が0であっても1であっても、このバイナリ列は正数のバイナリを表す.そしてこの一連のバイナリの補符号を算出し,算出した補符号を補符号としてBigIntegerにカプセル化する.大まかに理解すると、バイト配列を巡回して各バイトのバイナリ格納値(正は原符号、負は補符号)を得た後、つなぎ合わせて単一のバイナリを得、このバイナリを原符号として補符号を求め、BigIntegerにカプセル化する.また,表象点理解では,1番目のパラメータが−1の場合,得られた結果は1番目のパラメータが1の結果を逆にすることである.
    
        System.out.println(new BigInteger(-1, new byte[]{11}));         //   -11
        System.out.println(new BigInteger(-1, new byte[]{-11}));        //   -245
        System.out.println(new BigInteger(-1, new byte[]{11, 22}));     //   -2838
        System.out.println(new BigInteger(-1, new byte[]{-11, 22}));    //   -62742
        System.out.println(new BigInteger(-1, new byte[]{11, -22}));    //   -3050
        System.out.println(new BigInteger(-1, new byte[]{-11, -22}));   //   -62954

    | | | |
    こんなにたくさん言って、ちょっとくどくどして、初志ではなく、もともとこの2つの構造方法がどのように使われているのかを簡単に記録したいだけです.では、少し簡単にまとめます.
    BigInteger(byte[]val):この構造方法は1つのバイト配列に伝達され、このバイト配列を遍歴し、各バイトのバイナリ(正は原符号、負は補符号)を得て、得られたバイナリを長いバイナリにつなぎ、BigIntegerにカプセル化します.このバイト配列の最初の要素が負の場合、新しい結合のバイナリは補符号であり、BigIntegerに負の数がカプセル化されます.このバイト配列の最初の要素が正の場合、新しいパッチのバイナリは元のコード、すなわちBigIntegerに正数がカプセル化されます.
    BigInteger(int signum,byte[]magnitude):二次構造法は2つのパラメータを伝達し、パラメータ1 signumはパッケージの結果が正、0、負であり、フラグビットに相当する.パラメータ2 magnitudeバイト配列は、パッケージの数値サイズを表します.この構成方法では、入力されたバイト配列を遍歴し、そのバイナリ記憶値(正数が原符号、負数が補符号)を得た後、順次新しいバイナリ列に接合し、signumが1であれば、新しい接合されたバイナリ列(最高ビットが0または1であっても)を原符号として処理する.signumが0の場合、バイト配列の遍歴接合後のバイナリ結果は0でなければならない.signumが-1の場合、新しく結合されたバイナリ列からsignumが1の値を求め、結果の前にマイナス記号「-」を付けます.
    toString(int radix):このメソッドは、基数、すなわち進数の基数を意味するパラメータradixを渡します.N進法の基数はNである.このメソッドはradix進数の文字列を返します.一般的には、BigInteger bigInteger=new BigInteger(new byte[]{11,22})というオブジェクトであり、bigInteger.toString(N進)呼び出しメソッドの後、bigIntegerに包まれた数をN進値の文字列に戻します.この方法には、10進数の文字列表示形式に黙々と移行する、**toString()**無パラメータのリロード方法があります.以上は個人的な理解ですが、参考までに、問題があればご指摘ください.
    Javaはメール送信機能を実現
    JAva jdbcを使用してアクセスアクセスを容易にする