blocks|key|746516|text|InputFilter的这种实现解决了这个问题。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|746517|import+android.text.SpannableStringBuilder;
import+android.text.Spanned;
import+android.text.method.DigitsKeyListener;

public+class+MoneyValueFilter+extends+DigitsKeyListener+{
++++public+MoneyValueFilter()+{
++++++++super(false,+true);
++++}

++++private+int+digits+=+2;

++++public+void+setDigits(int+d)+{
++++++++digits+=+d;
++++}

++++@Override
++++public+CharSequence+filter(CharSequence+source,+int+start,+int+end,
++++++++++++Spanned+dest,+int+dstart,+int+dend)+{
++++++++CharSequence+out+=+super.filter(source,+start,+end,+dest,+dstart,+dend);

++++++++//+if+changed,+replace+the+source
++++++++if+(out+!=+null)+{
++++++++++++source+=+out;
++++++++++++start+=+0;
++++++++++++end+=+out.length();
++++++++}

++++++++int+len+=+end+-+start;

++++++++//+if+deleting,+source+is+empty
++++++++//+and+deleting+can't+break+anything
++++++++if+(len+==+0)+{
++++++++++++return+source;
++++++++}

++++++++int+dlen+=+dest.length();

++++++++//+Find+the+position+of+the+decimal+.
++++++++for+(int+i+=+0;+i+<+dstart;+i%2B%2B)+{
++++++++++++if+(dest.charAt(i)+==+'.')+{
++++++++++++++++//+being+here+means,+that+a+number+has
++++++++++++++++//+been+inserted+after+the+dot
++++++++++++++++//+check+if+the+amount+of+digits+is+right
++++++++++++++++return+(dlen-(i%2B1)+%2B+len+>+digits)+?+
++++++++++++++++++++""+:
++++++++++++++++++++new+SpannableStringBuilder(source,+start,+end);
++++++++++++}
++++++++}

++++++++for+(int+i+=+start;+i+<+end;+%2B%2Bi)+{
++++++++++++if+(source.charAt(i)+==+'.')+{
++++++++++++++++//+being+here+means,+dot+has+been+inserted
++++++++++++++++//+check+if+the+amount+of+digits+is+right
++++++++++++++++if+((dlen-dend)+%2B+(end-(i+%2B+1))+>+digits)
++++++++++++++++++++return+"";
++++++++++++++++else
++++++++++++++++++++break;++//+return+new+SpannableStringBuilder(source,+start,+end);
++++++++++++}
++++++++}

++++++++//+if+the+dot+is+after+the+inserted+part,
++++++++//+nothing+can+break
++++++++return+new+SpannableStringBuilder(source,+start,+end);
++++}
}|code-block|syntax|javascript|746518|entityMap^0|0|B|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

This implementation of <code>InputFilter</code> solves the problem.

<pre><code>import android.text.SpannableStringBuilder;
import android.text.Spanned;
import android.text.method.DigitsKeyListener;

public class MoneyValueFilter extends DigitsKeyListener {
 public MoneyValueFilter() {
 super(false, true);
 }

 private int digits = 2;

 public void setDigits(int d) {
 digits = d;
 }

 @Override
 public CharSequence filter(CharSequence source, int start, int end,
 Spanned dest, int dstart, int dend) {
 CharSequence out = super.filter(source, start, end, dest, dstart, dend);

 // if changed, replace the source
 if (out != null) {
 source = out;
 start = 0;
 end = out.length();
 }

 int len = end - start;

 // if deleting, source is empty
 // and deleting can't break anything
 if (len == 0) {
 return source;
 }

 int dlen = dest.length();

 // Find the position of the decimal .
 for (int i = 0; i &lt; dstart; i++) {
 if (dest.charAt(i) == '.') {
 // being here means, that a number has
 // been inserted after the dot
 // check if the amount of digits is right
 return (dlen-(i+1) + len &gt; digits) ? 
 "" :
 new SpannableStringBuilder(source, start, end);
 }
 }

 for (int i = start; i &lt; end; ++i) {
 if (source.charAt(i) == '.') {
 // being here means, dot has been inserted
 // check if the amount of digits is right
 if ((dlen-dend) + (end-(i + 1)) &gt; digits)
 return "";
 else
 break; // return new SpannableStringBuilder(source, start, end);
 }
 }

 // if the dot is after the inserted part,
 // nothing can break
 return new SpannableStringBuilder(source, start, end);
 }
}
</code></pre>

blocks|key|746554|text|不使用正则表达式的更简单的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|746555|import+android.text.InputFilter;
import+android.text.Spanned;

/**
+*+Input+filter+that+limits+the+number+of+decimal+digits+that+are+allowed+to+be
+*+entered.
+*/
public+class+DecimalDigitsInputFilter+implements+InputFilter+{

++private+final+int+decimalDigits;

++/**
+++*+Constructor.
+++*+
+++*+@param+decimalDigits+maximum+decimal+digits
+++*/
++public+DecimalDigitsInputFilter(int+decimalDigits)+{
++++this.decimalDigits+=+decimalDigits;
++}

++@Override
++public+CharSequence+filter(CharSequence+source,
++++++int+start,
++++++int+end,
++++++Spanned+dest,
++++++int+dstart,
++++++int+dend)+{


++++int+dotPos+=+-1;
++++int+len+=+dest.length();
++++for+(int+i+=+0;+i+<+len;+i%2B%2B)+{
++++++char+c+=+dest.charAt(i);
++++++if+(c+==+'.'+%7C%7C+c+==+',')+{
++++++++dotPos+=+i;
++++++++break;
++++++}
++++}
++++if+(dotPos+>=+0)+{

++++++//+protects+against+many+dots
++++++if+(source.equals(".")+%7C%7C+source.equals(","))
++++++{
++++++++++return+"";
++++++}
++++++//+if+the+text+is+entered+before+the+dot
++++++if+(dend+<=+dotPos)+{
++++++++return+null;
++++++}
++++++if+(len+-+dotPos+>+decimalDigits)+{
++++++++return+"";
++++++}
++++}

++++return+null;
++}

}|code-block|syntax|javascript|746556|要使用以下命令：|746557|editText.setFilters(new+InputFilter[]+{new+DecimalDigitsInputFilter(2)});|746558|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Simpler solution without using regex:

<pre><code>import android.text.InputFilter;
import android.text.Spanned;

/**
 * Input filter that limits the number of decimal digits that are allowed to be
 * entered.
 */
public class DecimalDigitsInputFilter implements InputFilter {

 private final int decimalDigits;

 /**
 * Constructor.
 * 
 * @param decimalDigits maximum decimal digits
 */
 public DecimalDigitsInputFilter(int decimalDigits) {
 this.decimalDigits = decimalDigits;
 }

 @Override
 public CharSequence filter(CharSequence source,
 int start,
 int end,
 Spanned dest,
 int dstart,
 int dend) {


 int dotPos = -1;
 int len = dest.length();
 for (int i = 0; i &lt; len; i++) {
 char c = dest.charAt(i);
 if (c == '.' || c == ',') {
 dotPos = i;
 break;
 }
 }
 if (dotPos &gt;= 0) {

 // protects against many dots
 if (source.equals(".") || source.equals(","))
 {
 return "";
 }
 // if the text is entered before the dot
 if (dend &lt;= dotPos) {
 return null;
 }
 if (len - dotPos &gt; decimalDigits) {
 return "";
 }
 }

 return null;
 }

}
</code></pre>

To use: 

<pre><code>editText.setFilters(new InputFilter[] {new DecimalDigitsInputFilter(2)});
</code></pre>

blocks|key|962356|text|更优雅的方式是使用正则表达式(+regex+)，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|962357|public+class+DecimalDigitsInputFilter+implements+InputFilter+{

Pattern+mPattern;

public+DecimalDigitsInputFilter(int+digitsBeforeZero,int+digitsAfterZero)+{
++++mPattern=Pattern.compile("[0-9]{0,"+%2B+(digitsBeforeZero-1)+%2B+"}%2B((\\.[0-9]{0,"+%2B+(digitsAfterZero-1)+%2B+"})?)%7C%7C(\\.)?");
}

@Override
public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+{

++++++++Matcher+matcher=mPattern.matcher(dest);+++++++
++++++++if(!matcher.matches())
++++++++++++return+"";
++++++++return+null;
++++}

}|code-block|syntax|javascript|962358|要使用它，请执行以下操作：|962359|editText.setFilters(new+InputFilter[]+{new+DecimalDigitsInputFilter(5,2)});|962360|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

More elegant way would be using a regular expression ( regex ) as follows:

<pre><code>public class DecimalDigitsInputFilter implements InputFilter {

Pattern mPattern;

public DecimalDigitsInputFilter(int digitsBeforeZero,int digitsAfterZero) {
 mPattern=Pattern.compile("[0-9]{0," + (digitsBeforeZero-1) + "}+((\\.[0-9]{0," + (digitsAfterZero-1) + "})?)||(\\.)?");
}

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {

 Matcher matcher=mPattern.matcher(dest); 
 if(!matcher.matches())
 return "";
 return null;
 }

}
</code></pre>

To use it do: 

<pre><code>editText.setFilters(new InputFilter[] {new DecimalDigitsInputFilter(5,2)});
</code></pre>

blocks|key|746673|text|DecimalFormat+form+=+new+DecimalFormat("#.##",+new+DecimalFormatSymbols(Locale.US));
++++EditText+et;+
++++et.setOnEditorActionListener(new+TextView.OnEditorActionListener()+{
++++++++@Override
++++++++public+boolean+onEditorAction(TextView+v,+int+actionId,+KeyEvent+event)+{

++++++++if+(actionId+==+EditorInfo.IME_ACTION_DONE)+{
++++++++++++double+a+=+Double.parseDouble(et.getText().toString());
++++++++++++et.setText(form.format(a));
++++++++}
++++++++return+false;
++++}
});|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|746674|这样做的目的是当您退出编辑阶段时，它会将字段格式化为正确的格式。目前，它只有两个十进制字符。我认为这是一种非常简单的方法。|unstyled|746675|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>DecimalFormat form = new DecimalFormat("#.##", new DecimalFormatSymbols(Locale.US));
 EditText et; 
 et.setOnEditorActionListener(new TextView.OnEditorActionListener() {
 @Override
 public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {

 if (actionId == EditorInfo.IME_ACTION_DONE) {
 double a = Double.parseDouble(et.getText().toString());
 et.setText(form.format(a));
 }
 return false;
 }
});
</code></pre>

What this does is when you exit editing phase it formats the field to the right format. At them moment it has only 2 decimal charachters. I think this is pretty easy way to do this.

blocks|key|962565|text|略微改进了@Pinhassi解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|962566|效果非常好。它验证连接的字符串。|962567|public+class+DecimalDigitsInputFilter+implements+InputFilter+{

Pattern+mPattern;

public+DecimalDigitsInputFilter()+{
++++mPattern+=+Pattern.compile("([1-9]{1}[0-9]{0,2}([0-9]{3})*(\\.[0-9]{0,2})?%7C[1-9]{1}[0-9]{0,}(\\.[0-9]{0,2})?%7C0(\\.[0-9]{0,2})?%7C(\\.[0-9]{1,2})?)");

}

@Override
public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+{

++++String+formatedSource+=+source.subSequence(start,+end).toString();

++++String+destPrefix+=+dest.subSequence(0,+dstart).toString();

++++String+destSuffix+=+dest.subSequence(dend,+dest.length()).toString();

++++String+result+=+destPrefix+%2B+formatedSource+%2B+destSuffix;

++++result+=+result.replace(",",+".");

++++Matcher+matcher+=+mPattern.matcher(result);

++++if+(matcher.matches())+{
++++++++return+null;
++++}

++++return+"";
}

+}|code-block|syntax|javascript|962568|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Slightly improved @Pinhassi solution.

