blocks|key|185992|text|请检查此代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|185993|++++String+pass+=+EditText.getText().toString();+
++++if(TextUtils.isEmpty(pass)+%7C%7C+pass.length+<+[YOUR+MIN+LENGTH])+
++++{+
+++++++EditText.setError("You+must+have+x+characters+in+your+txt");+
++++++++return;+
++++}

++++//continue+processing



edittext.setOnFocusChangeListener(+new+OnFocusChangeListener()+{

+++++++@Override
+++++++public+void+onFocusChange(View+v,+boolean+hasFocus)+{
++++++++++if(hasFocus)+{
+++++++++++//+USE+your+code+here+
++}|code-block|syntax|javascript|185994|有关edittext和带有文本观察器的edittextfilteres的更多详细信息，请单击USe以下链接。|185995|http://www.mobisoftinfotech.com/blog/android/android-edittext-setfilters-example-numeric-text-field-patterns-and-length-restriction/|offset|length|185996|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|3O|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|V|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|W|8|@]|9|@$K|X|L|Y|1|Z]]|A|$]]|$1|M|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|J]]]]

please check this code 

<pre><code> String pass = EditText.getText().toString(); 
 if(TextUtils.isEmpty(pass) || pass.length &lt; [YOUR MIN LENGTH]) 
 { 
 EditText.setError("You must have x characters in your txt"); 
 return; 
 }

 //continue processing



edittext.setOnFocusChangeListener( new OnFocusChangeListener() {

 @Override
 public void onFocusChange(View v, boolean hasFocus) {
 if(hasFocus) {
 // USE your code here 
 }
</code></pre>

USe the below link for more details about edittext and the edittextfilteres with text watcher.. 

<a href="http://www.mobisoftinfotech.com/blog/android/android-edittext-setfilters-example-numeric-text-field-patterns-and-length-restriction/" rel="nofollow">http://www.mobisoftinfotech.com/blog/android/android-edittext-setfilters-example-numeric-text-field-patterns-and-length-restriction/</a>

blocks|key|186029|text|在Pratik的代码中有一个小错误。例如，如果值是10，并且您在开头添加1以使110，则filter函数会将新值视为101。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|186030|有关此问题的修复，请参阅以下内容：|186031|@Override
public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+{
++++try+{
++++++++//+Removes+string+that+is+to+be+replaced+from+destination
++++++++//+and+adds+the+new+string+in.
++++++++String+newVal+=+dest.subSequence(0,+dstart)
++++++++++++++++//+Note+that+below+"toString()"+is+the+only+required:
++++++++++++++++%2B+source.subSequence(start,+end).toString()
++++++++++++++++%2B+dest.subSequence(dend,+dest.length());
++++++++int+input+=+Integer.parseInt(newVal);
++++++++if+(isInRange(min,+max,+input))
++++++++++++return+null;
++++}+catch+(NumberFormatException+nfe)+{+}
++++return+"";
}|code-block|syntax|javascript|186032|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|$]]

There is a small error in Pratik's code. For instance, if a value is 10 and you add a 1 at the beginning to make 110, the filter function would treat the new value as 101.
See below for a fix to this:
<pre><code>@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
 try {
 // Removes string that is to be replaced from destination
 // and adds the new string in.
 String newVal = dest.subSequence(0, dstart)
 // Note that below &quot;toString()&quot; is the only required:
 + source.subSequence(start, end).toString()
 + dest.subSequence(dend, dest.length());
 int input = Integer.parseInt(newVal);
 if (isInRange(min, max, input))
 return null;
 } catch (NumberFormatException nfe) { }
 return &quot;&quot;;
}
</code></pre>

blocks|key|404256|text|我扩展了@Pratik代码，使用BigDecimal对象而不是in，这样它就可以接受更大的数字，并说明EditText中任何不是数字的格式(如货币格式，即空格、逗号和句号)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|404257|编辑:请注意，此实现在BigDecimal+(请参阅MIN_SIG_FIG常量)上设置了2作为最小有效数字，因为我将其用于货币，因此小数点之前总是有2个前导数字。根据您自己的实现需要修改MIN_SIG_FIG常量。|404258|public+class+InputFilterMinMax+implements+InputFilter+{
private+static+final+int+MIN_SIG_FIG+=+2;
private+BigDecimal+min,+max;

public+InputFilterMinMax(BigDecimal+min,+BigDecimal+max)+{
++++this.min+=+min;
++++this.max+=+max;
}

public+InputFilterMinMax(String+min,+String+max)+{
++++this.min+=+new+BigDecimal(min);
++++this.max+=+new+BigDecimal(max);
}

@Override
public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,
++++++++int+dend)+{
++++try+{
++++++++BigDecimal+input+=+formatStringToBigDecimal(dest.toString()
++++++++++++++++%2B+source.toString());

++++++++if+(isInRange(min,+max,+input))+{

++++++++++++return+null;
++++++++}
++++}+catch+(NumberFormatException+nfe)+{

++++}
++++return+"";
}

private+boolean+isInRange(BigDecimal+a,+BigDecimal+b,+BigDecimal+c)+{
++++return+b.compareTo(a)+>+0+?+c.compareTo(a)+>=+0+&&+c.compareTo(b)+<=+0
++++++++++++:+c.compareTo(b)+>=+0+&&+c.compareTo(a)+<=+0;
}

public+static+BigDecimal+formatStringToBigDecimal(String+n)+{

++++Number+number+=+null;
++++try+{
++++++++number+=+getDefaultNumberFormat().parse(n.replaceAll("[%5E\\d]",+""));

++++++++BigDecimal+parsed+=+new+BigDecimal(number.doubleValue()).divide(new+BigDecimal(100),+2,
++++++++++++++++BigDecimal.ROUND_UNNECESSARY);
++++++++return+parsed;
++++}+catch+(ParseException+e)+{
++++++++return+new+BigDecimal(0);
++++}
}

private+static+NumberFormat+getDefaultNumberFormat()+{
++++NumberFormat+nf+=+NumberFormat.getInstance(Locale.getDefault());
++++nf.setMinimumFractionDigits(MIN_SIG_FIG);
++++return+nf;
}|code-block|syntax|javascript|404259|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|$]]

I extended @Pratik Sharmas code to use BigDecimal objects instead of ints so that it can accept larger numbers, and account for any formatting in the EditText that isn't a number (like currency formatting i.e. spaces, commas and periods)

EDIT: note that this implementation has 2 as the minimum significant figures set on the BigDecimal (see the MIN_SIG_FIG constant) as I used it for currency, so there was always 2 leading numbers before the decimal point. Alter the MIN_SIG_FIG constant as necessary for your own implementation. 

<pre><code>public class InputFilterMinMax implements InputFilter {
private static final int MIN_SIG_FIG = 2;
private BigDecimal min, max;

public InputFilterMinMax(BigDecimal min, BigDecimal max) {
 this.min = min;
 this.max = max;
}

public InputFilterMinMax(String min, String max) {
 this.min = new BigDecimal(min);
 this.max = new BigDecimal(max);
}

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart,
 int dend) {
 try {
 BigDecimal input = formatStringToBigDecimal(dest.toString()
 + source.toString());

 if (isInRange(min, max, input)) {

 return null;
 }
 } catch (NumberFormatException nfe) {

 }
 return "";
}

private boolean isInRange(BigDecimal a, BigDecimal b, BigDecimal c) {
 return b.compareTo(a) &gt; 0 ? c.compareTo(a) &gt;= 0 &amp;&amp; c.compareTo(b) &lt;= 0
 : c.compareTo(b) &gt;= 0 &amp;&amp; c.compareTo(a) &lt;= 0;
}

public static BigDecimal formatStringToBigDecimal(String n) {

 Number number = null;
 try {
 number = getDefaultNumberFormat().parse(n.replaceAll("[^\\d]", ""));

 BigDecimal parsed = new BigDecimal(number.doubleValue()).divide(new BigDecimal(100), 2,
 BigDecimal.ROUND_UNNECESSARY);
 return parsed;
 } catch (ParseException e) {
 return new BigDecimal(0);
 }
}

private static NumberFormat getDefaultNumberFormat() {
 NumberFormat nf = NumberFormat.getInstance(Locale.getDefault());
 nf.setMinimumFractionDigits(MIN_SIG_FIG);
 return nf;
}
</code></pre>

blocks|key|404341|text|我做了一个更简单的方法来设置Edittext的最小/最大值。我使用算术键盘，并使用以下方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|404342|+private+int+limit(EditText+x,int+z,int+limin,int+limax){

++++if(+x.getText().toString()==null+%7C%7C+x.getText().toString().length()==0){
++++++++x.setText(Integer.toString(limin));
++++++++return+z=0;
++++}
++++else{
++++++++z+=+Integer.parseInt(x.getText().toString());
+++++++++if(z+<limin+%7C%7C+z>limax){
+++++++++++++if(z<10){
+++++++++++++++++x.setText(Integer.toString(limin));
++++++++++++++++return++z=0;
+++++++++++++}
++++++++++++else{
++++++++++++++++x.setText(Integer.toString(limax));
++++++++++++++++return+z=limax;
++++++++++++}

+++++++++}
+++++++++else
++++++++++++return+z+=+Integer.parseInt(x.getText().toString());
++++}
+}|code-block|syntax|javascript|404343|该方法接受您的所有值，但如果用户的值不符合您的限制，它将自动设置为最小/最大限制。对于ex。limit+limin=10，limax+=80如果用户设置为8，则自动将10保存到变量，并将EditText设置为10。|404344|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 made a simpler way to set a min/max to an Edittext. I use arithmetic keypad and I work with this method: 

<pre><code> private int limit(EditText x,int z,int limin,int limax){

 if( x.getText().toString()==null || x.getText().toString().length()==0){
 x.setText(Integer.toString(limin));
 return z=0;
 }
 else{
 z = Integer.parseInt(x.getText().toString());
 if(z &lt;limin || z&gt;limax){
 if(z&lt;10){
 x.setText(Integer.toString(limin));
 return z=0;
 }
 else{
 x.setText(Integer.toString(limax));
 return z=limax;
 }

 }
 else
 return z = Integer.parseInt(x.getText().toString());
 }
 }
</code></pre>

The method accepts all of your values but if a value of users in not adhere to your limits it will be set automatically to the min/max limit. 
For ex. limit limin=10, limax =80 if the user sets 8, automatically 10 is saved to a variable and EditText is set to 10.

blocks|key|404438|text|在我看到的@Patrik的解决方案和@Zac的添加中，提供的代码仍然有一个很大的问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|404439|如果为min==3，则无法键入以1或2开头的任何数字(例如:+15，23)|offset|length|style|CODE|404440|如果为min>=10，则不可能键入任何内容，因为每个数字都必须以1，2，3开头...|404441|在我的理解中，我们不能通过简单地使用类InputFilterMinMax来达到EditText值的最小-最大限制，至少对于最小值不是这样，因为当用户输入一个正数时，值会增长，我们可以很容易地执行动态测试来检查它是否达到限制或超出范围并阻塞不符合的条目。测试最小值是另一回事，因为我们不能确定用户是否已经完成键入，因此不能决定是否应该阻止。|404442|这并不完全是OP所要求的，但为了验证的目的，我在我的解决方案中结合了一个InputFilter来测试最大值，以及一个OnFocusChangeListener来在EditText失去焦点时重新测试最小值，假设用户已经完成了输入，如下所示：|404443|package+test;


import+android.text.InputFilter;

import+android.text.Spanned;

public+class+InputFilterMax+implements+InputFilter+{

private+int+max;

public+InputFilterMax(int+max)+{
++++this.max+=+max;
}

public+InputFilterMax(String+max)+{
++++this.max+=+Integer.parseInt(max);
}

@Override
public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+{+++
++++try+{
++++++++String+replacement+=+source.subSequence(start,+end).toString();+

++++++++String+newVal+=+dest.toString().substring(0,+dstart)+%2B+replacement+%2Bdest.toString().substring(dend,+dest.toString().length());

++++++++int+input+=+Integer.parseInt(newVal);

++++++++if+(input<=max)
++++++++++++return+null;
++++}+catch+(NumberFormatException+nfe)+{+}+++
//Maybe+notify+user+that+the+value+is+not+good++++++
return+"";
}
}|code-block|syntax|javascript|404444|和OnFocusChangeListenerMin|404445|package+test;

import+android.text.TextUtils;
import+android.view.View;
import+android.view.View.OnFocusChangeListener;

public+class+OnFocusChangeListenerMin+implements+OnFocusChangeListener+{

private+int+min;

public+OnFocusChangeListenerMin(int+min)+{
++++this.min+=+min;
}

public+OnFocusChangeListenerMin(String+min)+{
++++this.min+=+Integer.parseInt(min);
}


@Override
public+void+onFocusChange(View+v,+boolean+hasFocus)+{
++++if(!hasFocus)+{
++++++++String+val+=+((EditText)v).getText().toString();
++++++++if(!TextUtils.isEmpty(val)){
++++++++++++if(Integer.valueOf(val)<min){
++++++++++++++++//Notify+user+that+the+value+is+not+good
++++++++++++}

++++++++}
++++}
}
}|404446|然后在Activity中将InputFilterMax和OnFocusChangeListenerMin设置为EditText注意:在onFocusChangeListener中可以同时设置最小值和最大值。|404447|mQteEditText.setOnFocusChangeListener(+new+OnFocusChangeListenerMin('20');
mQteEditText.setFilters(new+InputFilter[]{new+InputFilterMax(getActivity(),'50')});|404448|entityMap^0|0|3|6|0|3|7|0|J|H|13|8|0|10|B|1M|L|29|8|0|0|1|O|0|0|D|E|S|O|1J|8|1V|L|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@$D|14|E|15|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|16|8|@$D|17|E|18|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|19|8|@$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|1E|8|@$D|1F|E|1G|F|G]|$D|1H|E|1I|F|G]|$D|1J|E|1K|F|G]]|9|@]|A|$]]|$1|N|3|O|5|P|7|1L|8|@]|9|@]|A|$Q|R]]|$1|S|3|T|5|6|7|1M|8|@$D|1N|E|1O|F|G]]|9|@]|A|$]]|$1|U|3|V|5|P|7|1P|8|@]|9|@]|A|$Q|R]]|$1|W|3|X|5|6|7|1Q|8|@$D|1R|E|1S|F|G]|$D|1T|E|1U|F|G]|$D|1V|E|1W|F|G]|$D|1X|E|1Y|F|G]]|9|@]|A|$]]|$1|Y|3|Z|5|P|7|1Z|8|@]|9|@]|A|$Q|R]]|$1|10|3|-4|5|6|7|20|8|@]|9|@]|A|$]]]|11|$]]

