Java NumberFormat.setMaximumFractionDigits方法代码示例

import java.text.NumberFormat; //导入方法依赖的package包/类
public String convertByteTo(long byteData){
	NumberFormat formatter = NumberFormat.getInstance();
	formatter.setMaximumFractionDigits(2);
	try {
		double kb = byteData/1024L;
		if(kb >= 1024){
			double mb = kb/1024L;
			if(mb >= 1024){
				double gb = mb/1024L;
				return formatter.format(gb) +" GB";
			}else
				return  formatter.format(mb)+" MB";
		}else{				
			return formatter.format(kb)+" KB";
		}

	} catch (Exception e) {
		// TODO: handle exception
		return String.valueOf(byteData);
	}
}
 

import java.text.NumberFormat; //导入方法依赖的package包/类
public static String bytes2String(long sizeInBytes) {

        NumberFormat nf = new DecimalFormat();
        nf.setMaximumFractionDigits(1);
        nf.setMinimumFractionDigits(1);

        try {
            if (sizeInBytes < SPACE_KB) {
                return nf.format(sizeInBytes) + " Byte(s)";
            } else if (sizeInBytes < SPACE_MB) {
                return nf.format(sizeInBytes / SPACE_KB) + " KB";
            } else if (sizeInBytes < SPACE_GB) {
                return nf.format(sizeInBytes / SPACE_MB) + " MB";
            } else if (sizeInBytes < SPACE_TB) {
                return nf.format(sizeInBytes / SPACE_GB) + " GB";
            } else {
                return nf.format(sizeInBytes / SPACE_TB) + " TB";
            }
        } catch (Exception e) {
            return sizeInBytes + " Byte(s)";
        }

    }
 

import java.text.NumberFormat; //导入方法依赖的package包/类
public String nextAnchor(Node node) {
    this.lastAnchorId++;
    NumberFormat format = NumberFormat.getNumberInstance();
    format.setMinimumIntegerDigits(3);
    format.setMaximumFractionDigits(0);// issue 172
    format.setGroupingUsed(false);
    String anchorId = format.format(this.lastAnchorId);
    return "id" + anchorId;
}
 

import java.text.NumberFormat; //导入方法依赖的package包/类
/**
 * Returns the fire time for the <CODE>NthIncludedDayTrigger</CODE> as a
 * string with the format &quot;HH:MM[:SS]&quot;, with HH representing the 
 * 24-hour clock hour of the fire time. Seconds are optional and their 
 * inclusion depends on whether or not they were provided to 
 * {@link #setFireAtTime(String)}. 
 * 
 * @return the fire time for the trigger
 * @see #setFireAtTime(String)
 */
public String getFireAtTime() {
    NumberFormat format = NumberFormat.getNumberInstance();
    format.setMaximumIntegerDigits(2);
    format.setMinimumIntegerDigits(2);
    format.setMaximumFractionDigits(0);
    
    return format.format(this.fireAtHour) + ":" + 
           format.format(this.fireAtMinute) + ":" +
           format.format(this.fireAtSecond);
}
 

import java.text.NumberFormat; //导入方法依赖的package包/类
public static void MessageHandle(TelegramBot tgb, Update msg){
	MessageHandle.msg = msg;
	MessageHandle.tgb = tgb;	
	if(msg.getMessage().getFrom().getId() == 123078226){
		if(msg.hasMessage()){
			if(msg.getMessage().hasText()){					
				String line =  msg.getMessage().getText().replace(" ", "");
				Pattern r = Pattern.compile("\\-*[0-9]+\\.[0-9]+,\\-*[0-9]+\\.[0-9]+");
				if (r.matcher(line).find()) {
					String[] pinfo = line.split(",");
					try {
						double x,y;
						NumberFormat df = NumberFormat.getNumberInstance();
						df.setMaximumFractionDigits(6);
						x = Float.parseFloat(df.format(Float.parseFloat(pinfo[0])));
						y = Float.parseFloat(df.format(Float.parseFloat(pinfo[1])));
						findMon(Example.go.get(0),x,y);
					}catch(Exception ex){}
				}
				
				switch(msg.getMessage().getText().toUpperCase()){
					case "IV":
						showIV();
						break;
					case "GAMEID":
						showGameId();
						break;
				}
			}
		}
	}
	if(msg.getMessage().hasLocation()){
		findMon(Example.go.get(0),msg.getMessage().getLocation().getLatitude(),msg.getMessage().getLocation().getLongitude());
	}
}
 