Works very well. It validates concatenated strings.

<pre><code>public class DecimalDigitsInputFilter implements InputFilter {

Pattern mPattern;

public DecimalDigitsInputFilter() {
 mPattern = Pattern.compile("([1-9]{1}[0-9]{0,2}([0-9]{3})*(\\.[0-9]{0,2})?|[1-9]{1}[0-9]{0,}(\\.[0-9]{0,2})?|0(\\.[0-9]{0,2})?|(\\.[0-9]{1,2})?)");

}

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {

 String formatedSource = source.subSequence(start, end).toString();

 String destPrefix = dest.subSequence(0, dstart).toString();

 String destSuffix = dest.subSequence(dend, dest.length()).toString();

 String result = destPrefix + formatedSource + destSuffix;

 result = result.replace(",", ".");

 Matcher matcher = mPattern.matcher(result);

 if (matcher.matches()) {
 return null;
 }

 return "";
}

 }
</code></pre>

blocks|key|962622|text|以下是我的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|962623|+++++yourEditText.addTextChangedListener(new+TextWatcher()+{
++++++++@Override
++++++++public+void+onTextChanged(CharSequence+s,+int+start,+int+before,+int+count)+{
++++++++++++NumberFormat+formatter+=+new+DecimalFormat("#.##");
++++++++++++double+doubleVal+=+Double.parseDouble(s.toString());
++++++++++++yourEditText.setText(formatter.format(doubleVal));
++++++++}

++++++++@Override
++++++++public+void+beforeTextChanged(CharSequence+s,+int+start,+int+count,int+after)+{}

++++++++@Override
++++++++public+void+afterTextChanged(Editable+s)+{}
++++});|code-block|syntax|javascript|962624|如果用户输入的小数点后有两个以上的数字，则会自动更正。|962625|我希望我能帮上忙！|962626|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is my solution:

<pre><code> yourEditText.addTextChangedListener(new TextWatcher() {
 @Override
 public void onTextChanged(CharSequence s, int start, int before, int count) {
 NumberFormat formatter = new DecimalFormat("#.##");
 double doubleVal = Double.parseDouble(s.toString());
 yourEditText.setText(formatter.format(doubleVal));
 }

 @Override
 public void beforeTextChanged(CharSequence s, int start, int count,int after) {}

 @Override
 public void afterTextChanged(Editable s) {}
 });
</code></pre>

If the user enters a number with more than two numbers after the decimal point, it will be automatically corrected.

I hope I have helped!

blocks|key|962764|text|在TextWatcher的帮助下，我通过以下方式实现了这一点|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|962765|final+EditText+et+=+(EditText)+findViewById(R.id.EditText1);
int+count+=+-1;
et.addTextChangedListener(new+TextWatcher()+{
++++public+void+onTextChanged(CharSequence+arg0,+int+arg1,+int+arg2,int+arg3)+{+++++++++++++

++++}
++++public+void+beforeTextChanged(CharSequence+arg0,+int+arg1,int+arg2,+int+arg3)+{+++++++++++++

++++}

++++public+void+afterTextChanged(Editable+arg0)+{
++++++++if+(arg0.length()+>+0)+{
++++++++++++String+str+=+et.getText().toString();
++++++++++++et.setOnKeyListener(new+OnKeyListener()+{
++++++++++++++++public+boolean+onKey(View+v,+int+keyCode,+KeyEvent+event)+{
++++++++++++++++++++if+(keyCode+==+KeyEvent.KEYCODE_DEL)+{
++++++++++++++++++++++++count--;
++++++++++++++++++++++++InputFilter[]+fArray+=+new+InputFilter[1];
++++++++++++++++++++++++fArray[0]+=+new+InputFilter.LengthFilter(100);
++++++++++++++++++++++++et.setFilters(fArray);
++++++++++++++++++++++++//change+the+edittext's+maximum+length+to+100.+
++++++++++++++++++++++++//If+we+didn't+change+this+the+edittext's+maximum+length+will
++++++++++++++++++++++++//be+number+of+digits+we+previously+entered.
++++++++++++++++++++}
++++++++++++++++++++return+false;
++++++++++++++++}
++++++++++++});
++++++++++++char+t+=+str.charAt(arg0.length()+-+1);
++++++++++++if+(t+==+'.')+{
++++++++++++++++count+=+0;
++++++++++++}
++++++++++++if+(count+>=+0)+{
++++++++++++++++if+(count+==+2)+{++++++++++++++++++++++++
++++++++++++++++++++InputFilter[]+fArray+=+new+InputFilter[1];
++++++++++++++++++++fArray[0]+=+new+InputFilter.LengthFilter(arg0.length());
++++++++++++++++++++et.setFilters(fArray);
++++++++++++++++++++//prevent+the+edittext+from+accessing+digits+
++++++++++++++++++++//by+setting+maximum+length+as+total+number+of+digits+we+typed+till+now.
++++++++++++++++}
++++++++++++++++count%2B%2B;
++++++++++++}
++++++++}
++++}
});|code-block|syntax|javascript|962766|此解决方案将不允许用户在小数点后输入两位以上的数字。此外，您还可以输入小数点前的任意位数。我希望这能有所帮助。谢谢。|962767|entityMap^0|1|B|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

I achieved this with the help of <code>TextWatcher</code> by the following way
<pre><code>final EditText et = (EditText) findViewById(R.id.EditText1);
int count = -1;
et.addTextChangedListener(new TextWatcher() {
 public void onTextChanged(CharSequence arg0, int arg1, int arg2,int arg3) { 

 }
 public void beforeTextChanged(CharSequence arg0, int arg1,int arg2, int arg3) { 

 }

 public void afterTextChanged(Editable arg0) {
 if (arg0.length() &gt; 0) {
 String str = et.getText().toString();
 et.setOnKeyListener(new OnKeyListener() {
 public boolean onKey(View v, int keyCode, KeyEvent event) {
 if (keyCode == KeyEvent.KEYCODE_DEL) {
 count--;
 InputFilter[] fArray = new InputFilter[1];
 fArray[0] = new InputFilter.LengthFilter(100);
 et.setFilters(fArray);
 //change the edittext's maximum length to 100. 
 //If we didn't change this the edittext's maximum length will
 //be number of digits we previously entered.
 }
 return false;
 }
 });
 char t = str.charAt(arg0.length() - 1);
 if (t == '.') {
 count = 0;
 }
 if (count &gt;= 0) {
 if (count == 2) { 
 InputFilter[] fArray = new InputFilter[1];
 fArray[0] = new InputFilter.LengthFilter(arg0.length());
 et.setFilters(fArray);
 //prevent the edittext from accessing digits 
 //by setting maximum length as total number of digits we typed till now.
 }
 count++;
 }
 }
 }
});
</code></pre>
This solution will not allow the user to enter more than two digit after decimal point. Also you can enter any number of digits before decimal point. I hope this will help. Thank you.

blocks|key|747015|text|这里的所有答案都很复杂，我试着在我的代码中使用simpler.Look，然后自己决定--|type|unstyled|depth|inlineStyleRanges|entityRanges|data|747016|int+temp++=+0;
int+check+=+0;

editText.addTextChangedListener(new+TextWatcher()+{

++++@Override
++++public+void+onTextChanged(CharSequence+s,+int+start,+int+before,+int+count)+{

++++++++if(editText.getText().toString().length()<temp)
++++++++{
++++++++++++if(!editText.getText().toString().contains("."))
++++++++++++++++editText.setFilters(new+InputFilter[]+{+new+InputFilter.LengthFilter(editText.getText().toString().length()-1)+});
++++++++++++else
++++++++++++++++editText.setFilters(new+InputFilter[]+{+new+InputFilter.LengthFilter(editText.getText().toString().length()%2B1)+});

++++++++}

++++++++if(!editText.getText().toString().contains("."))
++++++++{
++++++++++++editText.setFilters(new+InputFilter[]+{+new+InputFilter.LengthFilter(editText.getText().toString().length()%2B1)+});
++++++++++++check=0;
++++++++}


++++++++else+if(check==0)
++++++++{
++++++++++++check=1;
++++++++++++editText.setFilters(new+InputFilter[]+{+new+InputFilter.LengthFilter(editText.getText().toString().length()%2B2)+});
++++++++}
++++}

++++@Override
++++public+void+beforeTextChanged(CharSequence+s,+int+start,+int+count,
++++++++++++int+after)+{
++++++++temp+=+editText.getText().toString().length();


++++}

++++@Override
++++public+void+afterTextChanged(Editable+s)+{
++++++++//+TODO+Auto-generated+method+stub

++++}
});|code-block|syntax|javascript|747017|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

All answers here are pretty complex I tried to make it much simpler.Look at my code and decide for yourself - 

<pre><code>int temp = 0;
int check = 0;

editText.addTextChangedListener(new TextWatcher() {

 @Override
 public void onTextChanged(CharSequence s, int start, int before, int count) {

 if(editText.getText().toString().length()&lt;temp)
 {
 if(!editText.getText().toString().contains("."))
 editText.setFilters(new InputFilter[] { new InputFilter.LengthFilter(editText.getText().toString().length()-1) });
 else
 editText.setFilters(new InputFilter[] { new InputFilter.LengthFilter(editText.getText().toString().length()+1) });

 }

 if(!editText.getText().toString().contains("."))
 {
 editText.setFilters(new InputFilter[] { new InputFilter.LengthFilter(editText.getText().toString().length()+1) });
 check=0;
 }


 else if(check==0)
 {
 check=1;
 editText.setFilters(new InputFilter[] { new InputFilter.LengthFilter(editText.getText().toString().length()+2) });
 }
 }

 @Override
 public void beforeTextChanged(CharSequence s, int start, int count,
 int after) {
 temp = editText.getText().toString().length();


 }

 @Override
 public void afterTextChanged(Editable s) {
 // TODO Auto-generated method stub

 }
});
</code></pre>

blocks|key|962910|text|我也遇到过这个问题。我希望能够在许多EditTexts中重用这些代码。这是我的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|962911|用法：|962912|CurrencyFormat+watcher+=+new+CurrencyFormat();
priceEditText.addTextChangedListener(watcher);|code-block|syntax|javascript|962913|类：|962914|public+static+class+CurrencyFormat+implements+TextWatcher+{

++++public+void+onTextChanged(CharSequence+arg0,+int+start,+int+arg2,int+arg3)+{}

++++public+void+beforeTextChanged(CharSequence+arg0,+int+start,int+arg2,+int+arg3)+{}

++++public+void+afterTextChanged(Editable+arg0)+{
++++++++int+length+=+arg0.length();
++++++++if(length>0){
++++++++++++if(nrOfDecimal(arg0.toString())>2)
++++++++++++++++++++arg0.delete(length-1,+length);
++++++++}

++++}


++++private+int+nrOfDecimal(String+nr){
++++++++int+len+=+nr.length();
++++++++int+pos+=+len;
++++++++for(int+i=0+;+i<len;+i%2B%2B){
++++++++++++if(nr.charAt(i)=='.'){
++++++++++++++++pos=i%2B1;
++++++++++++++++++++break;
++++++++++++}
++++++++}
++++++++return+len-pos;
++++}
}|962915|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I've also came across this problem. I wanted to be able to reuse the code in many EditTexts. This is my solution:

Usage :

<pre><code>CurrencyFormat watcher = new CurrencyFormat();
priceEditText.addTextChangedListener(watcher);
</code></pre>

Class:

<pre><code>public static class CurrencyFormat implements TextWatcher {

 public void onTextChanged(CharSequence arg0, int start, int arg2,int arg3) {}

 public void beforeTextChanged(CharSequence arg0, int start,int arg2, int arg3) {}

 public void afterTextChanged(Editable arg0) {
 int length = arg0.length();
 if(length&gt;0){
 if(nrOfDecimal(arg0.toString())&gt;2)
 arg0.delete(length-1, length);
 }

 }


 private int nrOfDecimal(String nr){
 int len = nr.length();
 int pos = len;
 for(int i=0 ; i&lt;len; i++){
 if(nr.charAt(i)=='.'){
 pos=i+1;
 break;
 }
 }
 return len-pos;
 }
}
</code></pre>

blocks|key|962971|text|我真的很喜欢Pinhassi的答案，但注意到用户在小数点后输入了指定的数字数字后，您不能再在小数点左侧输入文本。问题在于，解决方案只测试了之前输入的文本，而不是当前输入的文本。因此，我的解决方案是将新字符插入到原始文本中进行验证。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|962972|package+com.test.test;
import+java.util.regex.Matcher;
import+java.util.regex.Pattern;

import+android.text.InputFilter;
import+android.text.Spanned;
import+android.util.Log;

public+class+InputFilterCurrency+implements+InputFilter+{
++++Pattern+moPattern;

++++public+InputFilterCurrency(int+aiMinorUnits)+{
++++++++//+http://www.regexplanet.com/advanced/java/index.html
++++++++moPattern=Pattern.compile("[0-9]*%2B((\\.[0-9]{0,"%2B+aiMinorUnits+%2B+"})?)%7C%7C(\\.)?");

++++}+//+InputFilterCurrency

++++@Override
++++public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+{
++++++++String+lsStart++=+"";
++++++++String+lsInsert+=+"";
++++++++String+lsEnd++++=+"";
++++++++String+lsText+++=+"";

++++++++Log.d("debug",+moPattern.toString());
++++++++Log.d("debug",+"source:+"+%2B+source+%2B+",+start:+"+%2B+start+%2B+",+end:"+%2B+end+%2B+",+dest:+"+%2B+dest+%2B+",+dstart:+"+%2B+dstart+%2B+",+dend:+"+%2B+dend+);

++++++++lsText+=+dest.toString();

++++++++//+If+the+length+is+greater+then+0,+then+insert+the+new+character
++++++++//+into+the+original+text+for+validation
++++++++if+(lsText.length()+>+0)+{

++++++++++++lsStart+=+lsText.substring(0,+dstart);
++++++++++++Log.d("debug",+"lsStart+:+"+%2B+lsStart);
++++++++++++//+Check+to+see+if+they+have+deleted+a+character
++++++++++++if+(source+!=+"")+{
++++++++++++++++lsInsert+=+source.toString();
++++++++++++++++Log.d("debug",+"lsInsert:+"+%2B+lsInsert);
++++++++++++}+//+if
++++++++++++lsEnd+=+lsText.substring(dend);
++++++++++++Log.d("debug",+"lsEnd+++:+"+%2B+lsEnd);
++++++++++++lsText+=+lsStart+%2B+lsInsert+%2B+lsEnd;
++++++++++++Log.d("debug",+"lsText++:+"+%2B+lsText);

++++++++}+//+if

++++++++Matcher+loMatcher+=+moPattern.matcher(lsText);
++++++++Log.d("debug",+"loMatcher.matches():+"+%2B+loMatcher.matches()+%2B+",+lsText:+"+%2B+lsText);
++++++++if(!loMatcher.matches())+{
++++++++++++return+"";
++++++++}
++++++++return+null;

++++}+//+CharSequence

}+//+InputFilterCurrency|code-block|syntax|javascript|962973|以及设置editText过滤器的调用|962974|editText.setFilters(new+InputFilter[]+{new+InputFilterCurrency(2)});

Ouput+with+two+decimal+places
05-22+15:25:33.434:+D/debug(30524):+[0-9]*%2B((\.[0-9]{0,2})?)%7C%7C(\.)?
05-22+15:25:33.434:+D/debug(30524):+source:+5,+start:+0,+end:1,+dest:+123.4,+dstart:+5,+dend:+5
05-22+15:25:33.434:+D/debug(30524):+lsStart+:+123.4
05-22+15:25:33.434:+D/debug(30524):+lsInsert:+5
05-22+15:25:33.434:+D/debug(30524):+lsEnd+++:+
05-22+15:25:33.434:+D/debug(30524):+lsText++:+123.45
05-22+15:25:33.434:+D/debug(30524):+loMatcher.matches():+true,+lsText:+123.45

Ouput+inserting+a+5+in+the+middle
05-22+15:26:17.624:+D/debug(30524):+[0-9]*%2B((\.[0-9]{0,2})?)%7C%7C(\.)?
05-22+15:26:17.624:+D/debug(30524):+source:+5,+start:+0,+end:1,+dest:+123.45,+dstart:+2,+dend:+2
05-22+15:26:17.624:+D/debug(30524):+lsStart+:+12
05-22+15:26:17.624:+D/debug(30524):+lsInsert:+5
05-22+15:26:17.624:+D/debug(30524):+lsEnd+++:+3.45
05-22+15:26:17.624:+D/debug(30524):+lsText++:+1253.45
05-22+15:26:17.624:+D/debug(30524):+loMatcher.matches():+true,+lsText:+1253.45|962975|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I really liked Pinhassi's answer, but noticed that after the user had entered the specified number digits after the decimal point you could no longer enter text to the left side of the decimal point. The problem was that the solution only tested the previous text that had been entered, not the current text being entered. So here is my solution that inserts the new character into the original text for validation.

<pre><code>package com.test.test;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import android.text.InputFilter;
import android.text.Spanned;
import android.util.Log;

public class InputFilterCurrency implements InputFilter {
 Pattern moPattern;

 public InputFilterCurrency(int aiMinorUnits) {
 // http://www.regexplanet.com/advanced/java/index.html
 moPattern=Pattern.compile("[0-9]*+((\\.[0-9]{0,"+ aiMinorUnits + "})?)||(\\.)?");

 } // InputFilterCurrency

 @Override
 public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
 String lsStart = "";
 String lsInsert = "";
 String lsEnd = "";
 String lsText = "";

 Log.d("debug", moPattern.toString());
 Log.d("debug", "source: " + source + ", start: " + start + ", end:" + end + ", dest: " + dest + ", dstart: " + dstart + ", dend: " + dend );

 lsText = dest.toString();

 // If the length is greater then 0, then insert the new character
 // into the original text for validation
 if (lsText.length() &gt; 0) {

 lsStart = lsText.substring(0, dstart);
 Log.d("debug", "lsStart : " + lsStart);
 // Check to see if they have deleted a character
 if (source != "") {
 lsInsert = source.toString();
 Log.d("debug", "lsInsert: " + lsInsert);
 } // if
 lsEnd = lsText.substring(dend);
 Log.d("debug", "lsEnd : " + lsEnd);
 lsText = lsStart + lsInsert + lsEnd;
 Log.d("debug", "lsText : " + lsText);

 } // if

 Matcher loMatcher = moPattern.matcher(lsText);
 Log.d("debug", "loMatcher.matches(): " + loMatcher.matches() + ", lsText: " + lsText);
 if(!loMatcher.matches()) {
 return "";
 }
 return null;

 } // CharSequence

} // InputFilterCurrency
</code></pre>

And the call to set the editText filter

<pre><code>editText.setFilters(new InputFilter[] {new InputFilterCurrency(2)});

Ouput with two decimal places
05-22 15:25:33.434: D/debug(30524): [0-9]*+((\.[0-9]{0,2})?)||(\.)?
05-22 15:25:33.434: D/debug(30524): source: 5, start: 0, end:1, dest: 123.4, dstart: 5, dend: 5
05-22 15:25:33.434: D/debug(30524): lsStart : 123.4
05-22 15:25:33.434: D/debug(30524): lsInsert: 5
05-22 15:25:33.434: D/debug(30524): lsEnd : 
05-22 15:25:33.434: D/debug(30524): lsText : 123.45
05-22 15:25:33.434: D/debug(30524): loMatcher.matches(): true, lsText: 123.45

Ouput inserting a 5 in the middle
05-22 15:26:17.624: D/debug(30524): [0-9]*+((\.[0-9]{0,2})?)||(\.)?
05-22 15:26:17.624: D/debug(30524): source: 5, start: 0, end:1, dest: 123.45, dstart: 2, dend: 2
05-22 15:26:17.624: D/debug(30524): lsStart : 12
05-22 15:26:17.624: D/debug(30524): lsInsert: 5
05-22 15:26:17.624: D/debug(30524): lsEnd : 3.45
05-22 15:26:17.624: D/debug(30524): lsText : 1253.45
05-22 15:26:17.624: D/debug(30524): loMatcher.matches(): true, lsText: 1253.45
</code></pre>

blocks|key|962988|text|我的解决方案很简单，而且效果很好！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|962989|public+class+DecimalInputTextWatcher+implements+TextWatcher+{

private+String+mPreviousValue;
private+int+mCursorPosition;
private+boolean+mRestoringPreviousValueFlag;
private+int+mDigitsAfterZero;
private+EditText+mEditText;

public+DecimalInputTextWatcher(EditText+editText,+int+digitsAfterZero)+{
++++mDigitsAfterZero+=+digitsAfterZero;
++++mEditText+=+editText;
++++mPreviousValue+=+"";
++++mRestoringPreviousValueFlag+=+false;
}

@Override
public+void+beforeTextChanged(CharSequence+s,+int+start,+int+count,+int+after)+{
++++if+(!mRestoringPreviousValueFlag)+{
++++++++mPreviousValue+=+s.toString();
++++++++mCursorPosition+=+mEditText.getSelectionStart();
++++}
}

@Override
public+void+onTextChanged(CharSequence+s,+int+start,+int+before,+int+count)+{
}

@Override
public+void+afterTextChanged(Editable+s)+{
++++if+(!mRestoringPreviousValueFlag)+{

++++++++if+(!isValid(s.toString()))+{
++++++++++++mRestoringPreviousValueFlag+=+true;
++++++++++++restorePreviousValue();
++++++++}

++++}+else+{
++++++++mRestoringPreviousValueFlag+=+false;
++++}
}

private+void+restorePreviousValue()+{
++++mEditText.setText(mPreviousValue);
++++mEditText.setSelection(mCursorPosition);
}

private+boolean+isValid(String+s)+{
++++Pattern+patternWithDot+=+Pattern.compile("[0-9]*((\\.[0-9]{0,"+%2B+mDigitsAfterZero+%2B+"})?)%7C%7C(\\.)?");
++++Pattern+patternWithComma+=+Pattern.compile("[0-9]*((,[0-9]{0,"+%2B+mDigitsAfterZero+%2B+"})?)%7C%7C(,)?");

++++Matcher+matcherDot+=+patternWithDot.matcher(s);
++++Matcher+matcherComa+=+patternWithComma.matcher(s);

++++return+matcherDot.matches()+%7C%7C+matcherComa.matches();
}
}|code-block|syntax|javascript|962990|用法：|962991|myTextEdit.addTextChangedListener(new+DecimalInputTextWatcher(myTextEdit,+2));|962992|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

