Visualizzazione della valuta nel formato numerico indiano

Ho una domanda sulla formattazione della valuta della Rupia (Indian Rupee – INR).

In genere un valore come 450500 è formattato e visualizzato come 450,500 . In India, lo stesso valore viene visualizzato come 4,50,500

Ad esempio, i numeri qui sono rappresentati come:

 1 10 100 1,000 10,000 1,00,000 10,00,000 1,00,00,000 10,00,00,000 

Indicare il sistema di numerazione indiano

I separatori sono dopo due cifre, tranne l’ultimo set, che è in migliaia.

Ho cercato su internet e le persone hanno chiesto di usare le impostazioni locali en_GB o pattern #,##,##,##,##0.00

Ho provato questo su JSTL usando il seguente tag:

  

Ma questo non sembra risolvere il problema. Qualsiasi aiuto in questa materia sarà molto apprezzato.

Grazie

Sfortunatamente DecimalFormat non supporta i gruppi con larghezza variabile. Quindi non formatterà mai i valori esattamente come vuoi:

Se si fornisce uno schema con più caratteri di raggruppamento, l’intervallo tra l’ultimo e la fine dell’intero è quello che viene utilizzato. Quindi "#,##,###,####" == "######,####" == "##,####,####" .

La maggior parte dei meccanismi di formattazione dei numeri in Java sono basati su quella class e quindi ereditano questo difetto.

ICU4J (la versione Java di International Components for Unicode ) fornisce una class NumberFormat che supporta questa formattazione:

 Format format = com.ibm.icu.text.NumberFormat.getCurrencyInstance(new Locale("en", "in")); System.out.println(format.format(new BigDecimal("100000000"))); 

Questo codice produrrà questo risultato:

  Rs 10,00,00.000,00 

Nota: la class com.ibm.icu.text.NumberFormat non estende la class java.text.NumberFormat (perché estende già una class base interna ICU), ma estende la class java.text.Format , che ha il metodo format(Object) .

Con Android, questo ha funzionato per me:

 new DecimalFormat("##,##,##0").format(amount); 

450500 viene formattato come 4,50,500

http://developer.android.com/reference/java/text/DecimalFormat.html – DecimalFormat supporta due dimensioni di raggruppamento: la dimensione di raggruppamento principale e una utilizzata per tutte le altre.

ecco una cosa semplice che puoi fare,

  float amount = 100000; NumberFormat formatter = NumberFormat.getCurrencyInstance(new Locale("en", "IN")); String moneyString = formatter.format(amount); System.out.println(moneyString); 

L’output sarà di Rs.100.000,00.

Mi sono anche trovato nello stesso problema. Stavo lavorando con DecimalFormat .

Non ho conoscenza di JSTL ma puoi capire qualcosa con la mia soluzione.

Come, la dimensione del raggruppamento rimane costante in DecimalFormat . Ho separato entrambe le parti, formattato con modelli diversi e concatenato entrambi. Ecco il codice.

 public static String format(double value) { if(value < 1000) { return format("###", value); } else { double hundreds = value % 1000; int other = (int) (value / 1000); return format(",##", other) + ',' + format("000", hundreds); } } private static String format(String pattern, Object value) { return new DecimalFormat(pattern).format(value); } 

Fornirà un formato come il sistema di numerazione indiano.

Se vuoi punti decimali, aggiungi ".##" in entrambe le condizioni.

"###" su "###.##" e "000" su "000.##" .

La soluzione semplice è –

 Double amount = 5356673553123.0; //amount is an example ,can be used with any double value **DecimalFormat IndianCurrencyFormat = new DecimalFormat("##,##,###.00");** 

quindi usarlo come –

 String formattedAmount = IndianCurrencyFormat.format(amount); 
 public String getIndianCurrencyFormat(String amount) { StringBuilder stringBuilder = new StringBuilder(); char amountArray[] = amount.toCharArray(); int a = 0, b = 0; for (int i = amountArray.length - 1; i >= 0; i--) { if (a < 3) { stringBuilder.append(amountArray[i]); a++; } else if (b < 2) { if (b == 0) { stringBuilder.append(","); stringBuilder.append(amountArray[i]); b++; } else { stringBuilder.append(amountArray[i]); b = 0; } } } return stringBuilder.reverse().toString(); } 