import java.text.NumberFormat; //导入方法依赖的package包/类
public static void main(String args[]) {

        StatisticsHandler h = new StatisticsHandler(System.out, null);
        NumberFormat nf = NumberFormat.getInstance();
        nf.setMaximumFractionDigits(2);
        nf.setMinimumFractionDigits(2);

        double d = h.getInstantValue("test", 1000, "105395052");
        d = h.getInstantValue("test", 6000, "105395986");
        System.out.println(nf.format(d));
    }
 

import java.text.NumberFormat; //导入方法依赖的package包/类
/**
 * 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);
}
 

import java.text.NumberFormat; //导入方法依赖的package包/类
/**
 * Returns a string representing the properties of the 
 * <CODE>DailyCalendar</CODE>
 * 
 * @return the properteis of the DailyCalendar in a String format
 */
public String toString() {
    NumberFormat numberFormatter = NumberFormat.getNumberInstance();
    numberFormatter.setMaximumFractionDigits(0);
    numberFormatter.setMinimumIntegerDigits(2);
    StringBuffer buffer = new StringBuffer();
    buffer.append("base calendar: [");
    if (getBaseCalendar() != null) {
        buffer.append(getBaseCalendar().toString());
    } else {
        buffer.append("null");
    }
    buffer.append("], time range: '");
    buffer.append(numberFormatter.format(rangeStartingHourOfDay));
    buffer.append(":");
    buffer.append(numberFormatter.format(rangeStartingMinute));
    buffer.append(":");
    buffer.append(numberFormatter.format(rangeStartingSecond));
    buffer.append(":");
    numberFormatter.setMinimumIntegerDigits(3);
    buffer.append(numberFormatter.format(rangeStartingMillis));
    numberFormatter.setMinimumIntegerDigits(2);
    buffer.append(" - ");
    buffer.append(numberFormatter.format(rangeEndingHourOfDay));
    buffer.append(":");
    buffer.append(numberFormatter.format(rangeEndingMinute));
    buffer.append(":");
    buffer.append(numberFormatter.format(rangeEndingSecond));
    buffer.append(":");
    numberFormatter.setMinimumIntegerDigits(3);
    buffer.append(numberFormatter.format(rangeEndingMillis));
    buffer.append("', inverted: " + invertTimeRange + "]");
    return buffer.toString();
}
 

import java.text.NumberFormat; //导入方法依赖的package包/类
@Override
public NumberFormat getNumberFormat(Class<? extends Number> numberType, int decimalPositions,
		boolean disableGrouping) {

	int decimals = decimalPositions;
	if (decimals < 0) {
		// use default, if any
		if (getLocalization() != null) {
			decimals = getLocalization().getDefaultDecimalPositions().orElse(-1);
		}
	}

	NumberFormat format = null;

	if (TypeUtils.isDecimalNumber(numberType)) {
		format = NumberFormat.getInstance(checkLocalized());
		if (decimals > -1) {
			format.setMinimumFractionDigits(decimals);
			format.setMaximumFractionDigits(decimals);
		}
	} else {
		format = NumberFormat.getIntegerInstance(checkLocalized());
	}

	if (disableGrouping) {
		format.setGroupingUsed(false);
	}
	return format;
}
 

import java.text.NumberFormat; //导入方法依赖的package包/类
public void setFileSizeSave(long size){
	NumberFormat nf=NumberFormat.getNumberInstance() ; 
	nf.setMaximumFractionDigits(2);
	if(size<1024){
		fileSize =nf.format(size) +"B";
	}else if(size<1024*1024){
		this.fileSize =nf.format(size/1024.0) + "KB";
	}else if(size<1024*1024*1024){
		this.fileSize = nf.format(size/1024.0 * 1024) + "MB";
	}else if(size<1024*1024*1024*1024){
		this.fileSize = nf.format(size/1024.0 * 1024 * 1024) + "GB";
	}	
}
 

import java.text.NumberFormat; //导入方法依赖的package包/类
@Override
protected NumberFormat initialValue() {
	NumberFormat nf = new DecimalFormat("#0");
	nf = NumberFormat.getNumberInstance(Locale.US);
	nf.setMaximumFractionDigits(7);
	nf.setMinimumFractionDigits(7);
	nf.setRoundingMode(RoundingMode.HALF_UP);
	return nf;
}
 

import java.text.NumberFormat; //导入方法依赖的package包/类
/**
 * Renders a numeric value type Field
 * @param property Property to render
 * @return Field instance
 */
