OSDN Git Service

* java/lang/Integer.java: Merged with Classpath.
[pf3gnuchains/gcc-fork.git] / libjava / java / lang / Integer.java
1 /* java.lang.Integer
2    Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
3
4 This file is part of GNU Classpath.
5
6 GNU Classpath is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10  
11 GNU Classpath is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GNU Classpath; see the file COPYING.  If not, write to the
18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19 02111-1307 USA.
20
21 As a special exception, if you link this library with other files to
22 produce an executable, this library does not by itself cause the
23 resulting executable to be covered by the GNU General Public License.
24 This exception does not however invalidate any other reasons why the
25 executable file might be covered by the GNU General Public License. */
26
27
28 package java.lang;
29
30 /**
31  * Instances of class <code>Integer</code> represent primitive
32  * <code>int</code> values.
33  *
34  * Additionally, this class provides various helper functions and variables
35  * related to ints.
36  *
37  * @author Paul Fisher
38  * @author John Keiser
39  * @author Warren Levy
40  * @since JDK 1.0
41  */
42 public final class Integer extends Number implements Comparable
43 {
44   // compatible with JDK 1.0.2+
45   private static final long serialVersionUID = 1360826667806852920L;
46
47   /**
48    * The minimum value an <code>int</code> can represent is -2147483648.
49    */
50   public static final int MIN_VALUE = 0x80000000;
51
52   /**
53    * The maximum value an <code>int</code> can represent is 2147483647.
54    */
55   public static final int MAX_VALUE = 0x7fffffff;
56
57   /**
58    * The primitive type <code>int</code> is represented by this 
59    * <code>Class</code> object.
60    */
61   public static final Class TYPE = VMClassLoader.getPrimitiveClass ("int");
62
63   /**
64    * The immutable value of this Integer.
65    */
66   private final int value;
67
68   /**
69    * Create an <code>Integer</code> object representing the value of the 
70    * <code>int</code> argument.
71    *
72    * @param value the value to use
73    */
74   public Integer(int value)
75   {
76     this.value = value;
77   }
78
79   /**
80    * Create an <code>Integer</code> object representing the value of the 
81    * argument after conversion to an <code>int</code>.
82    *
83    * @param s the string to convert.
84    */
85   public Integer(String s) throws NumberFormatException
86   {
87     value = parseInt(s, 10);
88   }
89
90   /**
91    * Return a hashcode representing this Object.
92    *
93    * <code>Integer</code>'s hash code is calculated by simply returning its
94    * value.
95    *
96    * @return this Object's hash code.
97    */
98   public int hashCode()
99   {
100     return value;
101   }
102
103   /**
104    * If the <code>Object</code> is not <code>null</code>, is an
105    * <code>instanceof</code> <code>Integer</code>, and represents
106    * the same primitive <code>int</code> value return 
107    * <code>true</code>.  Otherwise <code>false</code> is returned.
108    */
109   public boolean equals(Object obj)
110   {
111     return obj instanceof Integer && value == ((Integer)obj).value;
112   }
113
114   /**
115    * Get the specified system property as an <code>Integer</code>.
116    *
117    * The <code>decode()</code> method will be used to interpret the value of
118    * the property.
119    * @param nm the name of the system property
120    * @return the system property as an <code>Integer</code>, or
121    *         <code>null</code> if the property is not found or cannot be
122    *         decoded as an <code>Integer</code>.
123    * @see java.lang.System#getProperty(java.lang.String)
124    * @see #decode(int)
125    */
126   public static Integer getInteger(String nm)
127   {
128     return getInteger(nm, null);
129   }
130
131   /**
132    * Get the specified system property as an <code>Integer</code>, or use a
133    * default <code>int</code> value if the property is not found or is not
134    * decodable.
135    * 
136    * The <code>decode()</code> method will be used to interpret the value of
137    * the property.
138    *
139    * @param nm the name of the system property
140    * @param val the default value to use if the property is not found or not
141    *        a number.
142    * @return the system property as an <code>Integer</code>, or the default
143    *         value if the property is not found or cannot be decoded as an
144    *         <code>Integer</code>.
145    * @see java.lang.System#getProperty(java.lang.String)
146    * @see #decode(int)
147    * @see #getInteger(java.lang.String,java.lang.Integer)
148    */
149   public static Integer getInteger(String nm, int val)
150   {
151     Integer result = getInteger(nm, null);
152     return (result == null) ? new Integer(val) : result;
153   }
154
155   /**
156    * Get the specified system property as an <code>Integer</code>, or use a
157    * default <code>Integer</code> value if the property is not found or is
158    * not decodable.
159    * 
160    * The <code>decode()</code> method will be used to interpret the value of
161    * the property.
162    *
163    * @param nm the name of the system property
164    * @param val the default value to use if the property is not found or not
165    *        a number.
166    * @return the system property as an <code>Integer</code>, or the default
167    *         value if the property is not found or cannot be decoded as an
168    *         <code>Integer</code>.
169    * @see java.lang.System#getProperty(java.lang.String)
170    * @see #decode(int)
171    * @see #getInteger(java.lang.String,int)
172    */
173   public static Integer getInteger(String nm, Integer def)
174   {
175     String val = System.getProperty(nm);
176     if (val == null) return def;
177     try
178       {
179       return decode(nm);
180       }
181     catch (NumberFormatException e)
182       {
183         return def;
184       }
185   }
186
187   private static String toUnsignedString(int num, int exp)
188   {
189     // Use an array large enough for a binary number.
190     int radix = 1 << exp;
191     int mask = radix - 1;
192     char[] buffer = new char[32];
193     int i = 32;
194     do
195       {
196         buffer[--i] = Character.forDigit(num & mask, radix);
197         num = num >>> exp;
198       }
199     while (num != 0);
200
201     return String.valueOf(buffer, i, 32-i);
202   }
203
204   /**
205    * Converts the <code>int</code> to a <code>String</code> assuming it is
206    * unsigned in base 16.
207    * @param i the <code>int</code> to convert to <code>String</code>
208    * @return the <code>String</code> representation of the argument.
209    */
210   public static String toHexString(int i)
211   {
212     return toUnsignedString(i, 4);
213   }
214
215   /**
216    * Converts the <code>int</code> to a <code>String</code> assuming it is
217    * unsigned in base 8.
218    * @param i the <code>int</code> to convert to <code>String</code>
219    * @return the <code>String</code> representation of the argument.
220    */
221   public static String toOctalString(int i)
222   {
223     return toUnsignedString(i, 3);
224   }
225
226   /**
227    * Converts the <code>int</code> to a <code>String</code> assuming it is
228    * unsigned in base 2.
229    * @param i the <code>int</code> to convert to <code>String</code>
230    * @return the <code>String</code> representation of the argument.
231    */
232   public static String toBinaryString(int i)
233   {
234     return toUnsignedString(i, 1);
235   }
236
237   /**
238    * Converts the <code>int</code> to a <code>String</code> and assumes
239    * a radix of 10.
240    * @param i the <code>int</code> to convert to <code>String</code>
241    * @return the <code>String</code> representation of the argument.
242    */
243   public static String toString(int i)
244   {
245     // This is tricky: in libgcj, String.valueOf(int) is a fast native
246     // implementation.  In Classpath it just calls back to
247     // Integer.toString(int,int).
248     return String.valueOf (i);
249   }
250
251   /**
252    * Converts the <code>Integer</code> value to a <code>String</code> and
253    * assumes a radix of 10.
254    * @return the <code>String</code> representation of this <code>Integer</code>.
255    */    
256   public String toString()
257   {
258     return toString (value);
259   }
260
261   /**
262    * Converts the <code>int</code> to a <code>String</code> using
263    * the specified radix (base).
264    * @param i the <code>int</code> to convert to <code>String</code>.
265    * @param radix the radix (base) to use in the conversion.
266    * @return the <code>String</code> representation of the argument.
267    */
268   public static String toString(int num, int radix)
269   {
270     if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
271       radix = 10;
272
273     // For negative numbers, print out the absolute value w/ a leading '-'.
274     // Use an array large enough for a binary number.
275     char[] buffer = new char[33];
276     int i = 33;
277     boolean isNeg;
278     if (num < 0)
279       {
280         isNeg = true;
281         num = -(num);
282
283         // When the value is MIN_VALUE, it overflows when made positive
284         if (num < 0)
285           {
286             buffer[--i] = Character.forDigit(-(num + radix) % radix, radix);
287             num = -(num / radix);
288           }
289       }
290     else
291       isNeg = false;
292
293     do
294       {
295         buffer[--i] = Character.forDigit(num % radix, radix);
296         num /= radix;
297       }
298     while (num > 0);
299
300     if (isNeg)
301       buffer[--i] = '-';
302
303     return String.valueOf(buffer, i, 33-i);
304   }
305
306   /**
307    * Creates a new <code>Integer</code> object using the <code>String</code>,
308    * assuming a radix of 10.
309    * @param s the <code>String</code> to convert.
310    * @return the new <code>Integer</code>.
311    * @see #Integer(java.lang.String)
312    * @see #parseInt(java.lang.String)
313    * @exception NumberFormatException thrown if the <code>String</code> 
314    * cannot be parsed as an <code>int</code>.
315    */
316   public static Integer valueOf(String s) throws NumberFormatException
317   {
318     return new Integer(parseInt(s));
319   }
320
321   /**
322    * Creates a new <code>Integer</code> object using the <code>String</code>
323    * and specified radix (base).
324    * @param s the <code>String</code> to convert.
325    * @param radix the radix (base) to convert with.
326    * @return the new <code>Integer</code>.
327    * @see #parseInt(java.lang.String,int)
328    * @exception NumberFormatException thrown if the <code>String</code> 
329    * cannot be parsed as an <code>int</code>.
330    */
331   public static Integer valueOf(String s, int radix)
332     throws NumberFormatException
333   {
334     return new Integer(parseInt(s, radix));
335   }
336
337   /**
338    * Converts the specified <code>String</code> into an <code>int</code>.
339    * This function assumes a radix of 10.
340    *
341    * @param s the <code>String</code> to convert
342    * @return the <code>int</code> value of the <code>String</code>
343    *         argument.
344    * @exception NumberFormatException thrown if the <code>String</code> 
345    * cannot be parsed as an <code>int</code>.
346    */
347   public static int parseInt(String s) throws NumberFormatException
348   {
349     return parseInt(s, 10);
350   }
351
352   /**
353    * Converts the specified <code>String</code> into an <code>int</code>
354    * using the specified radix (base).
355    *
356    * @param s the <code>String</code> to convert
357    * @param radix the radix (base) to use in the conversion
358    * @return the <code>String</code> argument converted to </code>int</code>.
359    * @exception NumberFormatException thrown if the <code>String</code> 
360    * cannot be parsed as a <code>int</code>.    
361    */
362   public static int parseInt(String str, int radix)
363     throws NumberFormatException
364   {
365     final int len;
366
367     if ((len = str.length()) == 0 ||
368         radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
369       throw new NumberFormatException();
370
371     boolean isNeg = false;
372     int index = 0;
373     if (str.charAt(index) == '-')
374       if (len > 1)
375         {
376           isNeg = true;
377           index++;
378         }
379       else
380         throw new NumberFormatException();
381
382     return parseInt(str, index, len, isNeg, radix);
383   }
384
385   private static int parseInt(String str, int index, int len, boolean isNeg,
386                               int radix)
387     throws NumberFormatException
388   {
389     int val = 0;
390     int digval;
391
392     int max = MAX_VALUE / radix;
393     // We can't directly write `max = (MAX_VALUE + 1) / radix'.
394     // So instead we fake it.
395     if (isNeg && MAX_VALUE % radix == radix - 1)
396       ++max;
397
398     for ( ; index < len; index++)
399       {
400         if (val < 0 || val > max)
401           throw new NumberFormatException();
402
403         if ((digval = Character.digit(str.charAt(index), radix)) < 0)
404           throw new NumberFormatException();
405
406         // Throw an exception for overflow if result is negative.
407         // However, we special-case the most negative value.
408         val = val * radix + digval;
409         if (val < 0 && (! isNeg || val != MIN_VALUE))
410           throw new NumberFormatException();
411       }
412
413     return isNeg ? -(val) : val;
414   }
415
416   /**
417    * Convert the specified <code>String</code> into an <code>Integer</code>.
418    * The <code>String</code> may represent decimal, hexadecimal, or 
419    * octal numbers.
420    *
421    * The <code>String</code> argument is interpreted based on the leading
422    * characters.  Depending on what the String begins with, the base will be
423    * interpreted differently:
424    *
425    * <table border=1>
426    * <tr><th>Leading<br>Characters</th><th>Base</th></tr>
427    * <tr><td>#</td><td>16</td></tr>
428    * <tr><td>0x</td><td>16</td></tr>
429    * <tr><td>0X</td><td>16</td></tr>
430    * <tr><td>0</td><td>8</td></tr>
431    * <tr><td>Anything<br>Else</td><td>10</td></tr>
432    * </table>
433    *
434    * @param str the <code>String</code> to interpret.
435    * @return the value of the String as an <code>Integer</code>.
436    * @exception NumberFormatException thrown if the <code>String</code> 
437    * cannot be parsed as an <code>int</code>.    
438    */
439   public static Integer decode(String str) throws NumberFormatException
440   {
441     boolean isNeg = false;
442     int index = 0;
443     int radix = 10;
444     final int len;
445
446     if (str == null || (len = str.length()) == 0)
447       throw new NumberFormatException("string null or empty");
448
449     // Negative numbers are always radix 10.
450     if (str.charAt(index) == '-')
451       {
452         radix = 10;
453         index++;
454         isNeg = true;
455       }
456     else if (str.charAt(index) == '#')
457       {
458         radix = 16;
459         index++;
460       }
461     else if (str.charAt(index) == '0')
462       {
463         // Check if str is just "0"
464         if (len == 1)
465           return new Integer(0);
466
467         index++;
468         if (str.charAt(index) == 'x' || str.charAt(index) == 'X')
469           {
470             radix = 16;
471             index++;
472           }
473         else
474           radix = 8;
475       }
476
477     if (index >= len)
478       throw new NumberFormatException("empty value");
479
480     return new Integer(parseInt(str, index, len, isNeg, radix));
481   }
482
483   /** Return the value of this <code>Integer</code> as a <code>byte</code>.
484    ** @return the value of this <code>Integer</code> as a <code>byte</code>.
485    **/
486   public byte byteValue()
487   {
488     return (byte) value;
489   }
490
491   /** Return the value of this <code>Integer</code> as a <code>short</code>.
492    ** @return the value of this <code>Integer</code> as a <code>short</code>.
493    **/
494   public short shortValue()
495   {
496     return (short) value;
497   }
498
499   /** Return the value of this <code>Integer</code> as an <code>int</code>.
500    ** @return the value of this <code>Integer</code> as an <code>int</code>.
501    **/
502   public int intValue()
503   {
504     return value;
505   }
506
507   /** Return the value of this <code>Integer</code> as a <code>long</code>.
508    ** @return the value of this <code>Integer</code> as a <code>long</code>.
509    **/
510   public long longValue()
511   {
512     return value;
513   }
514
515   /** Return the value of this <code>Integer</code> as a <code>float</code>.
516    ** @return the value of this <code>Integer</code> as a <code>float</code>.
517    **/
518   public float floatValue()
519   {
520     return value;
521   }
522
523   /** Return the value of this <code>Integer</code> as a <code>double</code>.
524    ** @return the value of this <code>Integer</code> as a <code>double</code>.
525    **/
526   public double doubleValue()
527   {
528     return value;
529   }
530
531   /**
532    * Compare two Integers numerically by comparing their
533    * <code>int</code> values.
534    * @return a positive value if this <code>Integer</code> is greater
535    * in value than the argument <code>Integer</code>; a negative value
536    * if this <code>Integer</code> is smaller in value than the argument
537    * <code>Integer</code>; and <code>0</code>, zero, if this
538    * <code>Integer</code> is equal in value to the argument
539    * <code>Integer</code>.  
540    *
541    * @since 1.2
542    */
543   public int compareTo(Integer i)
544   {
545     if (this.value == i.value)
546       return 0;
547
548     // Returns just -1 or 1 on inequality; doing math might overflow.
549     if (this.value > i.value)
550       return 1;
551
552     return -1;
553   }
554
555   /**
556    * Behaves like <code>compareTo(java.lang.Integer)</code> unless the Object
557    * is not a <code>Integer</code>.  Then it throws a 
558    * <code>ClassCastException</code>.
559    * @exception ClassCastException if the argument is not a
560    * <code>Integer</code>.
561    *
562    * @since 1.2
563    */
564   public int compareTo(Object o)
565   {
566     return compareTo((Integer)o);
567   }
568 }