Здравствуйте, Blazkowicz, Вы писали:

B>Здравствуйте, эйчЪ, Вы писали:

полностью согласен ., правда я вот нашол пример работы с Double может поможет :

import SubMacroUtils.FormatBigDecimal;
import javax.swing.AbstractAction;
import javax.swing.DefaultCellEditor;
import javax.swing.JFormattedTextField;
import javax.swing.JOptionPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.KeyStroke;
import javax.swing.SwingUtilities;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.awt.Component;
import java.awt.Toolkit;
import java.text.NumberFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import javax.swing.text.DefaultFormatterFactory;
import javax.swing.text.NumberFormatter;
 
/**
 * Implements a cell editor that uses a formatted text field
 * to edit Double values.
 */
public class CellDoubleEditor extends DefaultCellEditor {
  JFormattedTextField ftf;
  DecimalFormat DoubleFormat;
  private Double minimum, maximum, decimals;
  private boolean DEBUG = false;
  
  public CellDoubleEditor(double min, double max, int dec) {
    super(new JFormattedTextField());
    ftf = (JFormattedTextField)getComponent();
    minimum = new Double(min);
    maximum = new Double(max);
    decimals = new Double(dec);
    
    DoubleFormat = (DecimalFormat) NumberFormat.getNumberInstance();
    DoubleFormat.setDecimalSeparatorAlwaysShown(true);
    DoubleFormat.setMinimumFractionDigits(dec);
    NumberFormatter doubleFormatter = new NumberFormatter(DoubleFormat);
    doubleFormatter.setFormat(DoubleFormat);
    doubleFormatter.setMinimum(minimum);
    doubleFormatter.setMaximum(maximum);
    
    ftf.setFormatterFactory(new DefaultFormatterFactory(doubleFormatter));
    ftf.setValue(minimum);
    ftf.setHorizontalAlignment(JTextField.TRAILING);
    ftf.setFocusLostBehavior(JFormattedTextField.PERSIST);
    
    //React when the user presses Enter while the editor is
    //active.  (Tab is handled as specified by
    //JFormattedTextField's focusLostBehavior property.)
    ftf.getInputMap().put(KeyStroke.getKeyStroke(
      KeyEvent.VK_ENTER, 0),
      "check");
    ftf.getActionMap().put("check", new AbstractAction() {
      public void actionPerformed(ActionEvent e) {
        if (!ftf.isEditValid()) { //The text is invalid.
          if (userSaysRevert()) { //reverted
            ftf.postActionEvent(); //inform the editor
          }
        } else try {              //The text is valid,
          ftf.commitEdit();     //so use it.
          ftf.postActionEvent(); //stop editing
        } catch (java.text.ParseException exc) { }
      }
    });
  }
  
  //Override to invoke setValue on the formatted text field.
  public Component getTableCellEditorComponent(JTable table,
    Object value, boolean isSelected,
    int row, int column) {
    JFormattedTextField ftf =
      (JFormattedTextField)super.getTableCellEditorComponent(
      table, value, isSelected, row, column);
    if (!Geral.StrEmpty(value.toString()))
      ftf.setValue(value);
    return ftf;
  }
  
  //Override to ensure that the value remains an Double.
  public Object getCellEditorValue() {
    JFormattedTextField ftf = (JFormattedTextField)getComponent();
    Object o = ftf.getValue();
    if (o instanceof Double) {
      return o;
    } else if (o instanceof Integer) {
      return new Double(((Integer)o).doubleValue());
    } else if (o instanceof Number) {
      return new Double(((Number)o).doubleValue());
    } else {
      if (DEBUG) {
        System.out.println("getCellEditorValue: o isn't a Number");
      }
      try {
        return DoubleFormat.parseObject(o.toString());
      } catch (ParseException exc) {
        System.err.println("getCellEditorValue: can't parse o: " + o);
        return null;
      }
    }
  }
  
  //Override to check whether the edit is valid,
  //setting the value if it is and complaining if
  //it isn't.  If it's OK for the editor to go
  //away, we need to invoke the superclass's version
  //of this method so that everything gets cleaned up.
  public boolean stopCellEditing() {
    JFormattedTextField ftf = (JFormattedTextField)getComponent();
    if (ftf.isEditValid()) {
      try {
        ftf.commitEdit();
      } catch (java.text.ParseException exc) { }
      
    } else { //text is invalid
      if (!userSaysRevert()) { //user wants to edit
        return false; //don't let the editor go away
      }
    }
    return super.stopCellEditing();
  }
  
  /**
   * Lets the user know that the text they entered is
   * bad. Returns true if the user elects to revert to
   * the last good value.  Otherwise, returns false,
   * indicating that the user wants to continue editing.
   */
  protected boolean userSaysRevert() {
    Toolkit.getDefaultToolkit().beep();
    ftf.selectAll();
    Object[] options = {"Corrigir","Reverter"};
    int answer = JOptionPane.showOptionDialog(
      SwingUtilities.getWindowAncestor(ftf),
      "O valor deve estar entre "
      + minimum + " e "
      + maximum + ".\n"
      + "Você pode corrigir "
      + "ou reverter para o último valor válido.",
      "Valor inválido digitado",
      JOptionPane.YES_NO_OPTION,
      JOptionPane.ERROR_MESSAGE,
      null,
      options,
      options[1]);
    
    if (answer == 1) { //Revert!
      ftf.setValue(ftf.getValue());
      return true;
    }
    return false;
  }
}

С уважением, JITM!