My solution is simple and works perfect!

<pre><code>public class DecimalInputTextWatcher implements TextWatcher {

private String mPreviousValue;
private int mCursorPosition;
private boolean mRestoringPreviousValueFlag;
private int mDigitsAfterZero;
private EditText mEditText;

public DecimalInputTextWatcher(EditText editText, int digitsAfterZero) {
 mDigitsAfterZero = digitsAfterZero;
 mEditText = editText;
 mPreviousValue = "";
 mRestoringPreviousValueFlag = false;
}

@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
 if (!mRestoringPreviousValueFlag) {
 mPreviousValue = s.toString();
 mCursorPosition = mEditText.getSelectionStart();
 }
}

@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
}

@Override
public void afterTextChanged(Editable s) {
 if (!mRestoringPreviousValueFlag) {

 if (!isValid(s.toString())) {
 mRestoringPreviousValueFlag = true;
 restorePreviousValue();
 }

 } else {
 mRestoringPreviousValueFlag = false;
 }
}

private void restorePreviousValue() {
 mEditText.setText(mPreviousValue);
 mEditText.setSelection(mCursorPosition);
}

private boolean isValid(String s) {
 Pattern patternWithDot = Pattern.compile("[0-9]*((\\.[0-9]{0," + mDigitsAfterZero + "})?)||(\\.)?");
 Pattern patternWithComma = Pattern.compile("[0-9]*((,[0-9]{0," + mDigitsAfterZero + "})?)||(,)?");

 Matcher matcherDot = patternWithDot.matcher(s);
 Matcher matcherComa = patternWithComma.matcher(s);

 return matcherDot.matches() || matcherComa.matches();
}
}
</code></pre>

Usage:

<pre><code>myTextEdit.addTextChangedListener(new DecimalInputTextWatcher(myTextEdit, 2));
</code></pre>

blocks|key|747205|text|我为@Pinhassi解决方案做了一些修复。它可以处理一些情况：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|747206|1.您可以将光标移动到任何位置|747207|2.减号处理|747208|3.数字之前=2，数字之后=4，然后输入12.4545。然后如果你想删除"."，它将不允许。|747209|public+class+DecimalDigitsInputFilter+implements+InputFilter+{
++++private+int+mDigitsBeforeZero;
++++private+int+mDigitsAfterZero;
++++private+Pattern+mPattern;

++++private+static+final+int+DIGITS_BEFORE_ZERO_DEFAULT+=+100;
++++private+static+final+int+DIGITS_AFTER_ZERO_DEFAULT+=+100;

++++public+DecimalDigitsInputFilter(Integer+digitsBeforeZero,+Integer+digitsAfterZero)+{
++++this.mDigitsBeforeZero+=+(digitsBeforeZero+!=+null+?+digitsBeforeZero+:+DIGITS_BEFORE_ZERO_DEFAULT);
++++this.mDigitsAfterZero+=+(digitsAfterZero+!=+null+?+digitsAfterZero+:+DIGITS_AFTER_ZERO_DEFAULT);
++++mPattern+=+Pattern.compile("-?[0-9]{0,"+%2B+(mDigitsBeforeZero)+%2B+"}%2B((\\.[0-9]{0,"+%2B+(mDigitsAfterZero)
++++++++%2B+"})?)%7C%7C(\\.)?");
++++}

++++@Override
++++public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+{
++++String+replacement+=+source.subSequence(start,+end).toString();
++++String+newVal+=+dest.subSequence(0,+dstart).toString()+%2B+replacement
++++++++%2B+dest.subSequence(dend,+dest.length()).toString();
++++Matcher+matcher+=+mPattern.matcher(newVal);
++++if+(matcher.matches())
++++++++return+null;

++++if+(TextUtils.isEmpty(source))
++++++++return+dest.subSequence(dstart,+dend);
++++else
++++++++return+"";
++++}
}|code-block|syntax|javascript|747210|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I made some fixes for @Pinhassi solution. It handles some cases:

1.you can move cursor anywhere

2.minus sign handling

3.digitsbefore = 2 and digitsafter = 4 and you enter 12.4545. Then if you want to remove ".", it will not allow.

<pre><code>public class DecimalDigitsInputFilter implements InputFilter {
 private int mDigitsBeforeZero;
 private int mDigitsAfterZero;
 private Pattern mPattern;

 private static final int DIGITS_BEFORE_ZERO_DEFAULT = 100;
 private static final int DIGITS_AFTER_ZERO_DEFAULT = 100;

 public DecimalDigitsInputFilter(Integer digitsBeforeZero, Integer digitsAfterZero) {
 this.mDigitsBeforeZero = (digitsBeforeZero != null ? digitsBeforeZero : DIGITS_BEFORE_ZERO_DEFAULT);
 this.mDigitsAfterZero = (digitsAfterZero != null ? digitsAfterZero : DIGITS_AFTER_ZERO_DEFAULT);
 mPattern = Pattern.compile("-?[0-9]{0," + (mDigitsBeforeZero) + "}+((\\.[0-9]{0," + (mDigitsAfterZero)
 + "})?)||(\\.)?");
 }

 @Override
 public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
 String replacement = source.subSequence(start, end).toString();
 String newVal = dest.subSequence(0, dstart).toString() + replacement
 + dest.subSequence(dend, dest.length()).toString();
 Matcher matcher = mPattern.matcher(newVal);
 if (matcher.matches())
 return null;

 if (TextUtils.isEmpty(source))
 return dest.subSequence(dstart, dend);
 else
 return "";
 }
}
</code></pre>

blocks|key|963094|text|我改进了Pinhassi的使用正则表达式的解决方案，因此它也可以正确地处理边缘情况。在检查输入是否正确之前，首先按照android文档的描述构造最后一个字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|963095|public+class+DecimalDigitsInputFilter+implements+InputFilter+{

++++private+Pattern+mPattern;

++++private+static+final+Pattern+mFormatPattern+=+Pattern.compile("\\d%2B\\.\\d%2B");

++++public+DecimalDigitsInputFilter(int+digitsBeforeDecimal,+int+digitsAfterDecimal)+{
++++++++mPattern+=+Pattern.compile(
++++++++++++"%5E\\d{0,"+%2B+digitsBeforeDecimal+%2B+"}([\\.,](\\d{0,"+%2B+digitsAfterDecimal+%2B
++++++++++++++++"})?)?$");
++++}

++++@Override
++++public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+
+++++++++++++++++++++++++++++++int+dstart,+int+dend)+{

++++++++String+newString+=
++++++++++++dest.toString().substring(0,+dstart)+%2B+source.toString().substring(start,+end)+
++++++++++++%2B+dest.toString().substring(dend,+dest.toString().length());

++++++++Matcher+matcher+=+mPattern.matcher(newString);
++++++++if+(!matcher.matches())+{
++++++++++++return+"";
++++++++}
++++++++return+null;
++++}
}|code-block|syntax|javascript|963096|用法：|963097|editText.setFilters(new+InputFilter[]+{new+DecimalDigitsInputFilter(5,2)});|963098|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I improved on the solution that uses a regex by Pinhassi so it also handles the edge cases correctly. Before checking if the input is correct, first the final string is constructed as described by the android docs.

<pre><code>public class DecimalDigitsInputFilter implements InputFilter {

 private Pattern mPattern;

 private static final Pattern mFormatPattern = Pattern.compile("\\d+\\.\\d+");

 public DecimalDigitsInputFilter(int digitsBeforeDecimal, int digitsAfterDecimal) {
 mPattern = Pattern.compile(
 "^\\d{0," + digitsBeforeDecimal + "}([\\.,](\\d{0," + digitsAfterDecimal +
 "})?)?$");
 }

 @Override
 public CharSequence filter(CharSequence source, int start, int end, Spanned dest, 
 int dstart, int dend) {

 String newString =
 dest.toString().substring(0, dstart) + source.toString().substring(start, end) 
 + dest.toString().substring(dend, dest.toString().length());

 Matcher matcher = mPattern.matcher(newString);
 if (!matcher.matches()) {
 return "";
 }
 return null;
 }
}
</code></pre>

Usage:

<pre><code>editText.setFilters(new InputFilter[] {new DecimalDigitsInputFilter(5,2)});
</code></pre>

