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 */ 017package org.apache.commons.lang3.mutable; 018 019/** 020 * A mutable <code>float</code> wrapper. 021 * <p> 022 * Note that as MutableFloat does not extend Float, it is not treated by String.format as a Float parameter. 023 * 024 * @see Float 025 * @since 2.1 026 * @version $Id: MutableFloat.java 1436770 2013-01-22 07:09:45Z ggregory $ 027 */ 028public class MutableFloat extends Number implements Comparable<MutableFloat>, Mutable<Number> { 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 the initial value to store 051 */ 052 public MutableFloat(final float value) { 053 super(); 054 this.value = value; 055 } 056 057 /** 058 * Constructs a new MutableFloat with the specified value. 059 * 060 * @param value the initial value to store, not null 061 * @throws NullPointerException if the object is null 062 */ 063 public MutableFloat(final Number value) { 064 super(); 065 this.value = value.floatValue(); 066 } 067 068 /** 069 * Constructs a new MutableFloat parsing the given string. 070 * 071 * @param value the string to parse, not null 072 * @throws NumberFormatException if the string cannot be parsed into a float 073 * @since 2.5 074 */ 075 public MutableFloat(final String value) throws NumberFormatException { 076 super(); 077 this.value = Float.parseFloat(value); 078 } 079 080 //----------------------------------------------------------------------- 081 /** 082 * Gets the value as a Float instance. 083 * 084 * @return the value as a Float, never null 085 */ 086 @Override 087 public Float getValue() { 088 return Float.valueOf(this.value); 089 } 090 091 /** 092 * Sets the value. 093 * 094 * @param value the value to set 095 */ 096 public void setValue(final float value) { 097 this.value = value; 098 } 099 100 /** 101 * Sets the value from any Number instance. 102 * 103 * @param value the value to set, not null 104 * @throws NullPointerException if the object is null 105 */ 106 @Override 107 public void setValue(final Number value) { 108 this.value = value.floatValue(); 109 } 110 111 //----------------------------------------------------------------------- 112 /** 113 * Checks whether the float value is the special NaN value. 114 * 115 * @return true if NaN 116 */ 117 public boolean isNaN() { 118 return Float.isNaN(value); 119 } 120 121 /** 122 * Checks whether the float value is infinite. 123 * 124 * @return true if infinite 125 */ 126 public boolean isInfinite() { 127 return Float.isInfinite(value); 128 } 129 130 //----------------------------------------------------------------------- 131 /** 132 * Increments the value. 133 * 134 * @since Commons Lang 2.2 135 */ 136 public void increment() { 137 value++; 138 } 139 140 /** 141 * Decrements the value. 142 * 143 * @since Commons Lang 2.2 144 */ 145 public void decrement() { 146 value--; 147 } 148 149 //----------------------------------------------------------------------- 150 /** 151 * Adds a value to the value of this instance. 152 * 153 * @param operand the value to add, not null 154 * @since Commons Lang 2.2 155 */ 156 public void add(final float operand) { 157 this.value += operand; 158 } 159 160 /** 161 * Adds a value to the value of this instance. 162 * 163 * @param operand the value to add, not null 164 * @throws NullPointerException if the object is null 165 * @since Commons Lang 2.2 166 */ 167 public void add(final Number operand) { 168 this.value += operand.floatValue(); 169 } 170 171 /** 172 * Subtracts a value from the value of this instance. 173 * 174 * @param operand the value to subtract 175 * @since Commons Lang 2.2 176 */ 177 public void subtract(final float operand) { 178 this.value -= operand; 179 } 180 181 /** 182 * Subtracts a value from the value of this instance. 183 * 184 * @param operand the value to subtract, not null 185 * @throws NullPointerException if the object is null 186 * @since Commons Lang 2.2 187 */ 188 public void subtract(final Number operand) { 189 this.value -= operand.floatValue(); 190 } 191 192 //----------------------------------------------------------------------- 193 // shortValue and byteValue rely on Number implementation 194 /** 195 * Returns the value of this MutableFloat as an int. 196 * 197 * @return the numeric value represented by this object after conversion to type int. 198 */ 199 @Override 200 public int intValue() { 201 return (int) value; 202 } 203 204 /** 205 * Returns the value of this MutableFloat as a long. 206 * 207 * @return the numeric value represented by this object after conversion to type long. 208 */ 209 @Override 210 public long longValue() { 211 return (long) value; 212 } 213 214 /** 215 * Returns the value of this MutableFloat as a float. 216 * 217 * @return the numeric value represented by this object after conversion to type float. 218 */ 219 @Override 220 public float floatValue() { 221 return value; 222 } 223 224 /** 225 * Returns the value of this MutableFloat as a double. 226 * 227 * @return the numeric value represented by this object after conversion to type double. 228 */ 229 @Override 230 public double doubleValue() { 231 return value; 232 } 233 234 //----------------------------------------------------------------------- 235 /** 236 * Gets this mutable as an instance of Float. 237 * 238 * @return a Float instance containing the value from this mutable, never null 239 */ 240 public Float toFloat() { 241 return Float.valueOf(floatValue()); 242 } 243 244 //----------------------------------------------------------------------- 245 /** 246 * Compares this object against some other object. The result is <code>true</code> if and only if the argument is 247 * not <code>null</code> and is a <code>Float</code> object that represents a <code>float</code> that has the 248 * identical bit pattern to the bit pattern of the <code>float</code> represented by this object. For this 249 * purpose, two float values are considered to be the same if and only if the method 250 * {@link Float#floatToIntBits(float)}returns the same int value when applied to each. 251 * <p> 252 * Note that in most cases, for two instances of class <code>Float</code>,<code>f1</code> and <code>f2</code>, 253 * the value of <code>f1.equals(f2)</code> is <code>true</code> if and only if <blockquote> 254 * 255 * <pre> 256 * f1.floatValue() == f2.floatValue() 257 * </pre> 258 * 259 * </blockquote> 260 * <p> 261 * also has the value <code>true</code>. However, there are two exceptions: 262 * <ul> 263 * <li>If <code>f1</code> and <code>f2</code> both represent <code>Float.NaN</code>, then the 264 * <code>equals</code> method returns <code>true</code>, even though <code>Float.NaN==Float.NaN</code> has 265 * the value <code>false</code>. 266 * <li>If <code>f1</code> represents <code>+0.0f</code> while <code>f2</code> represents <code>-0.0f</code>, 267 * or vice versa, the <code>equal</code> test has the value <code>false</code>, even though 268 * <code>0.0f==-0.0f</code> has the value <code>true</code>. 269 * </ul> 270 * This definition allows hashtables to operate properly. 271 * 272 * @param obj the object to compare with, null returns false 273 * @return <code>true</code> if the objects are the same; <code>false</code> otherwise. 274 * @see java.lang.Float#floatToIntBits(float) 275 */ 276 @Override 277 public boolean equals(final Object obj) { 278 return obj instanceof MutableFloat 279 && Float.floatToIntBits(((MutableFloat) obj).value) == Float.floatToIntBits(value); 280 } 281 282 /** 283 * Returns a suitable hash code for this mutable. 284 * 285 * @return a suitable hash code 286 */ 287 @Override 288 public int hashCode() { 289 return Float.floatToIntBits(value); 290 } 291 292 //----------------------------------------------------------------------- 293 /** 294 * Compares this mutable to another in ascending order. 295 * 296 * @param other the other mutable to compare to, not null 297 * @return negative if this is less, zero if equal, positive if greater 298 */ 299 @Override 300 public int compareTo(final MutableFloat other) { 301 final float anotherVal = other.value; 302 return Float.compare(value, anotherVal); 303 } 304 305 //----------------------------------------------------------------------- 306 /** 307 * Returns the String value of this mutable. 308 * 309 * @return the mutable value as a string 310 */ 311 @Override 312 public String toString() { 313 return String.valueOf(value); 314 } 315 316}