com.github.paganini2008.devtools.primitives

类 Floats

java.lang.Object

com.github.paganini2008.devtools.primitives.Floats

public abstract class Floats
extends Object

Floats

版本:

1.0

作者:

Fred Feng

嵌套类概要

嵌套类

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

字段概要

字段

限定符和类型	字段和说明
static int	BYTES
private static LruMap<String,Float>	cache
static float[]	EMPTY_ARRAY
static Float[]	EMPTY_OBJECT_ARRAY

构造器概要

构造器

构造器和说明
Floats()

方法概要

限定符和类型	方法和说明
static float[]	add(float[] array, float a)
static double	avg(float[] array)
static boolean	between(float val, float start, float end)
static float	cast(boolean b)
static float	cast(char value)
static float	cast(Number n)
static float[]	casts(boolean[] value)
static float[]	casts(byte[] value)
static float[]	casts(char[] value)
static float[]	casts(double[] value)
static float[]	casts(double[] value, boolean thrown)
static float[]	casts(int[] value)
static float[]	casts(long[] value)
static float[]	casts(Number[] array)
static float[]	casts(Number[] array, boolean thrown)
static float[]	casts(short[] value)
static void	clearCache()
static float[]	clone(float[] array)
static int	compare(float a, float b)
static float[]	concat(float[] left, float[] right)
static boolean	contains(float[] a, float b)
static boolean	containsAll(float[] left, float[] right)
static float[]	copy(float[] array)
static float[]	copy(float[] array, int length)
static float[]	copy(float[] array, int startIndex, int length)
static float[]	copy(float[] array, int startIndex, int length, float defaultValue)
static float[]	create(int length)
static float[]	create(int length, float defaultValue)
static float[][]	create(int row, int column)
static float[][]	create(int row, int column, float defaultValue)
static boolean	deepEquals(float[] left, float[] right)
static int	deepHashCode(float[] args)
static Comparator<float[]>	defaultComparator()
static float[]	ensureCapacity(float[] array, int index)
static float[]	expandCapacity(float[] array)
static float[]	expandCapacity(float[] array, int size)
private static void	hardCopy(float[] src, int srcFrom, float[] dest, int destFrom, int length)
static int	hashCode(float arg)
static boolean	in(float val, float start, float end)
static int	indexOf(float[] a, float b)
static int	indexOf(float[] a, float b, int start, int end)
static float[]	intersect(float[] left, float[] right)
static boolean	isEmpty(float[] args)
static boolean	isFinite(float value)
static boolean	isNotEmpty(float[] args)
static boolean	isSameLength(float[] left, float[] right)
static boolean	isSerial(float[] array, float n)
static boolean	isSubarray(float[] left, float[] right)
static String	join(float[] array)
static String	join(float[] left, float[] right, String delimiter)
static String	join(float[] left, float[] right, String conjunction, String delimiter)
static String	join(float[] array, String delimiter)
static int	lastIndexOf(float[] a, float b)
static int	lastIndexOf(float[] a, float b, int start)
static boolean	leftIn(float val, float start, float end)
static void	leftScroll(float[] src, int n)
static int	length(float[] array)
static float	max(float[] array)
static float	max(float a, float b)
private static void	mergeSort(float[] src, float[] dest, int low, int high, boolean asc)
static float	min(float[] array)
static float	min(float a, float b)
static float[]	minus(float[] left, float[] right)
static boolean	notContains(float[] a, float b)
static float	parse(String str)
static float[]	parseMany(String[] strings)
static float[]	parseMany(String[] strings, boolean thrown)
private static float	parseStrictly(String str)
static float[]	remove(float[] array, float a)
static float[]	removeAt(float[] array, int index)
static void	reverse(float[] src)
static boolean	rightIn(float val, float start, float end)
static void	rightScroll(float[] src, int n)
private static void	rightScroll(float[] src, int n, int m)
static boolean	same(float[] array)
static void	shuffle(float[] src)
static void	shuffle(float[] src, Random rn)
static void	sort(float[] array, boolean asc)
private static void	sort(float[] array, int low, int high, boolean asc)
static float	sum(float[] array)
static void	swap(float[] x, int a, int b)
static float[]	toArray(Collection<?> collection)
static float	toFixed(float value, int scale)
static List<Float>	toList(float[] array)
static String	toPlainString(float value)
static float[]	toPrimitives(Byte[] array)
static float[]	toPrimitives(Character[] array)
static float[]	toPrimitives(Float[] array)
static float[]	toPrimitives(Integer[] array)
static float[]	toPrimitives(Long[] array)
static float[]	toPrimitives(Short[] array)
static String	toString(float[] array)
static String[]	toStringArray(float[] args, DecimalFormat df)
static Float[]	toWrappers(byte[] value)
static Float[]	toWrappers(char[] value)
static Float[]	toWrappers(float[] value)
static Float[]	toWrappers(int[] value)
static Float[]	toWrappers(long[] value)
static Float[]	toWrappers(short[] value)
static float[]	union(float[] left, float[] right)
static float[]	unionAll(float[] left, float[] right)
static Float	valueOf(Boolean b)
static Float	valueOf(Boolean b, Float defaultValue)
static Float	valueOf(Character c)
static Float	valueOf(Character c, Float defaultValue)
static Float[]	valueOf(Number[] array)
static Float[]	valueOf(Number[] array, Float defaultValue)
static Float	valueOf(Number n, Float defaultValue)
static Float	valueOf(String str)
static Float[]	valueOf(String[] strings)
static Float[]	valueOf(String[] strings, Float defaultValue)
static Float	valueOf(String str, Float defaultValue)

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

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

