001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.commons.lang.mutable; 018 019 import org.apache.commons.lang.math.NumberUtils; 020 021 /** 022 * A mutable <code>float</code> wrapper. 023 * 024 * @see Float 025 * @since 2.1 026 * @version $Id: MutableFloat.java 618693 2008-02-05 16:33:29Z sebb $ 027 */ 028 public class MutableFloat extends Number implements Comparable, Mutable { 029 030 /** 031 * Required for serialization support. 032 * 033 * @see java.io.Serializable 034 */ 035 private static final long serialVersionUID = 5787169186L; 036 037 /** The mutable value. */ 038 private float value; 039 040 /** 041 * Constructs a new MutableFloat with the default value of zero. 042 */ 043 public MutableFloat() { 044 super(); 045 } 046 047 /** 048 * Constructs a new MutableFloat with the specified value. 049 * 050 * @param value 051 * a value. 052 */ 053 public MutableFloat(float value) { 054 super(); 055 this.value = value; 056 } 057 058 /** 059 * Constructs a new MutableFloat with the specified value. 060 * 061 * @param value 062 * a value. 063 * @throws NullPointerException 064 * if the object is null 065 */ 066 public MutableFloat(Number value) { 067 super(); 068 this.value = value.floatValue(); 069 } 070 071 //----------------------------------------------------------------------- 072 /** 073 * Gets the value as a Float instance. 074 * 075 * @return the value as a Float 076 */ 077 public Object getValue() { 078 return new Float(this.value); 079 } 080 081 /** 082 * Sets the value. 083 * 084 * @param value 085 * the value to set 086 */ 087 public void setValue(float value) { 088 this.value = value; 089 } 090 091 /** 092 * Sets the value from any Number instance. 093 * 094 * @param value 095 * the value to set 096 * @throws NullPointerException 097 * if the object is null 098 * @throws ClassCastException 099 * if the type is not a {@link Number} 100 */ 101 public void setValue(Object value) { 102 setValue(((Number) value).floatValue()); 103 } 104 105 //----------------------------------------------------------------------- 106 /** 107 * Increments the value. 108 * 109 * @since Commons Lang 2.2 110 */ 111 public void increment() { 112 value++; 113 } 114 115 /** 116 * Decrements the value. 117 * 118 * @since Commons Lang 2.2 119 */ 120 public void decrement() { 121 value--; 122 } 123 124 //----------------------------------------------------------------------- 125 /** 126 * Adds a value. 127 * 128 * @param operand 129 * the value to add 130 * 131 * @since Commons Lang 2.2 132 */ 133 public void add(float operand) { 134 this.value += operand; 135 } 136 137 /** 138 * Adds a value. 139 * 140 * @param operand 141 * the value to add 142 * @throws NullPointerException 143 * if the object is null 144 * 145 * @since Commons Lang 2.2 146 */ 147 public void add(Number operand) { 148 this.value += operand.floatValue(); 149 } 150 151 /** 152 * Subtracts a value. 153 * 154 * @param operand 155 * the value to add 156 * 157 * @since Commons Lang 2.2 158 */ 159 public void subtract(float operand) { 160 this.value -= operand; 161 } 162 163 /** 164 * Subtracts a value. 165 * 166 * @param operand 167 * the value to add 168 * @throws NullPointerException 169 * if the object is null 170 * 171 * @since Commons Lang 2.2 172 */ 173 public void subtract(Number operand) { 174 this.value -= operand.floatValue(); 175 } 176 177 //----------------------------------------------------------------------- 178 // shortValue and bytValue rely on Number implementation 179 /** 180 * Returns the value of this MutableFloat as a int. 181 * 182 * @return the numeric value represented by this object after conversion to type int. 183 */ 184 public int intValue() { 185 return (int) value; 186 } 187 188 /** 189 * Returns the value of this MutableFloat as a long. 190 * 191 * @return the numeric value represented by this object after conversion to type long. 192 */ 193 public long longValue() { 194 return (long) value; 195 } 196 197 /** 198 * Returns the value of this MutableFloat as a float. 199 * 200 * @return the numeric value represented by this object after conversion to type float. 201 */ 202 public float floatValue() { 203 return value; 204 } 205 206 /** 207 * Returns the value of this MutableFloat as a double. 208 * 209 * @return the numeric value represented by this object after conversion to type double. 210 */ 211 public double doubleValue() { 212 return value; 213 } 214 215 /** 216 * Checks whether the float value is the special NaN value. 217 * 218 * @return true if NaN 219 */ 220 public boolean isNaN() { 221 return Float.isNaN(value); 222 } 223 224 /** 225 * Checks whether the float value is infinite. 226 * 227 * @return true if infinite 228 */ 229 public boolean isInfinite() { 230 return Float.isInfinite(value); 231 } 232 233 //----------------------------------------------------------------------- 234 /** 235 * Gets this mutable as an instance of Float. 236 * 237 * @return a Float instance containing the value from this mutable 238 */ 239 public Float toFloat() { 240 return new Float(floatValue()); 241 } 242 243 //----------------------------------------------------------------------- 244 /** 245 * Compares this object against some other object. The result is <code>true</code> if and only if the argument is 246 * not <code>null</code> and is a <code>Float</code> object that represents a <code>float</code> that has the 247 * identical bit pattern to the bit pattern of the <code>float</code> represented by this object. For this 248 * purpose, two float values are considered to be the same if and only if the method 249 * {@link Float#floatToIntBits(float)}returns the same int value when applied to each. 250 * <p> 251 * Note that in most cases, for two instances of class <code>Float</code>,<code>f1</code> and <code>f2</code>, 252 * the value of <code>f1.equals(f2)</code> is <code>true</code> if and only if <blockquote> 253 * 254 * <pre> 255 * f1.floatValue() == f2.floatValue() 256 * </pre> 257 * 258 * </blockquote> 259 * <p> 260 * also has the value <code>true</code>. However, there are two exceptions: 261 * <ul> 262 * <li>If <code>f1</code> and <code>f2</code> both represent <code>Float.NaN</code>, then the 263 * <code>equals</code> method returns <code>true</code>, even though <code>Float.NaN==Float.NaN</code> has 264 * the value <code>false</code>. 265 * <li>If <code>f1</code> represents <code>+0.0f</code> while <code>f2</code> represents <code>-0.0f</code>, 266 * or vice versa, the <code>equal</code> test has the value <code>false</code>, even though 267 * <code>0.0f==-0.0f</code> has the value <code>true</code>. 268 * </ul> 269 * This definition allows hashtables to operate properly. 270 * 271 * @param obj 272 * the object to be compared 273 * @return <code>true</code> if the objects are the same; <code>false</code> otherwise. 274 * @see java.lang.Float#floatToIntBits(float) 275 */ 276 public boolean equals(Object obj) { 277 return (obj instanceof MutableFloat) 278 && (Float.floatToIntBits(((MutableFloat) obj).value) == Float.floatToIntBits(value)); 279 } 280 281 //----------------------------------------------------------------------- 282 /** 283 * Returns a suitable hashcode for this mutable. 284 * 285 * @return a suitable hashcode 286 */ 287 public int hashCode() { 288 return Float.floatToIntBits(value); 289 } 290 291 /** 292 * Compares this mutable to another in ascending order. 293 * 294 * @param obj 295 * the mutable to compare to 296 * @return negative if this is less, zero if equal, positive if greater 297 */ 298 public int compareTo(Object obj) { 299 MutableFloat other = (MutableFloat) obj; 300 float anotherVal = other.value; 301 return NumberUtils.compare(value, anotherVal); 302 } 303 304 /** 305 * Returns the String value of this mutable. 306 * 307 * @return the mutable value as a string 308 */ 309 public String toString() { 310 return String.valueOf(value); 311 } 312 313 }