blocks|key|963127|text|@Meh为了你..|type|unstyled|depth|inlineStyleRanges|entityRanges|data|963128|txtlist.setFilters(new+InputFilter[]+{+new+DigitsKeyListener(+Boolean.FALSE,Boolean.TRUE)+{

++++++++int+beforeDecimal+=+7;
++++++++int+afterDecimal+=+2;

++++++++@Override
++++++++public+CharSequence+filter(CharSequence+source,+int+start,+int+end,Spanned+dest,+int+dstart,+int+dend)+{

++++++++++++String+etText+=+txtlist.getText().toString();
++++++++++++String+temp+=+txtlist.getText()+%2B+source.toString();
++++++++++++if+(temp.equals("."))+{
++++++++++++++++return+"0.";
++++++++++++}+else+if+(temp.toString().indexOf(".")+==+-1)+{
++++++++++++++++//+no+decimal+point+placed+yet
+++++++++++++++++if+(temp.length()+>+beforeDecimal)+{
++++++++++++++++++++return+"";
++++++++++++++++}
++++++++++++}+else+{
++++++++++++++++int+dotPosition+;
++++++++++++++++int+cursorPositon+=+txtlistprice.getSelectionStart();
++++++++++++++++if+(etText.indexOf(".")+==+-1)+{
++++++++++++++++++++dotPosition+=+temp.indexOf(".");
++++++++++++++++}else{
++++++++++++++++++++dotPosition+=+etText.indexOf(".");
++++++++++++++++}
++++++++++++++++if(cursorPositon+<=+dotPosition){
++++++++++++++++++++String+beforeDot+=+etText.substring(0,+dotPosition);
++++++++++++++++++++if(beforeDot.length()<beforeDecimal){
++++++++++++++++++++++++return+source;
++++++++++++++++++++}else{
++++++++++++++++++++++++if(source.toString().equalsIgnoreCase(".")){
++++++++++++++++++++++++++++return+source;
++++++++++++++++++++++++}else{
++++++++++++++++++++++++++++return+"";
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++}else{
++++++++++++++++++++temp+=+temp.substring(temp.indexOf(".")+%2B+1);
++++++++++++++++++++if+(temp.length()+>+afterDecimal)+{
++++++++++++++++++++++++return+"";
++++++++++++++++++++}
++++++++++++++++}
++++++++++++}
++++++++++++return+super.filter(source,+start,+end,+dest,+dstart,+dend);
++++++++}
++++}+});|code-block|syntax|javascript|963129|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

@Meh for u..

<pre><code>txtlist.setFilters(new InputFilter[] { new DigitsKeyListener( Boolean.FALSE,Boolean.TRUE) {

 int beforeDecimal = 7;
 int afterDecimal = 2;

 @Override
 public CharSequence filter(CharSequence source, int start, int end,Spanned dest, int dstart, int dend) {

 String etText = txtlist.getText().toString();
 String temp = txtlist.getText() + source.toString();
 if (temp.equals(".")) {
 return "0.";
 } else if (temp.toString().indexOf(".") == -1) {
 // no decimal point placed yet
 if (temp.length() &gt; beforeDecimal) {
 return "";
 }
 } else {
 int dotPosition ;
 int cursorPositon = txtlistprice.getSelectionStart();
 if (etText.indexOf(".") == -1) {
 dotPosition = temp.indexOf(".");
 }else{
 dotPosition = etText.indexOf(".");
 }
 if(cursorPositon &lt;= dotPosition){
 String beforeDot = etText.substring(0, dotPosition);
 if(beforeDot.length()&lt;beforeDecimal){
 return source;
 }else{
 if(source.toString().equalsIgnoreCase(".")){
 return source;
 }else{
 return "";
 }
 }
 }else{
 temp = temp.substring(temp.indexOf(".") + 1);
 if (temp.length() &gt; afterDecimal) {
 return "";
 }
 }
 }
 return super.filter(source, start, end, dest, dstart, dend);
 }
 } });
</code></pre>

blocks|key|963149|text|这是将小数点后的位数限制为两位的最简单解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|963150|myeditText2+=+(EditText)+findViewById(R.id.editText2);++
myeditText2.setInputType(3);|code-block|syntax|javascript|963151|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is the simplest solution to limit the number of digits after decimal point to two:

<pre><code>myeditText2 = (EditText) findViewById(R.id.editText2); 
myeditText2.setInputType(3);
</code></pre>

blocks|key|747313|text|et+=+(EditText)+vw.findViewById(R.id.tx_edittext);

et.setFilters(new+InputFilter[]+{
++++++++new+DigitsKeyListener(Boolean.FALSE,+Boolean.TRUE)+{
++++++++++++int+beforeDecimal+=+5,+afterDecimal+=+2;

++++++++++++@Override
++++++++++++public+CharSequence+filter(CharSequence+source,+int+start,+int+end,
++++++++++++++++++++Spanned+dest,+int+dstart,+int+dend)+{
++++++++++++++++String+temp+=+et.getText()+%2B+source.toString();

++++++++++++++++if+(temp.equals("."))+{
++++++++++++++++++++return+"0.";
++++++++++++++++}
++++++++++++++++else+if+(temp.toString().indexOf(".")+==+-1)+{
++++++++++++++++++++//+no+decimal+point+placed+yet
++++++++++++++++++++if+(temp.length()+>+beforeDecimal)+{
++++++++++++++++++++++++return+"";
++++++++++++++++++++}
++++++++++++++++}+else+{
++++++++++++++++++++temp+=+temp.substring(temp.indexOf(".")+%2B+1);
++++++++++++++++++++if+(temp.length()+>+afterDecimal)+{
++++++++++++++++++++++++return+"";
++++++++++++++++++++}
++++++++++++++++}

++++++++++++++++return+super.filter(source,+start,+end,+dest,+dstart,+dend);
++++++++++++}
++++++++}
});|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|747314|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>et = (EditText) vw.findViewById(R.id.tx_edittext);

et.setFilters(new InputFilter[] {
 new DigitsKeyListener(Boolean.FALSE, Boolean.TRUE) {
 int beforeDecimal = 5, afterDecimal = 2;

 @Override
 public CharSequence filter(CharSequence source, int start, int end,
 Spanned dest, int dstart, int dend) {
 String temp = et.getText() + source.toString();

 if (temp.equals(".")) {
 return "0.";
 }
 else if (temp.toString().indexOf(".") == -1) {
 // no decimal point placed yet
 if (temp.length() &gt; beforeDecimal) {
 return "";
 }
 } else {
 temp = temp.substring(temp.indexOf(".") + 1);
 if (temp.length() &gt; afterDecimal) {
 return "";
 }
 }

 return super.filter(source, start, end, dest, dstart, dend);
 }
 }
});
</code></pre>

blocks|key|963196|text|这对我来说很好。它允许即使在焦点改变和取回之后也可以输入值。例如：123.00、12.12、0.01等。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|963197|1.Integer.parseInt(getString(R.string.valuelength))指定输入的长度digits.Values从string.xml访问file.It很容易更改值。2.Integer.parseInt(getString(R.string.valuedecimal))，这是小数位数的最大限制。|963198|private+InputFilter[]+valDecimalPlaces;
private+ArrayList<EditText>+edittextArray;

valDecimalPlaces+=+new+InputFilter[]+{+new+DecimalDigitsInputFilterNew(
++++Integer.parseInt(getString(R.string.valuelength)),
++++Integer.parseInt(getString(R.string.valuedecimal)))+
};|code-block|syntax|javascript|963199|允许执行操作的EditText值的数组。|963200|for+(EditText+etDecimalPlace+:+edittextArray)+{
++++++++++++etDecimalPlace.setFilters(valDecimalPlaces);|963201|我只是在DecimalDigitsInputFilterNew.class文件中使用了包含多个编辑文本的值数组。|963202|import+android.text.InputFilter;
import+android.text.Spanned;

public+class+DecimalDigitsInputFilterNew+implements+InputFilter+{

++++private+final+int+decimalDigits;
++++private+final+int+before;

++++public+DecimalDigitsInputFilterNew(int+before+,int+decimalDigits)+{
++++++++this.decimalDigits+=+decimalDigits;
++++++++this.before+=+before;
++++}

++++@Override
++++public+CharSequence+filter(CharSequence+source,+int+start,+int+end,
++++++++Spanned+dest,+int+dstart,+int+dend)+{
++++++++StringBuilder+builder+=+new+StringBuilder(dest);
++++++++builder.replace(dstart,+dend,+source
++++++++++++++.subSequence(start,+end).toString());
++++++++if+(!builder.toString().matches("(([0-9]{1})([0-9]{0,"%2B(before-1)%2B"})?)?(\\.[0-9]{0,"%2BdecimalDigits%2B"})?"))+{
+++++++++++++if(source.length()==0)
++++++++++++++++++return+dest.subSequence(dstart,+dend);
+++++++++++++return+"";
++++++++}
++++++++return+null;
++++}
}|963203|entityMap^0|X|6|14|5|1A|4|0|2|1D|1M|D|20|A|2S|1E|0|0|7|8|0|0|4|X|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1G|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1H|8|@$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|S|3|T|5|J|7|1K|8|@]|D|@]|E|$K|L]]|$1|U|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|V|$]]

This works fine for me. It allows value to be entered even after focus changed and retrieved back. For example: <code>123.00</code>, <code>12.12</code>, <code>0.01</code>, etc..

1.<code>Integer.parseInt(getString(R.string.valuelength))</code>
Specifies the length of the input <code>digits.Values</code> accessed from <code>string.xml</code> file.It is quiet easy to change values.
2.<code>Integer.parseInt(getString(R.string.valuedecimal))</code>, this is for decimal places max limit.

<pre><code>private InputFilter[] valDecimalPlaces;
private ArrayList&lt;EditText&gt; edittextArray;

valDecimalPlaces = new InputFilter[] { new DecimalDigitsInputFilterNew(
 Integer.parseInt(getString(R.string.valuelength)),
 Integer.parseInt(getString(R.string.valuedecimal))) 
};
</code></pre>

Array of <code>EditText</code> values that allows to perform action.

<pre><code>for (EditText etDecimalPlace : edittextArray) {
 etDecimalPlace.setFilters(valDecimalPlaces);
</code></pre>

I just used array of values that contain multiple edittext
Next <code>DecimalDigitsInputFilterNew.class</code> file.

<pre><code>import android.text.InputFilter;
import android.text.Spanned;

public class DecimalDigitsInputFilterNew implements InputFilter {

 private final int decimalDigits;
 private final int before;

 public DecimalDigitsInputFilterNew(int before ,int decimalDigits) {
 this.decimalDigits = decimalDigits;
 this.before = before;
 }

 @Override
 public CharSequence filter(CharSequence source, int start, int end,
 Spanned dest, int dstart, int dend) {
 StringBuilder builder = new StringBuilder(dest);
 builder.replace(dstart, dend, source
 .subSequence(start, end).toString());
 if (!builder.toString().matches("(([0-9]{1})([0-9]{0,"+(before-1)+"})?)?(\\.[0-9]{0,"+decimalDigits+"})?")) {
 if(source.length()==0)
 return dest.subSequence(dstart, dend);
 return "";
 }
 return null;
 }
}
</code></pre>

blocks|key|963231|text|我已经修改了上面的解决方案并创建了以下解决方案。您可以设置小数点前后的位数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|963232|public+class+DecimalDigitsInputFilter+implements+InputFilter+{

private+final+Pattern+mPattern;

public+DecimalDigitsInputFilter(int+digitsBeforeZero,+int+digitsAfterZero)+{
++++mPattern+=+Pattern.compile(String.format("[0-9]{0,%25d}(\\.[0-9]{0,%25d})?",+digitsBeforeZero,+digitsAfterZero));
}

@Override
public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+{
++++Matcher+matcher+=+mPattern.matcher(createResultString(source,+start,+end,+dest,+dstart,+dend));
++++if+(!matcher.matches())
++++++++return+"";
++++return+null;
}

private+String+createResultString(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+{
++++String+sourceString+=+source.toString();
++++String+destString+=+dest.toString();
++++return+destString.substring(0,+dstart)+%2B+sourceString.substring(start,+end)+%2B+destString.substring(dend);
}|code-block|syntax|javascript|963233|}|963234|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I have modified the above solutions and created following one. You can set number of digits before and after decimal point.

<pre><code>public class DecimalDigitsInputFilter implements InputFilter {

private final Pattern mPattern;

public DecimalDigitsInputFilter(int digitsBeforeZero, int digitsAfterZero) {
 mPattern = Pattern.compile(String.format("[0-9]{0,%d}(\\.[0-9]{0,%d})?", digitsBeforeZero, digitsAfterZero));
}

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
 Matcher matcher = mPattern.matcher(createResultString(source, start, end, dest, dstart, dend));
 if (!matcher.matches())
 return "";
 return null;
}

private String createResultString(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
 String sourceString = source.toString();
 String destString = dest.toString();
 return destString.substring(0, dstart) + sourceString.substring(start, end) + destString.substring(dend);
}
</code></pre>

}

blocks|key|747573|text|简单的助手类在这里是为了防止用户在小数后输入超过2位的数字：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|747574|public+class+CostFormatter++implements+TextWatcher+{

private+final+EditText+costEditText;

public+CostFormatter(EditText+costEditText)+{
++++this.costEditText+=+costEditText;
}

@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+synchronized+void+afterTextChanged(final+Editable+text)+{
++++String+cost+=+text.toString().trim();

++++if(!cost.endsWith(".")+&&+cost.contains(".")){
++++++++String+numberBeforeDecimal+=+cost.split("\\.")[0];
++++++++String+numberAfterDecimal+=+cost.split("\\.")[1];

++++++++if(numberAfterDecimal.length()+>+2){
++++++++++++numberAfterDecimal+=+numberAfterDecimal.substring(0,+2);
++++++++}
++++++++cost+=+numberBeforeDecimal+%2B+"."+%2B+numberAfterDecimal;
++++}
++++costEditText.removeTextChangedListener(this);
++++costEditText.setText(cost);
++++costEditText.setSelection(costEditText.getText().toString().trim().length());
++++costEditText.addTextChangedListener(this);
}
}|code-block|syntax|javascript|747575|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Simple Helper class is here to prevent the user entering more than 2 digits after decimal :

<pre><code>public class CostFormatter implements TextWatcher {

private final EditText costEditText;

public CostFormatter(EditText costEditText) {
 this.costEditText = costEditText;
}

@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 synchronized void afterTextChanged(final Editable text) {
 String cost = text.toString().trim();

 if(!cost.endsWith(".") &amp;&amp; cost.contains(".")){
 String numberBeforeDecimal = cost.split("\\.")[0];
 String numberAfterDecimal = cost.split("\\.")[1];

 if(numberAfterDecimal.length() &gt; 2){
 numberAfterDecimal = numberAfterDecimal.substring(0, 2);
 }
 cost = numberBeforeDecimal + "." + numberAfterDecimal;
 }
 costEditText.removeTextChangedListener(this);
 costEditText.setText(cost);
 costEditText.setSelection(costEditText.getText().toString().trim().length());
 costEditText.addTextChangedListener(this);
}
}
</code></pre>

blocks|key|963296|text|一个非常晚的回应:我们可以简单地这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|963297|etv.addTextChangedListener(new+TextWatcher()+{
++++++++@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().length()+>+3+&&+s.toString().contains("."))+{
++++++++++++++++if+(s.toString().length()+-+s.toString().indexOf(".")+>+3)+{
++++++++++++++++++++etv.setText(s.toString().substring(0,+s.length()+-+1));
++++++++++++++++++++etv.setSelection(edtSendMoney.getText().length());
++++++++++++++++}
++++++++++++}
++++++++}

++++++++@Override
++++++++public+void+afterTextChanged(Editable+arg0)+{
++++++++}
}|code-block|syntax|javascript|963298|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A very late response:
We can do it simply like this:

<pre><code>etv.addTextChangedListener(new TextWatcher() {
 @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().length() &gt; 3 &amp;&amp; s.toString().contains(".")) {
 if (s.toString().length() - s.toString().indexOf(".") &gt; 3) {
 etv.setText(s.toString().substring(0, s.length() - 1));
 etv.setSelection(edtSendMoney.getText().length());
 }
 }
 }

 @Override
 public void afterTextChanged(Editable arg0) {
 }
}
</code></pre>

blocks|key|963343|text|这是基于pinhassi的答案-我遇到的问题是，一旦达到小数限制，就不能在小数之前加值。为了解决这个问题，我们需要在进行模式匹配之前构造最终的字符串。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|963344|import+java.util.regex.Matcher;
import+java.util.regex.Pattern;

import+android.text.InputFilter;
import+android.text.Spanned;

public+class+DecimalLimiter+implements+InputFilter
{
++++Pattern+mPattern;

++++public+DecimalLimiter(int+digitsBeforeZero,int+digitsAfterZero)+
++++{
++++++++mPattern=Pattern.compile("[0-9]{0,"+%2B+(digitsBeforeZero)+%2B+"}%2B((\\.[0-9]{0,"+%2B+(digitsAfterZero)+%2B+"})?)%7C%7C(\\.)?");
++++}

++++@Override
++++public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+
++++{
++++++++StringBuilder+sb+=+new+StringBuilder(dest);
++++++++sb.insert(dstart,+source,+start,+end);

++++++++Matcher+matcher+=+mPattern.matcher(sb.toString());
++++++++if(!matcher.matches())
++++++++++++return+"";
++++++++return+null;
++++}
}|code-block|syntax|javascript|963345|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is to build on pinhassi's answer - the issue that I came across was that you couldn't add values before the decimal once the decimal limit has been reached. To fix the issue, we need to construct the final string before doing the pattern match.

<pre><code>import java.util.regex.Matcher;
import java.util.regex.Pattern;

import android.text.InputFilter;
import android.text.Spanned;

public class DecimalLimiter implements InputFilter
{
 Pattern mPattern;

 public DecimalLimiter(int digitsBeforeZero,int digitsAfterZero) 
 {
 mPattern=Pattern.compile("[0-9]{0," + (digitsBeforeZero) + "}+((\\.[0-9]{0," + (digitsAfterZero) + "})?)||(\\.)?");
 }

 @Override
 public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) 
 {
 StringBuilder sb = new StringBuilder(dest);
 sb.insert(dstart, source, start, end);

 Matcher matcher = mPattern.matcher(sb.toString());
 if(!matcher.matches())
 return "";
 return null;
 }
}
</code></pre>

blocks|key|747666|text|实现这一目标的最简单方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|747667|et.addTextChangedListener(new+TextWatcher()+{
++++public+void+onTextChanged(CharSequence+arg0,+int+arg1,+int+arg2,+int+arg3)+{
++++++++String+text+=+arg0.toString();
++++++++if+(text.contains(".")+&&+text.substring(text.indexOf(".")+%2B+1).length()+>+2)+{
++++++++++++et.setText(text.substring(0,+text.length()+-+1));
++++++++++++et.setSelection(et.getText().length());
++++++++}
++++}

++++public+void+beforeTextChanged(CharSequence+arg0,+int+arg1,+int+arg2,+int+arg3)+{

++++}

++++public+void+afterTextChanged(Editable+arg0)+{
++++}
});|code-block|syntax|javascript|747668|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The simplest way to achieve that is:

<pre><code>et.addTextChangedListener(new TextWatcher() {
 public void onTextChanged(CharSequence arg0, int arg1, int arg2, int arg3) {
 String text = arg0.toString();
 if (text.contains(".") &amp;&amp; text.substring(text.indexOf(".") + 1).length() &gt; 2) {
 et.setText(text.substring(0, text.length() - 1));
 et.setSelection(et.getText().length());
 }
 }

 public void beforeTextChanged(CharSequence arg0, int arg1, int arg2, int arg3) {

 }

 public void afterTextChanged(Editable arg0) {
 }
});
</code></pre>

blocks|key|963401|text|我已经更改了answer№6+(由Favas+Kv编写)，因为在那里您可以将点放在第一个位置。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|963402|final+InputFilter+[]+filter+=+{+new+InputFilter()+{

++++@Override
++++public+CharSequence+filter(CharSequence+source,+int+start,+int+end,
+++++++++++++++++++++++++++++++Spanned+dest,+int+dstart,+int+dend)+{
++++++++StringBuilder+builder+=+new+StringBuilder(dest);
++++++++builder.replace(dstart,+dend,+source
++++++++++++++++.subSequence(start,+end).toString());
++++++++if+(!builder.toString().matches(
++++++++++++++++"(([1-9]{1})([0-9]{0,4})?(\\.)?)?([0-9]{0,2})?"

++++++++))+{
++++++++++++if(source.length()==0)
++++++++++++++++return+dest.subSequence(dstart,+dend);
++++++++++++return+"";
++++++++}
++++++++return+null;
++++}
}};|code-block|syntax|javascript|963403|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I have changed answer №6 (by Favas Kv) because there You can put just point in the first position. 

<pre><code>final InputFilter [] filter = { new InputFilter() {

 @Override
 public CharSequence filter(CharSequence source, int start, int end,
 Spanned dest, int dstart, int dend) {
 StringBuilder builder = new StringBuilder(dest);
 builder.replace(dstart, dend, source
 .subSequence(start, end).toString());
 if (!builder.toString().matches(
 "(([1-9]{1})([0-9]{0,4})?(\\.)?)?([0-9]{0,2})?"

 )) {
 if(source.length()==0)
 return dest.subSequence(dstart, dend);
 return "";
 }
 return null;
 }
}};
</code></pre>

blocks|key|963489|text|正如其他人所说，我在我的项目中添加了这个类，并将过滤器设置为我想要的EditText。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|963490|过滤器是从@Pixel的答案复制而来的。我只是把它们放在一起。|963491|public+class+DecimalDigitsInputFilter+implements+InputFilter+{

++++Pattern+mPattern;

++++public+DecimalDigitsInputFilter()+{
++++++++mPattern+=+Pattern.compile("([1-9]{1}[0-9]{0,2}([0-9]{3})*(\\.[0-9]{0,2})?%7C[1-9]{1}[0-9]{0,}(\\.[0-9]{0,2})?%7C0(\\.[0-9]{0,2})?%7C(\\.[0-9]{1,2})?)");

++++}

++++@Override
++++public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+{

++++++++String+formatedSource+=+source.subSequence(start,+end).toString();

++++++++String+destPrefix+=+dest.subSequence(0,+dstart).toString();

++++++++String+destSuffix+=+dest.subSequence(dend,+dest.length()).toString();

++++++++String+result+=+destPrefix+%2B+formatedSource+%2B+destSuffix;

++++++++result+=+result.replace(",",+".");

++++++++Matcher+matcher+=+mPattern.matcher(result);

++++++++if+(matcher.matches())+{
++++++++++++return+null;
++++++++}

++++++++return+"";
++++}
}|code-block|syntax|javascript|963492|现在在EditText中设置过滤器，如下所示。|963493|mEditText.setFilters(new+InputFilter[]{new+DecimalDigitsInputFilter()});|963494|这里有一件很重要的事情，它解决了我的问题，不允许在EditText中显示小数点后超过两位的数字，但问题是，当我从该EditText执行getText()操作时，它会返回我键入的整个输入。|963495|例如，在EditText上应用过滤器后，我尝试将输入设置为1.5699856987。所以在屏幕上它显示1.56，这是完美的。|963496|然后，我希望将此输入用于其他一些计算，因此我希望从该输入字段(EditText)中获取文本。当我调用mEditText.getText().toString()时，它返回1.5699856987，这在我的例子中是不可接受的。|963497|因此，在从EditText获得值之后，我必须再次解析该值。|963498|BigDecimal+amount+=+new+BigDecimal(Double.parseDouble(mEditText.getText().toString().trim()))
++++.setScale(2,+RoundingMode.HALF_UP);|963499|在从EditText获取全文后，setScale在这里完成了这项工作。|963500|entityMap^0|Y|8|0|0|0|3|8|0|0|P|8|1L|8|1V|9|0|4|8|0|V|8|1E|U|0|5|8|0|0|2|8|G|8|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|18|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1K|8|@$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|1N|8|@$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|W|3|X|5|6|7|1S|8|@$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|J|7|1V|8|@]|D|@]|E|$K|L]]|$1|10|3|11|5|6|7|1W|8|@$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]]|D|@]|E|$]]|$1|12|3|-4|5|6|7|21|8|@]|D|@]|E|$]]]|13|$]]

Like others said, I added this class in my project and set the filter to the <code>EditText</code> I want. 

The filter is copied from @Pixel's answer. I'm just putting it all together. 

<pre><code>public class DecimalDigitsInputFilter implements InputFilter {

 Pattern mPattern;

 public DecimalDigitsInputFilter() {
 mPattern = Pattern.compile("([1-9]{1}[0-9]{0,2}([0-9]{3})*(\\.[0-9]{0,2})?|[1-9]{1}[0-9]{0,}(\\.[0-9]{0,2})?|0(\\.[0-9]{0,2})?|(\\.[0-9]{1,2})?)");

 }

 @Override
 public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {

 String formatedSource = source.subSequence(start, end).toString();

 String destPrefix = dest.subSequence(0, dstart).toString();

 String destSuffix = dest.subSequence(dend, dest.length()).toString();

 String result = destPrefix + formatedSource + destSuffix;

 result = result.replace(",", ".");

 Matcher matcher = mPattern.matcher(result);

 if (matcher.matches()) {
 return null;
 }

 return "";
 }
}
</code></pre>

Now set the filter in your <code>EditText</code> like this.

<pre><code>mEditText.setFilters(new InputFilter[]{new DecimalDigitsInputFilter()});
</code></pre>

