深入学习java源码之Float.valueOf()与Float.sum()

深入学习java源码之ArrayList.iterator()与ArrayList.sum() 

float 型： 占 4 字节，7 位有效数字

double 型：占 8 字节，15～16 位有效数字

 

Comparable接口

此接口强行对实现它的每个类的对象进行整体排序。此排序被称为该类的自然排序 ，类的 compareTo 方法被称为它的自然比较方法 。实现此接口的对象列表（和数组）可以通过 Collections.sort （和 Arrays.sort ）进行自动排序。实现此接口的对象可以用作有序映射表中的键或有序集合中的元素，无需指定比较器。 强烈推荐（虽然不是必需的）使自然排序与 equals 一致。所谓与equals一致是指对于类 C 的每一个 e1 和 e2 来说，当且仅当 (e1.compareTo((Object)e2) == 0) 与e1.equals((Object)e2) 具有相同的布尔值时，类 C 的自然排序才叫做与 equals 一致 。

int compareTo(T o) 比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。 强烈推荐 (x.compareTo(y)==0) == (x.equals(y)) 这种做法，但不是 严格要求这样做。一般来说，任何实现 Comparable 接口和违背此条件的类都应该清楚地指出这一事实。推荐如此阐述：“注意：此类具有与 equals 不一致的自然排序。”

例如

Employee[] staff =  new Employee[ 3 ];  
staff[ 0 ] =  new Employee( "harry Hacker" , 35000 );  
staff[ 1 ] =  new Employee( "carl cracke" , 75000 );  
staff[ 2 ] =  new Employee( "tony Tester" , 38000 );  
Arrays.sort(staff); //sort方法可以实现对对象数组排序，但是必须实现 Comparable接口

因为要实现对Employee对象的排序，所以在Employee类中要实现Comparable接口，也就是要实现comepareTo()方法

class Employee  implements Comparable<Employee>  
{  

private int id;  
private String name;  
private double salary;  

public Employee(String n, double s)  
    {  
        name = n;  
        salary = s;  
        Random ID =  new Random();  
        id = ID.nextInt( 10000000 );  
    }  

public int compareTo(Employee other)  
    {  
if (id<other.id) //这里比较的是什么 sort方法实现的就是按照此比较的东西从小到大排列
return - 1 ;  
if (id>other.id)  
return 1 ;  
return 0 ;  
    }  
}

 

与Comparator的区别

Comparator位于包java.util下，而Comparable位于包java.lang下，Comparable接口将比较代码嵌入自身类中，而后者在一个独立的类中实现比较。 如果类的设计师没有考虑到Compare的问题而没有实现Comparable接口，可以通过  Comparator来实现比较算法进行排序，并且为了使用不同的排序标准做准备，比如：升序、降序。

import java.util.TreeSet; 
import java.util.Comparator; 
class NumComparator implements Comparator<NameTag> { 
    public int compare (NameTag left,NameTag right) { 
        return(left.getNumber() - right.getNumber()); 
    } 
} 
public class CollectionNine { 
    public static void main(String arg[]) { 
        new CollectionNine(); 
    } 
    CollectionNine() { 
        NumComparator comparator = new NumComparator(); 
        TreeSet<NameTag> set = new TreeSet<NameTag>(comparator); 
        set.add(new NameTag("Agamemnon",300)); 
        set.add(new NameTag("Cato",400)); 
        set.add(new NameTag("Plato",100)); 
        set.add(new NameTag("Zeno",200)); 
        set.add(new NameTag("Archimedes",500)); 
        for(NameTag tag : set) 
            System.out.println(tag); 
    } 
}

 

Modifier and Type	Method and Description
byte	byteValue() 返回此值 Float为 byte的基本收缩转换后。
static int	compare(float f1, float f2) 比较两个指定的 float值。
int	compareTo(Float anotherFloat) 数字比较两个 Float对象。
double	doubleValue() 返回此值 Float为 double一个宽元转换后。
boolean	equals(Object obj) 将此对象与指定对象进行比较。
static int	floatToIntBits(float value) 根据IEEE 754浮点“单格式”位布局返回指定浮点值的表示。
static int	floatToRawIntBits(float value) 根据IEEE 754浮点“单格式”位布局返回指定浮点值的表示，保留非数字（NaN）值。
float	floatValue() 返回此 Float对象的 float值。
int	hashCode() 返回此 Float对象的哈希码。
static int	hashCode(float value) 返回一个float值的哈希码; 兼容Float.hashCode() 。
static float	intBitsToFloat(int bits) 返回与给 float表示相对应的 float值。
int	intValue() 在 int后返回 Float作为int的值。
static boolean	isFinite(float f) 如果参数是有限浮点值，则返回true ; 返回false （对于NaN和无穷大参数）。
boolean	isInfinite() 返回 true如果这个 Float值是无限大， false否则。
static boolean	isInfinite(float v) 返回 true如果指定的数量是无限大， false其他。
boolean	isNaN() 如果这个 Float值 Float数字（NaN），则返回 true ， false false。
static boolean	isNaN(float v) 如果指定的数字是非数字（NaN）值，则返回 true ， false false。
long	longValue() 这个的返回值 Float为 long的基本收缩转换后。
static float	max(float a, float b) 返回两个 float的较大值，就像调用 Math.max一样 。
static float	min(float a, float b) 返回两个 float的较小值，就像调用 Math.min一样 。
static float	parseFloat(String s) 返回一个新 float初始化为指定的代表的值 String ，如通过执行 valueOf类的方法 Float 。
short	shortValue() 返回此值 Float为 short的基本收缩转换后。
static float	sum(float a, float b) 根据+运算符将两个 float值一起添加。
static String	toHexString(float f) 返回 float参数的十六进制字符串 float形式。
String	toString() 返回此 Float对象的字符串表示形式。
static String	toString(float f) 返回 float参数的字符串 float形式。
static Float	valueOf(float f) 返回一个 Float指定的 float值的 Float实例。
static Float	valueOf(String s) 返回一个 Float对象，保存由参数字符串 s的 float值。

