অ্যান্ড্রয়েড এডিট টেক্সটে দশমিক স্থান সীমাবদ্ধ করুন

Question

আমি এমন একটি অ্যাপ্লিকেশন লেখার চেষ্টা করছি যা আপনাকে আপনার আর্থিক পরিচালনায় সহায়তা করে। আমি এমন একটি EditTextক্ষেত্র ব্যবহার করছি যেখানে ব্যবহারকারী অর্থের পরিমাণ নির্দিষ্ট করতে পারেন।

আমি এটিতে সূক্ষ্মভাবে কাজ inputTypeকরে numberDecimalযা সেটাকে ব্যতীত, এটি লোককে এমন সংখ্যায় প্রবেশ করতে দেয় 123.122যা অর্থের জন্য উপযুক্ত নয়।

দশমিক পয়েন্টের পরে অক্ষরের সংখ্যা দুটি করে দেওয়ার কি কোনও উপায় আছে?

Comments

আপনি একটি নিয়মিত ভাব প্রকাশ করতে এবং সম্পাদনা পাঠ্যের বিষয়বস্তুটি ফোকাসটি হারাতে পারলে যাচাই করতে পারেন।

— ব্লাইন্ডস্টফ

আমি দেখেছি InputFilterইন্টারফেস, এটা আমি কি চাও বলে মনে হয় developer.android.com/reference/android/text/method/... কিন্তু পদ্ধতি filterআমি বাস্তবায়ন করতে আছে বরং আমাকে বিভ্রান্তিকর। ইতিমধ্যে কেউ কি এমন ফিল্টার লিখেছেন এবং কীভাবে এটি ব্যবহার করবেন তা জানেন?

— কনস্টান্টিন ওয়েটিজ 21

প্রস্তাবিত সমাধানগুলির কোনওটি কি আরটিএল লোকেলের জন্য কাজ করে? যতদূর আমি বলতে পারি তারা করবে না ...

— নিক

Answer 1

আরও মার্জিত উপায়ে নিয়মিত এক্সপ্রেশন (রেজেক্স) ব্যবহার করা হবে:

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;
    }

}

এটি ব্যবহার করতে:

editText.setFilters(new InputFilter[] {new DecimalDigitsInputFilter(5,2)});

Comments

হাই, কিছু প্রান্তের কেসগুলি এখনও ভালভাবে পরিচালনা করা হচ্ছে না। উদাহরণস্বরূপ, আমি 2.45 টাইপ করার পরে, আমি "পাঠ্যের বেশিরভাগ অংশে কার্সারটি সরিয়ে নিয়ে যাই"। আমি 12.45 পাঠ্যটি উত্পাদন করতে চাই, এটি অনুমতি দেবে না।

— চেওক ইয়ান চেং

দশমিক বিন্দুর পরে ব্যবহারকারী 2 ডিজিট প্রবেশ করার পরে এটি দশমিকের আগে অঙ্কগুলি পরিবর্তন করতে দেয় না।

— গৌরব সিঙ্গলা

দুর্দান্ত সমাধান তবে এটি পুরোপুরি সঠিক নয়। মিলকারীর পরীক্ষা করা উচিত নয় DEST, এটা editText মান পরীক্ষা করা উচিত (dest.subSequence (0, dstart) + + source.subSequence (শুরু, শেষ) + + dest.subSequence (dend, dest.length ()))

— Mihaela Romanca

মিহেলা ঠিক আছে, আমাদের সেই স্ট্রিংয়ের সাথে ম্যাচ করা উচিত যা এডিটেক্সটটি পূরণ করার চেষ্টা করছে। আমি খুঁজে পেয়েছি কীভাবে এই CharSequence ম্যাচ = TextUtils.concat (dest.subSequence (0, dstart), উত্স.সুবসেক্সেন্স (শুরু, সমাপ্তি), ডেসট.সুবসেকেন্স (ডেন্ড, ডেসটেলথ লেন্থ ())) এর মতো অন্য একটি প্রশ্নে কীভাবে যুক্ত হতে পারি; পরে রেজেক্স সমস্যা তৈরি করছিল যদিও আমি এটিকে এটিকে "" ^ \\ d {1, "+ ডিজিটপূর্বজিরো +"} (\\। \\ d {0, "+ ডিজিটস আফটারজিরো +"}) এ পরিবর্তন করেছি? But "তবে আপনি ' এর পরেও বৈধতা নিতে হবে কারণ "১" এই রেজেক্সের সাথে বৈধ তবে আমাদের সময়টি টাইপ করা যায় সেভাবে আমাদের এটি দরকার।

