com.github.paganini2008.devtools.primitives

类 Bytes

java.lang.Object

com.github.paganini2008.devtools.primitives.Bytes

public abstract class Bytes
extends Object

Bytes

版本:

1.0

作者:

Fred Feng

嵌套类概要

嵌套类

限定符和类型	类和说明
private static class	Bytes.LexicographicalComparator

字段概要

字段

限定符和类型	字段和说明
private static LruMap<String,Byte>	cache
static byte[]	EMPTY_ARRAY
static Byte[]	EMPTY_OBJECT_ARRAY

构造器概要

构造器

构造器和说明
Bytes()

方法概要

限定符和类型	方法和说明
static byte[]	add(byte[] array, byte a)
static double	avg(byte[] array)
static byte	cast(BigDecimal value)
static byte	cast(BigInteger value)
static byte	cast(boolean b)
static byte	cast(char c)
static byte	cast(long value)
static byte	cast(Number value)
static byte[]	casts(boolean[] value)
static byte[]	casts(char[] value)
static byte[]	casts(char[] value, boolean thrown)
static byte[]	casts(double[] value)
static byte[]	casts(double[] value, boolean thrown)
static byte[]	casts(float[] value)
static byte[]	casts(float[] value, boolean thrown)
static byte[]	casts(int[] value)
static byte[]	casts(int[] value, boolean thrown)
static byte[]	casts(long[] value)
static byte[]	casts(long[] value, boolean thrown)
static byte[]	casts(Number[] array)
static byte[]	casts(Number[] array, boolean thrown)
static byte[]	casts(short[] value)
static byte[]	casts(short[] value, boolean thrown)
static void	clearCache()
static byte[]	clone(byte[] array)
static int	compare(byte a, byte b)
static byte[]	concat(byte[] left, byte[] right)
static boolean	contains(byte[] a, byte b)
static boolean	containsAll(byte[] left, byte[] right)
static byte[]	copy(byte[] array)
static byte[]	copy(byte[] array, int length)
static byte[]	copy(byte[] array, int startIndex, int length)
static byte[]	copy(byte[] array, int startIndex, int length, byte defaultValue)
static byte[]	create(int length, byte defaultValue)
static byte[][]	create(int yLength, int xLength, byte defaultValue)
static boolean	deepEquals(byte[] left, byte[] right)
static int	deepHashCode(byte[] args)
static Comparator<byte[]>	defaultComparator()
static byte[]	ensureCapacity(byte[] array, int index)
static byte[]	expandCapacity(byte[] array)
static byte[]	expandCapacity(byte[] array, int size)
private static void	hardCopy(byte[] src, int srcFrom, byte[] dest, int destFrom, int length)
static int	hashCode(byte arg)
static int	indexOf(byte[] a, byte b)
static int	indexOf(byte[] a, byte b, int start)
static int	indexOf(byte[] a, byte b, int start, int end)
static byte[]	intersect(byte[] left, byte[] right)
static boolean	isEmpty(byte[] args)
static boolean	isEven(byte value)
static boolean	isEvens(byte[] values)
static boolean	isNotEmpty(byte[] args)
static boolean	isOdd(byte value)
static boolean	isOdds(byte[] values)
static boolean	isSameLength(byte[] left, byte[] right)
static boolean	isSerial(byte[] array)
static boolean	isSerial(byte[] array, int n)
static boolean	isSubarray(byte[] left, byte[] right)
static String	join(byte[] array)
static String	join(byte[] left, byte[] right, String delimiter)
static String	join(byte[] left, byte[] right, String conjunction, String delimiter)
static String	join(byte[] array, String delimiter)
static int	lastIndexOf(byte[] a, byte b)
static int	lastIndexOf(byte[] a, byte b, int start)
static void	leftScroll(byte[] src, int n)
static int	length(byte[] array)
static int	max(byte[] array)
private static void	mergeSort(byte[] src, byte[] dest, int low, int high, boolean asc)
static int	min(byte[] array)
static byte[]	minus(byte[] left, byte[] right)
static boolean	notContains(byte[] a, byte b)
static byte	parse(String str)
static byte[]	parseMany(String[] strings)
static byte[]	parseMany(String[] strings, boolean thrown)
private static byte	parseStrictly(String str)
static byte[]	remove(byte[] array, byte a)
static byte[]	removeAt(byte[] array, int index)
static void	reverse(byte[] src)
static void	rightScroll(byte[] src, int n)
private static void	rightScroll(byte[] src, int n, int m)
static boolean	same(byte[] array)
static void	shuffle(byte[] src)
static void	shuffle(byte[] src, Random rn)
static void	sort(byte[] array, boolean asc)
private static void	sort(byte[] array, int low, int high, boolean asc)
static int	sum(byte[] array)
static void	swap(byte[] x, int a, int b)
static byte[]	toArray(Collection<?> collection)
static boolean	toBoolean(byte[] b)
static byte[]	toByteArray(ByteBuffer bb)
static byte[]	toByteArray(ByteBuffer bb, byte[] defaultValue)
static byte[]	toBytes(boolean b)
static byte[]	toBytes(char c)
static byte[]	toBytes(double d)
static byte[]	toBytes(float f)
static byte[]	toBytes(int i)
static byte[]	toBytes(long l)
static byte[]	toBytes(short s)
static char	toChar(byte[] b)
static double	toDouble(byte[] b)
static float	toFloat(byte[] b)
static int	toInt(byte[] b)
static List<Byte>	toList(byte[] array)
static long	toLong(byte[] b)
static byte[]	toPrimitives(Byte[] array)
static short	toShort(byte[] b)
static String	toString(byte[] array)
static String[]	toStringArray(byte[] args, DecimalFormat df)
static Byte[]	toWrappers(boolean[] value)
static Byte[]	toWrappers(byte[] array)
static Byte[]	toWrappers(char[] value)
static byte[]	union(byte[] left, byte[] right)
static byte[]	unionAll(byte[] left, byte[] right)
static Byte	valueOf(Boolean b)
static Byte	valueOf(Boolean b, Byte defaultValue)
static Byte	valueOf(Character ch)
static Byte	valueOf(Character ch, Byte defaultValue)
static Byte	valueOf(Number n)
static Byte[]	valueOf(Number[] array)
static Byte[]	valueOf(Number[] array, Byte defaultValue)
static Byte	valueOf(Number n, Byte defaultValue)
static Byte	valueOf(String str)
static Byte[]	valueOf(String[] strings)
static Byte[]	valueOf(String[] strings, Byte defaultValue)
static Byte	valueOf(String str, Byte defaultValue)