Of what i've seen of @Patrik's solution and @Zac's addition, the code provided still has a big problem :

If <code>min==3</code> then it's impossible to type any number starting with 1 or 2 (ex: 15, 23) 
If <code>min&gt;=10</code> then it's impossible to type anything as every number will have to start with 1,2,3...

In my understanding we cannot achieve the min-max limitation of an <code>EditText</code>'s value with simple use of the class <code>InputFilterMinMax</code>, at least not for the min Value, because when user is typing a positive number, the value goes growing and we can easily perform an on-the-fly test to check if it's reached the limit or went outside the range and block entries that do not comply. Testing the min value is a different story as we cannot be sure if the user has finished typing or not and therefore cannot decide if we should block or not.

It's not exactly what OP requested but for validation purposes i've combined in my solution an <code>InputFilter</code> to test max values, with an <code>OnFocusChangeListener</code> to re-test for min value when the <code>EditText</code> loses the focus assuming the user's finished typing and it's something like this :

<pre><code>package test;


import android.text.InputFilter;

import android.text.Spanned;

public class InputFilterMax implements InputFilter {

private int max;

public InputFilterMax(int max) {
 this.max = max;
}

public InputFilterMax(String max) {
 this.max = Integer.parseInt(max);
}

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) { 
 try {
 String replacement = source.subSequence(start, end).toString(); 

 String newVal = dest.toString().substring(0, dstart) + replacement +dest.toString().substring(dend, dest.toString().length());

 int input = Integer.parseInt(newVal);

 if (input&lt;=max)
 return null;
 } catch (NumberFormatException nfe) { } 
//Maybe notify user that the value is not good 
return "";
}
}
</code></pre>