— dt0

আপনি কিভাবে কমা (()) এর জন্য এই কাজটি করবেন? বিশ্বের কিছু অঞ্চল কমা দিয়ে দশমিক সংখ্যা টাইপ করে (উদা: 123,45)।

— অ্যান্ড্রু

Answer 2

রিজেক্স ব্যবহার না করেই সহজ সমাধান:

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++) {
      char c = dest.charAt(i);
      if (c == '.' || c == ',') {
        dotPos = i;
        break;
      }
    }
    if (dotPos >= 0) {

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

    return null;
  }

}

ব্যবহার করা:

editText.setFilters(new InputFilter[] {new DecimalDigitsInputFilter(2)});

Comments

'অ' এর মতো স্ট্রিংয়ের ক্ষেত্রে অ সংখ্যাসূচক অক্ষর fromোকানো থেকে কী আমাকে থামিয়ে দেবে?

— কনস্ট্যান্টিন ওয়েটিজ

এটি: <এডিটেক্সট ... অ্যান্ড্রয়েড: ইনপুটটাইপ = "সংখ্যা" />

— পিসেপেস

এটি হওয়া উচিত: editText.setFilters (নতুন ইনপুটফিল্টার [] {নতুন দশমিকডিজিটস ইনপুটফিল্টার (2););

— ফ্রেঙ্ক

এটি "999" টাইপ করুন এবং তারপরে প্রথম 9 এর পরে দশমিক পয়েন্ট সন্নিবেশ করবে এমনটি এটি পরিচালনা করে না

— জেক স্টোফ্লার

ধন্যবাদ এই দরকারী। আমরা এর মতো দৈর্ঘ্যের ফিল্টার ব্যবহার করে দশমিক পয়েন্টের আগে সংখ্যাগুলিও সীমাবদ্ধ করতে পারি। কোটলিন: edtAnyAmount.filters = অ্যারেঅফ <ইনপুটফিল্টার> (ইনপুটফিল্টার en লেন্থ ফিল্টার (7), ডেসিমাল ডিজিটস ইনপুট ফিল্টার (2))

— ফাল্দু জলদীপ

Answer 3

এই বাস্তবায়ন InputFilterসমস্যার সমাধান করে।

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++) {
            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 > digits) ? 
                    "" :
                    new SpannableStringBuilder(source, start, end);
            }
        }

        for (int i = start; i < 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)) > 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);
    }
}

Comments

আমি কি জানতে পারি যে শূন্যের পরিবর্তে আমাদের স্প্যানিয়েবল স্ট্রিংবিল্ডার ফেরত দেওয়ার কোনও কারণ আছে? আমি নাল দিয়ে এটি পরীক্ষা করি, এটি খুব ভাল কাজ করে। এছাড়াও, আমাদের কি ডিজিটসকিস্টিলিস্টনার থেকে উত্তরাধিকারী হওয়ার দরকার আছে? অ্যান্ড্রয়েড ব্যবহার করার সময়: ইনপুটটাইপ = "নাম্বার ডেসিমাল" সমস্ত "0123456789." সম্পাদন করবে অক্ষর প্রয়োগ।

— চেওক ইয়ান চেং

ঠিকভাবে কাজ করে. আপনাকে অনেক ধন্যবাদ.

— Andrei Aulaska

Answer 4

এখানে একটি নমুনা ইনপুটফিল্টার রয়েছে যা কেবলমাত্র দশমিক পয়েন্টের আগে সর্বাধিক 4 ডিজিট এবং তার পরে সর্বোচ্চ 1 ডিজিটের অনুমতি দেয়।

যে মানগুলি editText অনুমতি দেয়: 555,2 , 555 , .2

মানগুলি যা সম্পাদনা করে: ব্লকগুলি 55555.2 , 055.2 , 555.42

        InputFilter filter = new InputFilter() {
        final int maxDigitsBeforeDecimalPoint=4;
        final int maxDigitsAfterDecimalPoint=1;

        @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,"+(maxDigitsBeforeDecimalPoint-1)+"})?)?(\\.[0-9]{0,"+maxDigitsAfterDecimalPoint+"})?"

                        )) {
                    if(source.length()==0)
                        return dest.subSequence(dstart, dend);
                    return "";
                }

            return null;

        }
    };

    mEdittext.setFilters(new InputFilter[] { filter });

