Bin (SoftLib 1.1.14-SNAPSHOT API)

java.lang.Object
- net.siisise.lang.Bin

```
public class Bin
extends Object
```
名前候補 BinかHex Hexというよりバイト列変換の主なもの. 配列をintやlongとbyteで変換してみたり、ちょっとしたbit演算をまとめて実行するだけのまとまり. HexとBASE64は統合したいかもしれない Number べーす java.util.BitSet があるらしいが変換には向かないので使わない.

コンストラクタのサマリー

コンストラクタ
コンストラクタと説明

Bin()

コンストラクタ
コンストラクタと説明
`Bin()`

メソッドのサマリー

すべてのメソッド staticメソッド concreteメソッド非推奨のメソッド
修飾子とタイプ	メソッドと説明
`static byte[]`	`and(byte[] a, byte[] b)` aの長さ合わせAND.
`static byte[]`	`and(byte[] a, int aoffset, byte[] b, int boffset, byte[] ret)` 左詰めAND.
`static int[]`	`btoi(byte[] src)` byte[]をint[]に変換する.
`static int[]`	`btoi(byte[] src, int offset, int length)` byte列の一部をint列に変換する
`static void`	`btoi(byte[] src, int offset, int[] dst, int length)` byte[]をint[]に変換する.
`static long[]`	`btol(byte[] src)` byte[]をlong[]に変換する.
`static long[]`	`btol(byte[] src, int offset, int length)` byte列の一部をlong列に変換する
`static void`	`btol(byte[] src, int offset, long[] dst, int length)` byte列の一部をlong列に変換する
`static void`	`inc(byte[] src)` byte列を大きな数値として+1する
`static void`	`inc(long[] src)` long列を大きな数値として+1する
`static byte[]`	`itob(int[] src)` int列をbyte列に変換する.
`static byte[]`	`itob(int[] src, byte[] ss, int doffset)` int[]をbyte[]に戻す.
`static byte[]`	`itob(int[] src, int offset, int len)` int列の一部をbyte列に変換する
`static long[]`	`itol(int[] src)` int列をlong列に変換する
`static void`	`itol(int[] src, int offset, long[] dst, int length)` byte列の一部をlong列に変換する
`static byte[]`	`left(byte[] a, int shift)` MSB が配列 0 側にある想定のシフト演算
`static byte[]`	`ltob(long[] src)` long列をbyte列に変換する
`static byte[]`	`ltob(long[] src, byte[] ss, int doffset)` long[] to byte[].
`static byte[]`	`ltob(long[] src, int offset, int srclen)` long列の一部をbyte列に変換する
`static int[]`	`ltoi(long[] src)` long列をint列に変換する
`static int[]`	`ltoi(long[] src, int offset, int length)` long列の一部をint列に変換する
`static void`	`ltoi(long[] src, int offset, int[] dst, int length)` long列の一部をint列に変換する
`static byte[]`	`not(byte[] a)`
`static byte[]`	`not(byte[] a, int aoffset, byte[] ret)`
`static byte[]`	`or(byte[] a, byte[] b)`
`static byte[]`	`or(byte[] a, int aoffset, byte[] b, int boffset, byte[] ret)` OR
`static byte[]`	`right(byte[] a, int shift)`
`static byte[]`	`rol(byte[] a)`
`static byte[]`	`ror(byte[] a)` 右1bit rotate
`static int[]`	`ror(int[] a)` 右1bit rotate
`static long[]`	`ror(long[] a)`
`static byte[]`	`shl(byte[] a)` Big endian 左シフト
`static long[]`	`shl(long[] a)` Big endian 左シフト
`static byte[]`	`shr(byte[] a)` 右1bitシフト
`static int[]`	`shr(int[] a)` 右1bitシフト
`static long[]`	`shr(long[] a)` 右1bitシフト
`static byte[]`	`toByte(int i)` intを4バイトに変換する
`static byte[]`	`toByte(int i, byte[] out, int offset)` int を out の offset位置から big endian 4バイトで書き込む.
`static byte[]`	`toByte(long l)` longをbig endian 8バイトに変換する
`static byte[]`	`toByte(long l, byte[] out, int offset)` long を out の offset位置から big endian 8バイトで書き込む.
`static byte[]`	`toByte(short i)` short を big endian 2バイトに変換する
`static byte[]`	`toByte(short i, byte[] out, int offset)` short を out の offset位置から big endian 2バイトで書き込む.
`static byte[]`	`toByteArray(BigInteger num, int length)` new BigInteger(byte[]) の逆にしたい.
`static byte[]`	`toByteArray(char[] txt)`
`static byte[]`	`toByteArray(char[] txt, int radixBase)` n進数を変換する試み. 2進数からHEX64まで対応したりしなかったり BigIntegerでまわすのでスピードは期待しない方向で 36進数までは 0-9,a-z,A-Z 62進数まではa-zとA-Zを区別する 64進数までは記号をいくつか
`static byte[]`	`toByteArray(char[] hex, int offset, int length)` 16進数をバイト列に変換する。
`static byte[]`	`toByteArray(CharSequence src)` 16進数をバイト列に変換する。
`static byte[]`	`toByteArray(String src)` 16進数をバイト列に変換する。
`static String`	`toHex(byte[] src)` バイト列を16進数(小文字)に変換する.
`static String`	`toUpperHex(byte[] src)` バイト列を16進数(大文字)に変換する.
`static byte[]`	`xor(byte[] a, byte[] b)` XORを計算するよ
`static byte[]`	`xor(byte[] a, int aoffset, byte[] b, int boffset, byte[] ret, int roffset)` 非推奨です。まだ未確定
`static long[]`	`xor(long[] a, int aoffset, long[] b, int boffset, long[] ret)` a と b の offset からの xor.
`static long[]`	`xor(long[] a, long[] b)` aとbのxorを返す.
`static byte[]`	`xorl(byte[] a, byte[] b)` a と b の xor 計算を a に戻す
`static long[]`	`xorl(long[] a, long[] b)` long列のXOR