And <code>OnFocusChangeListenerMin</code> 

<pre><code>package test;

import android.text.TextUtils;
import android.view.View;
import android.view.View.OnFocusChangeListener;

public class OnFocusChangeListenerMin implements OnFocusChangeListener {

private int min;

public OnFocusChangeListenerMin(int min) {
 this.min = min;
}

public OnFocusChangeListenerMin(String min) {
 this.min = Integer.parseInt(min);
}


@Override
public void onFocusChange(View v, boolean hasFocus) {
 if(!hasFocus) {
 String val = ((EditText)v).getText().toString();
 if(!TextUtils.isEmpty(val)){
 if(Integer.valueOf(val)&lt;min){
 //Notify user that the value is not good
 }

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

Then in Activity set the <code>InputFilterMax</code> and the<code>OnFocusChangeListenerMin</code> to <code>EditText</code> 
note : You can 2 both min and max in <code>onFocusChangeListener</code>.

<pre><code>mQteEditText.setOnFocusChangeListener( new OnFocusChangeListenerMin('20');
mQteEditText.setFilters(new InputFilter[]{new InputFilterMax(getActivity(),'50')});
</code></pre>

blocks|key|404507|text|如果您只关心最大限制，则只需添加以下行|type|unstyled|depth|inlineStyleRanges|entityRanges|data|404508|android:maxLength="10"+|code-block|syntax|javascript|404509|如果你需要添加最小限制，那么你可以这样做，在这种情况下，最小限制是7。用户被限制输入介于最小和最大限制之间的字符(在8和10之间)。|404510|public+final+static+boolean+isValidCellPhone(String+number){
++++++++if+(number.length()+<+8+%7C%7C+number.length()+>10+)+{
++++++++++++return+false;
++++++++}+else+{

+++++++++++return+android.util.Patterns.PHONE.matcher(number).matches();
++++++++}
++++}|404511|如果您还需要限制用户在启动时输入01，那么像这样修改If条件|404512|if+(!(number.startsWith("01"))+%7C%7C+number.length()+<+8+%7C%7C+number.length()+>10+)+{++
.
.
.
}|404513|在结束时调用像这样的方法|404514|+++....else+if+(!(Helper.isValidMobilePhone(textMobileNo))){
++++++++++++++++++++++++Helper.setEditTextError(etMobileNo,"Invalid+Mobile+Number");
++++++++++++++++++++}......|404515|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

If you are only concerned about max limit then just add below line in 

<pre><code>android:maxLength="10" 
</code></pre>

If you need to add min limit then you can do like this way in this case min limit is 7. user is restricted to enter character between min and max limit (in between 8 and 10) 

<pre><code>public final static boolean isValidCellPhone(String number){
 if (number.length() &lt; 8 || number.length() &gt;10 ) {
 return false;
 } else {

 return android.util.Patterns.PHONE.matcher(number).matches();
 }
 }
</code></pre>

If you also need to restrict user to enter 01 at start then modify if condition like this way 

<pre><code>if (!(number.startsWith("01")) || number.length() &lt; 8 || number.length() &gt;10 ) { 
.
.
.
}
</code></pre>

At the end call method like

<pre><code> ....else if (!(Helper.isValidMobilePhone(textMobileNo))){
 Helper.setEditTextError(etMobileNo,"Invalid Mobile Number");
 }......
</code></pre>

blocks|key|186361|text|如果你需要像-90:90这样的负数范围，你可以使用这个解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|186362|public+class+InputFilterMinMax+implements+InputFilter+{

private+int+min,+max;

public+InputFilterMinMax(int+min,+int+max)+{
++++this.min+=+min;
++++this.max+=+max;
}

public+InputFilterMinMax(String+min,+String+max)+{
++++this.min+=+Integer.parseInt(min);
++++this.max+=+Integer.parseInt(max);
}

@Override
public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+{
++++try+{
++++++++String+stringInput+=+dest.toString()+%2B+source.toString();
++++++++int+value;
++++++++if+(stringInput.length()+==+1+&&+stringInput.charAt(0)+==+'-')+{
++++++++++++value+=+-1;
++++++++}+else+{
++++++++++++value+=+Integer.parseInt(stringInput);
++++++++}
++++++++if+(isInRange(min,+max,+value))
++++++++++++return+null;
++++}+catch+(NumberFormatException+nfe)+{
++++}
++++return+"";
}

private+boolean+isInRange(int+min,+int+max,+int+value)+{
++++return+max+>+min+?+value+>=+min+&&+value+<=+max+:+value+>=+max+&&+value+<=+min;
}
}|code-block|syntax|javascript|186363|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 need range with negative numbers like -90:90, you can use this solution. 

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

private int min, max;

public InputFilterMinMax(int min, int max) {
 this.min = min;
 this.max = max;
}

public InputFilterMinMax(String min, String max) {
 this.min = Integer.parseInt(min);
 this.max = Integer.parseInt(max);
}

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
 try {
 String stringInput = dest.toString() + source.toString();
 int value;
 if (stringInput.length() == 1 &amp;&amp; stringInput.charAt(0) == '-') {
 value = -1;
 } else {
 value = Integer.parseInt(stringInput);
 }
 if (isInRange(min, max, value))
 return null;
 } catch (NumberFormatException nfe) {
 }
 return "";
}

private boolean isInRange(int min, int max, int value) {
 return max &gt; min ? value &gt;= min &amp;&amp; value &lt;= max : value &gt;= max &amp;&amp; value &lt;= min;
}
}
</code></pre>

blocks|key|404592|text|我找到了我自己的答案。现在已经很晚了，但我想和你分享。我实现了这个接口：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|404593|import+android.text.TextWatcher;


public+abstract+class+MinMaxTextWatcher+implements+TextWatcher+{
++++int+min,+max;
++++public+MinMaxTextWatcher(int+min,+int+max)+{
++++++++super();
++++++++this.min+=+min;
++++++++this.max+=+max;
++++}

}|code-block|syntax|javascript|404594|然后以这种方式在你的活动中实现它：|404595|private+void+limitEditText(final+EditText+ed,+int+min,+int+max)+{
++++ed.addTextChangedListener(new+MinMaxTextWatcher(min,+max)+{
++++++++@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+s)+{
++++++++++++String+str+=+s.toString();
++++++++++++int+n+=+0;
++++++++++++try+{
++++++++++++++++n+=+Integer.parseInt(str);
++++++++++++++++if(n+<+min)+{
++++++++++++++++++++ed.setText(min);
++++++++++++++++++++Toast.makeText(getApplicationContext(),+"Minimum+allowed+is+"+%2B+min,+Toast.LENGTH_SHORT).show();
++++++++++++++++}
++++++++++++++++else+if(n+>+max)+{
++++++++++++++++++++ed.setText(""+%2B+max);
++++++++++++++++++++Toast.makeText(getApplicationContext(),+"Maximum+allowed+is+"+%2B+max,+Toast.LENGTH_SHORT).show();
++++++++++++++++}
++++++++++++}
++++++++++++catch(NumberFormatException+nfe)+{
++++++++++++++++ed.setText(""+%2B+min);
++++++++++++++++Toast.makeText(getApplicationContext(),+"Bad+format+for+number!"+%2B+max,+Toast.LENGTH_SHORT).show();
++++++++++++}
++++++++}
++++});
}|404596|这是一个非常简单的答案，如果有更好的答案，请告诉我。|404597|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|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I found my own answer. It is very late now but I want to share it with you.
I implement this interface:

<pre><code>import android.text.TextWatcher;


public abstract class MinMaxTextWatcher implements TextWatcher {
 int min, max;
 public MinMaxTextWatcher(int min, int max) {
 super();
 this.min = min;
 this.max = max;
 }

}
</code></pre>

And then implement it in this way inside your activity:

<pre><code>private void limitEditText(final EditText ed, int min, int max) {
 ed.addTextChangedListener(new MinMaxTextWatcher(min, max) {
 @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 s) {
 String str = s.toString();
 int n = 0;
 try {
 n = Integer.parseInt(str);
 if(n &lt; min) {
 ed.setText(min);
 Toast.makeText(getApplicationContext(), "Minimum allowed is " + min, Toast.LENGTH_SHORT).show();
 }
 else if(n &gt; max) {
 ed.setText("" + max);
 Toast.makeText(getApplicationContext(), "Maximum allowed is " + max, Toast.LENGTH_SHORT).show();
 }
 }
 catch(NumberFormatException nfe) {
 ed.setText("" + min);
 Toast.makeText(getApplicationContext(), "Bad format for number!" + max, Toast.LENGTH_SHORT).show();
 }
 }
 });
}
</code></pre>

This is a very simple answer, if any better please tell me.

blocks|key|404664|text|//仍然有一些问题，但在这里您可以在任何范围(正或负)使用min，max|type|unstyled|depth|inlineStyleRanges|entityRanges|data|404665|//+in+filter+calss
+@Override
+public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+{
++++++++try+{
++++++++++++//+Remove+the+string+out+of+destination+that+is+to+be+replaced
++++++++++++int+input;
++++++++++++String+newVal+=+dest.toString()+%2B+source.toString();
++++++++++++if+(newVal.length()+==+1+&&+newVal.charAt(0)+==+'-')+{
++++++++++++++++input+=+min;+//allow
++++++++++++}
++++++++++++else+{
++++++++++++++++newVal+=+dest.toString().substring(0,+dstart)+%2B+dest.toString().substring(dend,+dest.toString().length());
++++++++++++++++//+Add+the+new+string+in
++++++++++++++++newVal+=+newVal.substring(0,+dstart)+%2B+source.toString()+%2B+newVal.substring(dstart,+newVal.length());
++++++++++++++++input+=+Integer.parseInt(newVal);
++++++++++++}

++++++++++++//int+input+=+Integer.parseInt(dest.toString()+%2B+source.toString());

++++++++++++if+(isInRange(min,+max,+input))
++++++++++++++++return+null;
++++++++}+catch+(NumberFormatException+nfe)+{
++++++++}
++++++++return+"";
++++}

//also+the+filler+must+set+as+below:+in+the+edit+createview
//+to+allow+enter+number+and+backspace.
et.setFilters(new+InputFilter[]{new+InputFilterMinMax(min+>=+10+?++"0"+:+String.valueOf(min),+max+>-10+?+String.valueOf(max)+:"0"+)});



//and+at+same+time+must+check+range+in+the+TextWatcher()
et.addTextChangedListener(new
+TextWatcher()+{

++++++@Override
++++++public+void+afterTextChanged+(Editable+editable)
++++++{
+++++++++String+tmpstr+=+et.getText().toString();
+++++++++if+(!tmpstr.isEmpty()+&&+!tmpstr.equals("-")+)+{
+++++++++++++int+datavalue+=+Integer.parseInt(tmpstr);
+++++++++++++if+(+datavalue+>=+min+%7C%7C+datavalue+<=+max)+{
+++++++++++++++//+accept+data+...+++++
+++++++++++++}
+++++++++}
++++++}
+});|code-block|syntax|javascript|404666|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|$]]