Comments

দেয় না। টাইপ করতে হবে

— AmiNadimi

Answer 5

আমি @ পিনহ্যাসি সমাধানের জন্য কিছু সমাধান করেছি। এটি কিছু ক্ষেত্রে পরিচালনা করে:

1. আপনি যে কোনও জায়গায় কার্সার স্থানান্তর করতে পারেন

2.মিনিস সাইন হ্যান্ডলিং

3. ডিজিটসফায়ার = 2 এবং অঙ্কগুলি পরে = 4 এবং আপনি 12.4545 লিখুন। তারপরে আপনি যদি "।" অপসারণ করতে চান তবে এটি অনুমতি দেবে না।

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 "";
    }
}

Comments

আমার মনে হয় এটি আমার নিখুঁত সমাধান হওয়া উচিত। ধন্যবাদ.

— প্রতীক বুটানী

@ ওমকার এই ভুল। দৈর্ঘ্য> ০, ভাগ্য দৈর্ঘ্য () == 0 এমনকি 0 এর চেয়ে বেশি পুরো পাঠ্য সম্পাদনা করলেও এই শর্তটি সর্বদা সত্য হবে ...

— ব্যবহারকারের 244

@ ওমকার আপনার মন্তব্য pls সরান

— user924

@ অ্যান্ড্রয়েড_দেব আমি নেতিবাচক মান (বিয়োগ) টাইপ করতে পারি না কেন?

— ব্যবহারকারী 924

যদি আপনি সেট করেন android:inputType="number"বা android:inputType="numberDecimal"এটি বিয়োগ টাইপ করতে দেয় না, এটি android:digits="0123456789.-"কোনও লাভ করে না

— user924

Answer 6

আমি অন্য সমাধানটি পছন্দ করি না এবং আমি নিজের তৈরি করেছি। এই সমাধানের সাহায্যে আপনি বিন্দুর আগে MAX_BEFORE_POINT অঙ্কের বেশি প্রবেশ করতে পারবেন না এবং দশমিকগুলি MAX_DECIMAL এর চেয়ে বেশি হতে পারে না।

আপনি মাত্রায় অতিরিক্ত অঙ্কটি টাইপ করতে পারবেন না, অন্য কোনও প্রভাব নেই! অতিরিক্ত লিখলে "।" এটি টাইপ করে "0."

1. লেআউটে এডিট টেক্সট সেট করুন:

   অ্যান্ড্রয়েড ইনপুট = "numberDecimal"

2. আপনার অনক্রিতে শ্রোতাদের যুক্ত করুন। আপনি যদি বিন্দুটির আগে এবং পরে সংখ্যার সংশোধন করতে চান তবে কলটি পারফেক্টডিসিমাল (টিআরটি, NUMBER_BEFORE_POINT, NUMBER_DECIMALS) এ সম্পাদনা করুন, এখানে 3 এবং 2 তে সেট করা আছে

   EditText targetEditText = (EditText)findViewById(R.id.targetEditTextLayoutId);
   
   targetEditText.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) {
       String str = targetEditText.getText().toString();
       if (str.isEmpty()) return;
       String str2 = PerfectDecimal(str, 3, 2);
   
       if (!str2.equals(str)) {
           targetEditText.setText(str2);
           int pos = targetEditText.getText().length();
           targetEditText.setSelection(pos);
       }
     }
   });

3. এই ফানসিওন অন্তর্ভুক্ত করুন:

   public String PerfectDecimal(String str, int MAX_BEFORE_POINT, int MAX_DECIMAL){
     if(str.charAt(0) == '.') str = "0"+str;
     int max = str.length();
   
     String rFinal = "";
     boolean after = false;
     int i = 0, up = 0, decimal = 0; char t;
     while(i < max){
       t = str.charAt(i);
       if(t != '.' && after == false){
           up++;
           if(up > MAX_BEFORE_POINT) return rFinal;
       }else if(t == '.'){
           after = true;
       }else{
           decimal++;
           if(decimal > MAX_DECIMAL)
               return rFinal;
       }
       rFinal = rFinal + t;
       i++;
     }return rFinal;
   }