Questo è quello che ho fatto, per ottenere il formato di valuta indiano. se l'input è 1234567890 significa che l'output è 1,23,45,67,890.

inserisci la descrizione dell'immagine qui

Basta copiare oltre questa funzione. 🙂

  public static String rupeeFormat(String value){ value=value.replace(",",""); char lastDigit=value.charAt(value.length()-1); String result = ""; int len = value.length()-1; int nDigits = 0; for (int i = len - 1; i >= 0; i--) { result = value.charAt(i) + result; nDigits++; if (((nDigits % 2) == 0) && (i > 0)) { result = "," + result; } } return (result+lastDigit); } 

Se non sono disponibili impostazioni locali predefinite e l’utente non apporta alcuna modifica alle impostazioni internazionali, possiamo procedere con l’impostazione del simbolo di valuta utilizzando la codifica unicode e decimale. Come nel codice qui sotto:

Ad es. Impostazione del simbolo di valuta indiano e formattazione del valore. Questo funzionerà senza che l’utente apporti modifiche nelle impostazioni.

  Locale locale = new Locale("en","IN"); DecimalFormat decimalFormat = (DecimalFormat) DecimalFormat.getCurrencyInstance(locale); DecimalFormatSymbols dfs = DecimalFormatSymbols.getInstance(locale); dfs.setCurrencySymbol("\u20B9"); decimalFormat.setDecimalFormatSymbols(dfs); System.out.println(decimalFormat.format(payment)); 

Produzione:

 ₹12,324.13 

I metodi predefiniti nelle librerie esistenti possono mostrare solo migliaia di separatori. quindi abbiamo bisogno di scrivere funzioni personalizzate per questo. È ansible utilizzare più operazioni di sottostringa per ottenere il risultato desiderato.

In java,

 function indianCurrencyNumberFormat(rupee) { string explore_remaining_units = ""; if (rupee.length() > 3) { last_three_digits = rupee.substring((rupee.length()-3), rupee.length()); remaining_units = rupee.substring(0, (rupee.length()-3)); remaining_units = ((remaining_units.length()) % 2 == 1) ? "0"+remaining_units : remaining_units; split_rupee = remaining_units.split("(?<=^(.{2})+)") for (i = 0; i < sizeof(split_rupee); i++) { explore_remaining_units += ((i == 0) ? ( (int) split_rupee[i]+"," ) : ( split_rupee[i]+"," )); } formatted_rupee = explore_remaining_units+last_three_digits; } else { formatted_rupee = rupee; } return formatted_rupee; } 

E in PHP:

 function indianCurrencyNumberFormat($rupee) { $explore_remaining_units = ""; if (strlen($rupee) > 3) { $last_three_digits = substr($rupee, strlen($rupee) - 3, strlen($rupee)); $remaining_units = substr($rupee, 0, strlen($rupee) - 3); $remaining_units = (strlen($remaining_units) % 2 == 1) ? "0".$remaining_units : $remaining_units; $split_rupee = str_split($remaining_units, 2); for ($i = 0; $i < sizeof($split_rupee); $i++) { $explore_remaining_units .= (($i == 0) ? ( (int) $split_rupee[$i] . "," ) : ( $split_rupee[$i] . "," )); } $formatted_rupee = $explore_remaining_units.$last_three_digits; } else { $formatted_rupee = $rupee; } return $formatted_rupee; } 

