반응형
통화 입력 editText를 포맷하는 더 좋은 방법?
editText가 있으며 시작 값은 $ 0.00입니다. 1을 누르면 $ 0.01로 변경됩니다. 4를 누르면 $ 0.14가됩니다. 8, $ 1.48을 누르십시오. 백 스페이스, $ 0.14 등을 누릅니다.
문제는 누군가가 커서를 수동으로 배치하면 서식에 문제가 발생한다는 것입니다. 소수점을 삭제하면 다시 나타나지 않습니다. 커서를 소수점 앞에 놓고 2를 입력하면 $ 2.00 대신 $ 02.00이 표시됩니다. 예를 들어 $를 삭제하려고하면 대신 숫자가 삭제됩니다.
여기에 내가 사용하는 코드가 있습니다. 어떤 제안이라도 감사하겠습니다.
mEditPrice.setRawInputType(Configuration.KEYBOARD_12KEY);
public void priceClick(View view) {
mEditPrice.addTextChangedListener(new TextWatcher(){
DecimalFormat dec = new DecimalFormat("0.00");
@Override
public void afterTextChanged(Editable arg0) {
}
@Override
public void beforeTextChanged(CharSequence s, int start,
int count, int after) {
}
@Override
public void onTextChanged(CharSequence s, int start,
int before, int count) {
if(!s.toString().matches("^\\$(\\d{1,3}(\\,\\d{3})*|(\\d+))(\\.\\d{2})?$"))
{
String userInput= ""+s.toString().replaceAll("[^\\d]", "");
if (userInput.length() > 0) {
Float in=Float.parseFloat(userInput);
float percen = in/100;
mEditPrice.setText("$"+dec.format(percen));
mEditPrice.setSelection(mEditPrice.getText().length());
}
}
}
});
나는 당신의 방법을 테스트했지만 큰 숫자를 사용하면 실패합니다 ... 이것을 만들었습니다.
private String current = "";
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
if(!s.toString().equals(current)){
[your_edittext].removeTextChangedListener(this);
String cleanString = s.toString().replaceAll("[$,.]", "");
double parsed = Double.parseDouble(cleanString);
String formatted = NumberFormat.getCurrencyInstance().format((parsed/100));
current = formatted;
[your_edittext].setText(formatted);
[your_edittext].setSelection(formatted.length());
[your_edittext].addTextChangedListener(this);
}
}
위의 답변 중 일부를 기반으로 다음과 같이 사용할 MoneyTextWatcher를 만들었습니다.
priceEditText.addTextChangedListener(new MoneyTextWatcher(priceEditText));
그리고 여기에 수업이 있습니다 :
public class MoneyTextWatcher implements TextWatcher {
private final WeakReference<EditText> editTextWeakReference;
public MoneyTextWatcher(EditText editText) {
editTextWeakReference = new WeakReference<EditText>(editText);
}
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
}
@Override
public void afterTextChanged(Editable editable) {
EditText editText = editTextWeakReference.get();
if (editText == null) return;
String s = editable.toString();
if (s.isEmpty()) return;
editText.removeTextChangedListener(this);
String cleanString = s.replaceAll("[$,.]", "");
BigDecimal parsed = new BigDecimal(cleanString).setScale(2, BigDecimal.ROUND_FLOOR).divide(new BigDecimal(100), BigDecimal.ROUND_FLOOR);
String formatted = NumberFormat.getCurrencyInstance().format(parsed);
editText.setText(formatted);
editText.setSelection(formatted.length());
editText.addTextChangedListener(this);
}
}
여기 내 습관이 있습니다. CurrencyEditText
import android.content.Context;import android.graphics.Rect;import android.text.Editable;import android.text.InputFilter;import android.text.InputType;import android.text.TextWatcher;
import android.util.AttributeSet;import android.widget.EditText;import java.math.BigDecimal;import java.math.RoundingMode;
import java.text.DecimalFormat;import java.text.DecimalFormatSymbols;
import java.util.Locale;
/**
* Some note <br/>
* <li>Always use locale US instead of default to make DecimalFormat work well in all language</li>
*/
public class CurrencyEditText extends android.support.v7.widget.AppCompatEditText {
private static String prefix = "VND ";
private static final int MAX_LENGTH = 20;
private static final int MAX_DECIMAL = 3;
private CurrencyTextWatcher currencyTextWatcher = new CurrencyTextWatcher(this, prefix);
public CurrencyEditText(Context context) {
this(context, null);
}
public CurrencyEditText(Context context, AttributeSet attrs) {
this(context, attrs, android.support.v7.appcompat.R.attr.editTextStyle);
}
public CurrencyEditText(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
this.setInputType(InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_FLAG_DECIMAL);
this.setHint(prefix);
this.setFilters(new InputFilter[] { new InputFilter.LengthFilter(MAX_LENGTH) });
}
@Override
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
super.onFocusChanged(focused, direction, previouslyFocusedRect);
if (focused) {
this.addTextChangedListener(currencyTextWatcher);
} else {
this.removeTextChangedListener(currencyTextWatcher);
}
handleCaseCurrencyEmpty(focused);
}
/**
* When currency empty <br/>
* + When focus EditText, set the default text = prefix (ex: VND) <br/>
* + When EditText lose focus, set the default text = "", EditText will display hint (ex:VND)
*/
private void handleCaseCurrencyEmpty(boolean focused) {
if (focused) {
if (getText().toString().isEmpty()) {
setText(prefix);
}
} else {
if (getText().toString().equals(prefix)) {
setText("");
}
}
}
private static class CurrencyTextWatcher implements TextWatcher {
private final EditText editText;
private String previousCleanString;
private String prefix;
CurrencyTextWatcher(EditText editText, String prefix) {
this.editText = editText;
this.prefix = prefix;
}
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
// do nothing
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
// do nothing
}
@Override
public void afterTextChanged(Editable editable) {
String str = editable.toString();
if (str.length() < prefix.length()) {
editText.setText(prefix);
editText.setSelection(prefix.length());
return;
}
if (str.equals(prefix)) {
return;
}
// cleanString this the string which not contain prefix and ,
String cleanString = str.replace(prefix, "").replaceAll("[,]", "");
// for prevent afterTextChanged recursive call
if (cleanString.equals(previousCleanString) || cleanString.isEmpty()) {
return;
}
previousCleanString = cleanString;
String formattedString;
if (cleanString.contains(".")) {
formattedString = formatDecimal(cleanString);
} else {
formattedString = formatInteger(cleanString);
}
editText.removeTextChangedListener(this); // Remove listener
editText.setText(formattedString);
handleSelection();
editText.addTextChangedListener(this); // Add back the listener
}
private String formatInteger(String str) {
BigDecimal parsed = new BigDecimal(str);
DecimalFormat formatter =
new DecimalFormat(prefix + "#,###", new DecimalFormatSymbols(Locale.US));
return formatter.format(parsed);
}
private String formatDecimal(String str) {
if (str.equals(".")) {
return prefix + ".";
}
BigDecimal parsed = new BigDecimal(str);
// example pattern VND #,###.00
DecimalFormat formatter = new DecimalFormat(prefix + "#,###." + getDecimalPattern(str),
new DecimalFormatSymbols(Locale.US));
formatter.setRoundingMode(RoundingMode.DOWN);
return formatter.format(parsed);
}
/**
* It will return suitable pattern for format decimal
* For example: 10.2 -> return 0 | 10.23 -> return 00, | 10.235 -> return 000
*/
private String getDecimalPattern(String str) {
int decimalCount = str.length() - str.indexOf(".") - 1;
StringBuilder decimalPattern = new StringBuilder();
for (int i = 0; i < decimalCount && i < MAX_DECIMAL; i++) {
decimalPattern.append("0");
}
return decimalPattern.toString();
}
private void handleSelection() {
if (editText.getText().length() <= MAX_LENGTH) {
editText.setSelection(editText.getText().length());
} else {
editText.setSelection(MAX_LENGTH);
}
}
}
}
XML에서 사용하십시오.
<...CurrencyEditText
android:layout_width="match_parent"
android:layout_height="wrap_content"
/>
프로젝트에 적합하도록 아래 2 개의 상수를 편집해야합니다.
private static String prefix = "VND ";
private static final int MAX_DECIMAL = 3;
실제로 이전에 제공된 솔루션이 작동하지 않습니다. 100.00을 입력하려면 작동하지 않습니다.
바꾸다:
double parsed = Double.parseDouble(cleanString);
String formato = NumberFormat.getCurrencyInstance().format((parsed/100));
와:
BigDecimal parsed = new BigDecimal(cleanString).setScale(2,BigDecimal.ROUND_FLOOR).divide(new BigDecimal(100),BigDecimal.ROUND_FLOOR);
String formato = NumberFormat.getCurrencyInstance().format(parsed);
나는 내 코드를 약간 수정했다고 말해야한다. 문제는 BigDecimal을 사용해야한다는 것입니다.
값을 편집 할 때 Brasil 통화 형식을 사용하고 커서 위치를 조정하도록 TextWatcher를 구현하여 클래스를 변경합니다.
공용 클래스 MoneyTextWatcher는 TextWatcher {를 구현합니다.
개인 EditText editText;
private String lastAmount = "";
private int lastCursorPosition = -1;
public MoneyTextWatcher (EditText editText) {
감독자();
this.editText = editText;
}
@우세하다
public void onTextChanged (CharSequence amount, int start, int before, int count) {
if (! amount.toString (). equals (lastAmount)) {
문자열 cleanString = clearCurrencyToNumber (amount.toString ());
{
문자열 formattedAmount = transformToCurrency (cleanString);
editText.removeTextChangedListener (this);
editText.setText (formattedAmount);
editText.setSelection (formattedAmount.length ());
editText.addTextChangedListener (this);
if (lastCursorPosition! = lastAmount.length () && lastCursorPosition! = -1) {
int lengthDelta = formattedAmount.length ()-lastAmount.length ();
int newCursorOffset = max (0, min (formattedAmount.length (), lastCursorPosition + lengthDelta));
editText.setSelection (newCursorOffset);
}
} catch (예외 e) {
// 로그
}
}
}
@우세하다
public void afterTextChanged (Editable s) {
}
@우세하다
public void beforeTextChanged (CharSequence s, int start, int count, int after) {
문자열 값 = s.toString ();
if (! value.equals ( "")) {
문자열 cleanString = clearCurrencyToNumber (값);
문자열 formattedAmount = transformToCurrency (cleanString);
lastAmount = formattedAmount;
lastCursorPosition = editText.getSelectionStart ();
}
}
public static String clearCurrencyToNumber (String currencyValue) {
문자열 결과 = null;
if (currencyValue == null) {
결과 = "";
} else {
result = currencyValue.replaceAll ( "[(az) | (AZ) | ($ ,.)]", "");
}
반환 결과;
}
public static boolean isCurrencyValue (String currencyValue, boolean podeSerZero) {
부울 결과;
if (currencyValue == null || currencyValue.length () == 0) {
결과 = 거짓;
} else {
if (! podeSerZero && currencyValue.equals ( "0,00")) {
결과 = 거짓;
} else {
결과 = 참;
}
}
반환 결과;
}
public static String transformToCurrency (String value) {
double parsed = Double.parseDouble (value);
String formatted = NumberFormat.getCurrencyInstance (new Locale ( "pt", "BR")). format ((parsed / 100));
formatted = formatted.replaceAll ( "[^ (0-9) (.,)]", "");
반환 형식;
}
}
Guilhermes 답변을 기반으로 작성했지만 커서의 위치를 유지하고 마침표도 다르게 처리합니다. 이렇게하면 사용자가 마침표 이후에 입력하는 경우 마침표 이전의 숫자에는 영향을주지 않습니다. .
[yourtextfield].addTextChangedListener(new TextWatcher()
{
NumberFormat currencyFormat = NumberFormat.getCurrencyInstance();
private String current = "";
@Override
public void onTextChanged(CharSequence s, int start, int before, int count)
{
if(!s.toString().equals(current))
{
[yourtextfield].removeTextChangedListener(this);
int selection = [yourtextfield].getSelectionStart();
// We strip off the currency symbol
String replaceable = String.format("[%s,\\s]", NumberFormat.getCurrencyInstance().getCurrency().getSymbol());
String cleanString = s.toString().replaceAll(replaceable, "");
double price;
// Parse the string
try
{
price = Double.parseDouble(cleanString);
}
catch(java.lang.NumberFormatException e)
{
price = 0;
}
// If we don't see a decimal, then the user must have deleted it.
// In that case, the number must be divided by 100, otherwise 1
int shrink = 1;
if(!(s.toString().contains(".")))
{
shrink = 100;
}
// Reformat the number
String formated = currencyFormat.format((price / shrink));
current = formated;
[yourtextfield].setText(formated);
[yourtextfield].setSelection(Math.min(selection, [yourtextfield].getText().length()));
[yourtextfield].addTextChangedListener(this);
}
}
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after)
{
}
@Override
public void afterTextChanged(Editable s)
{
}
});
좋아, 통화 형식을 처리하는 더 좋은 방법, 뒤로 삭제 키 입력이 있습니다. 이 코드는 위의 @androidcurious '코드를 기반으로합니다 ... 그러나 역방향 삭제 및 일부 구문 분석 예외와 관련된 몇 가지 문제를 다룹니다. http://miguelt.blogspot.ca/2013/01/textwatcher-for-currency-masksformatting .html [업데이트] 이전 솔루션에는 몇 가지 문제가있었습니다 ... 이것은 더 나은 솔루션입니다 : http://miguelt.blogspot.ca/2013/02/update-textwatcher-for-currency.html 그리고 ... 여기에 세부:
이 접근 방식은 기존 Android 메커니즘을 사용하기 때문에 더 좋습니다. 아이디어는 사용자가 뷰에 존재 한 후에 값을 포맷하는 것입니다.
InputFilter를 정의하여 숫자 값을 제한하십시오. 화면이 긴 EditText보기를 수용 할만큼 충분히 크지 않기 때문에 대부분의 경우에 필요합니다. 이것은 정적 내부 클래스이거나 다른 일반 클래스 일 수 있습니다.
/** Numeric range Filter. */
class NumericRangeFilter implements InputFilter {
/** Maximum value. */
private final double maximum;
/** Minimum value. */
private final double minimum;
/** Creates a new filter between 0.00 and 999,999.99. */
NumericRangeFilter() {
this(0.00, 999999.99);
}
/** Creates a new filter.
* @param p_min Minimum value.
* @param p_max Maximum value.
*/
NumericRangeFilter(double p_min, double p_max) {
maximum = p_max;
minimum = p_min;
}
@Override
public CharSequence filter(
CharSequence p_source, int p_start,
int p_end, Spanned p_dest, int p_dstart, int p_dend
) {
try {
String v_valueStr = p_dest.toString().concat(p_source.toString());
double v_value = Double.parseDouble(v_valueStr);
if (v_value<=maximum && v_value>=minimum) {
// Returning null will make the EditText to accept more values.
return null;
}
} catch (NumberFormatException p_ex) {
// do nothing
}
// Value is out of range - return empty string.
return "";
}
}
View.OnFocusChangeListener를 구현할 클래스 (내부 정적 또는 클래스)를 정의합니다. Utils 클래스를 사용하고 있습니다. 구현은 "Amounts, Taxes"에서 찾을 수 있습니다.
/** Used to format the amount views. */
class AmountOnFocusChangeListener implements View.OnFocusChangeListener {
@Override
public void onFocusChange(View p_view, boolean p_hasFocus) {
// This listener will be attached to any view containing amounts.
EditText v_amountView = (EditText)p_view;
if (p_hasFocus) {
// v_value is using a currency mask - transfor over to cents.
String v_value = v_amountView.getText().toString();
int v_cents = Utils.parseAmountToCents(v_value);
// Now, format cents to an amount (without currency mask)
v_value = Utils.formatCentsToAmount(v_cents);
v_amountView.setText(v_value);
// Select all so the user can overwrite the entire amount in one shot.
v_amountView.selectAll();
} else {
// v_value is not using a currency mask - transfor over to cents.
String v_value = v_amountView.getText().toString();
int v_cents = Utils.parseAmountToCents(v_value);
// Now, format cents to an amount (with currency mask)
v_value = Utils.formatCentsToCurrency(v_cents);
v_amountView.setText(v_value);
}
}
}
이 클래스는 표준 메커니즘에 따라 편집 할 때 통화 형식을 제거합니다. 사용자가 종료하면 통화 형식이 다시 적용됩니다.
인스턴스 수를 최소화하려면 일부 정적 변수를 정의하는 것이 좋습니다.
static final InputFilter[] FILTERS = new InputFilter[] {new NumericRangeFilter()};
static final View.OnFocusChangeListener ON_FOCUS = new AmountOnFocusChangeListener();
마지막으로 onCreateView (...) 내에서 :
EditText mAmountView = ....
mAmountView.setFilters(FILTERS);
mAmountView.setOnFocusChangeListener(ON_FOCUS);
여러 EditText보기에서 FILTERS 및 ON_FOCUS를 재사용 할 수 있습니다.
다음은 Utils 클래스입니다.
public class Utils {
private static final NumberFormat FORMAT_CURRENCY = NumberFormat.getCurrencyInstance();
/** Parses an amount into cents.
* @param p_value Amount formatted using the default currency.
* @return Value as cents.
*/
public static int parseAmountToCents(String p_value) {
try {
Number v_value = FORMAT_CURRENCY.parse(p_value);
BigDecimal v_bigDec = new BigDecimal(v_value.doubleValue());
v_bigDec = v_bigDec.setScale(2, BigDecimal.ROUND_HALF_UP);
return v_bigDec.movePointRight(2).intValue();
} catch (ParseException p_ex) {
try {
// p_value doesn't have a currency format.
BigDecimal v_bigDec = new BigDecimal(p_value);
v_bigDec = v_bigDec.setScale(2, BigDecimal.ROUND_HALF_UP);
return v_bigDec.movePointRight(2).intValue();
} catch (NumberFormatException p_ex1) {
return -1;
}
}
}
/** Formats cents into a valid amount using the default currency.
* @param p_value Value as cents
* @return Amount formatted using a currency.
*/
public static String formatCentsToAmount(int p_value) {
BigDecimal v_bigDec = new BigDecimal(p_value);
v_bigDec = v_bigDec.setScale(2, BigDecimal.ROUND_HALF_UP);
v_bigDec = v_bigDec.movePointLeft(2);
String v_currency = FORMAT_CURRENCY.format(v_bigDec.doubleValue());
return v_currency.replace(FORMAT_CURRENCY.getCurrency().getSymbol(), "").replace(",", "");
}
/** Formats cents into a valid amount using the default currency.
* @param p_value Value as cents
* @return Amount formatted using a currency.
*/
public static String formatCentsToCurrency(int p_value) {
BigDecimal v_bigDec = new BigDecimal(p_value);
v_bigDec = v_bigDec.setScale(2, BigDecimal.ROUND_HALF_UP);
v_bigDec = v_bigDec.movePointLeft(2);
return FORMAT_CURRENCY.format(v_bigDec.doubleValue());
}
}
여기에 많은 답변이 있지만 가장 강력하고 깨끗한 답변이라고 믿기 때문에 여기 에서 찾은이 코드를 공유하고 싶습니다 .
class CurrencyTextWatcher implements TextWatcher {
boolean mEditing;
public CurrencyTextWatcher() {
mEditing = false;
}
public synchronized void afterTextChanged(Editable s) {
if(!mEditing) {
mEditing = true;
String digits = s.toString().replaceAll("\\D", "");
NumberFormat nf = NumberFormat.getCurrencyInstance();
try{
String formatted = nf.format(Double.parseDouble(digits)/100);
s.replace(0, s.length(), formatted);
} catch (NumberFormatException nfe) {
s.clear();
}
mEditing = false;
}
}
public void beforeTextChanged(CharSequence s, int start, int count, int after) { }
public void onTextChanged(CharSequence s, int start, int before, int count) { }
}
도움이되기를 바랍니다.
여기 에서 가져 와서 포르투갈어 통화 형식에 맞게 변경했습니다.
import java.text.NumberFormat;
import java.util.Currency;
import java.util.Locale;
import android.text.Editable;
import android.text.TextWatcher;
import android.widget.EditText;
public class CurrencyTextWatcher implements TextWatcher {
private String current = "";
private int index;
private boolean deletingDecimalPoint;
private final EditText currency;
public CurrencyTextWatcher(EditText p_currency) {
currency = p_currency;
}
@Override
public void beforeTextChanged(CharSequence p_s, int p_start, int p_count, int p_after) {
if (p_after>0) {
index = p_s.length() - p_start;
} else {
index = p_s.length() - p_start - 1;
}
if (p_count>0 && p_s.charAt(p_start)==',') {
deletingDecimalPoint = true;
} else {
deletingDecimalPoint = false;
}
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
}
@Override
public void afterTextChanged(Editable p_s) {
if(!p_s.toString().equals(current)){
currency.removeTextChangedListener(this);
if (deletingDecimalPoint) {
p_s.delete(p_s.length()-index-1, p_s.length()-index);
}
// Currency char may be retrieved from NumberFormat.getCurrencyInstance()
String v_text = p_s.toString().replace("€","").replace(",", "");
v_text = v_text.replaceAll("\\s", "");
double v_value = 0;
if (v_text!=null && v_text.length()>0) {
v_value = Double.parseDouble(v_text);
}
// Currency instance may be retrieved from a static member.
NumberFormat numberFormat = NumberFormat.getCurrencyInstance(new Locale("pt", "PT"));
String v_formattedValue = numberFormat.format((v_value/100));
current = v_formattedValue;
currency.setText(v_formattedValue);
if (index>v_formattedValue.length()) {
currency.setSelection(v_formattedValue.length());
} else {
currency.setSelection(v_formattedValue.length()-index);
}
// include here anything you may want to do after the formatting is completed.
currency.addTextChangedListener(this);
}
}
}
layout.xml
<EditText
android:id="@+id/edit_text_your_id"
...
android:text="0,00 €"
android:inputType="numberDecimal"
android:digits="0123456789" />
작동시키기
yourEditText = (EditText) findViewById(R.id.edit_text_your_id);
yourEditText.setRawInputType(Configuration.KEYBOARD_12KEY);
yourEditText.addTextChangedListener(new CurrencyTextWatcher(yourEditText));
Nathan Leigh가 참조한 구현과 Kayvan N과 user2582318의 제안 된 정규식을 사용하여 숫자를 제외한 모든 문자를 제거하여 다음 버전을 만들었습니다.
fun EditText.addCurrencyFormatter() {
// Reference: https://stackoverflow.com/questions/5107901/better-way-to-format-currency-input-edittext/29993290#29993290
this.addTextChangedListener(object: TextWatcher {
private var current = ""
override fun afterTextChanged(s: Editable?) {
}
override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
}
override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
if (s.toString() != current) {
this@addCurrencyFormatter.removeTextChangedListener(this)
// strip off the currency symbol
// Reference for this replace regex: https://stackoverflow.com/questions/5107901/better-way-to-format-currency-input-edittext/28005836#28005836
val cleanString = s.toString().replace("\\D".toRegex(), "")
val parsed = if (cleanString.isBlank()) 0.0 else cleanString.toDouble()
// format the double into a currency format
val formated = NumberFormat.getCurrencyInstance()
.format(parsed / 100)
current = formated
this@addCurrencyFormatter.setText(formated)
this@addCurrencyFormatter.setSelection(formated.length)
this@addCurrencyFormatter.addTextChangedListener(this)
}
}
})
}
이것은 EditText의 TextChangedListener에 TextWatcher를 추가하는 Kotlin의 확장 함수입니다.
사용하려면 다음을 수행하십시오.
yourEditText = (EditText) findViewById(R.id.edit_text_your_id);
yourEditText.addCurrencyFormatter()
도움이되기를 바랍니다.
나를 위해 그것은 이렇게 작동했습니다
public void onTextChanged(CharSequence s, int start,
int before, int count) {
if(!s.toString().matches("^\\$(\\d{1,3}(\\,\\d{3})*|(\\d+))(\\.\\d{2})?$"))
{
String userInput= ""+s.toString().replaceAll("[^\\d]", "");
if (userInput.length() > 2) {
Float in=Float.parseFloat(userInput);
price = Math.round(in); // just to get an Integer
//float percen = in/100;
String first, last;
first = userInput.substring(0, userInput.length()-2);
last = userInput.substring(userInput.length()-2);
edEx1.setText("$"+first+"."+last);
Log.e(MainActivity.class.toString(), "first: "+first + " last:"+last);
edEx1.setSelection(edEx1.getText().length());
}
}
}
InputFilter 인터페이스를 사용하는 것이 좋습니다. 정규식을 사용하면 모든 종류의 입력을 훨씬 쉽게 처리 할 수 있습니다. 통화 입력 형식에 대한 내 솔루션 :
public class CurrencyFormatInputFilter implements InputFilter {
Pattern mPattern = Pattern.compile("(0|[1-9]+[0-9]*)(\\.[0-9]{1,2})?");
@Override
public CharSequence filter(
CharSequence source,
int start,
int end,
Spanned dest,
int dstart,
int dend) {
String result =
dest.subSequence(0, dstart)
+ source.toString()
+ dest.subSequence(dend, dest.length());
Matcher matcher = mPattern.matcher(result);
if (!matcher.matches()) return dest.subSequence(dstart, dend);
return null;
}
}
유효 : 0.00, 0.0, 10.00, 111.1
유효하지 않음 : 0, 0.000, 111, 10, 010.00, 01.0
사용하는 방법:
editText.setFilters(new InputFilter[] {new CurrencyFormatInputFilter()});
나는 이것을 사용하여 사용자가 통화를 입력하고 문자열에서 int로 변환하여 db에 저장하고 int에서 문자열로 다시 변경하는 데 사용했습니다.
json 통화 필드가 숫자 유형 (문자열이 아님)이면 3.1, 3.15 또는 3으로 올 수 있습니다. json이 자동으로 숫자 필드를 반올림하기 때문입니다.
이 경우 적절한 표시를 위해 반올림해야 할 수 있습니다 (나중에 입력 필드에 마스크를 사용할 수 있도록 함).
NumberFormat nf = NumberFormat.getCurrencyInstance();
float value = 200 // it can be 200, 200.3 or 200.37, BigDecimal will take care
BigDecimal valueAsBD = BigDecimal.valueOf(value);
valueAsBD.setScale(2, BigDecimal.ROUND_HALF_UP);
String formated = nf.format(valueAsBD);
왜 이것이 필요한가요?
모든 답변은 센트를 받고 있다고 판단 할 때 통화 심볼을 제거하는 것을 가리 키므로 dolar + cents / 100 = dolar, cents 형식을 지정합니다. 그러나 json 통화 필드가 숫자 유형 (문자열이 아님)이면 센트가 반올림되며 3, 3.1 또는 3.15가 될 수 있습니다.
다른 접근 방식이지만 Guilherme 답변을 기반으로 합니다. 이 방법은 국가 로케일을 사용할 수 없거나 사용자 정의 통화 기호를 사용하려는 경우에 유용합니다. 이 구현은 10 진수가 아닌 양수에만 적용됩니다.
이 코드는 Kotlin setMaskingMoney에 있습니다.EditText
fun EditText.setMaskingMoney(currencyText: String) {
this.addTextChangedListener(object: MyTextWatcher{
val editTextWeakReference: WeakReference<EditText> = WeakReference<EditText>(this@setMaskingMoney)
override fun afterTextChanged(editable: Editable?) {
val editText = editTextWeakReference.get() ?: return
val s = editable.toString()
editText.removeTextChangedListener(this)
val cleanString = s.replace("[Rp,. ]".toRegex(), "")
val newval = currencyText + cleanString.monetize()
editText.setText(newval)
editText.setSelection(newval.length)
editText.addTextChangedListener(this)
}
})
}
그런 다음 MyTextWatcher인터페이스는 TextWatcher. afterTextChanged메서드 만 필요 하므로이 인터페이스에서 다른 메서드를 재정의해야합니다.
interface MyTextWatcher: TextWatcher {
override fun onTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {}
override fun beforeTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {}
}
수익 창출 방법은 다음과 같습니다.
fun String.monetize(): String = if (this.isEmpty()) "0"
else DecimalFormat("#,###").format(this.replace("[^\\d]".toRegex(),"").toLong())
전체 구현 :
fun EditText.setMaskingMoney(currencyText: String) {
this.addTextChangedListener(object: MyTextWatcher{
val editTextWeakReference: WeakReference<EditText> = WeakReference<EditText>(this@setMaskingMoney)
override fun afterTextChanged(editable: Editable?) {
val editText = editTextWeakReference.get() ?: return
val s = editable.toString()
editText.removeTextChangedListener(this)
val cleanString = s.replace("[Rp,. ]".toRegex(), "")
val newval = currencyText + cleanString.monetize()
editText.setText(newval)
editText.setSelection(newval.length)
editText.addTextChangedListener(this)
}
})
}
interface MyTextWatcher: TextWatcher {
override fun onTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {}
override fun beforeTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {}
}
fun String.monetize(): String = if (this.isEmpty()) "0"
else DecimalFormat("#,###").format(this.replace("[^\\d]".toRegex(),"").toLong())
그리고 어딘가에 onCreate 메소드 :
yourTextView.setMaskingMoney("Rp. ")
너무 많은 검색과 Doubles, BigDecimals 등으로 실패한 후이 코드를 만들었습니다. 그것은 플러그 앤 플레이를 작동합니다. kotlin에 있습니다. 그래서 다른 사람들을 돕기 위해 나처럼 갇혀 있습니다.
코드는 기본적으로 textWatcher를 배치하고 코마를 올바른 위치로 조정하는 기능입니다.
먼저 다음 함수를 만듭니다.
fun CurrencyWatcher( editText:EditText) {
editText.addTextChangedListener(object : TextWatcher {
//this will prevent the loop
var changed: Boolean = false
override fun afterTextChanged(p0: Editable?) {
changed = false
}
override fun beforeTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {
editText.setSelection(p0.toString().length)
}
@SuppressLint("SetTextI18n")
override fun onTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {
if (!changed) {
changed = true
var str: String = p0.toString().replace(",", "").trim()
var element0: String = str.elementAt(0).toString()
var element1: String = "x"
var element2: String = "x"
var element3: String = "x"
var element4: String = "x"
var element5: String = "x"
var element6: String = "x"
//this variables will store each elements of the initials data for the case we need to move this numbers like: 0,01 to 0,11 or 0,11 to 0,01
if (str.length >= 2) {
element1 = str.elementAt(1).toString()
}
if (str.length >= 3) {
element2 = str.elementAt(2).toString()
}
editText.removeTextChangedListener(this)
//this first block of code will take care of the case
//where the number starts with 0 and needs to adjusta the 0 and the "," place
if (str.length == 1) {
str = "0,0" + str
editText.setText(str)
} else if (str.length <= 3 && str == "00") {
str = "0,00"
editText.setText(str)
editText.setSelection(str.length)
} else if (element0 == "0" && element1 == "0" && element2 == "0") {
str = str.replace("000", "")
str = "0,0" + str
editText.setText(str)
} else if (element0 == "0" && element1 == "0" && element2 != "0") {
str = str.replace("00", "")
str = "0," + str
editText.setText(str)
} else {
//This block of code works with the cases that we need to move the "," only because the value is bigger
//lets get the others elements
if (str.length >= 4) {
element3 = str.elementAt(3).toString()
}
if (str.length >= 5) {
element4 = str.elementAt(4).toString()
}
if (str.length >= 6) {
element5 = str.elementAt(5).toString()
}
if (str.length == 7) {
element6 = str.elementAt(6).toString()
}
if (str.length >= 4 && element0 != "0") {
val sb: StringBuilder = StringBuilder(str)
//set the coma in right place
sb.insert(str.length - 2, ",")
str = sb.toString()
}
//change the 0,11 to 1,11
if (str.length == 4 && element0 == "0") {
val sb: StringBuilder = StringBuilder(str)
//takes the initial 0 out
sb.deleteCharAt(0);
str = sb.toString()
val sb2: StringBuilder = StringBuilder(str)
sb2.insert(str.length - 2, ",")
str = sb2.toString()
}
//this will came up when its like 11,11 and the user delete one, so it will be now 1,11
if (str.length == 3 && element0 != "0") {
val sb: StringBuilder = StringBuilder(str)
sb.insert(str.length - 2, ",")
str = sb.toString()
}
//came up when its like 0,11 and the user delete one, output will be 0,01
if (str.length == 2 && element0 == "0") {
val sb: StringBuilder = StringBuilder(str)
//takes 0 out
sb.deleteCharAt(0);
str = sb.toString()
str = "0,0" + str
}
//came up when its 1,11 and the user delete, output will be 0,11
if (str.length == 2 && element0 != "0") {
val sb: StringBuilder = StringBuilder(str)
//retira o 0 da frente
sb.insert(0, "0,")
str = sb.toString()
}
editText.setText(str)
}
//places the selector at the end to increment the number
editText.setSelection(str.length)
editText.addTextChangedListener(this)
}
}
})
}
그런 다음이 함수를 이렇게 호출합니다.
val etVal:EditText = findViewById(R.id.etValue)
CurrencyWatcher(etVal)
다른 방법에 StackOverflow의 게시물 대부분의보고 후를 사용하여이를 달성하기 위해 TextWatcher, InputFilter또는 같은 라이브러리 CurrencyEditText 나는를 사용하여이 간단한 솔루션에 정착했습니다 OnFocusChangeListener.
논리는 EditText초점이 맞춰 졌을 때 숫자 로 구문 분석하고 초점을 잃을 때 다시 형식을 지정하는 것입니다.
amount.setOnFocusChangeListener(new View.OnFocusChangeListener() {
@Override
public void onFocusChange(View view, boolean hasFocus) {
Number numberAmount = 0f;
try {
numberAmount = Float.valueOf(amount.getText().toString());
} catch (NumberFormatException e1) {
e1.printStackTrace();
try {
numberAmount = NumberFormat.getCurrencyInstance().parse(amount.getText().toString());
} catch (ParseException e2) {
e2.printStackTrace();
}
}
if (hasFocus) {
amount.setText(numberAmount.toString());
} else {
amount.setText(NumberFormat.getCurrencyInstance().format(numberAmount));
}
}
});
Kotlin + Rx 버전을 구현했습니다.
브라질 통화 (예 : 1,500.00-5,21-192,90) 용이지만 다른 형식에도 쉽게 적용 할 수 있습니다.
다른 사람이 도움이되기를 바랍니다.
RxTextView
.textChangeEvents(fuel_price) // Observe text event changes
.filter { it.text().isNotEmpty() } // do not accept empty text when event first fires
.flatMap {
val onlyNumbers = Regex("\\d+").findAll(it.text()).fold(""){ acc:String,it:MatchResult -> acc.plus(it.value)}
Observable.just(onlyNumbers)
}
.distinctUntilChanged()
.map { it.trimStart('0') }
.map { when (it.length) {
1-> "00"+it
2-> "0"+it
else -> it }
}
.subscribe {
val digitList = it.reversed().mapIndexed { i, c ->
if ( i == 2 ) "${c},"
else if ( i < 2 ) c
else if ( (i-2)%3==0 ) "${c}." else c
}
val currency = digitList.reversed().fold(""){ acc,it -> acc.toString().plus(it) }
fuel_price.text = SpannableStringBuilder(currency)
fuel_price.setSelection(currency.length)
}
CurrencyTextWatcher.java
public class CurrencyTextWatcher implements TextWatcher {
private final static String DS = "."; //Decimal Separator
private final static String TS = ","; //Thousands Separator
private final static String NUMBERS = "0123456789"; //Numbers
private final static int MAX_LENGTH = 13; //Maximum Length
private String format;
private DecimalFormat decimalFormat;
private EditText editText;
public CurrencyTextWatcher(EditText editText) {
String pattern = "###" + TS + "###" + DS + "##";
decimalFormat = new DecimalFormat(pattern);
this.editText = editText;
this.editText.setInputType(InputType.TYPE_CLASS_NUMBER);
this.editText.setKeyListener(DigitsKeyListener.getInstance(NUMBERS + DS));
this.editText.setFilters(new InputFilter[]{new InputFilter.LengthFilter(MAX_LENGTH)});
}
@Override
public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {
}
@Override
public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
}
@Override
public void afterTextChanged(Editable editable) {
editText.removeTextChangedListener(this);
String value = editable.toString();
if (!value.isEmpty()) {
value = value.replace(TS, "");
try {
format = decimalFormat.format(Double.parseDouble(value));
format = format.replace("0", "");
} catch (Exception e) {
System.out.println(e.getMessage());
}
editText.setText(format);
}
editText.addTextChangedListener(this);
}
}
EditTextCurrency.java
public class EditTextCurrency extends AppCompatEditText {
public EditTextCurrency(Context context) {
super(context);
}
public EditTextCurrency(Context context, AttributeSet attrs) {
super(context, attrs);
addTextChangedListener(new CurrencyTextWatcher(this));
}
}
다음은 구현하기 쉽고 사방에 미친 기호의 가능성없이 사용자에게 잘 작동하는 EditText에 통화를 표시 할 수 있었던 방법입니다. 이것은 EditText에 더 이상 포커스가 없을 때까지 어떤 포맷팅도 시도하지 않을 것입니다. 사용자는 서식을 손상시키지 않고 돌아가서 편집 할 수 있습니다. 'formattedPrice'변수는 표시 용으로 만 사용하고 'itemPrice'변수는 계산 용으로 저장 / 사용하는 값으로 사용합니다.
정말 잘 작동하는 것 같지만 몇 주 밖에 안 되었으니 건설적인 비판은 절대 환영합니다!
xml의 EditText보기에는 다음 속성이 있습니다.
android:inputType="numberDecimal"
전역 변수 :
private String formattedPrice;
private int itemPrice = 0;
onCreate 메소드에서 :
EditText itemPriceInput = findViewById(R.id.item_field_price);
itemPriceInput.setOnFocusChangeListener(new View.OnFocusChangeListener() {
@Override
public void onFocusChange(View v, boolean hasFocus) {
String priceString = itemPriceInput.getText().toString();
if (! priceString.equals("")) {
itemPrice = Double.parseDouble(priceString.replaceAll("[$,]", ""));
formattedPrice = NumberFormat.getCurrencyInstance().format(itemPrice);
itemPriceInput.setText(formattedPrice);
}
}
});
누군가 RxBinding 및 Kotlin을 사용하여 수행하는 방법에 관심이있는 경우 :
var isEditing = false
RxTextView.textChanges(dollarValue)
.filter { !isEditing }
.filter { it.isNotBlank() }
.map { it.toString().filter { it.isDigit() } }
.map { BigDecimal(it).setScale(2, BigDecimal.ROUND_FLOOR).divide(100.toBigDecimal(), BigDecimal.ROUND_FLOOR) }
.map { NumberFormat.getCurrencyInstance(Locale("pt", "BR")).format(it) }
.subscribe {
isEditing = true
dollarValue.text = SpannableStringBuilder(it)
dollarValue.setSelection(it.length)
isEditing = false
}
승인 된 답변에 대한 추가 의견입니다. 구문 분석으로 인해 edittext 필드에서 커서를 이동할 때 충돌이 발생할 수 있습니다. try catch 문을 수행했지만 자신의 코드를 구현하십시오.
@Override public void onTextChanged(CharSequence s, int start, int before, int count) {
if(!s.toString().equals(current)){
amountEditText.removeTextChangedListener(this);
String cleanString = s.toString().replaceAll("[$,.]", "");
try{
double parsed = Double.parseDouble(cleanString);
String formatted = NumberFormat.getCurrencyInstance().format((parsed/100));
current = formatted;
amountEditText.setText(formatted);
amountEditText.setSelection(formatted.length());
} catch (Exception e) {
}
amountEditText.addTextChangedListener(this);
}
}
이 방법을 사용할 수 있습니다
import android.text.Editable
import android.text.TextWatcher
import android.widget.EditText
import android.widget.TextView
import java.text.NumberFormat
import java.util.*
fun TextView.currencyFormat() {
addTextChangedListener(object : TextWatcher {
override fun afterTextChanged(s: Editable?) {}
override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
removeTextChangedListener(this)
text = if (s?.toString().isNullOrBlank()) {
""
} else {
s.toString().currencyFormat()
}
if(this@currencyFormat is EditText){
setSelection(text.toString().length)
}
addTextChangedListener(this)
}
})
}
fun String.currencyFormat(): String {
var current = this
if (current.isEmpty()) current = "0"
return try {
if (current.contains('.')) {
NumberFormat.getNumberInstance(Locale.getDefault()).format(current.replace(",", "").toDouble())
} else {
NumberFormat.getNumberInstance(Locale.getDefault()).format(current.replace(",", "").toLong())
}
} catch (e: Exception) {
"0"
}
}
참고 URL : https://stackoverflow.com/questions/5107901/better-way-to-format-currency-input-edittext
반응형
'Programing' 카테고리의 다른 글
| CSS를 사용하는 dp (밀도 독립 픽셀) 단위는 무엇입니까? (0) | 2020.10.09 |
|---|---|
| Java 배열에 항목을 동적으로 추가하려면 어떻게해야합니까? (0) | 2020.10.09 |
| 스칼라 맵을 반복하는 방법? (0) | 2020.10.09 |
| netbeans의 코드 정리 (0) | 2020.10.08 |
| Java에서 변경 불가능한 객체를 만드는 방법은 무엇입니까? (0) | 2020.10.08 |