এবং এটি শেষ!

Comments

চিয়ার্স। কাজ খুব ভাল যখন অন্য আমাকে জন্য কাজ না করে

— বিয়ার

এটি স্বীকৃত উত্তর হওয়া উচিত .. এটি নিখুঁত .. সমস্ত শর্ত এখানে সন্তুষ্ট।

— নয়ন

সমস্ত উচ্চ ভোট দেওয়া উত্তরের উপর, এই উত্তরটি আমার পক্ষে আসলে কাজ করেছে।

— রোহিত মান্দিওয়াল

সাবাশ! আমি সমস্ত সংমিশ্রণ চেষ্টা করেছি এবং মনে হচ্ছে এটি দুর্দান্ত কাজ করে। ধন্যবাদ.

— akelec

আমি জানি না এটি কীভাবে কাজ করে তবে এটি কেবল মনোমুগ্ধকর মতো কাজ করে।

— wonsuc

Answer 7

আমি TextWatcherনিম্নলিখিত উপায়ে সাহায্যে এটি অর্জন করেছি

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

এই সমাধানটি ব্যবহারকারীকে দশমিক পয়েন্টের পরে দুই অঙ্কের বেশি প্রবেশ করতে দেয় না। দশমিক বিন্দুর আগে আপনি যে কোনও সংখ্যক সংখ্যাও প্রবেশ করতে পারেন। একাধিক সম্পাদনা পাঠের জন্য ফিল্টার সেট করতে এই ব্লগটি http://v4all123.blogspot.com/2013/05/set-limit-for-fration-in-decimal.html দেখুন । আমি আশা করি এটি সাহায্য করবে ধন্যবাদ.

Comments

দেরী তথ্যের জন্য দুঃখিত। countসঙ্গে আরম্ভ করতে ভুলবেন না -1। তবে শুধুমাত্র এটি সঠিকভাবে কাজ করবে। int count = -1;

— গুণসিলান

গুণসিলান - আমি উপরের কোডটি এবং এটির কার্যকারিতা ভাল করে চেষ্টা করেছি। তবে আমি যখন টাইপ করা পাঠ্যটি মুছে ফেলি এবং আবার টাইপ করা শুরু করি তবে এটির জন্য কেবল একটি অঙ্কের টাইপিং, এর জন্য কোনও সমাধান .....

— সিভা কে

@ শিভাক কোনও উপায় নেই বন্ধু। আপনি যদি মুছুন এবং টাইপ করেন তবে এটি ন্যূনতম 100 ডিজিট গ্রহণ করবে। আপনি কীভাবে এটি অ্যাক্সেস করছেন তা আমি জানি না listener। যে কোনও উপায়ে দয়া করে আমার ব্লগ পোস্টটি একবার দেখুন । আপনি একটি ধারণা পেতে পারেন। আপনি যদি না পারেন দয়া করে আমাকে জানান। আমি এই সমস্যাটি সম্পর্কে আপনাকে সহায়তা করব।

— গুণসিলান

@SivaK যা বলেছে তা আমি যাচাই করেছি। এটি যে কোনও ক্ষেত্রেই চালাক তবে আমি এটির জন্য কিছু সম্পাদনা করব যাতে এটি সম্পূর্ণ কার্যকরী হয় (আমার মতে)

— মিঃ ত্রিস্তান

@ গুণাসিলান আপনার সমাধানের জন্য আপনাকে ধন্যবাদ তবে এটিতে কিছু বাগ রয়েছে। উদাহরণস্বরূপ, আমি যখন দ্বিতীয় দশমিক মোছা করি তখন এটি আবার টাইপ করা অসম্ভব (আবার এটি টাইপ করতে সক্ষম হওয়ার জন্য আমাকে অবশ্যই সমস্ত দশমিক মুছতে হবে)। এছাড়াও, সম্পূর্ণ এন্ট্রি মোছার পরে, আবার টাইপ করার সময় কিছু অদ্ভুত সীমাবদ্ধতা ঘটে।

— akelec

Answer 8

আমি যে ইনপুটফিল্টারটি নিয়ে এসেছি তা আপনাকে দশমিক জায়গার আগে এবং পরে সংখ্যার সংখ্যা কনফিগার করতে দেয়। অতিরিক্তভাবে, এটি নেতৃস্থানীয় শূন্যগুলিকে অস্বীকার করে।

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)});