//still has some problem but Here you can use min, max at any range (positive or negative)

<pre><code>// in filter calss
 @Override
 public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
 try {
 // Remove the string out of destination that is to be replaced
 int input;
 String newVal = dest.toString() + source.toString();
 if (newVal.length() == 1 &amp;&amp; newVal.charAt(0) == '-') {
 input = min; //allow
 }
 else {
 newVal = dest.toString().substring(0, dstart) + dest.toString().substring(dend, dest.toString().length());
 // Add the new string in
 newVal = newVal.substring(0, dstart) + source.toString() + newVal.substring(dstart, newVal.length());
 input = Integer.parseInt(newVal);
 }

 //int input = Integer.parseInt(dest.toString() + source.toString());

 if (isInRange(min, max, input))
 return null;
 } catch (NumberFormatException nfe) {
 }
 return "";
 }

//also the filler must set as below: in the edit createview
// to allow enter number and backspace.
et.setFilters(new InputFilter[]{new InputFilterMinMax(min &gt;= 10 ? "0" : String.valueOf(min), max &gt;-10 ? String.valueOf(max) :"0" )});



//and at same time must check range in the TextWatcher()
et.addTextChangedListener(new
 TextWatcher() {

 @Override
 public void afterTextChanged (Editable editable)
 {
 String tmpstr = et.getText().toString();
 if (!tmpstr.isEmpty() &amp;&amp; !tmpstr.equals("-") ) {
 int datavalue = Integer.parseInt(tmpstr);
 if ( datavalue &gt;= min || datavalue &lt;= max) {
 // accept data ... 
 }
 }
 }
 });