字段详细资料

EMPTY_ARRAY

public static final float[] EMPTY_ARRAY

EMPTY_OBJECT_ARRAY

public static final Float[] EMPTY_OBJECT_ARRAY

cache

private static final LruMap<String,Float> cache

BYTES

public static final int BYTES

另请参阅:

常量字段值

构造器详细资料

Floats

public Floats()

方法详细资料

clearCache

public static void clearCache()

clone

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

length

public static int length(float[] array)

isFinite

public static boolean isFinite(float value)

create

public static float[][] create(int row,
                               int column)

create

public static float[][] create(int row,
                               int column,
                               float defaultValue)

create

public static float[] create(int length)

create

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

isNotEmpty

public static boolean isNotEmpty(float[] args)

isEmpty

public static boolean isEmpty(float[] args)

notContains

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

contains

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

indexOf

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

indexOf

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

lastIndexOf

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

lastIndexOf

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

concat

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

add

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

remove

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

removeAt

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

copy

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

copy

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

copy

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

copy

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

hardCopy

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

toPrimitives

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

toPrimitives

public static float[] toPrimitives(Short[] array)

toPrimitives

public static float[] toPrimitives(Character[] array)

toPrimitives

public static float[] toPrimitives(Integer[] array)

toPrimitives

public static float[] toPrimitives(Long[] array)

toPrimitives

public static float[] toPrimitives(Float[] array)

ensureCapacity

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

expandCapacity

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

expandCapacity

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

max

public static float max(float[] array)

min

public static float min(float[] array)

sum

public static float sum(float[] array)

avg

public static double avg(float[] array)

toString

public static String toString(float[] array)

join

public static String join(float[] array)

join

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

join

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

join

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

swap

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

sort

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

sort

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

mergeSort

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

unionAll

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

union

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

minus

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

intersect

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

toArray

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

toList

public static List<Float> toList(float[] array)

reverse

public static void reverse(float[] src)

hashCode

public static int hashCode(float arg)

deepEquals

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

valueOf

public static Float valueOf(Character c)

valueOf

public static Float valueOf(Character c,
                            Float defaultValue)

valueOf

public static Float valueOf(Boolean b)

valueOf

public static Float valueOf(Boolean b,
                            Float defaultValue)

valueOf

public static Float valueOf(String str)

valueOf

public static Float valueOf(String str,
                            Float defaultValue)

valueOf

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

valueOf

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

parseMany

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

parseMany

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

parse

public static float parse(String str)

parseStrictly

private static float parseStrictly(String str)

cast

public static float cast(boolean b)

casts

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

cast

public static float cast(char value)

casts

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

casts

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

casts

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

cast

public static float cast(Number n)

casts

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

casts

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

valueOf

public static Float valueOf(Number n,
                            Float defaultValue)

valueOf

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

valueOf

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

toWrappers

public static Float[] toWrappers(byte[] value)

toWrappers

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

toWrappers

public static Float[] toWrappers(short[] value)

toWrappers

public static Float[] toWrappers(float[] value)

toWrappers

public static Float[] toWrappers(int[] value)

toWrappers

public static Float[] toWrappers(long[] value)

casts

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

casts

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

casts

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

casts

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

deepHashCode

public static int deepHashCode(float[] args)

toFixed

public static float toFixed(float value,
                            int scale)

toPlainString

public static String toPlainString(float value)

toStringArray

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

isSameLength

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

same

public static boolean same(float[] array)

isSerial

public static boolean isSerial(float[] array,
                               float n)

isSubarray

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

containsAll

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

leftScroll

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

rightScroll

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

rightScroll

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

max

public static float max(float a,
                        float b)

min

public static float min(float a,
                        float b)

between

public static boolean between(float val,
                              float start,
                              float end)

rightIn

public static boolean rightIn(float val,
                              float start,
                              float end)

leftIn

public static boolean leftIn(float val,
                             float start,
                             float end)

in

public static boolean in(float val,
                         float start,
                         float end)

shuffle

public static void shuffle(float[] src)

shuffle

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

compare

public static int compare(float a,
                          float b)

defaultComparator

public static Comparator<float[]> defaultComparator()