java源码

package java.lang;

import sun.misc.FloatingDecimal;
import sun.misc.FloatConsts;
import sun.misc.DoubleConsts;

public final class Float extends Number implements Comparable<Float> {


    public static final float POSITIVE_INFINITY = 1.0f / 0.0f;

    public static final float NEGATIVE_INFINITY = -1.0f / 0.0f;

    public static final float NaN = 0.0f / 0.0f;
	
    public static final float MAX_VALUE = 0x1.fffffeP+127f; // 3.4028235e+38f	
	
    public static final float MIN_NORMAL = 0x1.0p-126f; // 1.17549435E-38f
	
    public static final float MIN_VALUE = 0x0.000002P-126f; // 1.4e-45f	
	
    public static final int MAX_EXPONENT = 127;	
	
    public static final int MIN_EXPONENT = -126;	
	
    public static final int SIZE = 32;	
	
    public static final int BYTES = SIZE / Byte.SIZE;	
	
    @SuppressWarnings("unchecked")
    public static final Class<Float> TYPE = (Class<Float>) Class.getPrimitiveClass("float");	
	
    public static String toString(float f) {
        return FloatingDecimal.toJavaFormatString(f);
    }	

    public static String toHexString(float f) {
        if (Math.abs(f) < FloatConsts.MIN_NORMAL
            &&  f != 0.0f ) {// float subnormal
            // Adjust exponent to create subnormal double, then
            // replace subnormal double exponent with subnormal float
            // exponent
            String s = Double.toHexString(Math.scalb((double)f,
                                                     /* -1022+126 */
                                                     DoubleConsts.MIN_EXPONENT-
                                                     FloatConsts.MIN_EXPONENT));
            return s.replaceFirst("p-1022$", "p-126");
        }
        else // double string will be the same as float string
            return Double.toHexString(f);
    }

    public static Float valueOf(String s) throws NumberFormatException {
        return new Float(parseFloat(s));
    }

    public static Float valueOf(float f) {
        return new Float(f);
    }

    public static float parseFloat(String s) throws NumberFormatException {
        return FloatingDecimal.parseFloat(s);
    }

    public static boolean isNaN(float v) {
        return (v != v);
    }
	
    public static boolean isInfinite(float v) {
        return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
    }	
	
     public static boolean isFinite(float f) {
        return Math.abs(f) <= FloatConsts.MAX_VALUE;
    }
	
    private final float value;	
	
    public Float(float value) {
        this.value = value;
    }	
	
    public Float(double value) {
        this.value = (float)value;
    }	
	
    public Float(String s) throws NumberFormatException {
        value = parseFloat(s);
    }	
	
    public boolean isNaN() {
        return isNaN(value);
    }	
	
    public boolean isInfinite() {
        return isInfinite(value);
    }	

    public String toString() {
        return Float.toString(value);
    }
	
    public byte byteValue() {
        return (byte)value;
    }	
	
    public short shortValue() {
        return (short)value;
    }

    public int intValue() {
        return (int)value;
    }

    public long longValue() {
        return (long)value;
    }

    public float floatValue() {
        return value;
    }

    public double doubleValue() {
        return (double)value;
    }

    @Override
    public int hashCode() {
        return Float.hashCode(value);
    }

    public static int hashCode(float value) {
        return floatToIntBits(value);
    }

    public boolean equals(Object obj) {
        return (obj instanceof Float)
               && (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
    }

    public static int floatToIntBits(float value) {
        int result = floatToRawIntBits(value);
        // Check for NaN based on values of bit fields, maximum
        // exponent and nonzero significand.
        if ( ((result & FloatConsts.EXP_BIT_MASK) ==
              FloatConsts.EXP_BIT_MASK) &&
             (result & FloatConsts.SIGNIF_BIT_MASK) != 0)
            result = 0x7fc00000;
        return result;
    }

    public static native int floatToRawIntBits(float value);


    public static native float intBitsToFloat(int bits);

    public int compareTo(Float anotherFloat) {
        return Float.compare(value, anotherFloat.value);
    }

    public static int compare(float f1, float f2) {
        if (f1 < f2)
            return -1;           // Neither val is NaN, thisVal is smaller
        if (f1 > f2)
            return 1;            // Neither val is NaN, thisVal is larger

        // Cannot use floatToRawIntBits because of possibility of NaNs.
        int thisBits    = Float.floatToIntBits(f1);
        int anotherBits = Float.floatToIntBits(f2);

        return (thisBits == anotherBits ?  0 : // Values are equal
                (thisBits < anotherBits ? -1 : // (-0.0, 0.0) or (!NaN, NaN)
                 1));                          // (0.0, -0.0) or (NaN, !NaN)
    }

    public static float sum(float a, float b) {
        return a + b;
    }

    public static float max(float a, float b) {
        return Math.max(a, b);
    }

    public static float min(float a, float b) {
        return Math.min(a, b);
    }
    private static final long serialVersionUID = -2671257302660747028L;
}

package java.lang;
import java.util.*;

public interface Comparable<T> {

    public int compareTo(T o);
}

package java.lang;

public abstract class Number implements java.io.Serializable {

    public abstract int intValue();

    public abstract long longValue();

    public abstract float floatValue();

    public abstract double doubleValue();

    public byte byteValue() {
        return (byte)intValue();
    }

    public short shortValue() {
        return (short)intValue();
    }
	
    private static final long serialVersionUID = -8742448824652078965L;
}