</code></pre>

blocks|key|186511|text|@Override
public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+{
++++try+{
++++++++String+prefix+=+dest.toString().substring(0,+dstart);
++++++++String+insert+=+source.toString();
++++++++String+suffix+=+dest.toString().substring(dend);
++++++++String+input_string+=+prefix+%2B+insert+%2B+suffix;
++++++++int+input+=+Integer.parseInt(input_string);

++++++++if+(isInRange(min,+max,+input)+%7C%7C+input_string.length()+<+String.valueOf(min).length())
++++++++++++return+null;
++++}+catch+(NumberFormatException+nfe)+{+}
++++return+"";
}

private+boolean+isInRange(int+a,+int+b,+int+c)+{
++++return+b+>+a+?+c+>=+a+&&+c+<=+b+:+c+>=+b+&&+c+<=+a;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|186512|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 CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
 try {
 String prefix = dest.toString().substring(0, dstart);
 String insert = source.toString();
 String suffix = dest.toString().substring(dend);
 String input_string = prefix + insert + suffix;
 int input = Integer.parseInt(input_string);

 if (isInRange(min, max, input) || input_string.length() &lt; String.valueOf(min).length())
 return null;
 } catch (NumberFormatException nfe) { }
 return "";
}

private boolean isInRange(int a, int b, int c) {
 return b &gt; a ? c &gt;= a &amp;&amp; c &lt;= b : c &gt;= b &amp;&amp; c &lt;= a;
}
</code></pre>

blocks|key|404709|text|在公认的答案中有一些错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|404710|int+input+=+Integer.parseInt(dest.toString()+%2B+source.toString());|code-block|syntax|javascript|404711|如果我把光标移到文本中间，然后输入一些东西，那么上面的语句将产生错误的结果。例如，首先输入"12“，然后输入介于1和2之间的"0”，那么上面提到的语句将生成"120“而不是102。我将此语句修改为以下语句：|404712|String+destString+=+dest.toString();
++String+inputString+=+destString.substring(0,+dstart)+%2B+source.toString()+%2B+destString.substring(dstart);
++int+input+=+Integer.parseInt(inputString);|404713|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|$]]

There is something wrong in the accepted answer.

<pre><code>int input = Integer.parseInt(dest.toString() + source.toString());
</code></pre>

If I move cursor into middle of text, then type something, then the above statement will produce wrong result.
For example, type "12" first, then type "0" between 1 and 2, then the statement mentioned above will produce "120" instead of 102.
I modified this statement to statements below:

<pre><code>String destString = dest.toString();
 String inputString = destString.substring(0, dstart) + source.toString() + destString.substring(dstart);
 int input = Integer.parseInt(inputString);
</code></pre>

blocks|key|186556|text|这是我使用的方法，它对负数有效|type|unstyled|depth|inlineStyleRanges|entityRanges|data|186557|首先，使用以下代码创建MinMaxFIlter.java类：|186558|import+android.text.InputFilter;
import+android.text.Spanned;
import+android.util.Log;

/**
*+Created+by+21+on+4/5/2016.
*/
public+class+MinMaxFilter+implements+InputFilter+{

private+double+mIntMin,+mIntMax;

public+MinMaxFilter(double+minValue,+double+maxValue)+{
++++this.mIntMin+=+minValue;
++++this.mIntMax+=+maxValue;
}

public+MinMaxFilter(String+minValue,+String+maxValue)+{
++++this.mIntMin+=+Double.parseDouble(minValue);
++++this.mIntMax+=+Double.parseDouble(maxValue);
}

@Override
public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+{
++++try+{
++++++++Boolean+isNeg+=+false;
++++++++String+provi+=+dest.toString()+%2B+source.toString();
++++++++if("-".equals(provi.substring(0,1))){
++++++++++++if(provi.length()>1)+{
++++++++++++++++provi+=+provi.substring(1,+provi.length());
++++++++++++++++isNeg+=+true;
++++++++++++}
++++++++++++else{
++++++++++++++++if("".equals(source)){
++++++++++++++++++++return+null;
++++++++++++++++}
++++++++++++++++return+"-";
++++++++++++}
++++++++}

++++++++double+input+=+Double.parseDouble(provi);+
++++++++if(isNeg){input+=+input+*+(-1);}

++++++++if+(isInRange(mIntMin,+mIntMax,+input))+{
++++++++++++return+null;
++++++++}
++++}+catch+(Exception+nfe)+{}
++++return+"";
}

private+boolean+isInRange(double+a,+double+b,+double+c)+{
++++if((c>=a+&&+c<=b)){
++++++++return+true;
++++}
++++else{
++++++++return+false;
++++}
}
}|code-block|syntax|javascript|186559|然后，创建过滤器并将其设置为edittext，如下所示：|186560|EditText+edittext+=+new+EditText(context);
editext.setInputType(InputType.TYPE_CLASS_NUMBER+%7C+InputType.TYPE_NUMBER_FLAG_SIGNED);
eInt.setFilters(new+InputFilter[]{new+MinMaxFilter(min,+max)});|186561|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|$]]

here's the way I've used, it's working for negative number

First, create MinMaxFIlter.java class with the following code :

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

/**
* Created by 21 on 4/5/2016.
*/
public class MinMaxFilter implements InputFilter {

private double mIntMin, mIntMax;

public MinMaxFilter(double minValue, double maxValue) {
 this.mIntMin = minValue;
 this.mIntMax = maxValue;
}

public MinMaxFilter(String minValue, String maxValue) {
 this.mIntMin = Double.parseDouble(minValue);
 this.mIntMax = Double.parseDouble(maxValue);
}

@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
 try {
 Boolean isNeg = false;
 String provi = dest.toString() + source.toString();
 if("-".equals(provi.substring(0,1))){
 if(provi.length()&gt;1) {
 provi = provi.substring(1, provi.length());
 isNeg = true;
 }
 else{
 if("".equals(source)){
 return null;
 }
 return "-";
 }
 }

 double input = Double.parseDouble(provi); 
 if(isNeg){input = input * (-1);}

 if (isInRange(mIntMin, mIntMax, input)) {
 return null;
 }
 } catch (Exception nfe) {}
 return "";
}

private boolean isInRange(double a, double b, double c) {
 if((c&gt;=a &amp;&amp; c&lt;=b)){
 return true;
 }
 else{
 return false;
 }
}
}
</code></pre>

Then, create and set your filter to your edittext like this :

<pre><code>EditText edittext = new EditText(context);
editext.setInputType(InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_FLAG_SIGNED);
eInt.setFilters(new InputFilter[]{new MinMaxFilter(min, max)});
</code></pre>

blocks|key|404751|text|这是我的代码max=100，min=0|type|unstyled|depth|inlineStyleRanges|entityRanges|data|404752|xml|404753|<TextView
++++++++++++++++++++android:id="@%2Bid/txt_Mass_smallWork"
++++++++++++++++++++android:layout_width="match_parent"
++++++++++++++++++++android:layout_height="wrap_content"
++++++++++++++++++++android:textColor="#000"
++++++++++++++++++++android:textSize="20sp"
++++++++++++++++++++android:textStyle="bold"+/>|code-block|syntax|javascript|404754|java|404755|EditText+ed+=+findViewById(R.id.txt_Mass_smallWork);
++++ed.addTextChangedListener(new+TextWatcher()+{
++++++++@Override
++++++++public+void+beforeTextChanged(CharSequence+charSequence,+int+i,+int+i1,+int+i2)+{`

++++++++}

++++++++@Override
++++++++public+void+onTextChanged(CharSequence+charSequence,+int+i,+int+i1,+int+i2)+{
++++++++++++if(!charSequence.equals(""))+{
++++++++++++++++int+massValue+=+Integer.parseInt(charSequence.toString());
++++++++++++++++if+(massValue+>+10)+{
++++++++++++++++++++ed.setFilters(new+InputFilter[]{new+InputFilter.LengthFilter(2)});
++++++++++++++++}+else+{
++++++++++++++++++++ed.setFilters(new+InputFilter[]{new+InputFilter.LengthFilter(3)});
++++++++++++++++}
++++++++++++}
++++++++}

++++++++@Override
++++++++public+void+afterTextChanged(Editable+editable)+{

++++++++}
++++});|404756|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|$]]

this is my code max=100, min=0

xml

<pre><code>&lt;TextView
 android:id="@+id/txt_Mass_smallWork"
 android:layout_width="match_parent"
 android:layout_height="wrap_content"
 android:textColor="#000"
 android:textSize="20sp"
 android:textStyle="bold" /&gt;
</code></pre>

java

<pre><code>EditText ed = findViewById(R.id.txt_Mass_smallWork);
 ed.addTextChangedListener(new TextWatcher() {
 @Override
 public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {`

 }

 @Override
 public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
 if(!charSequence.equals("")) {
 int massValue = Integer.parseInt(charSequence.toString());
 if (massValue &gt; 10) {
 ed.setFilters(new InputFilter[]{new InputFilter.LengthFilter(2)});
 } else {
 ed.setFilters(new InputFilter[]{new InputFilter.LengthFilter(3)});
 }
 }
 }

 @Override
 public void afterTextChanged(Editable editable) {

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

blocks|key|186581|text|Kotlin上的一个非常简单的例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|186582|import+android.text.InputFilter
import+android.text.Spanned

class+InputFilterRange(private+var+range:+IntRange)+:+InputFilter+{

++++override+fun+filter(source:+CharSequence,+start:+Int,+end:+Int,+dest:+Spanned,+dstart:+Int,+dend:+Int)+=+try+{
++++++++val+input+=+Integer.parseInt(dest.toString()+%2B+source.toString())
++++++++if+(range.contains(input))+null+else+""
++++}+catch+(nfe:+NumberFormatException)+{
++++++++""
++++}
}|code-block|syntax|javascript|186583|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|$]]