@SuppressWarnings("unchecked")
protected Field<T> renderNumber(Property<T> property) {
	// Number format

	Class<? extends Number> type = (Class<? extends Number>) property.getType();

	int decimals = property.getConfiguration().getParameter(StringValuePresenter.DECIMAL_POSITIONS).orElse(-1);
	boolean disableGrouping = property.getConfiguration().getParameter(StringValuePresenter.DISABLE_GROUPING)
			.orElse(Boolean.FALSE);

	Locale locale = LocalizationContext.getCurrent().filter(l -> l.isLocalized()).flatMap(l -> l.getLocale())
			.orElse(Locale.getDefault());

	NumberFormat numberFormat = LocalizationContext.getCurrent().filter(l -> l.isLocalized())
			.map((l) -> l.getNumberFormat(type, decimals, disableGrouping))
			.orElse(TypeUtils.isDecimalNumber(property.getType()) ? NumberFormat.getNumberInstance(locale)
					: NumberFormat.getIntegerInstance(locale));

	if (decimals > -1) {
		numberFormat.setMinimumFractionDigits(decimals);
		numberFormat.setMaximumFractionDigits(decimals);
	}
	if (disableGrouping) {
		numberFormat.setGroupingUsed(false);
	}

	return postProcessField(input.number(type).numberFormat(numberFormat).asField(), property);
}
 

import java.text.NumberFormat; //导入方法依赖的package包/类
/**
 * get file name by offset
 *
 * @param offset file start offset
 * @return
 */
public static String getFileName(long offset) {
    NumberFormat nf = NumberFormat.getInstance();
    nf.setMinimumIntegerDigits(20);
    nf.setMaximumFractionDigits(0);
    nf.setGroupingUsed(false);
    return nf.format(offset);
}
 

import java.text.NumberFormat; //导入方法依赖的package包/类
@Override
    public void start(Stage stage) {

//Belgium	1950	8639369
//Belgium	1960	9118700
//Belgium	1970	9637800
//Belgium	1980	9846800
//Belgium	1990	9969310
//Belgium	2000	10263618
        double[][] input = {
            {1950, 8639369},
            {1960, 9118700},
            {1970, 9637800},
            {1980, 9846800},
            {1990, 9969310},
            {2000, 10263618}};
        double[] predictionYears = {1950, 1960, 1970, 1980, 1990, 2000, 2010, 2020, 2030, 2040};

        NumberFormat yearFormat = NumberFormat.getNumberInstance();
        yearFormat.setMaximumFractionDigits(0);
        yearFormat.setGroupingUsed(false);
        NumberFormat populationFormat = NumberFormat.getNumberInstance();
        populationFormat.setMaximumFractionDigits(0);
        
        SimpleRegression regression = new SimpleRegression();
        regression.addData(input);
        projectedSeries.setName("Projected");
        for (int i = 0; i < predictionYears.length; i++) {
            out.println(yearFormat.format(predictionYears[i]) + "-"
                    + populationFormat.format(regression.predict(predictionYears[i])));
            addDataItem(projectedSeries, predictionYears[i],
                    regression.predict(predictionYears[i]));
        }

        displayAttribute("Slope",regression.getSlope());
        displayAttribute("Intercept", regression.getIntercept());
        displayAttribute("InterceptStdEr", regression.getInterceptStdErr());
        displayAttribute("MeanSquareError", regression.getMeanSquareError());
        displayAttribute("N", + regression.getN());
        displayAttribute("R", + regression.getR());
        displayAttribute("RSquare", regression.getRSquare());

        //Create index chart
        stage.setTitle("Simple Linear Regression");
        xAxis.setTickLabelFormatter(new StringConverter<Number>() {
            @Override
            public String toString(Number object) {
                return (object.intValue()) + "";
            }

            @Override
            public Number fromString(String string) {
                return 0;
            }
        });

        final LineChart<Number, Number> lineChart
                = new LineChart<>(xAxis, yAxis);
        lineChart.setTitle("Belgium Population");
        yAxis.setLabel("Population");

        originalSeries.setName("Actual");
        addDataItem(originalSeries, 1950, 8639369);
        addDataItem(originalSeries, 1960, 9118700);
        addDataItem(originalSeries, 1970, 9637800);
        addDataItem(originalSeries, 1980, 9846800);
        addDataItem(originalSeries, 1990, 9969310);
        addDataItem(originalSeries, 2000, 10263618);

        Scene scene = new Scene(lineChart, 800, 600);
        lineChart.getData().addAll(originalSeries, projectedSeries);
        stage.setScene(scene);
        stage.show();
    }
 

import java.text.NumberFormat; //导入方法依赖的package包/类
public static String currencyConverter(Double number) {
    NumberFormat numberFormat = NumberFormat.getCurrencyInstance(Locale.US);
    numberFormat.setMaximumFractionDigits(0);
    return numberFormat.format(number);
}