Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. Examples of GoF Design Patterns
I am learning GoF Java Design Patterns and I want to see some real life examples of them. Can you guys point to some good usage of these Design Patterns.(preferably in Java's core libraries). Thank you
2. Why does DecimalFormat allow characters as suffix?
I'm using DecimalFormat to parse / validate user input. Unfortunately it allows characters as a suffix while parsing. Example code: try { final NumberFormat numberFormat = new DecimalFormat(); System.out.println(numberFormat.parse("12abc")); System.out.println(numberFormat.parse("abc12")); } catch (final ParseException e) { System.out.println("parse exception"); } Result: 12 parse ...
3. When to use a Constructor and when to use getInstance() method (static factory methods)?
When and how should we use a Constructor Foo bar = new Foo(); And When and how should we use getInstance() (static factory methods) Foo bar = Foo.getInstance(); What is the difference between these two, I always use the 1st way but when to use the 2nd way?? UPDATE 1 Say, I need to implement the class too and use .getInstance() from a different class. UPDATE 2 What do you guys mean by ...
4. Convert a String to Number - Java
What is the easiest and correct way to convert a String number with commas (for example: 835,111.2) to a Double instance. Thanks, Rod
5. How do I convert a String to Double in Java using a specific locale?
I want to convert some numbers which I got as strings into Doubles, but these numbers are not in US standard locale, but in a different one. How can I do that?
6. Convert 1 to 01
I have an int between 1 - 99. How do I get it to always be a double digit, ie: 01, 04, 21?
7. Most elegant way to detect if a String is a number?
Is there a better, more elegant (and/or possibly faster) way than boolean isNumber = false; try{ Double.valueOf(myNumber); isNumber = true; } catch (NumberFormatException e) { } ...? Edit: Since I can't pick two answers I'm going with the regex one because a) it's elegant and b) saying "Jon Skeet solved the problem" is a tautology because Jon Skeet himself is the solution to all pr...
8. What's the proper way to show money in an UI in Java?
On the backend I'm storing money values in a Money class which wraps a BigDecimal and sets rounding to be always Half Even with scale 8. All basic operations work fine and behave as expected. But I need to show those values to the user with scale of 2, and that's bringing me rounding errors. For example, I have these values in the backend: a = 109.11432 b = 9015.57069 c = 9124.68501 Each one...
9. Strange behaviour of NumberFormat Java
I have the following code to parse a String variable called str. NumberFormat formatter = NumberFormat.getInstance(); Number number = formatter.parse(str); I want to catch the Exception thrown when str is not a number just to validate it. The problem I have is that it does't always throws the ParseException expected. When the String str starts with a number but then are characters it seems ...
10. How do I format a Currency for a Locale in Java
I'm surprised that I'm having real trouble finding how to do this. It seems to me it should be pretty straightforward. Perhaps I'm looking in the wrong place. Suppose I have the following code: double amount = 123.45D; //yes, I know that I should be using longs Locale uk = Locale.UK; Locale fr = Locale.FR; Currency euro = Currency.getInstance("EUR"); How do I get instances of NumberFormat t...
11. Java binding JTextField -> java.lang.Integer problem
I have a text field which is bound with Integer variable, so when user enters number into this field, binding mechanism automatically converts text into Integer and sets this value into var. Problem is, since user types text into text field, that binding mechanism is converting only values, and if user types some letters into it, binding would not activate because there is no legal value inside...
12. How can a primitive float value be -0.0? What does that mean?
How come a primitive float value can be -0.0? What does that mean? Can I cancel that feature? When I have: float fl; Then fl == -0.0 returns true and so does fl == 0. But when I print it, it prints -0.0.
13. How can I get the Double.toString() behaviour AND thousands separator?
I want to add the thousands separator to a variable of type double. I have tried using String.format("%,f", x); and similar, but it seems to have a fixed number of decimal places, unlike Double.toString(). For example, with the value 1234.5: Double.toString(): 1234.5 String.format(): 1.234,500000 Desired: 1.234,5
14. Displaying Currency in Indian Numbering Format
I have a question about formatting the Rupee currency (Indian Rupee - INR). Typically a value like 450500 is formatted and shown as 450,500. In India, the same value is displayed as 4,50,500 For example, numbers here are represented as: 1 10 100 1,000 10,000 1,00,000 10,00,000 1,00,00,000 10,00,00,000 Refer Indian Numbering System The separators are after two digits, except for the last s...
15. Java - BigDecimal
I was trying to make my own class for currencies using longs, but Apparently I should use BigDecimal (and then whenever I print it just add the $ sign before it). Could someone please get me started? What would be the best way to use BigDecimals for Dollar currencies, like making it at least but no more than 2 decimal places for the cents, etc. The api for BigDecimal is huge, and I don't know w...
16. Java: Converting a double to a String
I have a double whose value is 10,000,000.00 (ten millions). I have to convert it to a String. When using the method "toString" I am getting the String "1.0E7" which is correct following the specification. Unfortunately I need the String "10,000,000.00" (or the equivalent depending on the locale). How can achieve this? Thanks in advance, Luis
17. Java floating point math - (conversion for feet/meters)
Pretty basic question I think - I'm performing this function: private double convertMetersToFeet(double meters) { //function converts Feet to Meters. double toFeet = meters; toFeet = meters*3.2808; // official conversion rate of Meters to Feet return toFeet; } Problem is the output; for example I get 337.36080000000004 from an input of 101. What's the appropriate practic...
18. How to Format a Value within a JSP?
I'm working on a J2EE application which uses Struts (v1) and I would like to format a value being displayed in a JSP. The value to be displayed is a 7 or 8 digit integer and I would like to insert dashes into it, like so: 1234567 -> 1-234-567 12345678 -> 12-345-678 What is the best way to go about this? My first thought was to write a special getter in my form bean which would return t...
19. What is the Java equivalent of C's printf %g format specifier?
I tried using Formatter.format, but that seems to leave the mantissa on numbers with 0 mantissa, whereas the C version does not. Is there an equivalent of C's %g format specifier in Java, and if not, is there a way to fake it? My intention is to preserve the mantissa exactly like C's for compatibility reasons. foo.c #include <stdio.h> int main (int argc, char const *argv[]) { print...
20. Convert VB's Val to Java?
How to implement VB's Val() function using Java programming language or is there any API that has the same method?
21. Parsing a currency String in java
Suppose I'm supplied with a String which is like "$123,456,56.25" or "123'456.67" or something similar to this (with digits and a decimal point and some seperator like , or ' or something else which is not predictable). I need to write a method which takes an argument like the one above and returns a String like "12345656.25" or "123456.67" respectively. Could you please suggest the most effi... 
1
   /*
2
    * Copyright 1996-2005 Sun Microsystems, Inc.  All Rights Reserved.
3
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
    *
5
    * This code is free software; you can redistribute it and/or modify it
6
    * under the terms of the GNU General Public License version 2 only, as
7
    * published by the Free Software Foundation.  Sun designates this
8
    * particular file as subject to the "Classpath" exception as provided
9
    * by Sun in the LICENSE file that accompanied this code.
10
   *
11
   * This code is distributed in the hope that it will be useful, but WITHOUT
12
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
   * version 2 for more details (a copy is included in the LICENSE file that
15
   * accompanied this code).
16
   *
17
   * You should have received a copy of the GNU General Public License version
18
   * 2 along with this work; if not, write to the Free Software Foundation,
19
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
   *
21
   * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
   * CA 95054 USA or visit www.sun.com if you need additional information or
23
   * have any questions.
24
   */