Here one important thing is it does solves my problem of not allowing showing more than two digits after the decimal point in that <code>EditText</code> but the problem is when I <code>getText()</code> from that <code>EditText</code>, it returns the whole input I typed. 

For example, after applying the filter over the <code>EditText</code>, I tried to set input 1.5699856987. So in the screen it shows 1.56 which is perfect.

Then I wanted to use this input for some other calculations so I wanted to get the text from that input field (<code>EditText</code>). When I called <code>mEditText.getText().toString()</code> it returns 1.5699856987 which was not acceptable in my case.

So I had to parse the value again after getting it from the <code>EditText</code>. 

<pre><code>BigDecimal amount = new BigDecimal(Double.parseDouble(mEditText.getText().toString().trim()))
 .setScale(2, RoundingMode.HALF_UP);
</code></pre>

<code>setScale</code> does the trick here after getting the full text from the <code>EditText</code>.

blocks|key|963541|text|我想出的InputFilter允许您配置小数点前后的位数。此外，它不允许前导零。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|963542|public+class+DecimalDigitsInputFilter+implements+InputFilter
{
++++Pattern+pattern;

++++public+DecimalDigitsInputFilter(int+digitsBeforeDecimal,+int+digitsAfterDecimal)
++++{
++++++++pattern+=+Pattern.compile("(([1-9]{1}[0-9]{0,"+%2B+(digitsBeforeDecimal+-+1)+%2B+"})?%7C%7C[0]{1})((\\.[0-9]{0,"+%2B+digitsAfterDecimal+%2B+"})?)%7C%7C(\\.)?");
++++}

++++@Override+public+CharSequence+filter(CharSequence+source,+int+sourceStart,+int+sourceEnd,+Spanned+destination,+int+destinationStart,+int+destinationEnd)
++++{
++++++++//+Remove+the+string+out+of+destination+that+is+to+be+replaced.
++++++++String+newString+=+destination.toString().substring(0,+destinationStart)+%2B+destination.toString().substring(destinationEnd,+destination.toString().length());

++++++++//+Add+the+new+string+in.
++++++++newString+=+newString.substring(0,+destinationStart)+%2B+source.toString()+%2B+newString.substring(destinationStart,+newString.length());

++++++++//+Now+check+if+the+new+string+is+valid.
++++++++Matcher+matcher+=+pattern.matcher(newString);

++++++++if(matcher.matches())
++++++++{
++++++++++++//+Returning+null+indicates+that+the+input+is+valid.
++++++++++++return+null;
++++++++}

++++++++//+Returning+the+empty+string+indicates+the+input+is+invalid.
++++++++return+"";
++++}
}

//+To+use+this+InputFilter,+attach+it+to+your+EditText+like+so:
final+EditText+editText+=+(EditText)+findViewById(R.id.editText);

EditText.setFilters(new+InputFilter[]{new+DecimalDigitsInputFilter(4,+4)});|code-block|syntax|javascript|963543|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The InputFilter I came up with allows you to configure the number of digits before and after the decimal place. Additionally, it disallows leading zeroes.

<pre><code>public class DecimalDigitsInputFilter implements InputFilter
{
 Pattern pattern;

 public DecimalDigitsInputFilter(int digitsBeforeDecimal, int digitsAfterDecimal)
 {
 pattern = Pattern.compile("(([1-9]{1}[0-9]{0," + (digitsBeforeDecimal - 1) + "})?||[0]{1})((\\.[0-9]{0," + digitsAfterDecimal + "})?)||(\\.)?");
 }

 @Override public CharSequence filter(CharSequence source, int sourceStart, int sourceEnd, Spanned destination, int destinationStart, int destinationEnd)
 {
 // Remove the string out of destination that is to be replaced.
 String newString = destination.toString().substring(0, destinationStart) + destination.toString().substring(destinationEnd, destination.toString().length());

 // Add the new string in.
 newString = newString.substring(0, destinationStart) + source.toString() + newString.substring(destinationStart, newString.length());

 // Now check if the new string is valid.
 Matcher matcher = pattern.matcher(newString);

 if(matcher.matches())
 {
 // Returning null indicates that the input is valid.
 return null;
 }

 // Returning the empty string indicates the input is invalid.
 return "";
 }
}

// To use this InputFilter, attach it to your EditText like so:
final EditText editText = (EditText) findViewById(R.id.editText);

EditText.setFilters(new InputFilter[]{new DecimalDigitsInputFilter(4, 4)});
</code></pre>

blocks|key|747825|text|@Override
public+void+beforeTextChanged(CharSequence+s,+int+start,+int+count,+int+after)+{
++++String+numero+=+total.getText().toString();
++++int+dec+=+numero.indexOf(".");
++++int+longitud+=+numero.length();
++++if+(dec%2B3+==+longitud+&&+dec+!=+-1)+{+//3+number+decimal+%2B+1
++++++++log.i("ento","si");
++++++++numero+=+numero.substring(0,dec%2B3);
++++++++if+(contador+==+0)+{
++++++++++++contador+=+1;
++++++++++++total.setText(numero);
++++++++++++total.setSelection(numero.length());
++++++++}+else+{
++++++++++++contador+=+0;
++++++++}
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|747826|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
 String numero = total.getText().toString();
 int dec = numero.indexOf(".");
 int longitud = numero.length();
 if (dec+3 == longitud &amp;&amp; dec != -1) { //3 number decimal + 1
 log.i("ento","si");
 numero = numero.substring(0,dec+3);
 if (contador == 0) {
 contador = 1;
 total.setText(numero);
 total.setSelection(numero.length());
 } else {
 contador = 0;
 }
 }
}
</code></pre>

blocks|key|963589|text|这段代码运行良好，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|963590|public+class+DecimalDigitsInputFilter+implements+InputFilter+{

++++private+final+int+digitsBeforeZero;
++++private+final+int+digitsAfterZero;
++++private+Pattern+mPattern;

++++public+DecimalDigitsInputFilter(int+digitsBeforeZero,+int+digitsAfterZero)+{
++++++++this.digitsBeforeZero+=+digitsBeforeZero;
++++++++this.digitsAfterZero+=+digitsAfterZero;
++++++++applyPattern(digitsBeforeZero,+digitsAfterZero);
++++}

++++private+void+applyPattern(int+digitsBeforeZero,+int+digitsAfterZero)+{
++++++++mPattern+=+Pattern.compile("[0-9]{0,"+%2B+(digitsBeforeZero+-+1)+%2B+"}%2B((\\.[0-9]{0,"+%2B+(digitsAfterZero+-+1)+%2B+"})?)%7C(\\.)?");
++++}

++++@Override
++++public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+{
++++++++if+(dest.toString().contains(".")+%7C%7C+source.toString().contains("."))
++++++++++++applyPattern(digitsBeforeZero+%2B+2,+digitsAfterZero);
++++++++else
++++++++++++applyPattern(digitsBeforeZero,+digitsAfterZero);

++++++++Matcher+matcher+=+mPattern.matcher(dest);
++++++++if+(!matcher.matches())
++++++++++++return+"";
++++++++return+null;
++++}

}|code-block|syntax|javascript|963591|应用筛选器：|963592|edittext.setFilters(new+InputFilter[]+{new+DecimalDigitsInputFilter(5,2)});|963593|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This code works well,

<pre><code>public class DecimalDigitsInputFilter implements InputFilter {

 private final int digitsBeforeZero;
 private final int digitsAfterZero;
 private Pattern mPattern;

 public DecimalDigitsInputFilter(int digitsBeforeZero, int digitsAfterZero) {
 this.digitsBeforeZero = digitsBeforeZero;
 this.digitsAfterZero = digitsAfterZero;
 applyPattern(digitsBeforeZero, digitsAfterZero);
 }

 private void applyPattern(int digitsBeforeZero, int digitsAfterZero) {
 mPattern = Pattern.compile("[0-9]{0," + (digitsBeforeZero - 1) + "}+((\\.[0-9]{0," + (digitsAfterZero - 1) + "})?)|(\\.)?");
 }

 @Override
 public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
 if (dest.toString().contains(".") || source.toString().contains("."))
 applyPattern(digitsBeforeZero + 2, digitsAfterZero);
 else
 applyPattern(digitsBeforeZero, digitsAfterZero);

 Matcher matcher = mPattern.matcher(dest);
 if (!matcher.matches())
 return "";
 return null;
 }

}
</code></pre>

applying filter:

<pre><code>edittext.setFilters(new InputFilter[] {new DecimalDigitsInputFilter(5,2)});
</code></pre>

blocks|key|963638|text|正如其他人所说，我在项目中添加了这个类，并将过滤器设置为EditText+Simpler解决方案，而不使用正则表达式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|963639|public+class+DecimalDigitsInputFilter+implements+InputFilter+{
int+digitsBeforeZero+=0;
int+digitsAfterZero=0;

public+DecimalDigitsInputFilter(int+digitsBeforeZero,int+digitsAfterZero)+{
this.digitsBeforeZero=digitsBeforeZero;
this.digitsAfterZero=digitsAfterZero;
}

@Override
public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+{
if(dest!=null+&&+dest.toString().trim().length()<(digitsBeforeZero%2BdigitsAfterZero)){
++++String+value=dest.toString().trim();
++++if(value.contains(".")+&&+(value.substring(value.indexOf(".")).length()<(digitsAfterZero%2B1))){
++++++++return+((value.indexOf(".")%2B1%2BdigitsAfterZero)>dstart)?null:"";
++++}else+if(value.contains(".")+&&+(value.indexOf(".")<dstart)){
++++++++return+"";
++++}else+if(source!=null+&&+source.equals(".")&&+((value.length()-dstart)>=(digitsAfterZero%2B1))){
++++++++return+"";
++++}

}else{
++++return+"";
}
++++return+null;
}|code-block|syntax|javascript|963640|}|963641|应用筛选器：|963642|edittext.setFilters(new+InputFilter[]+{new+DecimalDigitsInputFilter(5,2)});|963643|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Like others said, I added this class in my project and set the filter to the EditText Simpler solution without using regex:

<pre><code>public class DecimalDigitsInputFilter implements InputFilter {
int digitsBeforeZero =0;
int digitsAfterZero=0;

public DecimalDigitsInputFilter(int digitsBeforeZero,int digitsAfterZero) {
this.digitsBeforeZero=digitsBeforeZero;
this.digitsAfterZero=digitsAfterZero;
}

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
if(dest!=null &amp;&amp; dest.toString().trim().length()&lt;(digitsBeforeZero+digitsAfterZero)){
 String value=dest.toString().trim();
 if(value.contains(".") &amp;&amp; (value.substring(value.indexOf(".")).length()&lt;(digitsAfterZero+1))){
 return ((value.indexOf(".")+1+digitsAfterZero)&gt;dstart)?null:"";
 }else if(value.contains(".") &amp;&amp; (value.indexOf(".")&lt;dstart)){
 return "";
 }else if(source!=null &amp;&amp; source.equals(".")&amp;&amp; ((value.length()-dstart)&gt;=(digitsAfterZero+1))){
 return "";
 }

}else{
 return "";
}
 return null;
}
</code></pre>

}

applying filter:

<pre><code>edittext.setFilters(new InputFilter[] {new DecimalDigitsInputFilter(5,2)});
</code></pre>

