|
1
7
8
20
21 package java.text;
22
23 import java.io.InvalidObjectException  ;
24 import java.io.IOException ;
25 import java.io.ObjectInputStream ;
26 import java.math.BigDecimal ;
27 import java.math.BigInteger ;
28 import java.util.ArrayList ;
29 import java.util.Currency ;
30 import java.util.Hashtable ;
31 import java.util.Locale ;
32 import java.util.ResourceBundle ;
33 import sun.text.resources.LocaleData;
34
35
357 public class DecimalFormat extends NumberFormat {
358
359
374 public DecimalFormat() {
375 Locale def = Locale.getDefault();
376 String pattern = (String ) cachedLocaleData.get(def);
378 if (pattern == null) {
379 ResourceBundle rb = LocaleData.getLocaleElements(def);
381 String [] all = rb.getStringArray("NumberPatterns");
382 pattern = all[0];
383
384 cachedLocaleData.put(def, pattern);
385 }
386
387 this.symbols = new DecimalFormatSymbols (def);
389 applyPattern(pattern, false);
390 }
391
392
393
411 public DecimalFormat(String pattern) {
412 this.symbols = new DecimalFormatSymbols (Locale.getDefault());
414 applyPattern(pattern, false);
415 }
416
417
418
439 public DecimalFormat (String pattern, DecimalFormatSymbols symbols) {
440 this.symbols = (DecimalFormatSymbols )symbols.clone();
442 applyPattern(pattern, false);
443 }
444
445
446
465 public final StringBuffer format(Object number,
466 StringBuffer toAppendTo,
467 FieldPosition pos) {
468 if (number instanceof Long || number instanceof Integer ||
469 number instanceof Short || number instanceof Byte ||
470 (number instanceof BigInteger &&
471 ((BigInteger )number).bitLength () < 64)) {
472 return format(((Number )number).longValue(), toAppendTo, pos);
473 } else if (number instanceof BigDecimal ) {
474 return format((BigDecimal )number, toAppendTo, pos);
475 } else if (number instanceof BigInteger ) {
476 return format((BigInteger )number, toAppendTo, pos);
477 } else if (number instanceof Number ) {
478 return format(((Number )number).doubleValue(), toAppendTo, pos);
479 } else {
480 throw new IllegalArgumentException ("Cannot format given Object as a Number");
481 }
482 }
483
484
493 public StringBuffer format(double number, StringBuffer result,
494 FieldPosition fieldPosition) {
495 fieldPosition.setBeginIndex(0);
496 fieldPosition.setEndIndex(0);
497
498 return format(number, result, fieldPosition.getFieldDelegate());
499 }
500
501
508 private StringBuffer format(double number, StringBuffer result,
509 FieldDelegate delegate) {
510 if (Double.isNaN(number) ||
511 (Double.isInfinite(number) && multiplier == 0)) {
512 int iFieldStart = result.length();
513 result.append(symbols.getNaN());
514 delegate.formatted(INTEGER_FIELD, Field.INTEGER, Field.INTEGER,
515 iFieldStart, result.length(), result);
516 return result;
517 }
518
519
529 boolean isNegative = ((number < 0.0) || (number == 0.0 && 1/number < 0.0)) ^ (multiplier < 0);
530
531 if (multiplier != 1) {
532 number *= multiplier;
533 }
534
535 if (Double.isInfinite(number)) {
536 if (isNegative) {
537 append(result, negativePrefix, delegate,
538 getNegativePrefixFieldPositions(), Field.SIGN);
539 } else {
540 append(result, positivePrefix, delegate,
541 getPositivePrefixFieldPositions(), Field.SIGN);
542 }
543
544 int iFieldStart = result.length();
545 result.append(symbols.getInfinity());
546 delegate.formatted(INTEGER_FIELD, Field.INTEGER, Field.INTEGER,
547 iFieldStart, result.length(), result);
548
549 if (isNegative) {
550 append(result, negativeSuffix, delegate,
551 getNegativeSuffixFieldPositions(), Field.SIGN);
552 } else {
553 append(result, positiveSuffix, delegate,
554 getPositiveSuffixFieldPositions(), Field.SIGN);
555 }
556
557 return result;
558 }
559
560 if (isNegative) {
561 number = -number;
562 }
563
564 assert(number >= 0 && !Double.isInfinite(number));
566
567 synchronized(digitList) {
568 int maxIntDigits = super.getMaximumIntegerDigits();
569 int minIntDigits = super.getMinimumIntegerDigits();
570 int maxFraDigits = super.getMaximumFractionDigits();
571 int minFraDigits = super.getMinimumFractionDigits();
572
573 digitList.set(number, useExponentialNotation ?
574 maxIntDigits + maxFraDigits : maxFraDigits,
575 !useExponentialNotation);
576 return subformat(result, delegate, isNegative, false,
577 maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);
578 }
579 }
580
581
590 public StringBuffer format(long number, StringBuffer result,
591 FieldPosition fieldPosition) {
592 fieldPosition.setBeginIndex(0);
593 fieldPosition.setEndIndex(0);
594
595 return format(number, result, fieldPosition.getFieldDelegate());
596 }
597
598
606 private StringBuffer format(long number, StringBuffer result,
607 FieldDelegate delegate) {
608 boolean isNegative = (number < 0);
609 if (isNegative) {
610 number = -number;
611 }
612
613 boolean useBigInteger = false;
620 if (number < 0) { if (multiplier != 0) {
622 useBigInteger = true;
623 }
624 } else if (multiplier != 1 && multiplier != 0) {
625 long cutoff = Long.MAX_VALUE / multiplier;
626 if (cutoff < 0) {
627 cutoff = -cutoff;
628 }
629 useBigInteger = (number > cutoff);
630 }
631
632 if (useBigInteger) {
633 if (isNegative) {
634 number = -number;
635 }
636 BigInteger bigIntegerValue = BigInteger.valueOf(number);
637 return format(bigIntegerValue, result, delegate, true);
638 }
639
640 number *= multiplier;
641 if (number == 0) {
642 isNegative = false;
643 } else {
644 if (multiplier < 0) {
645 number = -number;
646 isNegative = !isNegative;
647 }
648 }
649
650 synchronized(digitList) {
651 int maxIntDigits = super.getMaximumIntegerDigits();
652 int minIntDigits = super.getMinimumIntegerDigits();
653 int maxFraDigits = super.getMaximumFractionDigits();
654 int minFraDigits = super.getMinimumFractionDigits();
655
656 digitList.set(number,
657 useExponentialNotation ? maxIntDigits + maxFraDigits : 0);
658
659 return subformat(result, delegate, isNegative, true,
660 maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);
661 }
662 }
663
664
673 private StringBuffer format(BigDecimal number, StringBuffer result,
674 FieldPosition fieldPosition) {
675 fieldPosition.setBeginIndex(0);
676 fieldPosition.setEndIndex(0);
677 return format(number, result, fieldPosition.getFieldDelegate());
678 }
679
680
687 private StringBuffer format(BigDecimal number, StringBuffer result,
688 FieldDelegate delegate) {
689 if (multiplier != 1) {
690 number = number.multiply(getBigDecimalMultiplier());
691 }
692 boolean isNegative = number.signum() == -1;
693 if (isNegative) {
694 number = number.negate();
695 }
696
697 synchronized(digitList) {
698 int maxIntDigits = getMaximumIntegerDigits();
699 int minIntDigits = getMinimumIntegerDigits();
700 int maxFraDigits = getMaximumFractionDigits();
701 int minFraDigits = getMinimumFractionDigits();
702 int maximumDigits = maxIntDigits + maxFraDigits;
703
704 digitList.set(number, useExponentialNotation ?
705 ((maximumDigits < 0) ? Integer.MAX_VALUE : maximumDigits) :
706 maxFraDigits, !useExponentialNotation);
707
708 return subformat(result, delegate, isNegative, false,
709 maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);
710 }
711 }
712
713
722 private StringBuffer format(BigInteger number, StringBuffer result,
723 FieldPosition fieldPosition) {
724 fieldPosition.setBeginIndex(0);
725 fieldPosition.setEndIndex(0);
726
727 return format(number, result, fieldPosition.getFieldDelegate(), false);
728 }
729
730
738 private StringBuffer format(BigInteger number, StringBuffer result,
739 FieldDelegate delegate, boolean formatLong) {
740 if (multiplier != 1) {
741 number = number.multiply(getBigIntegerMultiplier());
742 }
743 boolean isNegative = number.signum() == -1;
744 if (isNegative) {
745 number = number.negate();
746 }
747
748 synchronized(digitList) {
749 int maxIntDigits, minIntDigits, maxFraDigits, minFraDigits, maximumDigits;
750 if (formatLong) {
751 maxIntDigits = super.getMaximumIntegerDigits();
752 minIntDigits = super.getMinimumIntegerDigits();
753 maxFraDigits = super.getMaximumFractionDigits();
754 minFraDigits = super.getMinimumFractionDigits();
755 maximumDigits = maxIntDigits + maxFraDigits;
756 } else {
757 maxIntDigits = getMaximumIntegerDigits();
758 minIntDigits = getMinimumIntegerDigits();
759 maxFraDigits = getMaximumFractionDigits();
760 minFraDigits = getMinimumFractionDigits();
761 maximumDigits = maxIntDigits + maxFraDigits;
762 if (maximumDigits < 0) {
763 maximumDigits = Integer.MAX_VALUE;
764 }
765 }
766
767 digitList.set(number, useExponentialNotation ? maximumDigits : 0);
768
769 return subformat(result, delegate, isNegative, true,
770 maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);
771 }
772 }
773
774
791 public AttributedCharacterIterator formatToCharacterIterator(Object obj) {
792 CharacterIteratorFieldDelegate delegate =
793 new CharacterIteratorFieldDelegate ();
794 StringBuffer sb = new StringBuffer ();
795
796 if (obj instanceof Double || obj instanceof Float ) {
797 format(((Number )obj).doubleValue(), sb, delegate);
798 } else if (obj instanceof Long || obj instanceof Integer ||
799 obj instanceof Short || obj instanceof Byte ) {
800 format(((Number )obj).longValue(), sb, delegate);
801 } else if (obj instanceof BigDecimal ) {
802 format((BigDecimal )obj, sb, delegate);
803 } else if (obj instanceof BigInteger ) {
804 format((BigInteger )obj, sb, delegate, false);
805 } else if (obj == null) {
806 throw new NullPointerException (
807 "formatToCharacterIterator must be passed non-null object");
808 } else {
809 throw new IllegalArgumentException (
810 "Cannot format given Object as a Number");
811 }
812 return delegate.getIterator(sb.toString());
813 }
814
815
819 private StringBuffer subformat(StringBuffer result, FieldDelegate delegate,
820 boolean isNegative, boolean isInteger,
821 int maxIntDigits, int minIntDigits,
822 int maxFraDigits, int minFraDigits) {
823
837 char zero = symbols.getZeroDigit();
838 int zeroDelta = zero - '0'; char grouping = symbols.getGroupingSeparator();
840 char decimal = isCurrencyFormat ?
841 symbols.getMonetaryDecimalSeparator() :
842 symbols.getDecimalSeparator();
843
844
850 if (digitList.isZero()) {
851 digitList.decimalAt = 0; }
853
854 if (isNegative) {
855 append(result, negativePrefix, delegate,
856 getNegativePrefixFieldPositions(), Field.SIGN);
857 } else {
858 append(result, positivePrefix, delegate,
859 getPositivePrefixFieldPositions(), Field.SIGN);
860 }
861
862 if (useExponentialNotation) {
863 int iFieldStart = result.length();
864 int iFieldEnd = -1;
865 int fFieldStart = -1;
866
867
871 int exponent = digitList.decimalAt;
879 int repeat = maxIntDigits;
880 int minimumIntegerDigits = minIntDigits;
881 if (repeat > 1 && repeat > minIntDigits) {
882 if (exponent >= 1) {
888 exponent = ((exponent - 1) / repeat) * repeat;
889 } else {
890 exponent = ((exponent - repeat) / repeat) * repeat;
892 }
893 minimumIntegerDigits = 1;
894 } else {
895 exponent -= minimumIntegerDigits;
897 }
898
899 |
Java API By Example, From Geeks To Geeks.