25
  
26
  /*
27
   * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
28
   * (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved
29
   *
30
   *   The original version of this source code and documentation is copyrighted
31
   * and owned by Taligent, Inc., a wholly-owned subsidiary of IBM. These
32
   * materials are provided under terms of a License Agreement between Taligent
33
   * and Sun. This technology is protected by multiple US and International
34
   * patents. This notice and attribution to Taligent may not be removed.
35
   *   Taligent is a registered trademark of Taligent, Inc.
36
   *
37
   */
38
  
39
  package java.text;
40
  
49
  import java.util.HashMap;
51
  import java.util.Locale;
52
  import java.util.Map;
NumberFormat is the abstract base class for all number formats. This class provides the interface for formatting and parsing numbers. NumberFormat also provides methods for determining which locales have number formats, and what their names are.

NumberFormat helps you to format and parse numbers for any locale. Your code can be completely independent of the locale conventions for decimal points, thousands-separators, or even the particular decimal digits used, or whether the number format is even decimal.

To format a number for the current Locale, use one of the factory class methods: 

  myString = NumberFormat.getInstance().format(myNumber);
If you are formatting multiple numbers, it is more efficient to get the format and use it multiple times so that the system doesn't have to fetch the information about the local language and country conventions multiple times. 
 NumberFormat nf = NumberFormat.getInstance();
 for (int i = 0; i < myNumber.length; ++i) {
     output.println(nf.format(myNumber[i]) + "; ");
 }
To format a number for a different Locale, specify it in the call to getInstance. 
 NumberFormat nf = NumberFormat.getInstance(Locale.FRENCH);
You can also use a NumberFormat to parse numbers: 
 myNumber = nf.parse(myString);
Use getInstance or getNumberInstance to get the normal number format. Use getIntegerInstance to get an integer number format. Use getCurrencyInstance to get the currency number format. And use getPercentInstance to get a format for displaying percentages. With this format, a fraction like 0.53 is displayed as 53%.

You can also control the display of numbers with such methods as setMinimumFractionDigits. If you want even more control over the format or parsing, or want to give your users more control, you can try casting the NumberFormat you get from the factory methods to a DecimalFormat. This will work for the vast majority of locales; just remember to put it in a try block in case you encounter an unusual one.

NumberFormat and DecimalFormat are designed such that some controls work for formatting and others work for parsing. The following is the detailed description for each these control methods,

setParseIntegerOnly : only affects parsing, e.g. if true, "3456.78" -> 3456 (and leaves the parse position just after index 6) if false, "3456.78" -> 3456.78 (and leaves the parse position just after index 8) This is independent of formatting. If you want to not show a decimal point where there might be no digits after the decimal point, use setDecimalSeparatorAlwaysShown.