クラスから継承されたメソッド java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- コンストラクタの詳細
  - Bin
```
public Bin()
```
- メソッドの詳細
  - toHex
```
public static String toHex(byte[] src)
```
    バイト列を16進数(小文字)に変換する.
    
    パラメータ:
    
    src - バイト列
    
    戻り値:
    
    16進文字列
  - toUpperHex
```
public static String toUpperHex(byte[] src)
```
    バイト列を16進数(大文字)に変換する.
    
    パラメータ:
    
    src - バイト列
    
    戻り値:
    
    16進文字列(大文字)
  - toByteArray
```
public static byte[] toByteArray(CharSequence src)
```
    16進数をバイト列に変換する。
    
    パラメータ:
    
    src - 2の倍数の長さ限定 16進数文字列
    
    戻り値:
    
    バイト列
  - toByteArray
```
public static byte[] toByteArray(String src)
```
    16進数をバイト列に変換する。
    
    パラメータ:
    
    src - 2の倍数の長さ限定 16進数文字列
    
    戻り値:
    
    バイト列
  - toByteArray
```
public static byte[] toByteArray(char[] txt)
```
  - toByteArray
```
public static byte[] toByteArray(char[] hex,
                                 int offset,
                                 int length)
```
    16進数をバイト列に変換する。
    
    パラメータ:
    
    hex - 2の倍数の長さ限定 16進数文字列
    
    offset - txt の16進数の位置
    
    length - txt の16進数の長さ
    
    戻り値:
    
    バイト列
  - toByteArray
```
public static byte[] toByteArray(char[] txt,
                                 int radixBase)
```
    n進数を変換する試み. 2進数からHEX64まで対応したりしなかったり BigIntegerでまわすのでスピードは期待しない方向で 36進数までは 0-9,a-z,A-Z 62進数まではa-zとA-Zを区別する 64進数までは記号をいくつか
    
    パラメータ:
    
    txt - baae64まで
    
    radixBase - 6まで
    
    戻り値:
  - toByteArray
