8 回答

• 6

  使用 TextWatcher ...

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

  回复于 2024-04-16T17:05:33+08:00
• 4

  TextWatcher 接口有3个回调方法，当文本发生更改时，这些方法按以下顺序调用：

  1 beforeTextChanged（CharSequence s，int start，int count，int after）

  ：调用 before 已将更改应用于文本 .
  s 参数为 the text before ，将应用任何更改 .
  start 参数是文本中已更改部分开头的 position .
  count 参数是自 start 位置以来 s 序列中已更改部件的 length .
  after 参数是 length of the new sequence ，它将 start 序列的部分从 start 替换为 start+count .
  您 TextView 来自此方法的 TextView 中的文本（通过使用 myTextView.setText(String newText) ） .

  2 onTextChanged（CharSequence s，int start，int before，int count）

  与 beforeTextChanged 方法类似但名为 after 的文本更改 .
  s 参数已应用 the text after 更改 .
  start 参数与 beforeTextChanged 方法中的参数相同 .
  count 参数是beforeTextChanged方法中的 after 参数 .
  before 参数是beforeTextChanged方法中的 count 参数 .
  您_158775_来自此方法的 TextView 中的文本（通过使用 myTextView.setText(String newText) ） .

  3 afterTextChanged（可编辑的s）

  您 TextView 中此方法的 TextView 中的文本 .
  /!\ Warning: 当您更改 TextView 中的文本时，将再次触发 TextWatcher ，开始无限循环 . 然后你应该添加像 boolean _ignore 属性，以防止无限循环 .
  例：

  new TextWatcher() {
          boolean _ignore = false; // indicates if the change was made by the TextWatcher itself.
  
          @Override
          public void afterTextChanged(Editable s) {
              if (_ignore)
                  return;
  
              _ignore = true; // prevent infinite loop
              // Change your text here.
              // myTextView.setText(myNewText);
              _ignore = false; // release, so the TextWatcher start to listen again.
          }
  
          // Other methods...
      }
  

  摘要：

  

  我的自定义监听器：

  就个人而言，我制作了自定义文本监听器，它为我提供了4个不同字符串的部分，对我来说，使用它更加直观 .

  /**
     * Text view listener which splits the update text event in four parts:
     * <ul>
     *     <li>The text placed <b>before</b> the updated part.</li>
     *     <li>The <b>old</b> text in the updated part.</li>
     *     <li>The <b>new</b> text in the updated part.</li>
     *     <li>The text placed <b>after</b> the updated part.</li>
     * </ul>
     * Created by Jeremy B.
     */
  
    public abstract class TextViewListener implements TextWatcher {
      /**
       * Unchanged sequence which is placed before the updated sequence.
       */
      private String _before;
  
      /**
       * Updated sequence before the update.
       */
      private String _old;
  
      /**
       * Updated sequence after the update.
       */
      private String _new;
  
      /**
       * Unchanged sequence which is placed after the updated sequence.
       */
      private String _after;
  
      /**
       * Indicates when changes are made from within the listener, should be omitted.
       */
      private boolean _ignore = false;
  
      @Override
      public void beforeTextChanged(CharSequence sequence, int start, int count, int after) {
          _before = sequence.subSequence(0,start).toString();
          _old = sequence.subSequence(start, start+count).toString();
          _after = sequence.subSequence(start+count, sequence.length()).toString();
      }
  
      @Override
      public void onTextChanged(CharSequence sequence, int start, int before, int count) {
          _new = sequence.subSequence(start, start+count).toString();
      }
  
      @Override
      public void afterTextChanged(Editable sequence) {
          if (_ignore)
              return;
  
          onTextChanged(_before, _old, _new, _after);
      }
  
      /**
       * Triggered method when the text in the text view has changed.
       * 
  
       * You can apply changes to the text view from this method
       * with the condition to call {@link #startUpdates()} before any update,
       * and to call {@link #endUpdates()} after them.
       *
       * @param before Unchanged part of the text placed before the updated part.
       * @param old Old updated part of the text.
       * @param aNew New updated part of the text?
       * @param after Unchanged part of the text placed after the updated part.
       */
      protected abstract void onTextChanged(String before, String old, String aNew, String after);
  
      /**
       * Call this method when you start to update the text view, so it stops listening to it and then prevent an infinite loop.
       * @see #endUpdates()
       */
      protected void startUpdates(){
          _ignore = true;
      }
  
      /**
       * Call this method when you finished to update the text view in order to restart to listen to it.
       * @see #startUpdates()
       */
      protected void endUpdates(){
          _ignore = false;
      }
    }
  

  例：

  myEditText.addTextChangedListener(new TextViewListener() {
          @Override
          protected void onTextChanged(String before, String old, String aNew, String after) {
             // intuitive usation of parametters
             String completeOldText = before + old + after;
             String completeNewText = before + aNew + after;
  
             // update TextView
              startUpdates(); // to prevent infinite loop.
              myEditText.setText(myNewText);
              endUpdates();
          }
  

  回复于 2024-04-16T17:05:33+08:00
• 66

  补充答案

  这是对其他答案的视觉补充 . 我对代码和解释的更全面的答案是here .

  • 红色：即将删除的文本（已替换）

  • 绿色：刚刚添加的文本（替换旧的红色文本）

  

  回复于 2024-04-16T17:05:33+08:00
• 5

  Using TextWatcher in Android

  这是一个示例代码 . 尝试使用TextView的 addTextChangedListener 方法

  addTextChangedListener(new TextWatcher() {
  
          BigDecimal previousValue;
          BigDecimal currentValue;
  
          @Override
          public void onTextChanged(CharSequence s, int start, int before, int
                  count) {
              if (isFirstTimeChange) {
                  return;
              }
              if (s.toString().length() > 0) {
                  try {
                      currentValue = new BigDecimal(s.toString().replace(".", "").replace(',', '.'));
                  } catch (Exception e) {
                      currentValue = new BigDecimal(0);
                  }
              }
          }
  
          @Override
          public void beforeTextChanged(CharSequence s, int start, int count,
                  int after) {
              if (isFirstTimeChange) {
                  return;
              }
              if (s.toString().length() > 0) {
                  try {
                      previousValue = new BigDecimal(s.toString().replace(".", "").replace(',', '.'));
                  } catch (Exception e) {
                      previousValue = new BigDecimal(0);
                  }
              }
          }
  
          @Override
          public void afterTextChanged(Editable editable) {
              if (isFirstTimeChange) {
                  isFirstTimeChange = false;
                  return;
              }
              if (currentValue != null && previousValue != null) {
                  if ((currentValue.compareTo(previousValue) > 0)) {
                      //setBackgroundResource(R.color.devises_overview_color_green);
                      setBackgroundColor(flashOnColor);
                  } else if ((currentValue.compareTo(previousValue) < 0)) {
                      //setBackgroundResource(R.color.devises_overview_color_red);
  
                      setBackgroundColor(flashOffColor);
                  } else {
                      //setBackgroundColor(textColor);
                  }
                  handler.removeCallbacks(runnable);
                  handler.postDelayed(runnable, 1000);
              }
          }
      });
  

  回复于 2024-04-16T17:05:33+08:00
• 150

  创建自定义TextWatcher子类：

  public class CustomWatcher implements TextWatcher {
  
      private boolean mWasEdited = false;
  
      @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) {
  
          if (mWasEdited){
  
              mWasEdited = false;
              return;
          }
  
          // get entered value (if required)
          String enteredValue  = s.toString();
  
          String newValue = "new value";
  
          // don't get trap into infinite loop
          mWasEdited = true;
          // just replace entered value with whatever you want
          s.replace(0, s.length(), newValue);
  
      }
  }
  

  为EditText设置监听器：

  mTargetEditText.addTextChangedListener(new CustomWatcher());
  

  回复于 2024-04-16T17:05:33+08:00
• 20

  解决方案的一个更大的视角：

  @Override
      public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
          View v = inflater.inflate(R.layout.yourlayout, container, false);
          View tv = v.findViewById(R.id.et1);
          ((TextView) tv).addTextChangedListener(new TextWatcher() {
              @Override
              public void onTextChanged(CharSequence s, int start, int before, int count) {
                   SpannableString contentText = new SpannableString(((TextView) tv).getText());
                   String contents = Html.toHtml(contentText).toString();
              }
  
              @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
              }
          });
          return v;
      }
  

  这对我有用，我第一次这样做 .

  回复于 2024-04-16T17:05:33+08:00