setDecimalSeparatorAlwaysShown : only affects formatting, and only where there might be no digits after the decimal point, such as with a pattern like "#,##0.##", e.g., if true, 3456.00 -> "3,456." if false, 3456.00 -> "3456" This is independent of parsing. If you want parsing to stop at the decimal point, use setParseIntegerOnly.

You can also use forms of the parse and format methods with ParsePosition and FieldPosition to allow you to:

  • progressively parse through pieces of a string
  • align the decimal point and other areas
For example, you can align numbers in two ways:
  1. If you are using a monospaced font with spacing for alignment, you can pass the FieldPosition in your format call, with field = INTEGER_FIELD. On output, getEndIndex will be set to the offset between the last character of the integer and the decimal. Add (desiredSpaceCount - getEndIndex) spaces at the front of the string.
  2. If you are using proportional fonts, instead of padding with spaces, measure the width of the string in pixels from the start to getEndIndex. Then move the pen by (desiredPixelWidth - widthToAlignmentPoint) before drawing the text. It also works where there is no decimal, but possibly additional characters at the end, e.g., with parentheses in negative numbers: "(12)" for -12.

Synchronization

Number formats are generally not synchronized. It is recommended to create separate format instances for each thread. If multiple threads access a format concurrently, it must be synchronized externally.

Author(s):
Mark Davis
Helena Shih
See also:
DecimalFormat
ChoiceFormat
181
 