Comments

চমৎকার সমাধান! এটি আমার পক্ষে কাজ করে তবে আমি অগ্রণী সময়কালের (বিন্দু) অস্বীকার করতে চাই। উদাহরণস্বরূপ, ".123" ক্রম অনুমোদিত নয়। কীভাবে এটি অর্জন করবেন?

— আইবোগোলিউবস্কি

Answer 9

দশমিকের পরে প্রয়োজনীয়তা 2 ডিজিট। দশমিক পয়েন্টের আগে অঙ্কগুলির জন্য কোনও সীমা থাকা উচিত নয় । সুতরাং, সমাধান হওয়া উচিত,

public class DecimalDigitsInputFilter implements InputFilter {

    Pattern mPattern;

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

    @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;
    }
}

এবং এটি হিসাবে ব্যবহার করুন

mEditText.setFilters(new InputFilter[]{new DecimalDigitsInputFilter()});

অনুপ্রেরণার জন্য @ পিনহ্যাসিকে ধন্যবাদ।

Comments

ভাল ... ঠিক আছে কাজ

— জোজো

Answer 10

আমার সমাধানটি সহজ এবং নিখুঁতভাবে কাজ করে!

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();
}
}

ব্যবহার:

myTextEdit.addTextChangedListener(new DecimalInputTextWatcher(myTextEdit, 2));

Comments

isValid()প্রতিটি isValid()কলে পুনর্নির্মাণের প্যাটার্নগুলি এড়ানোর জন্য নিদর্শনগুলি থেকে নির্মাত্রে সরান ।

— হেমন্ত কৌশিক

Answer 11

আপনার স্ট্রিংটিকে কোনও টেক্সটভিউতে রাখার আগে ফর্ম্যাট করার জন্য নাম্বার ফর্ম্যাট.গেটেনসিআইনস্ট্যান্স () ব্যবহার করে দেখুন ।

কিছুটা এইরকম:

NumberFormat currency = NumberFormat.getCurrencyInstance();
myTextView.setText(currency.format(dollars));

সম্পাদনা করুন - মুদ্রার জন্য কোনও ইনপুট টাইপ নেই যা আমি ডক্সে খুঁজে পেতে পারি। আমি ধারণা করি এটি এর কারণ কারণ এমন কিছু মুদ্রা রয়েছে যা জাপানি ইয়েনের দশমিক জায়গাগুলির জন্য একই নিয়ম অনুসরণ করে না।

লেফেলম্যানিয়া যেমন উল্লেখ করেছে, উপরের কোডটি ব্যবহার করে আপনি নিজের TextWatcherউপর সেট করা ব্যবহারকারীর ইনপুট সংশোধন করতে পারেন EditText।

Answer 12

@Pinhassi সমাধানটি কিছুটা উন্নত।

খুব ভাল কাজ করে। এটি সংক্ষিপ্ত স্ট্রিংকে বৈধতা দেয়।

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 "";
}

 }

Answer 13

আমি উপরের সমাধানগুলি সংশোধন করেছি এবং নিম্নলিখিতগুলি তৈরি করেছি। দশমিক বিন্দুর আগে এবং পরে অঙ্কের সংখ্যা নির্ধারণ করতে পারেন।

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);
}

}

Comments

এটা প্রায় কি reisub উপর 2014. এখানে একই প্রশ্নে উত্তর দেওয়া হয়েছে

— তানবিরা Joisar

Answer 14

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;
    }
});

এটি যখন আপনি সম্পাদনা পর্বের বাইরে বেরোন তখন এটি ক্ষেত্রটিকে সঠিক ফর্ম্যাটে ফর্ম্যাট করে। তাদের এই মুহুর্তে এটিতে মাত্র 2 দশমিক চ্যাটার রয়েছে। আমি মনে করি এটি করার এটি বেশ সহজ উপায়।

Answer 15

এখানে সমস্ত উত্তরগুলি বেশ জটিল I

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()+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

    }
});

Comments

এটা আমার জন্য নিখুঁত কাজ। আমি সমস্ত দৃশ্য যাচাই করেছিলাম। ধন্যবাদ।

— অমরনাথ বৈঠা

