下面列出了java.text.NumberFormat#setGroupingUsed ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
/**
*
*/
private static ByteBuffer encodeLogicalType(final Field field, final String fieldValue) {
String logicalType = field.getProp("logicalType");
if (!"decimal".contentEquals(logicalType)) {
throw new IllegalArgumentException("The field '" + field.name() + "' has a logical type of '" + logicalType
+ "' that is currently not supported.");
}
JsonNode rawPrecision = field.getJsonProp("precision");
if (null == rawPrecision) {
throw new IllegalArgumentException("The field '" + field.name() + "' is missing the required precision property");
}
int precision = rawPrecision.asInt();
JsonNode rawScale = field.getJsonProp("scale");
int scale = null == rawScale ? 0 : rawScale.asInt();
NumberFormat numberFormat = DecimalFormat.getInstance();
numberFormat.setGroupingUsed(false);
normalizeNumberFormat(numberFormat, scale, precision);
BigDecimal decimal = null == fieldValue ? new BigDecimal(retrieveDefaultFieldValue(field).asText()) : new BigDecimal(fieldValue);
return ByteBuffer.wrap(numberFormat.format(decimal).getBytes(StandardCharsets.UTF_8));
}
/**
* Return a string with a table describing all tasks performed.
* For custom reporting, call getTaskInfo() and use the task info directly.
*/
public String prettyPrint() {
StringBuilder sb = new StringBuilder(shortSummary());
sb.append('\n');
if (!this.keepTaskList) {
sb.append("No task info kept");
} else {
TaskInfo[] tasks = getTaskInfo();
sb.append("-----------------------------------------\n");
sb.append("ms % Task name\n");
sb.append("-----------------------------------------\n");
NumberFormat nf = NumberFormat.getNumberInstance();
nf.setMinimumIntegerDigits(5);
nf.setGroupingUsed(false);
NumberFormat pf = NumberFormat.getPercentInstance();
pf.setMinimumIntegerDigits(3);
pf.setGroupingUsed(false);
for (TaskInfo task : tasks) {
sb.append(nf.format(task.getTimeMillis())).append(" ");
sb.append(pf.format(task.getTimeSeconds() / getTotalTimeSeconds())).append(" ");
sb.append(task.getTaskName()).append("\n");
}
}
return sb.toString();
}
/**
* Rounding formatting numbers
* Optional point form, default 2 bit precision
* @param val The value that needs to be converted
* @param isGroupingUsed Whether to display points
* @param precision The first is the maximum number of decimal places,
* and the second is the minimum number of decimal places.
* @return String
*/
public static String parseNumber(Object val, Boolean isGroupingUsed,
int... precision)
{
int max = PRECISION_TWO;
int min = PRECISION_TWO;
if (precision.length == PRECISION_ONE)
{
max = precision[0];
}
else if (precision.length == PRECISION_TWO)
{
max = precision[0];
min = precision[1];
}
NumberFormat nf = NumberFormat.getNumberInstance();
nf.setRoundingMode(RoundingMode.HALF_UP);
nf.setMaximumFractionDigits(max);
nf.setMinimumFractionDigits(min > max ? max : min);
nf.setGroupingUsed(isGroupingUsed);
return nf.format(val);
}
/**
* ECMA 15.7.4.5 Number.prototype.toFixed (fractionDigits) specialized for int fractionDigits
*
* @param self self reference
* @param fractionDigits how many digits should be after the decimal point, 0 if undefined
*
* @return number in decimal fixed point notation
*/
@SpecializedFunction
public static String toFixed(final Object self, final int fractionDigits) {
if (fractionDigits < 0 || fractionDigits > 20) {
throw rangeError("invalid.fraction.digits", "toFixed");
}
final double x = getNumberValue(self);
if (Double.isNaN(x)) {
return "NaN";
}
if (Math.abs(x) >= 1e21) {
return JSType.toString(x);
}
final NumberFormat format = NumberFormat.getNumberInstance(Locale.US);
format.setMinimumFractionDigits(fractionDigits);
format.setMaximumFractionDigits(fractionDigits);
format.setGroupingUsed(false);
format.setRoundingMode(RoundingMode.HALF_UP);
return format.format(x);
}
/**
* Convert an input Number object into a String.
*
* @param value The input value to be converted
* @return the converted String value.
* @throws Throwable if an error occurs converting to a String
*/
@Override
protected String convertToString(Object value) throws Throwable {
String result = null;
if (useLocaleFormat && value instanceof Number) {
NumberFormat format = getFormat();
format.setGroupingUsed(false);
result = format.format(value);
if (log().isDebugEnabled()) {
log().debug(" Converted to String using format '" + result + "'");
}
} else {
result = value.toString();
if (log().isDebugEnabled()) {
log().debug(" Converted to String using toString() '" + result + "'");
}
}
return result;
}
/**
* Return a string with a table describing all tasks performed.
* For custom reporting, call getTaskInfo() and use the task info directly.
*/
public String prettyPrint() {
StringBuilder sb = new StringBuilder(shortSummary());
sb.append('\n');
if (!this.keepTaskList) {
sb.append("No task info kept");
} else {
sb.append("-----------------------------------------\n");
sb.append("ms % Task name\n");
sb.append("-----------------------------------------\n");
NumberFormat nf = NumberFormat.getNumberInstance();
nf.setMinimumIntegerDigits(5);
nf.setGroupingUsed(false);
NumberFormat pf = NumberFormat.getPercentInstance();
pf.setMinimumIntegerDigits(3);
pf.setGroupingUsed(false);
for (TaskInfo task : getTaskInfo()) {
sb.append(nf.format(task.getTimeMillis())).append(" ");
sb.append(pf.format(task.getTimeSeconds() / getTotalTimeSeconds())).append(" ");
sb.append(task.getTaskName()).append("\n");
}
}
return sb.toString();
}
public static String offset2FileName(final long offset) {
final NumberFormat nf = NumberFormat.getInstance();
nf.setMinimumIntegerDigits(20);
nf.setMaximumFractionDigits(0);
nf.setGroupingUsed(false);
return nf.format(offset);
}
@Override
public NumberFormat initialValue() {
NumberFormat fmt = NumberFormat.getInstance();
fmt.setGroupingUsed(false);
fmt.setMinimumIntegerDigits(6);
return fmt;
}
@Override
public NumberFormat initialValue() {
NumberFormat fmt = NumberFormat.getInstance();
fmt.setGroupingUsed(false);
fmt.setMinimumIntegerDigits(4);
return fmt;
}
static String offset2FileName(final long offset) {
final NumberFormat nf = NumberFormat.getInstance();
nf.setMinimumIntegerDigits(20);
nf.setMaximumFractionDigits(0);
nf.setGroupingUsed(false);
return nf.format(offset);
}
/**
* 将offset转化成字符串形式<br>
* 左补零对齐至20位
*/
public static String offset2FileName(final long offset) {
final NumberFormat nf = NumberFormat.getInstance();
nf.setMinimumIntegerDigits(20);
nf.setMaximumFractionDigits(0);
nf.setGroupingUsed(false);
return nf.format(offset);
}
private void createUIComponents() {
NumberFormat format = NumberFormat.getInstance();
format.setGroupingUsed(false);
NumberFormatter formatter = new NumberFormatter(format);
formatter.setValueClass(Integer.class);
formatter.setMaximum(65535);
formatter.setAllowsInvalid(false);
formatter.setCommitsOnValidEdit(true);
portTextField = new JFormattedTextField(formatter);
jvmPortTextField = new JFormattedTextField(formatter);
appsMap = new JBTable(new ModulesTableModel());
}
/**
* @return a unique number which shorts in descending order
*/
private static String nextId() {
NumberFormat numberFormat = NumberFormat.getInstance();
numberFormat.setMinimumIntegerDigits(10);
numberFormat.setGroupingUsed(false);
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd_HH.mm.ss");
return Utils.format("{}-{}", dateFormat.format(new Date()), numberFormat.format(fileCounter.incrementAndGet()));
}
/**
* Initialize the formatter for double values.
* @return a {@code NumberFormat} instance.
*/
private NumberFormat initDoubleFormatter() {
final NumberFormat doubleFormatter = NumberFormat.getInstance(locale);
doubleFormatter.setGroupingUsed(true);
doubleFormatter.setMinimumFractionDigits(2);
doubleFormatter.setMaximumFractionDigits(2);
doubleFormatter.setMinimumIntegerDigits(1);
return doubleFormatter;
}
/**
* This test runs a comparision of the performance of various string
* formatting methods and validates that DoubleFormat is the fastest.
* Not a replacement for in-depth analysis.
*
* If this test is failing, either DoubleFormat has a performance
* regression or the built-in methods have improved enough to reconsider.
*
* The test can take multiple seconds to run.
*/
@Test
public void benchmark() throws Exception {
final long iterations = 1000000;
long duration_StringFormat = run_benchmark(iterations, (a) -> String.format("%.6f", a));
NumberFormat javaFormatter = NumberFormat.getInstance();
javaFormatter.setMinimumFractionDigits(0);
javaFormatter.setMaximumFractionDigits(6);
javaFormatter.setGroupingUsed(false);
long duration_JavaFormat = run_benchmark(iterations, (a) -> javaFormatter.format(a));
long duration_JavaStringBuilder = run_benchmark(iterations, (a) -> (new StringBuilder()).append(a));
long duration_DoubleFormat = run_benchmark(iterations, (a) -> DoubleFormat.format(new StringBuilder(), a));
System.out.println("DoubleFormat Performance comparison: " + iterations +" iterations");
System.out.println("\tJava String.format: " + duration_StringFormat + " ms");
System.out.println("\tJava NumberFormat: " + duration_JavaFormat + " ms");
System.out.println("\tJava StringBuilder: " + duration_JavaStringBuilder + " ms");
System.out.println("\tDoubleFormat: " + duration_DoubleFormat + " ms");
assertTrue(duration_DoubleFormat < duration_StringFormat);
assertTrue(duration_DoubleFormat < duration_JavaFormat);
assertTrue(duration_DoubleFormat < duration_JavaStringBuilder);
}
@Test(timeout = 1000)
public void testLongWithPadding() throws Exception {
FastNumberFormat fastNumberFormat = FastNumberFormat.getInstance();
fastNumberFormat.setMinimumIntegerDigits(6);
NumberFormat numberFormat = NumberFormat.getInstance();
numberFormat.setGroupingUsed(false);
numberFormat.setMinimumIntegerDigits(6);
long[] testLongs = {1, 23, 456, 7890, 12345, 678901, 2345689, 0, -0, -1, -23, -456, -7890, -12345, -678901, -2345689};
for (long l: testLongs) {
Assert.assertEquals("Number formats should be equal", numberFormat.format(l), fastNumberFormat.format(l));
}
}
/**
* Format a real number
*
* @param value real number to format
* @param precision max # of digits after the decimal place
* @param bTruncateZeros remove any trailing zeros after decimal place
* @param bRound Whether the number will be rounded to the precision, or
* truncated off.
* @return formatted string
*/
public static String
formatDecimal(
double value,
int precision,
boolean bTruncateZeros,
boolean bRound)
{
if (Double.isNaN(value) || Double.isInfinite(value)) {
return Constants.INFINITY_STRING;
}
double tValue;
if (bRound) {
tValue = value;
} else {
// NumberFormat rounds, so truncate at precision
if (precision == 0) {
tValue = (long) value;
} else {
double shift = Math.pow(10, precision);
tValue = ((long) (value * shift)) / shift;
}
}
int cache_index = (precision << 2) + ((bTruncateZeros ? 1 : 0) << 1)
+ (bRound ? 1 : 0);
NumberFormat nf = null;
if (cache_index < cached_number_formats.length) {
nf = cached_number_formats[cache_index];
}
if (nf == null) {
nf = NumberFormat.getNumberInstance();
nf.setGroupingUsed(false); // no commas
if (!bTruncateZeros) {
nf.setMinimumFractionDigits(precision);
}
if (bRound) {
nf.setMaximumFractionDigits(precision);
}
if (cache_index < cached_number_formats.length) {
cached_number_formats[cache_index] = nf;
}
}
return nf.format(tValue);
}
public void outputStateGraph(String file, boolean withProbs) {
try {
NumberFormat num = NumberFormat.getInstance();
num.setMaximumFractionDigits(6);
num.setGroupingUsed(false);
BufferedWriter out = new BufferedWriter(new FileWriter(file));
out.write("digraph G {\n");
for (State m : stateGraph) {
// for (String state : stateGraph.keySet()) {
// for (State m : stateGraph.get(state)) {
if (withProbs) {
out.write(m.getID() + " [shape=\"ellipse\",label=\"" + m.getID() + "\\n<" + m.stateVector
+ ">\\nProb = " + num.format(m.getCurrentProb()) + "\"]\n");
}
else {
out.write(m.getID() + " [shape=\"ellipse\",label=\"" + m.getID() + "\\n<" + m.stateVector
+ ">\"]\n");
}
for (StateTransitionPair next : m.getNextStatesWithTrans()) {
/*
* System.out.println(m.getID() + " -> " +
* next.getState().getID() + " [label=\"" +
* next.getTransition() + "\\n");
* System.out.println(m.getTransitionSum());
* System.out.println(lhpn.getTransitionRateTree(
* next.getTransition ()).evaluateExpr(m.getVariables()));
*/
if (next.isEnabled()) {
out.write(m.getID() + " -> " + next.getState().getID() + " [label=\""
+ next.getTransitionName() + "\\n" + num.format(next.getTransition()) + "\"]\n");
}
// if (lhpn.getTransitionRateTree(next.getTransition())
// != null) {
// out.write(m.getID()
// + " -> "
// + next.getState().getID()
// + " [label=\""
// + next.getTransition()
// + "\\n"
// +
// num.format((lhpn.getTransitionRateTree(next.getTransition()).evaluateExpr(m
// .getVariables()) /*
// * / m . getTransitionSum ( )
// */)) + "\"]\n");
// }
// else {
// out.write(m.getID() + " -> " +
// next.getState().getID() +
// " [label=\"" + next.getTransition() + "\"]\n");
// }
}
}
// }
out.write("}");
out.close();
}
catch (Exception e) {
e.printStackTrace();
System.err.println("Error outputting state graph as dot file.");
}
}
/**
* Obtains a formatter for decimal percentages configured by grouping and decimal places.
* <p>
* The formatter will have the specified number of decimal places.
* The integer part will be grouped if the flag is set.
* The decimal part will never be grouped or truncated.
* The implementation uses English locale data, which uses commas as a separator and a decimal point (dot).
* The formatter will suffix the output with '%'.
* Numbers will be rounded using {@link RoundingMode#HALF_EVEN}
* <p>
* The number passed in must be the decimal representation of the percentage.
* It will be multiplied by 100 before formatting.
*
* @param grouped true to group, false to not group
* @param minDecimalPlaces the minimum number of decimal places, from 0 to 9
* @param maxDecimalPlaces the minimum number of decimal places, from 0 to 9
* @return the formatter
* @throws IllegalArgumentException if the decimal places is invalid
*/
public static NumberFormatter ofPercentage(boolean grouped, int minDecimalPlaces, int maxDecimalPlaces) {
ArgChecker.inRangeInclusive(minDecimalPlaces, 0, 9, "minDecimalPlaces");
ArgChecker.inRangeInclusive(maxDecimalPlaces, 0, 9, "maxDecimalPlaces");
ArgChecker.isTrue(minDecimalPlaces <= maxDecimalPlaces, "Expected minDecimalPlaces <= maxDecimalPlaces");
NumberFormat format = NumberFormat.getPercentInstance(Locale.ENGLISH);
format.setGroupingUsed(grouped);
format.setMinimumIntegerDigits(1);
format.setMinimumFractionDigits(minDecimalPlaces);
format.setMaximumFractionDigits(maxDecimalPlaces);
return new NumberFormatter(format);
}
/**
* Create and populate relation in the {@link #namespace}.
*
* @return The #of distinct entries.
*/
private int loadData(final int scale) {
final String[] names = new String[] { "John", "Mary", "Saul", "Paul",
"Leon", "Jane", "Mike", "Mark", "Jill", "Jake", "Alex", "Lucy" };
final Random rnd = new Random();
// #of distinct instances of each name.
final int populationSize = Math.max(10, (int) Math.ceil(scale / 10.));
// #of trailing zeros for each name.
final int nzeros = 1 + (int) Math.ceil(Math.log10(populationSize));
// System.out.println("scale=" + scale + ", populationSize="
// + populationSize + ", nzeros=" + nzeros);
final NumberFormat fmt = NumberFormat.getIntegerInstance();
fmt.setMinimumIntegerDigits(nzeros);
fmt.setMaximumIntegerDigits(nzeros);
fmt.setGroupingUsed(false);
// create the relation.
final R rel = new R(jnl, namespace, ITx.UNISOLATED, new Properties());
rel.create();
// data to insert.
final E[] a = new E[scale];
for (int i = 0; i < scale; i++) {
final String n1 = names[rnd.nextInt(names.length)]
+ fmt.format(rnd.nextInt(populationSize));
final String n2 = names[rnd.nextInt(names.length)]
+ fmt.format(rnd.nextInt(populationSize));
// System.err.println("i=" + i + ", n1=" + n1 + ", n2=" + n2);
a[i] = new E(n1, n2);
}
// sort before insert for efficiency.
Arrays.sort(a,R.primaryKeyOrder.getComparator());
// insert data (the records are not pre-sorted).
final long ninserts = rel.insert(new ChunkedArrayIterator<E>(a.length, a, null/* keyOrder */));
// Do commit since not scale-out.
jnl.commit();
// should exist as of the last commit point.
this.rel = (R) jnl.getResourceLocator().locate(namespace,
ITx.READ_COMMITTED);
assertNotNull(rel);
return (int) ninserts;
}