从类继承的方法 java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

字段详细资料

EMPTY_ARRAY

public static final byte[] EMPTY_ARRAY

EMPTY_OBJECT_ARRAY

public static final Byte[] EMPTY_OBJECT_ARRAY

cache

private static final LruMap<String,Byte> cache

构造器详细资料

Bytes

public Bytes()

方法详细资料

clearCache

public static void clearCache()

clone

public static byte[] clone(byte[] array)

length

public static int length(byte[] array)

create

public static byte[][] create(int yLength,
                              int xLength,
                              byte defaultValue)

create

public static byte[] create(int length,
                            byte defaultValue)

isNotEmpty

public static boolean isNotEmpty(byte[] args)

isEmpty

public static boolean isEmpty(byte[] args)

notContains

public static boolean notContains(byte[] a,
                                  byte b)

contains

public static boolean contains(byte[] a,
                               byte b)

indexOf

public static int indexOf(byte[] a,
                          byte b)

indexOf

public static int indexOf(byte[] a,
                          byte b,
                          int start)

indexOf

public static int indexOf(byte[] a,
                          byte b,
                          int start,
                          int end)

lastIndexOf

public static int lastIndexOf(byte[] a,
                              byte b)

lastIndexOf

public static int lastIndexOf(byte[] a,
                              byte b,
                              int start)

concat

public static byte[] concat(byte[] left,
                            byte[] right)

add

public static byte[] add(byte[] array,
                         byte a)

remove

public static byte[] remove(byte[] array,
                            byte a)

removeAt

public static byte[] removeAt(byte[] array,
                              int index)

copy

public static byte[] copy(byte[] array)

copy

public static byte[] copy(byte[] array,
                          int length)

copy

public static byte[] copy(byte[] array,
                          int startIndex,
                          int length)

copy

public static byte[] copy(byte[] array,
                          int startIndex,
                          int length,
                          byte defaultValue)

hardCopy

private static void hardCopy(byte[] src,
                             int srcFrom,
                             byte[] dest,
                             int destFrom,
                             int length)

toWrappers

public static Byte[] toWrappers(char[] value)

toWrappers

public static Byte[] toWrappers(boolean[] value)

toWrappers

public static Byte[] toWrappers(byte[] array)

toPrimitives

public static byte[] toPrimitives(Byte[] array)

ensureCapacity

public static byte[] ensureCapacity(byte[] array,
                                    int index)

expandCapacity

public static byte[] expandCapacity(byte[] array)

expandCapacity

public static byte[] expandCapacity(byte[] array,
                                    int size)

max

public static int max(byte[] array)

min

public static int min(byte[] array)

sum

public static int sum(byte[] array)

avg

public static double avg(byte[] array)

toString

public static String toString(byte[] array)

join

public static String join(byte[] array)

join

public static String join(byte[] array,
                          String delimiter)

join

public static String join(byte[] left,
                          byte[] right,
                          String delimiter)

join

public static String join(byte[] left,
                          byte[] right,
                          String conjunction,
                          String delimiter)

swap

public static void swap(byte[] x,
                        int a,
                        int b)

sort

private static void sort(byte[] array,
                         int low,
                         int high,
                         boolean asc)

sort

public static void sort(byte[] array,
                        boolean asc)

mergeSort