ধরুন আমি 1234.56 এ প্রবেশ করেছি, এখন আমি 12378.56 এর মতো এডিট করতে চাই, দশমিক ছাড়াই আমি এটি করতে পারি না।

— আমান ভার্মা

Answer 16

আমি পিনহাসির উত্তরটি সত্যিই পছন্দ করেছি তবে লক্ষ্য করেছি যে ব্যবহারকারী দশমিক বিন্দুর পরে নির্দিষ্ট নম্বর অঙ্কের পরে দশমিক পয়েন্টের বাম দিকে পাঠ্য প্রবেশ করতে পারবেন না। সমস্যাটি হ'ল সমাধানটি কেবলমাত্র পূর্ববর্তী পাঠ্য যা পরীক্ষামূলকভাবে প্রবেশ করানো হয়েছিল তা পরীক্ষা করেছিল, বর্তমান পাঠ্যটি প্রবেশ করা হচ্ছে না। সুতরাং এখানে আমার সমাধান যা বৈধতার জন্য মূল পাঠ্যে নতুন চরিত্রটি সন্নিবেশ করিয়েছে।

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() > 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

এবং সম্পাদনা পাঠ্য ফিল্টার সেট করার জন্য কল

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

Answer 17

আমি পিনহাসি দ্বারা একটি রেজেেক্স ব্যবহার করে এমন সমাধানে উন্নতি করেছি যাতে এটি প্রান্তের কেসগুলিও সঠিকভাবে পরিচালনা করে। ইনপুটটি সঠিক কিনা তা পরীক্ষা করার আগে প্রথমে চূড়ান্ত স্ট্রিংটি অ্যান্ড্রয়েড ডক্স দ্বারা বর্ণিত হিসাবে নির্মিত হয় is

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;
    }
}

ব্যবহার:

editText.setFilters(new InputFilter[] {new DecimalDigitsInputFilter(5,2)});

Answer 18

দশমিকের পরে ব্যবহারকারী 2 টির বেশি সংখ্যায় প্রবেশ করতে বাধা দিতে সরকারী সহায়ক শ্রেণি এখানে রয়েছে:

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 + "." + numberAfterDecimal;
    }
    costEditText.removeTextChangedListener(this);
    costEditText.setText(cost);
    costEditText.setSelection(costEditText.getText().toString().trim().length());
    costEditText.addTextChangedListener(this);
}
}

Answer 19

আমি উত্তর changed6 (ফাভাস কেভি দ্বারা) পরিবর্তন করেছি কারণ সেখানে আপনি প্রথম অবস্থানে স্রেফ পয়েন্ট রাখতে পারেন।

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;
    }
}};

Answer 20

অন্যরা যেমন বলেছেন, আমি এই প্রকল্পটি আমার প্রকল্পে যুক্ত করেছি এবং ফিল্টারটি আমার পছন্দসইতে সেট EditTextকরেছি।

@ পিক্সেলের উত্তর থেকে ফিল্টারটি অনুলিপি করা হয়েছে। আমি শুধু সব একসাথে রাখছি।

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 "";
    }
}

এবার আপনার EditTextমতো ফিল্টারটি সেট করুন ।

mEditText.setFilters(new InputFilter[]{new DecimalDigitsInputFilter()});

এখানে একটি গুরুত্বপূর্ণ বিষয় হ'ল এটি আমার দশমিক পয়েন্টের পরে দুইটি বেশি সংখ্যাকে না দেখানোর সমস্যাটি সমাধান করে EditTextতবে সমস্যাটি যখন আমি তখন getText()থেকে EditTextআসে, এটি আমার টাইপ করা পুরো ইনপুটটি ফিরিয়ে দেয়।

উদাহরণস্বরূপ, ফিল্টার প্রয়োগ করার পরে EditText, আমি ইনপুট 1.5699856987 সেট করার চেষ্টা করেছি। সুতরাং স্ক্রিনে এটি 1.56 দেখায় যা নিখুঁত।

তারপরে আমি এই ইনপুটটি অন্য কয়েকটি গণনার জন্য ব্যবহার করতে চেয়েছিলাম তাই আমি input ইনপুট ক্ষেত্রটি ( EditText) থেকে পাঠ্যটি পেতে চাই । যখন ফোন করলামmEditText.getText().toString() এটিকে 1.5699856987 রিটার্ন বলেছিলাম যা আমার ক্ষেত্রে গ্রহণযোগ্য নয়।