Very simple example on Kotlin:

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

class InputFilterRange(private var range: IntRange) : InputFilter {

 override fun filter(source: CharSequence, start: Int, end: Int, dest: Spanned, dstart: Int, dend: Int) = try {
 val input = Integer.parseInt(dest.toString() + source.toString())
 if (range.contains(input)) null else ""
 } catch (nfe: NumberFormatException) {
 ""
 }
}
</code></pre>

blocks|key|186612|text|你可以用一个InputFilter来做这件事。显然，您可以使用的只有这个输入过滤器接口。在你用讨厌的方式创建一个扩展输入过滤器的新类之前，你可以使用这个快捷方式来实例化innerclass接口。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|186613|因此，您只需执行以下操作：|186614|EditText+subTargetTime+=+(EditText)+findViewById(R.id.my_time);
subTargetTime.setFilters(+new+InputFilter[]+{
++++++++++++++++new+InputFilter()+{
++++++++++++++++++++@Override
++++++++++++++++++++public+CharSequence+filter(CharSequence+source,+int+start,+int+end,+Spanned+dest,+int+dstart,+int+dend)+{
++++++++++++++++++++++++int+t+=+Integer.parseInt(source.toString());
++++++++++++++++++++++++if(t+<8)+{+t+=+8;+}
++++++++++++++++++++++++return+t%2B"";

++++++++++++++++++++}
++++++++++++++++}
++++++++});|code-block|syntax|javascript|186615|在本例中，我检查EditText的值是否大于8。如果不是，则将其设置为8。因此，目前您需要自己计算最小值、最大值或其他过滤逻辑。但至少你可以将过滤逻辑直接写到EditText中，非常整洁和简短。|186616|希望这能有所帮助|186617|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|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can do this with an an InputFilter. Apparently ther is just this Input Filter Interface you can use. Before you do it the annoying way an create a new Class that extends Input filter, u can use this shortcut with a innerclass Interface instantiation.

Therefore you just do this:

<pre><code>EditText subTargetTime = (EditText) findViewById(R.id.my_time);
subTargetTime.setFilters( new InputFilter[] {
 new InputFilter() {
 @Override
 public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
 int t = Integer.parseInt(source.toString());
 if(t &lt;8) { t = 8; }
 return t+"";

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

In this example I check if the value of the EditText is greater than 8. If not it shall be set to 8. So apaprently you need to com up with the min max or whatever filter logic by yourself. But at least u can write the filter logic pretty neat and short directly into the EditText.

Hope this helps

blocks|key|404819|text|为了定义EditText的最小值，我使用了以下命令：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|404820|if+(message.trim().length()+>=+1+&&+message.trim().length()+<=+12)+{
++//+do+stuf
}+else+{
++//+Too+short+or+too+long
}|code-block|syntax|javascript|404821|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|$]]

To define the minimum value of the EditText, I used this:

<pre><code>if (message.trim().length() &gt;= 1 &amp;&amp; message.trim().length() &lt;= 12) {
 // do stuf
} else {
 // Too short or too long
}
</code></pre>

blocks|key|404848|text|如果有人需要的话，这里是我对Pratik对Kotlin和Double的回答|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|404849|class+InputFilterMinMax+:+InputFilter+{

private+var+min:+Double+=+MIN_LIMIT
private+var+max:+Double+=+MIN_LIMIT

constructor(min:+Int,+max:+Int)+{
++++this.min+=+min.toDouble()
++++this.max+=+max.toDouble()
}

constructor(min:+String,+max:+String)+{
++++this.min+=+min.toDouble()
++++this.max+=+max.toDouble()
}

constructor(min:+Double,+max:+Double)+{
++++this.min+=+min
++++this.max+=+max
}

override+fun+filter(
++++source:+CharSequence,
++++start:+Int,
++++end:+Int,
++++dest:+Spanned,
++++dstart:+Int,
++++dend:+Int
):+CharSequence?+{
++++try+{
++++++++val+input+=+(dest.toString()+%2B+source.toString()).toDouble()
++++++++if+(isInRange(min,+max,+input))
++++++++++++return+null
++++}+catch+(nfe:+NumberFormatException)+{
++++++++Timber.e(nfe)
++++}

++++return+""
}

private+fun+isInRange(a:+Double,+b:+Double,+c:+Double):+Boolean+{
++++return+if+(b+>+a)+c+in+a..b+else+c+in+b..a
}
}|code-block|syntax|javascript|404850|entityMap^0|L|6|S|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Here's my take on Pratik Sharma's answer for <code>Kotlin</code> and <code>Double</code> if any one needs it

<pre><code>class InputFilterMinMax : InputFilter {

private var min: Double = MIN_LIMIT
private var max: Double = MIN_LIMIT

constructor(min: Int, max: Int) {
 this.min = min.toDouble()
 this.max = max.toDouble()
}

constructor(min: String, max: String) {
 this.min = min.toDouble()
 this.max = max.toDouble()
}

constructor(min: Double, max: Double) {
 this.min = min
 this.max = max
}

override fun filter(
 source: CharSequence,
 start: Int,
 end: Int,
 dest: Spanned,
 dstart: Int,
 dend: Int
): CharSequence? {
 try {
 val input = (dest.toString() + source.toString()).toDouble()
 if (isInRange(min, max, input))
 return null
 } catch (nfe: NumberFormatException) {
 Timber.e(nfe)
 }

 return ""
}

private fun isInRange(a: Double, b: Double, c: Double): Boolean {
 return if (b &gt; a) c in a..b else c in b..a
}
}
</code></pre>

blocks|key|186686|text|Kotlin+(如果有人需要它)(使用Utilities)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|186687|class+InputFilterMinMax:+InputFilter+{
++++private+var+min:Int+=+0
++++private+var+max:Int+=+0
++++constructor(min:Int,+max:Int)+{
++++++++this.min+=+min
++++++++this.max+=+max
++++}
++++constructor(min:String,+max:String)+{
++++++++this.min+=+Integer.parseInt(min)
++++++++this.max+=+Integer.parseInt(max)
++++}
++++override+fun+filter(source:CharSequence,+start:Int,+end:Int,+dest:+Spanned,+dstart:Int,+dend:Int):+CharSequence?+{
++++++++try
++++++++{
++++++++++++val+input+=+Integer.parseInt(dest.toString()+%2B+source.toString())
++++++++++++if+(isInRange(min,+max,+input))
++++++++++++++++return+null
++++++++}
++++++++catch+(nfe:NumberFormatException)+{}
++++++++return+""
++++}
++++private+fun+isInRange(a:Int,+b:Int,+c:Int):Boolean+{
++++++++return+if+(b+>+a)+c+in+a..b+else+c+in+b..a
++++}
}|code-block|syntax|javascript|186688|然后在你的Kotlin类中使用这个|186689|percentage_edit_text.filters+=+arrayOf(Utilities.InputFilterMinMax(1,+100))|186690|此EditText允许从1到100。|186691|然后在您的XML中使用它|186692|android:inputType="number"|186693|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Kotlin if any one needs it (Use Utilities)

<pre><code>class InputFilterMinMax: InputFilter {
 private var min:Int = 0
 private var max:Int = 0
 constructor(min:Int, max:Int) {
 this.min = min
 this.max = max
 }
 constructor(min:String, max:String) {
 this.min = Integer.parseInt(min)
 this.max = Integer.parseInt(max)
 }
 override fun filter(source:CharSequence, start:Int, end:Int, dest: Spanned, dstart:Int, dend:Int): CharSequence? {
 try
 {
 val input = Integer.parseInt(dest.toString() + source.toString())
 if (isInRange(min, max, input))
 return null
 }
 catch (nfe:NumberFormatException) {}
 return ""
 }
 private fun isInRange(a:Int, b:Int, c:Int):Boolean {
 return if (b &gt; a) c in a..b else c in b..a
 }
}
</code></pre>

Then use this from your Kotlin class

<pre><code>percentage_edit_text.filters = arrayOf(Utilities.InputFilterMinMax(1, 100))
</code></pre>

This EditText allows from 1 to 100.

Then use this from your XML

<pre><code>android:inputType="number"
</code></pre>

blocks|key|404909|text|这里的许多解决方案都很好，但我想提供一个更快的替代方案，如果你只是在寻找一种防止溢出的方法，它可能就足够了：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|404910|android:maxLength="9"|code-block|syntax|javascript|404911|这将确保您不会在非小数的32位整数上发生溢出。所以这里的最小值是-99999999，最大值是999999999。|offset|length|style|CODE|404912|entityMap^0|0|0|W|9|1A|9|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|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Many solutions here are great, but I want to provide a quicker alternative that might be enough if you are just looking for a way to prevent overflows:
<pre><code>android:maxLength=&quot;9&quot;
</code></pre>
This will make sure that you cannot get an overflow on 32 bit integers for non decimals. So here the min value is <code>-99999999</code> and max value is <code>999999999</code>.

blocks|key|186719|text|在Kotlin：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|186720|class+InputFilterMinMax(private+val+min:+Float,+private+val+max:+Float)+:+InputFilter+{

++++override+fun+filter(source:+CharSequence,+start:+Int,+end:+Int,+dest:+Spanned,+dstart:+Int,+dend:+Int):+CharSequence?+{
++++++++try+{
++++++++++++val+input+=+(dest.subSequence(0,+dstart).toString()+%2B+source+%2B+dest.subSequence(dend,+dest.length)).toFloat()
++++++++++++if+(isInRange(min,+max,+input))+return+null
++++++++}+catch+(e:+NumberFormatException)+{
++++++++++++e.printStackTrace()
++++++++}
++++++++return+""
++++}

++++private+fun+isInRange(a:+Float,+b:+Float,+c:+Float):+Boolean+{
++++++++return+if+(b+>+a)+c+in+a..b+else+c+in+b..a
++++}
}|code-block|syntax|javascript|186721|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|$]]

In Kotlin:
<pre class="lang-kotlin prettyprint-override"><code>class InputFilterMinMax(private val min: Float, private val max: Float) : InputFilter {

 override fun filter(source: CharSequence, start: Int, end: Int, dest: Spanned, dstart: Int, dend: Int): CharSequence? {
 try {
 val input = (dest.subSequence(0, dstart).toString() + source + dest.subSequence(dend, dest.length)).toFloat()
 if (isInRange(min, max, input)) return null
 } catch (e: NumberFormatException) {
 e.printStackTrace()
 }
 return &quot;&quot;
 }

 private fun isInRange(a: Float, b: Float, c: Float): Boolean {
 return if (b &gt; a) c in a..b else c in b..a
 }
}
</code></pre>

I want to define a min and max value for an <code>EditText</code>. 

For example: if any person tries to enter a month value in it, the value must be between 1-12.

I can do it by using <code>TextWatcher</code> but I want to know if there is any other way to do it in layout file or elsewhere.

Edit:
I don't want to limit character count. I want to limit the value. For example, if I limit month <code>EditText</code> w characters when I enter 12 it will accept it but if I enter 22 it mustn't accept it while I am entering.

Is there a way to define a min and max value for EditText in Android?

动态测试

Kotlin

我想为EditText定义一个最小值和最大值。例如:如果任何人尝试在其中输入月值，则该值必须介于1-12之间。我可以使用TextWatcher来实现，但我想知道是否有其他方法可以在布局文件或其他地方实现。编辑:我不想限制字符数。我想限制它的值。例如，如果我限制month EditText w个字符，当我输入12时，它将...

问在安卓系统中，有没有办法定义EditText的最小值和最大值？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在安卓系统中，有没有办法定义EditText的最小值和最大值？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在安卓系统中，有没有办法定义EditText的最小值和最大值？
EN