private static void mergeSort(byte[] src,
                              byte[] dest,
                              int low,
                              int high,
                              boolean asc)

unionAll

public static byte[] unionAll(byte[] left,
                              byte[] right)

union

public static byte[] union(byte[] left,
                           byte[] right)

minus

public static byte[] minus(byte[] left,
                           byte[] right)

intersect

public static byte[] intersect(byte[] left,
                               byte[] right)

toArray

public static byte[] toArray(Collection<?> collection)

toList

public static List<Byte> toList(byte[] array)

reverse

public static void reverse(byte[] src)

hashCode

public static int hashCode(byte arg)

deepEquals

public static boolean deepEquals(byte[] left,
                                 byte[] right)

valueOf

public static Byte valueOf(Boolean b)

valueOf

public static Byte valueOf(Boolean b,
                           Byte defaultValue)

valueOf

public static Byte valueOf(Character ch)

valueOf

public static Byte valueOf(Character ch,
                           Byte defaultValue)

valueOf

public static Byte valueOf(String str)

valueOf

public static Byte valueOf(String str,
                           Byte defaultValue)

valueOf

public static Byte[] valueOf(String[] strings)

valueOf

public static Byte[] valueOf(String[] strings,
                             Byte defaultValue)

parseMany

public static byte[] parseMany(String[] strings)

parseMany

public static byte[] parseMany(String[] strings,
                               boolean thrown)

parse

public static byte parse(String str)

parseStrictly

private static byte parseStrictly(String str)

casts

public static byte[] casts(int[] value)

casts

public static byte[] casts(int[] value,
                           boolean thrown)

casts

public static byte[] casts(short[] value)

casts

public static byte[] casts(short[] value,
                           boolean thrown)

casts

public static byte[] casts(long[] value)

casts

public static byte[] casts(long[] value,
                           boolean thrown)

casts

public static byte[] casts(float[] value)

casts

public static byte[] casts(float[] value,
                           boolean thrown)

casts

public static byte[] casts(double[] value)

casts

public static byte[] casts(double[] value,
                           boolean thrown)

cast

public static byte cast(boolean b)

casts

public static byte[] casts(boolean[] value)

casts

public static byte[] casts(char[] value)

casts

public static byte[] casts(char[] value,
                           boolean thrown)

cast

public static byte cast(char c)

cast

public static byte cast(Number value)

cast

public static byte cast(long value)

cast

public static byte cast(BigDecimal value)

cast

public static byte cast(BigInteger value)

casts

public static byte[] casts(Number[] array)

casts

public static byte[] casts(Number[] array,
                           boolean thrown)

valueOf

public static Byte valueOf(Number n)

valueOf

public static Byte valueOf(Number n,
                           Byte defaultValue)

valueOf

public static Byte[] valueOf(Number[] array)

valueOf

public static Byte[] valueOf(Number[] array,
                             Byte defaultValue)

deepHashCode

public static int deepHashCode(byte[] args)

toStringArray

public static String[] toStringArray(byte[] args,
                                     DecimalFormat df)

isEven

public static boolean isEven(byte value)

isEvens

public static boolean isEvens(byte[] values)

isOdds

public static boolean isOdds(byte[] values)

isOdd

public static boolean isOdd(byte value)

isSameLength

public static boolean isSameLength(byte[] left,
                                   byte[] right)

same

public static boolean same(byte[] array)

isSerial

public static boolean isSerial(byte[] array)

isSerial

public static boolean isSerial(byte[] array,
                               int n)

isSubarray

public static boolean isSubarray(byte[] left,
                                 byte[] right)

containsAll

public static boolean containsAll(byte[] left,
                                  byte[] right)

leftScroll

public static void leftScroll(byte[] src,
                              int n)

rightScroll

public static void rightScroll(byte[] src,
                               int n)

rightScroll

private static void rightScroll(byte[] src,
                                int n,
                                int m)

shuffle

public static void shuffle(byte[] src)

shuffle

public static void shuffle(byte[] src,
                           Random rn)

toBytes

public static byte[] toBytes(boolean b)

toBoolean

public static boolean toBoolean(byte[] b)

toBytes

public static byte[] toBytes(char c)

toChar

public static char toChar(byte[] b)

toBytes

public static byte[] toBytes(short s)

toShort

public static short toShort(byte[] b)

toBytes

public static byte[] toBytes(int i)

toInt

public static int toInt(byte[] b)

toBytes

public static byte[] toBytes(long l)

toLong

public static long toLong(byte[] b)

toBytes

public static byte[] toBytes(double d)

toBytes

public static byte[] toBytes(float f)

toFloat

public static float toFloat(byte[] b)

toDouble

public static double toDouble(byte[] b)

toByteArray

public static byte[] toByteArray(ByteBuffer bb)

toByteArray

public static byte[] toByteArray(ByteBuffer bb,
                                 byte[] defaultValue)

defaultComparator

public static Comparator<byte[]> defaultComparator()

compare

public static int compare(byte a,
                          byte b)