blocks|key|963702|text|我不使用正则表达式的简单解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|963703|++++int+start=Edit1.getSelectionStart();
++++String+sp=Edit1.getText().toString();
++++sp=sp.replace(",",".");
++++Double+d=Double.valueOf(sp);
++++String+s=String.format("%25.2f",d+);
++++if(!Edit1.getText().toString().equals(s))
++++++++Edit1.setText(s);
++++if(start>Edit1.getText().length())start--;
++++Edit1.setSelection(start);|code-block|syntax|javascript|963704|放入onTextChange。通过删除逗号，零加倍，因为数字变成了整数。|963705|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

My simple solution without regex

<pre><code> int start=Edit1.getSelectionStart();
 String sp=Edit1.getText().toString();
 sp=sp.replace(",",".");
 Double d=Double.valueOf(sp);
 String s=String.format("%.2f",d );
 if(!Edit1.getText().toString().equals(s))
 Edit1.setText(s);
 if(start&gt;Edit1.getText().length())start--;
 Edit1.setSelection(start);
</code></pre>

putting into onTextChange. By deleting the comma, the zeros double because the number becomes an integer.

blocks|key|963710|text|对于Kotlin|type|unstyled|depth|inlineStyleRanges|entityRanges|data|963711|val+inputFilter+=++arrayOf<InputFilter>(DecimalDigitsInputFilter(5,2))
++++++++++++et_total_value.setFilters(inputFilter)|code-block|syntax|javascript|963712|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For Kotlin

<pre><code>val inputFilter = arrayOf&lt;InputFilter&gt;(DecimalDigitsInputFilter(5,2))
 et_total_value.setFilters(inputFilter)
</code></pre>

blocks|key|963724|text|InputFilter的这种实现解决了这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|963725|import+android.text.SpannableStringBuilder;
import+android.text.Spanned;
import+android.text.method.DigitsKeyListener;

public+class+MoneyValueFilter+extends+DigitsKeyListener+{
++++public+MoneyValueFilter()+{
++++++++super(false,+true);
++++}

++++private+int+digits+=+2;

++++public+void+setDigits(int+d)+{
++++++++digits+=+d;
++++}

++++@Override
++++public+CharSequence+filter(CharSequence+source,+int+start,+int+end,
++++++++++++Spanned+dest,+int+dstart,+int+dend)+{
++++++++CharSequence+out+=+super.filter(source,+start,+end,+dest,+dstart,+dend);

++++++++//+if+changed,+replace+the+source
++++++++if+(out+!=+null)+{
++++++++++++source+=+out;
++++++++++++start+=+0;
++++++++++++end+=+out.length();
++++++++}

++++++++int+len+=+end+-+start;

++++++++//+if+deleting,+source+is+empty
++++++++//+and+deleting+can't+break+anything
++++++++if+(len+==+0)+{
++++++++++++return+source;
++++++++}

++++++++int+dlen+=+dest.length();

++++++++//+Find+the+position+of+the+decimal+.
++++++++for+(int+i+=+0;+i+<+dstart;+i%2B%2B)+{
++++++++++++if+(dest.charAt(i)+==+'.')+{
++++++++++++++++//+being+here+means,+that+a+number+has
++++++++++++++++//+been+inserted+after+the+dot
++++++++++++++++//+check+if+the+amount+of+digits+is+right
++++++++++++++++return+(dlen-(i%2B1)+%2B+len+>+digits)+?+
++++++++++++++++++++""+:
++++++++++++++++++++new+SpannableStringBuilder(source,+start,+end);
++++++++++++}
++++++++}

++++++++for+(int+i+=+start;+i+<+end;+%2B%2Bi)+{
++++++++++++if+(source.charAt(i)+==+'.')+{
++++++++++++++++//+being+here+means,+dot+has+been+inserted
++++++++++++++++//+check+if+the+amount+of+digits+is+right
++++++++++++++++if+((dlen-dend)+%2B+(end-(i+%2B+1))+>+digits)
++++++++++++++++++++return+"";
++++++++++++++++else
++++++++++++++++++++break;++//+return+new+SpannableStringBuilder(source,+start,+end);
++++++++++++}
++++++++}

++++++++//+if+the+dot+is+after+the+inserted+part,
++++++++//+nothing+can+break
++++++++return+new+SpannableStringBuilder(source,+start,+end);
++++}
}|code-block|syntax|javascript|963726|要使用以下命令：|963727|editCoin.setFilters(new+InputFilter[]+{new+MoneyValueFilter(2)});|963728|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This implementation of InputFilter solves the problem.
<pre><code>import android.text.SpannableStringBuilder;
import android.text.Spanned;
import android.text.method.DigitsKeyListener;

public class MoneyValueFilter extends DigitsKeyListener {
 public MoneyValueFilter() {
 super(false, true);
 }

 private int digits = 2;

 public void setDigits(int d) {
 digits = d;
 }

 @Override
 public CharSequence filter(CharSequence source, int start, int end,
 Spanned dest, int dstart, int dend) {
 CharSequence out = super.filter(source, start, end, dest, dstart, dend);

 // if changed, replace the source
 if (out != null) {
 source = out;
 start = 0;
 end = out.length();
 }

 int len = end - start;

 // if deleting, source is empty
 // and deleting can't break anything
 if (len == 0) {
 return source;
 }

 int dlen = dest.length();

 // Find the position of the decimal .
 for (int i = 0; i &lt; dstart; i++) {
 if (dest.charAt(i) == '.') {
 // being here means, that a number has
 // been inserted after the dot
 // check if the amount of digits is right
 return (dlen-(i+1) + len &gt; digits) ? 
 &quot;&quot; :
 new SpannableStringBuilder(source, start, end);
 }
 }

 for (int i = start; i &lt; end; ++i) {
 if (source.charAt(i) == '.') {
 // being here means, dot has been inserted
 // check if the amount of digits is right
 if ((dlen-dend) + (end-(i + 1)) &gt; digits)
 return &quot;&quot;;
 else
 break; // return new SpannableStringBuilder(source, start, end);
 }
 }

 // if the dot is after the inserted part,
 // nothing can break
 return new SpannableStringBuilder(source, start, end);
 }
}
</code></pre>
To use:
<pre><code>editCoin.setFilters(new InputFilter[] {new MoneyValueFilter(2)});
</code></pre>

blocks|key|963756|text|Kotlin中的简单BindingAdapter：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|963757|@BindingAdapter("maxDecimalPlaces")
fun+TextInputEditText.limitDecimalPlaces(maxDecimalPlaces:+Int)+{
++++filters+%2B=+InputFilter+{+source,+_,+_,+dest,+dstart,+dend+->
++++++++val+value+=+if+(source.isEmpty())+{
++++++++++++dest.removeRange(dstart,+dend)
++++++++}+else+{
++++++++++++StringBuilder(dest).insert(dstart,+source)
++++++++}
++++++++val+matcher+=+Pattern.compile("([1-9][0-9]*)%7C([1-9][0-9]*\\.[0-9]{0,$maxDecimalPlaces})%7C(\\.[0-9]{0,$maxDecimalPlaces})").matcher(value)
++++++++if+(!matcher.matches())+""+else+null
++++}
}|code-block|syntax|javascript|963758|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Simple BindingAdapter in Kotlin:
<pre><code>@BindingAdapter(&quot;maxDecimalPlaces&quot;)
fun TextInputEditText.limitDecimalPlaces(maxDecimalPlaces: Int) {
 filters += InputFilter { source, _, _, dest, dstart, dend -&gt;
 val value = if (source.isEmpty()) {
 dest.removeRange(dstart, dend)
 } else {
 StringBuilder(dest).insert(dstart, source)
 }
 val matcher = Pattern.compile(&quot;([1-9][0-9]*)|([1-9][0-9]*\\.[0-9]{0,$maxDecimalPlaces})|(\\.[0-9]{0,$maxDecimalPlaces})&quot;).matcher(value)
 if (!matcher.matches()) &quot;&quot; else null
 }
}
</code></pre>

blocks|key|748049|text|如果你想对整数部分有限制，下面是代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|748050|class+PropertyCostInputFilter+:+DigitsKeyListener(false,+true)+{

override+fun+filter(source:+CharSequence,+start:+Int,+end:+Int,+dest:+Spanned,+dstart:+Int,+dend:+Int):+CharSequence+{
++++var+source+=+source
++++var+start+=+start
++++var+end+=+end
++++val+out+=+super.filter(source,+start,+end,+dest,+dstart,+dend)

++++if+(out+!=+null)+{
++++++++source+=+out
++++++++start+=+0
++++++++end+=+out.length
++++}

++++val+sourceLength+=+end+-+start

++++//+If+length+=+0,+then+there+was+a+deletion+and+therefore+the+length+could+not+become+greater+than+the+max+value
++++if+(sourceLength+==+0)+{
++++++++return+source
++++}

++++val+result+=+dest.replaceRange((dstart+until+dend),+source.substring(start,+end))
++++val+parts+=+result.split(SEPARATOR)

++++if+(parts.size+>+0+&&+parts[0].length+>+INTEGER_PART_MAX_DIGITS
++++++++%7C%7C+parts.size+>+1+&&+parts[1].length+>+FRACTIONAL_PART_MAX_DIGITS
++++)+{
++++++++return+""
++++}

++++return+SpannableStringBuilder(source,+start,+end)
}

companion+object+{
++++private+const+val+INTEGER_PART_MAX_DIGITS+=+20
++++private+const+val+FRACTIONAL_PART_MAX_DIGITS+=+2
++++private+const+val+SEPARATOR+=+'.'
}
}|code-block|syntax|javascript|748051|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you want to have restrictions on integer part also here is the code
<pre><code>class PropertyCostInputFilter : DigitsKeyListener(false, true) {

override fun filter(source: CharSequence, start: Int, end: Int, dest: Spanned, dstart: Int, dend: Int): CharSequence {
 var source = source
 var start = start
 var end = end
 val out = super.filter(source, start, end, dest, dstart, dend)

 if (out != null) {
 source = out
 start = 0
 end = out.length
 }

 val sourceLength = end - start

 // If length = 0, then there was a deletion and therefore the length could not become greater than the max value
 if (sourceLength == 0) {
 return source
 }

 val result = dest.replaceRange((dstart until dend), source.substring(start, end))
 val parts = result.split(SEPARATOR)

 if (parts.size &gt; 0 &amp;&amp; parts[0].length &gt; INTEGER_PART_MAX_DIGITS
 || parts.size &gt; 1 &amp;&amp; parts[1].length &gt; FRACTIONAL_PART_MAX_DIGITS
 ) {
 return &quot;&quot;
 }

 return SpannableStringBuilder(source, start, end)
}

companion object {
 private const val INTEGER_PART_MAX_DIGITS = 20
 private const val FRACTIONAL_PART_MAX_DIGITS = 2
 private const val SEPARATOR = '.'
}
}
</code></pre>

I'm trying to write an app that helps you manage your finances. I'm using an <code>EditText</code> Field where the user can specify an amount of money.

I set the <code>inputType</code> to <code>numberDecimal</code> which works fine, except that this allows people to enter numbers such as <code>123.122</code> which is not perfect for money.

Is there a way to limit the number of characters after the decimal point to two?

Limit Decimal Places in Android EditText

Kotlin

我正在试着写一个应用程序，帮助你管理你的财务。我使用的是一个EditText字段，用户可以在其中指定金额。我将inputType设置为numberDecimal，它工作得很好，除了它允许人们输入123.122这样的数字，这对于金钱来说并不是完美的。有没有办法将小数点后的字符数限制在两个以内？

问安卓EditText的小数位数限制
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问安卓EditText的小数位数限制EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问安卓EditText的小数位数限制
EN