সুতরাং আমি এটি থেকে পাওয়ার পরে আবার মানটি পার্স করতে হয়েছিল EditText।

BigDecimal amount = new BigDecimal(Double.parseDouble(mEditText.getText().toString().trim()))
    .setScale(2, RoundingMode.HALF_UP);

setScaleথেকে সম্পূর্ণ পাঠ্য প্রাপ্তির পরে কৌতুকটি এখানে করে EditText।

Comments

হ্যালো, আমি কীভাবে এটি নিশ্চিত করতে পারি যে যদি ব্যবহারকারী দশমিক (।) ইনপুট না করে তবে তিনি 2 টির বেশি সংখ্যায় প্রবেশ করতে সক্ষম হবেন না?

— মণীশনেগি

Answer 21

আমিও এই সমস্যাটি পেরিয়ে এসেছি। আমি অনেক এডিটেক্সটগুলিতে কোডটি পুনরায় ব্যবহার করতে সক্ষম হতে চেয়েছিলাম। এটি আমার সমাধান:

ব্যবহার:

CurrencyFormat watcher = new CurrencyFormat();
priceEditText.addTextChangedListener(watcher);

ক্লাস:

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++){
            if(nr.charAt(i)=='.'){
                pos=i+1;
                    break;
            }
        }
        return len-pos;
    }
}

Answer 22

@ মেহ আপনার জন্য ..

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() > 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(".") + 1);
                    if (temp.length() > afterDecimal) {
                        return "";
                    }
                }
            }
            return super.filter(source, start, end, dest, dstart, dend);
        }
    } });

Answer 23

খুব দেরিতে প্রতিক্রিয়া: আমরা এটি সহজভাবে এটি করতে পারি:

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) {
        }
}

Answer 24

এখানে দশমিক বিন্দুর পরে TextWatcherকেবলমাত্র n সংখ্যার অনুমতি দেয় ।

TextWatcher

private static boolean flag;
public static TextWatcher getTextWatcherAllowAfterDeci(final int allowAfterDecimal){

    TextWatcher watcher = new TextWatcher() {

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {
            // TODO Auto-generated method stub

        }

        @Override
        public void beforeTextChanged(CharSequence s, int start, int count,
                int after) {
            // TODO Auto-generated method stub

        }

        @Override
        public void afterTextChanged(Editable s) {
            // TODO Auto-generated method stub
            String str = s.toString();
            int index = str.indexOf ( "." );
            if(index>=0){
                if((index+1)<str.length()){
                    String numberD = str.substring(index+1);
                    if (numberD.length()!=allowAfterDecimal) {
                        flag=true;
                    }else{
                        flag=false;
                    }   
                }else{
                    flag = false;
                }                   
            }else{
                flag=false;
            }
            if(flag)
                s.delete(s.length() - 1,
                        s.length());
        }
    };
    return watcher;
}

ব্যবহারবিধি

yourEditText.addTextChangedListener(getTextWatcherAllowAfterDeci(1));

Comments

একটি যাদুমন্ত্র মত কাজ করে!!. ধন্যবাদ হিরেন :)

— নিশা .1313 এ 5

Answer 25

এটি অর্জনের সহজতম উপায় হ'ল:

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(".") + 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) {
    }
});

Comments

সহজ এবং পারফেক্ট উত্তর

— লোগো 13

Answer 26

এখানে আমার সমাধান:

     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) {}
    });

দশমিক পয়েন্টের পরে ব্যবহারকারী যদি দুটি সংখ্যার বেশি সংখ্যায় প্রবেশ করে তবে এটি স্বয়ংক্রিয়ভাবে সংশোধন করা হবে।

আমি সাহায্য করেছি আশা করি!

Comments

আপনি কি এই কোডটি পরীক্ষা করেছেন? এটি সত্যিই কাজ করতে পারে না, কারণ আপনি যখনই সেট-টেক্সট () পাঠ্য ওয়াচচার পুনরায় অগ্নি <=> অসীম লুপ কল করেন।

— মোটিজেনফ্লো

06-07 08: 01: 35.006: ই / অ্যান্ড্রয়েডআরআরটাইম (30230): জাভা.লং.স্ট্যাক ওভারফ্লো এরিয়ার কাজ করছে না

— অঞ্জুলা

Answer 27