```
public static byte[] toByteArray(BigInteger num,
                                 int length)
```
    new BigInteger(byte[]) の逆にしたい.
    
    パラメータ:
    
    num - バイト列をBigInteger にしたもの
    
    length - 最短バイト長
    
    戻り値:
    
    最短バイト長より長いこともある
  - toByte
```
public static byte[] toByte(short i)
```
    short を big endian 2バイトに変換する
    
    パラメータ:
    
    i - 数値
    
    戻り値:
    
    2バイト列
  - toByte
```
public static byte[] toByte(short i,
                            byte[] out,
                            int offset)
```
    short を out の offset位置から big endian 2バイトで書き込む.
    
    パラメータ:
    
    i - 数値
    
    out - 書き込む先
    
    offset - 書き込み位置
    
    戻り値:
    
    outと同じ列
  - toByte
```
public static byte[] toByte(int i)
```
    intを4バイトに変換する
    
    パラメータ:
    
    i - 入力値
    
    戻り値:
    
    4バイト列
  - toByte
```
public static byte[] toByte(int i,
                            byte[] out,
                            int offset)
```
    int を out の offset位置から big endian 4バイトで書き込む.
    
    パラメータ:
    
    i - 数値
    
    out - 書き込む先
    
    offset - 書き込み位置
    
    戻り値:
    
    outと同じ列
  - toByte
```
public static byte[] toByte(long l)
```
    longをbig endian 8バイトに変換する
    
    パラメータ:
    
    l - 入力値
    
    戻り値:
    
    8バイト列
  - toByte
```
public static byte[] toByte(long l,
                            byte[] out,
                            int offset)
```
    long を out の offset位置から big endian 8バイトで書き込む.
    
    パラメータ:
    
    l - 数値
    
    out - 書き込む先
    
    offset - 書き込み位置
    
    戻り値:
    
    outと同じ列
  - and
```
public static byte[] and(byte[] a,
                         int aoffset,
                         byte[] b,
                         int boffset,
                         byte[] ret)
```
    左詰めAND. c = a AND b returnでcとして返すタイプ
    
    パラメータ:
    
    a - 長さの基準
    
    aoffset - aの開始位置
    
    b -
    
    boffset - bの開始位置
    
    ret - 長さの制限
    
    戻り値:
    
    a AND b 新配列
  - and
```
public static byte[] and(byte[] a,
                         byte[] b)
```
    aの長さ合わせAND. bが短いときは0埋め.
    
    パラメータ:
    
    a -
    
    b -
    
    戻り値:
  - or
```
public static byte[] or(byte[] a,
                        int aoffset,
                        byte[] b,
                        int boffset,
                        byte[] ret)
```
    OR
    
    パラメータ:
    
    a - 長さの基準
    
    aoffset -
    
    b -
    
    boffset -
    
    ret -
    
    戻り値:
    
    a OR b
  - or
```
public static byte[] or(byte[] a,
                        byte[] b)
```
  - xor
```
public static byte[] xor(byte[] a,
                         int aoffset,
                         byte[] b,
                         int boffset,
                         byte[] ret,
                         int roffset)
```
    非推奨です。まだ未確定
    
    ret = a XOR b
    
    パラメータ:
    
    a -
    
    aoffset -
    
    b -
    
    boffset -
    
    ret -
    
    roffset -
    
    戻り値:
    
    a XOR b
  - xor
```
public static byte[] xor(byte[] a,
                         byte[] b)
```
    XORを計算するよ
    
    パラメータ:
    
    a - バイト列長さの基準
    
    b - バイト列
    
    戻り値:
    
    a ^ b
  - xorl
```
public static byte[] xorl(byte[] a,
                          byte[] b)
```
    a と b の xor 計算を a に戻す
    
    パラメータ:
    
    a - 結果もこっちへ
    
    b -
    
    戻り値:
    
    a = a ^ b
  - xorl