182
 public abstract class NumberFormat extends Format  {

    
Field constant used to construct a FieldPosition object. Signifies that the position of the integer part of a formatted number should be returned.

See also:
FieldPosition
188
 
189
     public static final int INTEGER_FIELD = 0;

    
Field constant used to construct a FieldPosition object. Signifies that the position of the fraction part of a formatted number should be returned.

See also:
FieldPosition
195
 
196
     public static final int FRACTION_FIELD = 1;

    
Sole constructor. (For invocation by subclass constructors, typically implicit.) 
201
 
202
     protected NumberFormat() {
203
     }

    
Formats a number and appends the resulting text to the given string buffer. The number can be of any subclass of java.lang.Number.

This implementation extracts the number's value using java.lang.Number.longValue() for all integral type values that can be converted to long without loss of information, including BigInteger values with a bit length of less than 64, and java.lang.Number.doubleValue() for all other types. It then calls format(long,java.lang.StringBuffer,java.text.FieldPosition) or format(double,java.lang.StringBuffer,java.text.FieldPosition). This may result in loss of magnitude information and precision for BigInteger and BigDecimal values.

Parameters:
number the number to format
toAppendTo the StringBuffer to which the formatted text is to be appended
pos On input: an alignment field, if desired. On output: the offsets of the alignment field.
Returns:
the value passed in as toAppendTo
Throws:
java.lang.IllegalArgumentException if number is null or not an instance of Number.
java.lang.NullPointerException if toAppendTo or pos is null
java.lang.ArithmeticException if rounding is needed with rounding mode being set to RoundingMode.UNNECESSARY
See also:
FieldPosition
234
 
235
     public StringBuffer format(Object number,
236
                                StringBuffer toAppendTo,
237
                                FieldPosition pos) {
238
         if (number instanceof Long || number instanceof Integer ||
239
             number instanceof Short || number instanceof Byte ||
240
             number instanceof AtomicInteger || number instanceof AtomicLong ||
241
             (number instanceof BigInteger &&
242
              ((BigInteger)number).bitLength() < 64)) {
243
             return format(((Number)number).longValue(), toAppendTo, pos);
244
         } else if (number instanceof Number) {
245
             return format(((Number)number).doubleValue(), toAppendTo, pos);
246
         } else {
247
             throw new IllegalArgumentException("Cannot format given Object as a Number");
248
         }
249
     }

    
Parses text from a string to produce a Number.

The method attempts to parse text starting at the index given by pos. If parsing succeeds, then the index of pos is updated to the index after the last character used (parsing does not necessarily use all characters up to the end of the string), and the parsed number is returned. The updated pos can be used to indicate the starting point for the next call to this method. If an error occurs, then the index of pos is not changed, the error index of pos is set to the index of the character where the error occurred, and null is returned.

See the parse(java.lang.String,java.text.ParsePosition) method for more information on number parsing.

Parameters:
source A String, part of which should be parsed.
pos A ParsePosition object with index and error index information as described above.
Returns:
A Number parsed from the string. In case of error, returns null.
Throws:
java.lang.NullPointerException if pos is null.
274
 
275
     public final Object parseObject(String source, ParsePosition pos) {
276
         return parse(source, pos);
277
     }

   
Specialization of format.

Throws:
java.lang.ArithmeticException if rounding is needed with rounding mode being set to RoundingMode.UNNECESSARY
See also:
Format.format(java.lang.Object)
284
 
285
     public final String format(double number) {
286
         return format(number, new StringBuffer(),
287
                       .).toString();
288
     }

   
Specialization of format.

Throws:
java.lang.ArithmeticException if rounding is needed with rounding mode being set to RoundingMode.UNNECESSARY
See also:
Format.format(java.lang.Object)
295
 
296
     public final String format(long number) {
297
         return format(number, new StringBuffer(),
298
                       .).toString();
299
     }

   
Specialization of format.

Throws:
java.lang.ArithmeticException if rounding is needed with rounding mode being set to RoundingMode.UNNECESSARY
See also:
Format.format(java.lang.Object)
306
 
307
     public abstract StringBuffer format(double number,
308
                                         StringBuffer toAppendTo,
309
                                         FieldPosition pos);

   
Specialization of format.

Throws:
java.lang.ArithmeticException if rounding is needed with rounding mode being set to RoundingMode.UNNECESSARY
See also:
Format.format(java.lang.Object)
316
 
317
     public abstract StringBuffer format(long number,
318
                                         StringBuffer toAppendTo,
319
                                         FieldPosition pos);

   
Returns a Long if possible (e.g., within the range [Long.MIN_VALUE, Long.MAX_VALUE] and with no decimals), otherwise a Double. If IntegerOnly is set, will stop at a decimal point (or equivalent; e.g., for rational numbers "1 2/3", will stop after the 1). Does not throw an exception; if no object can be parsed, index is unchanged!

See also:
isParseIntegerOnly()
Format.parseObject(java.lang.String)
331
 
332
     public abstract Number parse(String source, ParsePosition parsePosition);

    
Parses text from the beginning of the given string to produce a number. The method may not use the entire text of the given string.

See the parse(java.lang.String,java.text.ParsePosition) method for more information on number parsing.

Parameters:
source A String whose beginning should be parsed.
Returns:
A Number parsed from the string.
Throws:
ParseException if the beginning of the specified string cannot be parsed.
345
 
346
     public Number parse(String source) throws ParseException {
347
         ParsePosition parsePosition = new ParsePosition(0);
348
         Number result = parse(source, parsePosition);
349
         if (parsePosition.index == 0) {
350
             throw new ParseException("Unparseable number: \"" + source + "\"",
351
                                      parsePosition.errorIndex);
352
         }
353
         return result;
354
     }

    
Returns true if this format will parse numbers as integers only. For example in the English locale, with ParseIntegerOnly true, the string "1234." would be parsed as the integer value 1234 and parsing would stop at the "." character. Of course, the exact format accepted by the parse operation is locale dependant and determined by sub-classes of NumberFormat. 
363
 
364
     public boolean isParseIntegerOnly() {
365
         return ;
366
     }

    
Sets whether or not numbers should be parsed as integers only.

See also:
isParseIntegerOnly()
371
 
372
     public void setParseIntegerOnly(boolean value) {
373
          = value;
374
     }
375
 
376
     //============== Locale Stuff =====================
377
 
    
Returns a general-purpose number format for the current default locale. This is the same as calling getNumberInstance(). 
382
 
383
     public final static NumberFormat getInstance() {
384
         return getInstance(Locale.getDefault(), );
385
     }

    
Returns a general-purpose number format for the specified locale. This is the same as calling getNumberInstance(inLocale). 
391
 
392
     public static NumberFormat getInstance(Locale inLocale) {
393
         return getInstance(inLocale, );
394
     }

    
Returns a general-purpose number format for the current default locale. 
398
 
399
     public final static NumberFormat getNumberInstance() {
400
         return getInstance(Locale.getDefault(), );
401
     }

    
Returns a general-purpose number format for the specified locale. 
405
 
406
     public static NumberFormat getNumberInstance(Locale inLocale) {
407
         return getInstance(inLocale, );
408
     }

    
Returns an integer number format for the current default locale. The returned number format is configured to round floating point numbers to the nearest integer using half-even rounding (see java.math.RoundingMode.HALF_EVEN) for formatting, and to parse only the integer part of an input string (see isParseIntegerOnly()).

Returns:
a number format for integer values
Since:
1.4
See also:
getRoundingMode()
421
 
422
     public final static NumberFormat getIntegerInstance() {
423
         return getInstance(Locale.getDefault(), );
424
     }

    
Returns an integer number format for the specified locale. The returned number format is configured to round floating point numbers to the nearest integer using half-even rounding (see java.math.RoundingMode.HALF_EVEN) for formatting, and to parse only the integer part of an input string (see isParseIntegerOnly()).

Returns:
a number format for integer values
Since:
1.4
See also:
getRoundingMode()
437
 
438
     public static NumberFormat getIntegerInstance(Locale inLocale) {
439
         return getInstance(inLocale, );
440
     }

    
Returns a currency format for the current default locale. 
444
 
445
     public final static NumberFormat getCurrencyInstance() {
446
         return getInstance(Locale.getDefault(), );
447
     }

    
Returns a currency format for the specified locale. 
451
 
452
     public static NumberFormat getCurrencyInstance(Locale inLocale) {
453
         return getInstance(inLocale, );
454
     }

    
Returns a percentage format for the current default locale. 
458
 
459
     public final static NumberFormat getPercentInstance() {
460
         return getInstance(Locale.getDefault(), );
461
     }

    
Returns a percentage format for the specified locale. 
465
 
466
     public static NumberFormat getPercentInstance(Locale inLocale) {
467
         return getInstance(inLocale, );
468
     }

    
Returns a scientific format for the current default locale. 
472
 
473
     /*public*/ final static NumberFormat getScientificInstance() {
474
         return getInstance(Locale.getDefault(), );
475
     }

    
Returns a scientific format for the specified locale. 
479
 
480
     /*public*/ static NumberFormat getScientificInstance(Locale inLocale) {
481
         return getInstance(inLocale, );
482
     }

    
Returns an array of all locales for which the get*Instance methods of this class can return localized instances. The returned array represents the union of locales supported by the Java runtime and by installed NumberFormatProvider implementations. It must contain at least a Locale instance equal to Locale.US.

Returns:
An array of locales for which localized NumberFormat instances are available.
496
 
497
     public static Locale[] getAvailableLocales() {
498
         LocaleServiceProviderPool pool =
499
             LocaleServiceProviderPool.getPool(NumberFormatProvider.class);
500
         return pool.getAvailableLocales();
501
     }

    
Overrides hashCode 
505
 
506
     public int hashCode() {
507
         return  * 37 + ;
508
         // just enough fields for a reasonable distribution
509
     }

    
Overrides equals 
513
 
514
     public boolean equals(Object obj) {
515
         if (obj == null) {
516
             return false;
517
         }
518
         if (this == obj) {
519
             return true;
520
         }
521
         if (getClass() != obj.getClass()) {
522
             return false;
523
         }
524
         NumberFormat other = (NumberFormat) obj;
525
         return ( == other.maximumIntegerDigits
526
             &&  == other.minimumIntegerDigits
527
             &&  == other.maximumFractionDigits
528
             &&  == other.minimumFractionDigits
529
             &&  == other.groupingUsed
530
             &&  == other.parseIntegerOnly);
531
     }

    
Overrides Cloneable 
535
 
536
     public Object clone() {
537
         NumberFormat other = (NumberFormat) super.clone();
538
         return other;
539
     }

    
Returns true if grouping is used in this format. For example, in the English locale, with grouping on, the number 1234567 might be formatted as "1,234,567". The grouping separator as well as the size of each group is locale dependant and is determined by sub-classes of NumberFormat.

See also:
setGroupingUsed(boolean)
547
 
548
     public boolean isGroupingUsed() {
549
         return ;
550
     }

    
Set whether or not grouping will be used in this format.

See also:
isGroupingUsed()
555
 
556
     public void setGroupingUsed(boolean newValue) {
557
          = newValue;
558
     }

    
Returns the maximum number of digits allowed in the integer portion of a number.

See also:
setMaximumIntegerDigits(int)
564
 
565
     public int getMaximumIntegerDigits() {
566
         return ;
567
     }

    
Sets the maximum number of digits allowed in the integer portion of a number. maximumIntegerDigits must be >= minimumIntegerDigits. If the new value for maximumIntegerDigits is less than the current value of minimumIntegerDigits, then minimumIntegerDigits will also be set to the new value.

Parameters:
newValue the maximum number of integer digits to be shown; if less than zero, then zero is used. The concrete subclass may enforce an upper limit to this value appropriate to the numeric type being formatted.
See also:
getMaximumIntegerDigits()
579
 
580
     public void setMaximumIntegerDigits(int newValue) {
581
          = Math.max(0,newValue);
582
         if ( > ) {
583
              = ;
584
         }
585
     }

    
Returns the minimum number of digits allowed in the integer portion of a number.

See also:
setMinimumIntegerDigits(int)
591
 
592
     public int getMinimumIntegerDigits() {
593
         return ;
594
     }

    
Sets the minimum number of digits allowed in the integer portion of a number. minimumIntegerDigits must be <= maximumIntegerDigits. If the new value for minimumIntegerDigits exceeds the current value of maximumIntegerDigits, then maximumIntegerDigits will also be set to the new value

Parameters:
newValue the minimum number of integer digits to be shown; if less than zero, then zero is used. The concrete subclass may enforce an upper limit to this value appropriate to the numeric type being formatted.
See also:
getMinimumIntegerDigits()
606
 
607
     public void setMinimumIntegerDigits(int newValue) {
608
          = Math.max(0,newValue);
609
         if ( > ) {
610
              = ;
611
         }
612
     }

    
Returns the maximum number of digits allowed in the fraction portion of a number.

See also:
setMaximumFractionDigits(int)
618
 
619
     public int getMaximumFractionDigits() {
620
         return ;
621
     }

    
Sets the maximum number of digits allowed in the fraction portion of a number. maximumFractionDigits must be >= minimumFractionDigits. If the new value for maximumFractionDigits is less than the current value of minimumFractionDigits, then minimumFractionDigits will also be set to the new value.

Parameters:
newValue the maximum number of fraction digits to be shown; if less than zero, then zero is used. The concrete subclass may enforce an upper limit to this value appropriate to the numeric type being formatted.
See also:
getMaximumFractionDigits()
633
 
634
     public void setMaximumFractionDigits(int newValue) {
635
          = Math.max(0,newValue);
636
         if ( < ) {
637
              = ;
638
         }
639
     }

    
Returns the minimum number of digits allowed in the fraction portion of a number.

See also:
setMinimumFractionDigits(int)
645
 
646
     public int getMinimumFractionDigits() {
647
         return ;
648
     }

    
Sets the minimum number of digits allowed in the fraction portion of a number. minimumFractionDigits must be <= maximumFractionDigits. If the new value for minimumFractionDigits exceeds the current value of maximumFractionDigits, then maximumIntegerDigits will also be set to the new value

Parameters:
newValue the minimum number of fraction digits to be shown; if less than zero, then zero is used. The concrete subclass may enforce an upper limit to this value appropriate to the numeric type being formatted.
See also:
getMinimumFractionDigits()
660
 
661
     public void setMinimumFractionDigits(int newValue) {
662
          = Math.max(0,newValue);
663
         if ( < ) {
664
              = ;
665
         }
666
     }

    
Gets the currency used by this number format when formatting currency values. The initial value is derived in a locale dependent way. The returned value may be null if no valid currency could be determined and no currency has been set using setCurrency.

The default implementation throws UnsupportedOperationException.

Returns:
the currency used by this number format, or null
Throws:
java.lang.UnsupportedOperationException if the number format class doesn't implement currency formatting
Since:
1.4
682
 
683
     public Currency getCurrency() {
684
         throw new UnsupportedOperationException();
685
     }

    
Sets the currency used by this number format when formatting currency values. This does not update the minimum or maximum number of fraction digits used by the number format.

The default implementation throws UnsupportedOperationException.

Parameters:
currency the new currency to be used by this number format
Throws:
java.lang.UnsupportedOperationException if the number format class doesn't implement currency formatting
java.lang.NullPointerException if currency is null
Since:
1.4
700
 
701
     public void setCurrency(Currency currency) {
702
         throw new UnsupportedOperationException();
703
     }

    
Gets the java.math.RoundingMode used in this NumberFormat. The default implementation of this method in NumberFormat always throws java.lang.UnsupportedOperationException. Subclasses which handle different rounding modes should override this method.

Returns:
The RoundingMode used for this NumberFormat.
Throws:
java.lang.UnsupportedOperationException The default implementation always throws this exception
Since:
1.6
See also:
setRoundingMode(java.math.RoundingMode)
717
 
718
     public RoundingMode getRoundingMode() {
719
         throw new UnsupportedOperationException();
720
     }

    
Sets the java.math.RoundingMode used in this NumberFormat. The default implementation of this method in NumberFormat always throws java.lang.UnsupportedOperationException. Subclasses which handle different rounding modes should override this method.

Parameters:
roundingMode The RoundingMode to be used
Throws:
java.lang.UnsupportedOperationException The default implementation always throws this exception
java.lang.NullPointerException if roundingMode is null
Since:
1.6
See also:
getRoundingMode()
735
 
736
     public void setRoundingMode(RoundingMode roundingMode) {
737
         throw new UnsupportedOperationException();
738
     }
739
 
740
     // =======================privates===============================
741
 
742
     private static NumberFormat getInstance(Locale desiredLocale,
743
                                            int choice) {
744
         // Check whether a provider can provide an implementation that's closer
745
         // to the requested locale than what the Java runtime itself can provide.
746
         LocaleServiceProviderPool pool =
747
             LocaleServiceProviderPool.getPool(NumberFormatProvider.class);
748
         if (pool.hasProviders()) {
749
             NumberFormat providersInstance = pool.getLocalizedObject(
750
                                     .,
751
                                     desiredLocale,
752
                                     choice);
753
             if (providersInstance != null) {
754
                 return providersInstance;
755
             }
756
         }
757
 
758
         /* try the cache first */
759
         String[] numberPatterns = (String[]).get(desiredLocale);
760
         if (numberPatterns == null) { /* cache miss */
761
             ResourceBundle resource = LocaleData.getNumberFormatData(desiredLocale);
762
             numberPatterns = resource.getStringArray("NumberPatterns");
763
             /* update cache */
764
             .put(desiredLocale, numberPatterns);
765
         }
766
 
767
         DecimalFormatSymbols symbols = DecimalFormatSymbols.getInstance(desiredLocale);
768
         int entry = (choice == ) ?  : choice;
769
         DecimalFormat format = new DecimalFormat(numberPatterns[entry], symbols);
770
 
771
         if (choice == ) {
772
             format.setMaximumFractionDigits(0);
773
             format.setDecimalSeparatorAlwaysShown(false);
774
             format.setParseIntegerOnly(true);
775
         } else if (choice == ) {
776
             format.adjustForCurrencyDefaultFractionDigits();
777
         }
778
 
779
         return format;
780
     }

    
First, read in the default serializable data. Then, if serialVersionOnStream is less than 1, indicating that the stream was written by JDK 1.1, set the int fields such as maximumIntegerDigits to be equal to the byte fields such as maxIntegerDigits, since the int fields were not present in JDK 1.1. Finally, set serialVersionOnStream back to the maximum allowed value so that default serialization will work properly if this object is streamed out again.

If minimumIntegerDigits is greater than maximumIntegerDigits or minimumFractionDigits is greater than maximumFractionDigits, then the stream data is invalid and this method throws an InvalidObjectException. In addition, if any of these values is negative, then this method throws an InvalidObjectException.

Since:
1.2
801
 
802
     private void readObject(ObjectInputStream stream)
803
          throws IOException, ClassNotFoundException
804
     {
805
         stream.defaultReadObject();
806
         if ( < 1) {
807
             // Didn't have additional int fields, reassign to use them.
808
              = ;
809
              = ;
810
              = ;
811
              = ;
812
         }
813
         if ( >  ||
814
              >  ||
815
              < 0 ||  < 0) {
816
             throw new InvalidObjectException("Digit count range invalid");
817
         }
819
     }

    
Write out the default serializable data, after first setting the byte fields such as maxIntegerDigits to be equal to the int fields such as maximumIntegerDigits (or to Byte.MAX_VALUE, whichever is smaller), for compatibility with the JDK 1.1 version of the stream format.

Since:
1.2
829
 
830
     private void writeObject(ObjectOutputStream stream)
831
          throws IOException
832
     {
834
                            . : (byte);
836
                            . : (byte);
838
                             . : (byte);
840
                             . : (byte);
841
         stream.defaultWriteObject();
842
     }

    
Cache to hold the NumberPatterns of a Locale. 
846
 
847
     private static final Hashtable cachedLocaleData = new Hashtable(3);
848
 
849
     // Constants used by factory methods to specify a style of format.
850
     private static final int NUMBERSTYLE = 0;
851
     private static final int CURRENCYSTYLE = 1;
852
     private static final int PERCENTSTYLE = 2;
853
     private static final int SCIENTIFICSTYLE = 3;
854
     private static final int INTEGERSTYLE = 4;

    
True if the grouping (i.e. thousands) separator is used when formatting and parsing numbers.

See also:
isGroupingUsed()
Serial:
862
 
863
     private boolean groupingUsed = true;

    
The maximum number of digits allowed in the integer portion of a number. maxIntegerDigits must be greater than or equal to minIntegerDigits.

Note: This field exists only for serialization compatibility with JDK 1.1. In Java platform 2 v1.2 and higher, the new int field maximumIntegerDigits is used instead. When writing to a stream, maxIntegerDigits is set to maximumIntegerDigits or Byte.MAX_VALUE, whichever is smaller. When reading from a stream, this field is used only if serialVersionOnStream is less than 1.

See also:
getMaximumIntegerDigits()
Serial:
880
 
881
     private byte    maxIntegerDigits = 40;

    
The minimum number of digits allowed in the integer portion of a number. minimumIntegerDigits must be less than or equal to maximumIntegerDigits.

Note: This field exists only for serialization compatibility with JDK 1.1. In Java platform 2 v1.2 and higher, the new int field minimumIntegerDigits is used instead. When writing to a stream, minIntegerDigits is set to minimumIntegerDigits or Byte.MAX_VALUE, whichever is smaller. When reading from a stream, this field is used only if serialVersionOnStream is less than 1.

See also:
getMinimumIntegerDigits()
Serial:
898
 
899
     private byte    minIntegerDigits = 1;

    
The maximum number of digits allowed in the fractional portion of a number. maximumFractionDigits must be greater than or equal to minimumFractionDigits.

Note: This field exists only for serialization compatibility with JDK 1.1. In Java platform 2 v1.2 and higher, the new int field maximumFractionDigits is used instead. When writing to a stream, maxFractionDigits is set to maximumFractionDigits or Byte.MAX_VALUE, whichever is smaller. When reading from a stream, this field is used only if serialVersionOnStream is less than 1.

See also:
getMaximumFractionDigits()
Serial:
916
 
917
     private byte    maxFractionDigits = 3;    // invariant, >= minFractionDigits
918
 
    
The minimum number of digits allowed in the fractional portion of a number. minimumFractionDigits must be less than or equal to maximumFractionDigits.

Note: This field exists only for serialization compatibility with JDK 1.1. In Java platform 2 v1.2 and higher, the new int field minimumFractionDigits is used instead. When writing to a stream, minFractionDigits is set to minimumFractionDigits or Byte.MAX_VALUE, whichever is smaller. When reading from a stream, this field is used only if serialVersionOnStream is less than 1.

See also:
getMinimumFractionDigits()
Serial:
934
 
935
     private byte    minFractionDigits = 0;

    
True if this format will parse numbers as integers only.

See also:
isParseIntegerOnly()
Serial:
942
 
943
     private boolean parseIntegerOnly = false;
944
 
945
     // new fields for 1.2.  byte is too small for integer digits.
946
 
    
The maximum number of digits allowed in the integer portion of a number. maximumIntegerDigits must be greater than or equal to minimumIntegerDigits.

Since:
1.2
See also:
getMaximumIntegerDigits()
Serial:
955
 
956
     private int    maximumIntegerDigits = 40;

    
The minimum number of digits allowed in the integer portion of a number. minimumIntegerDigits must be less than or equal to maximumIntegerDigits.

Since:
1.2
See also:
getMinimumIntegerDigits()
Serial:
966
 
967
     private int    minimumIntegerDigits = 1;

    
The maximum number of digits allowed in the fractional portion of a number. maximumFractionDigits must be greater than or equal to minimumFractionDigits.

Since:
1.2
See also:
getMaximumFractionDigits()
Serial:
977
 
978
     private int    maximumFractionDigits = 3;    // invariant, >= minFractionDigits
979
 
    
The minimum number of digits allowed in the fractional portion of a number. minimumFractionDigits must be less than or equal to maximumFractionDigits.

Since:
1.2
See also:
getMinimumFractionDigits()
Serial:
988
 
989
     private int    minimumFractionDigits = 0;
990
 
991
     static final int currentSerialVersion = 1;

    
Describes the version of NumberFormat present on the stream. Possible values are:
  • 0 (or uninitialized): the JDK 1.1 version of the stream format. In this version, the int fields such as maximumIntegerDigits were not present, and the byte fields such as maxIntegerDigits are used instead.
  • 1: the 1.2 version of the stream format. The values of the byte fields such as maxIntegerDigits are ignored, and the int fields such as maximumIntegerDigits are used instead.
When streaming out a NumberFormat, the most recent format (corresponding to the highest allowable serialVersionOnStream) is always written.

Since:
1.2
Serial:
1016
    // Removed "implements Cloneable" clause.  Needs to update serialization
1017
    // ID for backward compatibility.
1018
    static final long serialVersionUID = -2308460125733713944L;
1021
    //
1022
    // class for AttributedCharacterIterator attributes
1023
    //
1024
    
Defines constants that are used as attribute keys in the AttributedCharacterIterator returned from NumberFormat.formatToCharacterIterator and as field identifiers in FieldPosition.

Since:
1.4
1032
    public static class Field extends Format.Field {
1034
        // Proclaim serial compatibility with 1.4 FCS
1035
        private static final long serialVersionUID = 7494728892700160890L;
1037
        // table of all instances in this class, used by readResolve
1038
        private static final Map instanceMap = new HashMap(11);

        
Creates a Field instance with the specified name.

Parameters:
name Name of the attribute
1046
        protected Field(String name) {
1047
            super(name);
1048
            if (this.getClass() == NumberFormat.Field.class) {
1049
                .put(name, this);
1050
            }
1051
        }

        
Resolves instances being deserialized to the predefined constants.

Returns:
resolved NumberFormat.Field constant
Throws:
java.io.InvalidObjectException if the constant could not be resolved.
1059
        protected Object readResolve() throws InvalidObjectException {
1060
            if (this.getClass() != NumberFormat.Field.class) {
1061
                throw new InvalidObjectException("subclass didn't correctly implement readResolve");
1062
            }
1064
            Object instance = .get(getName());
1065
            if (instance != null) {
1066
                return instance;
1067
            } else {
1068
                throw new InvalidObjectException("unknown attribute name");
1069
            }
1070
        }

        
Constant identifying the integer field. 
1075
        public static final Field INTEGER = new Field("integer");

        
Constant identifying the fraction field. 
1080
        public static final Field FRACTION = new Field("fraction");

        
Constant identifying the exponent field. 
1085
        public static final Field EXPONENT = new Field("exponent");

        
Constant identifying the decimal separator field. 
1090
        public static final Field DECIMAL_SEPARATOR =
1091
                            new Field("decimal separator");

        
Constant identifying the sign field. 
1096
        public static final Field SIGN = new Field("sign");

        
Constant identifying the grouping separator field. 
1101
        public static final Field GROUPING_SEPARATOR =
1102
                            new Field("grouping separator");

        
Constant identifying the exponent symbol field. 
1107
        public static final Field EXPONENT_SYMBOL = new
1108
                            Field("exponent symbol");

        
Constant identifying the percent field. 
1113
        public static final Field PERCENT = new Field("percent");

        
Constant identifying the permille field. 
1118
        public static final Field PERMILLE = new Field("per mille");

        
Constant identifying the currency field. 
1123
        public static final Field CURRENCY = new Field("currency");

        
Constant identifying the exponent sign field. 
1128
        public static final Field EXPONENT_SIGN = new Field("exponent sign");
1129
    }

    
Obtains a NumberFormat instance from a NumberFormatProvider implementation. 
1134
    private static class NumberFormatGetter
1136
                                                                   NumberFormat> {
1137
        private static final NumberFormatGetter INSTANCE = new NumberFormatGetter();
1139
        public NumberFormat getObject(NumberFormatProvider numberFormatProvider,
1140
                                Locale locale,
1141
                                String key,
1142
                                Object... params) {
1143
            assert params.length == 1;
1144
            int choice = (Integer)params[0];
1146
            switch (choice) {
1147
            case :
1148
                return numberFormatProvider.getNumberInstance(locale);
1149
            case :
1150
                return numberFormatProvider.getPercentInstance(locale);
1151
            case :
1152
                return numberFormatProvider.getCurrencyInstance(locale);
1153
            case :
1154
                return numberFormatProvider.getIntegerInstance(locale);
1155
            default:
1156
                assert false : choice;
1157
            }
1159
            return null;
1160
        }
1161
    }
New to GrepCode? Check out our FAQ X