Puoi vedere maggiori dettagli qui .

 import java.util.*; public class string1 { public static void main(String args[]) { int i,j; boolean op=false; StringBuffer sbuffer = new StringBuffer(); Scanner input = new Scanner(System.in); System.out.println("Enter a string"); sbuffer.append(input.nextLine()); int length=sbuffer.length(); if(sbuffer.length()<3) { System.out.println("string="+sbuffer); } else { for ( i = sbuffer.length(); i >0; i--) { if (i==length-3) { sbuffer.insert(i, ","); op=true; } while(i>1 && op==true) { i=i-2; if(i>=1) { sbuffer.insert(i, ","); } } } } System.out.println("string="+sbuffer); } } 
 //Input: long num = 450500; // Unlike other countries, there is no direct Locale field for India.Therefore, we need to construct a locale for India. Locale loc = new Locale("en", "in"); // This will display currency with "Rs." symbol. // or use below to display currency with "INR" symbol. Locale loc = new Locale("", "in"); NumberFormat indiacurrency = NumberFormat.getCurrencyInstance(loc); String result = indiacurrency.format(num); System.out.print(result); 

È una risposta migliore e funziona in modo dinamico invece di specificare singole impostazioni internazionali nel codice manualmente.

 public String convertToDefaultCurrencyFormat(String amountToConvert){ NumberFormat formatter = NumberFormat.getCurrencyInstance(Locale.getDefault()); String moneyString = formatter.format(Double.valueOf(amountToConvert)); return moneyString; } 

per il cambio di formato delle rupie indiane nel tuo dispositivo Android:

Setting > Language & Input Settings > scegli English(India)

Produzione:

 ₹10,00,000 (Starting with Indian Rupee symbol) 

Su Android android.icu.text.NumberFormat è disponibile solo dopo l’API 24. Quindi per supportare la versione inferiore ho scritto il mio metodo in java.

 public static String formatIndianCommaSeparated(long rupee){ // remove sign if present String raw = String.valueOf(Math.abs(rupee)); int numDigits = raw.length(); StringBuilder sb = new StringBuilder(raw); // Reverse the string to start from right most digits sb = sb.reverse(); // Counter to keep track of number of commas placed int commas = 0; for (int i=0; i 

Versione di Kotlin, Funziona su Android API 26

 fun currencyLocale(value: Double): String { val formatter = NumberFormat.getCurrencyInstance(Locale("en", "in")) return formatter.format(value) } fun parseCommaSeparatedCurrency(value: String): Number { return NumberFormat.getCurrencyInstance(Locale("en", "in")).parse(value) } 

ALTER FUNCTION [dbo]. [Udf_CurrencyFormat] (@ UC varchar (50)) RETURNS varchar (50) AS BEGIN dichiara @FC varchar (50), @ Scale varchar (3), @ i bigint = 1, @ a int = 3 , @ b int = 2, @ WhileLength bigint, @ UCScale varchar (50), @Con varchar (20) set @ Scale = charindex (‘.’, @ UC) – se il numero ha ‘.’ quindi valore else ‘0’ se (@Scale! = ‘0’) inizia set @ UCScale = @ UC set @ Con = sottostringa (@ UCScale, charindex (‘.’, @ UCScale), 3) set @ UC = sottostringa ( @ UC, 0, charindex (‘.’, @ UC)) – fine della sottostringa if (cast (len (@UC) come bigint)% 2! = 0) –if dispari inizio set @ WhileLength = (cast (len (@UC) come bigint) -3) / 2 while (@i <= @ WhileLength) - length-3/2 = 3 se length è 9 (cast (len (@UC) come bigint) -3) / 2 begin set @ a = 3 * @ i set @UC = stuff (@ UC, @ a, 0, ',') set @ i = @ i + 1 end - while set @ FC = @ UC end --if dispari Scala '0' else if (cast (len (@UC) come bigint)% 2 = 0) --if che inizi anche set @WhileLength = (((cast (len (@UC) come bigint) -1) -3) / 2) +1 while (@i <= @ WhileLength) inizia se (@ i = 1) inizia set @ UC = stuff (@ UC, @ b, 0, ',') finisce altrimenti inizia set @ b = @ b +3 set @ UC = stuff (@ UC, @ b, 0, ',') end set @ i = @ i + 1 end set @ FC = @ UC end if (@Scale! = '0') inizia set @ FC = @ FC + @ Con end --if (@Scale! = '0') --set @ FC = @ UC return @FC END