```
public static long[] xorl(long[] a,
                          long[] b)
```
    long列のXOR
    
    パラメータ:
    
    a -
    
    b -
    
    戻り値:
    
    a = a ^ b
  - xor
```
public static long[] xor(long[] a,
                         int aoffset,
                         long[] b,
                         int boffset,
                         long[] ret)
```
    a と b の offset からの xor.
    
    パラメータ:
    
    a - 入力a
    
    aoffset - aのバイト位置
    
    b - 入力b
    
    boffset - bのバイト位置
    
    ret - 結果格納用
    
    戻り値:
    
    retと同じ
  - xor
```
public static long[] xor(long[] a,
                         long[] b)
```
    aとbのxorを返す.
    
    パラメータ:
    
    a - 入力a
    
    b - 入力b
    
    戻り値:
    
    xor結果, 長さはaと同じ
  - not
```
public static byte[] not(byte[] a,
                         int aoffset,
                         byte[] ret)
```
  - not
```
public static byte[] not(byte[] a)
```
  - shl
```
public static byte[] shl(byte[] a)
```
    Big endian 左シフト
    
    パラメータ:
    
    a - 元列
    
    戻り値:
    
    1ビット左シフト
  - shl
```
public static long[] shl(long[] a)
```
    Big endian 左シフト
    
    パラメータ:
    
    a - 元列
    
    戻り値:
    
    シフトした列
  - rol
```
public static byte[] rol(byte[] a)
```
  - left
```
public static byte[] left(byte[] a,
                          int shift)
```
    MSB が配列 0 側にある想定のシフト演算
    
    パラメータ:
    
    a - 配列
    
    shift - シフトビット数とりあえず 0 から 7
    
    戻り値:
    
    シフトされた列
  - shr
```
public static byte[] shr(byte[] a)
```
    右1bitシフト
    
    パラメータ:
    
    a - 元列
    
    戻り値:
    
    右シフト
  - shr
```
public static int[] shr(int[] a)
```
    右1bitシフト
    
    パラメータ:
    
    a - 非破壊
    
    戻り値:
    
    右シフト
  - shr
```
public static long[] shr(long[] a)
```
    右1bitシフト
    
    パラメータ:
    
    a - 非破壊
    
    戻り値:
    
    右シフト
  - ror
```
public static byte[] ror(byte[] a)
```
    右1bit rotate
    
    パラメータ:
    
    a - 非破壊
    
    戻り値:
  - ror
```
public static int[] ror(int[] a)
```
    右1bit rotate
    
    パラメータ:
    
    a - 非破壊
    
    戻り値:
  - ror
```
public static long[] ror(long[] a)
```
    パラメータ:
    
    a - 非破壊
    
    戻り値:
  - right
```
public static byte[] right(byte[] a,
                           int shift)
```
  - btoi
```
public static final int[] btoi(byte[] src)
```
    byte[]をint[]に変換する.
    
    パラメータ:
    
    src - byte列
    
    戻り値:
    
    int列
  - btol
```
public static final long[] btol(byte[] src)
```
    byte[]をlong[]に変換する.
    
    パラメータ:
    
    src - byte列
    
    戻り値:
    
    long列
  - itob
```
public static byte[] itob(int[] src)
```
    int列をbyte列に変換する.
    
    パラメータ:
    
    src - int配列
    
    戻り値:
    
    byte配列
  - ltob
```
public static byte[] ltob(long[] src)
```
    long列をbyte列に変換する
    
    パラメータ:
    
    src - long列
    
    戻り値:
    
    byte列
  - ltoi
```
public static final int[] ltoi(long[] src)
```
    long列をint列に変換する
    
    パラメータ:
    
    src - long列
    
    戻り値:
    
    int列
  - itol
```
public static final long[] itol(int[] src)
```
    int列をlong列に変換する
    
    パラメータ:
    
    src - int列
    
    戻り値:
    
    long列
  - itob