এটি আমার পক্ষে ভাল কাজ করে। ফোকাস পরিবর্তিত হয়ে ফিরে ফিরে আসার পরেও এটি মান প্রবেশ করার অনুমতি দেয়। উদাহরণস্বরূপ: 123.00, 12.12, 0.01, ইত্যাদি ..

1. ফাইল থেকে অ্যাক্সেস করা ইনপুটটির Integer.parseInt(getString(R.string.valuelength)) দৈর্ঘ্য নির্দিষ্ট করে I এটি মান পরিবর্তন করতে শান্ত is ২. , এটি দশমিক স্থানের সর্বাধিক সীমা।digits.Valuesstring.xmlInteger.parseInt(getString(R.string.valuedecimal))

private InputFilter[] valDecimalPlaces;
private ArrayList<EditText> edittextArray;

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

EditTextক্রিয়া সম্পাদন করতে দেয় এমন মানগুলির অ্যারে ।

for (EditText etDecimalPlace : edittextArray) {
            etDecimalPlace.setFilters(valDecimalPlaces);

আমি একাধিক এডিটেক্সট নেক্সট DecimalDigitsInputFilterNew.classফাইল ধারণ করে এমন মানগুলির অ্যারে ব্যবহার করেছি contain

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;
    }
}

Answer 28

এটি পিনহাসির উত্তরের ভিত্তিতে তৈরি করা - আমি যে বিষয়টি এসেছি তা হ'ল দশমিক সীমা পৌঁছে যাওয়ার পরে আপনি দশমিকের আগে মান যুক্ত করতে পারবেন না add সমস্যাটি সমাধান করতে, প্যাটার্ন ম্যাচটি করার আগে আমাদের চূড়ান্ত স্ট্রিংটি তৈরি করতে হবে।

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;
    }
}

Answer 29

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() > beforeDecimal) {
                        return "";
                    }
                } else {
                    temp = temp.substring(temp.indexOf(".") + 1);
                    if (temp.length() > afterDecimal) {
                        return "";
                    }
                }

                return super.filter(source, start, end, dest, dstart, dend);
            }
        }
});

Comments

আপনার উত্তর সময় থেকে প্রায় 2 বছর। আমি আপনার কোড ব্যবহার করার চেষ্টা এমতাবস্থায় দেখলাম আপনার সমাধান সম্পর্কে সমস্যা যোগ হয় sourceপরে et.getText()। এটি সর্বদা বুঝতে পারে যে বাক্সটি শুরু করার পরিবর্তে লোকেরা বাক্সের শেষে টাইপ করে। StringBuilder stringBuilder = new StringBuilder(text.getText().toString()); stringBuilder.replace(dstart, dend, source.toString()); String temp = stringBuilder.toString();কাজ করা উচিত. যাই হোক ধন্যবাদ.

— ট্রুং হিউ

Answer 30

ডেসিমালডিজিটস ইনপুটফিল্টার নামে অ্যান্ড্রয়েড কোটলিনে একটি নতুন ক্লাস তৈরি করুন

class DecimalDigitsInputFilter(digitsBeforeZero: Int, digitsAfterZero: Int) : InputFilter {
lateinit var mPattern: Pattern
init {
    mPattern =
        Pattern.compile("[0-9]{0," + (digitsBeforeZero) + "}+((\\.[0-9]{0," + (digitsAfterZero) + "})?)||(\\.)?")
}
override fun filter(
    source: CharSequence?,
    start: Int,
    end: Int,
    dest: Spanned?,
    dstart: Int,
    dend: Int
): CharSequence? {
    val matcher: Matcher = mPattern.matcher(dest?.subSequence(0, dstart).toString() + source?.subSequence(start, end).toString() + dest?.subSequence(dend, dest?.length!!).toString())
    if (!matcher.matches())
        return ""
    else
        return null
}

এই ক্লাসটি নিম্নলিখিত লাইনের সাথে কল করুন

 et_buy_amount.filters = (arrayOf<InputFilter>(DecimalDigitsInputFilter(8,2)))

এর জন্য অনেকগুলি উত্তর রয়েছে তবে এটি আপনাকে দশমিকের আগে 8 ডিজিট এবং দশমিকের পরে 2 সংখ্যার প্রবেশ করতে দেয়

অন্যান্য উত্তরগুলি কেবল 8 টি সংখ্যা গ্রহণ করছে