• -2

  public class Test extends AppCompatActivity {
  
      EditText firstEditText;
      EditText secondEditText;
  
      @Override
      protected void onCreate(@Nullable Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.test);
          firstEditText = (EditText)findViewById(R.id.firstEditText);
          secondEditText = (EditText)findViewById(R.id.secondEditText);
  
          firstEditText.addTextChangedListener(new EditTextListener());
  
      }
  
      private class EditTextListener implements 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) {
              secondEditText.setText(firstEditText.getText());
          }
  
          @Override
          public void afterTextChanged(Editable s) {
          }
      }
  }
  

  回复于 2024-04-16T17:05:33+08:00
• 0

  editext1.addTextChangedListener(new TextWatcher() {
  
     @Override
      public void onTextChanged(CharSequence s, int start, int before,
      int count) {
       editext2.setText(new String(s.toString()));
  
            }
  
     @Override
       public void beforeTextChanged(CharSequence s, int start, int count,
        int after) {
  
           editext2.setText(new String(s.toString()));
          }
  
        @Override
            public void afterTextChanged(Editable s) {
  
            editext2.setText(new String(s.toString()));
        }
  
           });
  

  如需更多参考，请点击此处http://androiddhina.blogspot.in/2015/05/android-textwatcher.html

  回复于 2024-04-16T17:05:33+08:00