```
public static final byte[] itob(int[] src,
                                int offset,
                                int len)
```
    int列の一部をbyte列に変換する
    
    パラメータ:
    
    src - int列
    
    offset - 位置
    
    len - 長さ
    
    戻り値:
    
    byte列
  - btoi
```
public static final int[] btoi(byte[] src,
                               int offset,
                               int length)
```
    byte列の一部をint列に変換する
    
    パラメータ:
    
    src - byte列
    
    offset - 位置
    
    length - 長さ
    
    戻り値:
    
    int列
  - btol
```
public static final long[] btol(byte[] src,
                                int offset,
                                int length)
```
    byte列の一部をlong列に変換する
    
    パラメータ:
    
    src - byte列
    
    offset - 位置
    
    length - 長さ
    
    戻り値:
    
    long列
  - ltoi
```
public static final int[] ltoi(long[] src,
                               int offset,
                               int length)
```
    long列の一部をint列に変換する
    
    パラメータ:
    
    src - long列
    
    offset - src位置
    
    length - src長さ
    
    戻り値:
    
    int列
  - ltob
```
public static byte[] ltob(long[] src,
                          int offset,
                          int srclen)
```
    long列の一部をbyte列に変換する
    
    パラメータ:
    
    src - long列
    
    offset - src位置
    
    srclen - src長さ
    
    戻り値:
    
    byte列
  - btol
```
public static final void btol(byte[] src,
                              int offset,
                              long[] dst,
                              int length)
```
    byte列の一部をlong列に変換する
    
    パラメータ:
    
    src - 転送元byte列
    
    offset - 転送元位置
    
    dst - 転送先long列
    
    length - 転送先長
  - itol
```
public static final void itol(int[] src,
                              int offset,
                              long[] dst,
                              int length)
```
    byte列の一部をlong列に変換する
    
    パラメータ:
    
    src - byte列
    
    offset - src位置
    
    dst - long列
    
    length - 長さ
  - btoi
```
public static void btoi(byte[] src,
                        int offset,
                        int[] dst,
                        int length)
```
    byte[]をint[]に変換する.
    
    パラメータ:
    
    src - バイト列
    
    offset - src位置
    
    dst - 戻りint列
    
    length - int長
  - ltoi
```
public static void ltoi(long[] src,
                        int offset,
                        int[] dst,
                        int length)
```
    long列の一部をint列に変換する
    
    パラメータ:
    
    src - long列
    
    offset - src位置
    
    dst - 戻りint列
    
    length - 長さ
  - itob
```
public static byte[] itob(int[] src,
                          byte[] ss,
                          int doffset)
```
    int[]をbyte[]に戻す.
    
    パラメータ:
    
    src -
    
    ss -
    
    doffset -
    
    戻り値:
  - ltob
```
public static final byte[] ltob(long[] src,
                                byte[] ss,
                                int doffset)
```
    long[] to byte[].
    
    パラメータ:
    
    src -
    
    ss -
    
    doffset -
    
    戻り値:
  - inc
```
public static final void inc(byte[] src)
```
    byte列を大きな数値として+1する
    
    パラメータ:
    
    src - 数値1つぶん
  - inc
```
public static final void inc(long[] src)
```
    long列を大きな数値として+1する
    
    パラメータ:
    
    src - 数値1つぶん

クラス Bin

コンストラクタのサマリー

メソッドのサマリー

クラスから継承されたメソッド java.lang.Object

コンストラクタの詳細

Bin

メソッドの詳細

toHex

toUpperHex

toByteArray

toByteArray

toByteArray

toByteArray

toByteArray

toByteArray

toByte

toByte

toByte

toByte

toByte

toByte

and

and

or

or

xor

xor

xorl

xorl

xor

xor

not

not

shl

shl

rol

left

shr

shr

shr

ror

ror

ror

right

btoi

btol

itob

ltob

ltoi

itol

itob

btoi

btol

ltoi

ltob

btol

itol

btoi

ltoi

itob

ltob

inc

inc