Java Jtable Number编辑器，带“，”&引用；分隔符而不是“分隔符”&引用；

我是法国人，对爪哇并不陌生。 在法语中，双打有“，”分隔符而不是“.”。因此，我有一个列class=Double的JTable单元格，当我输入例如2.4时，它是Ok的。但当我输入2,4时，它会阻塞

我使用了

Locale.setDefault（Locale.FRENCH）但我得到了相同的结果：


如下图所示，我的应用程序以法语语言环境开始：
有没有办法输入2,4而不是2.4

诚恳。
我建议您使用实现自定义数据模型，然后在方法内部使用如下：

NumberFormat.getInstance(Locale.FRENCH).format(2.4);

如果您的应用程序只供法国用户使用，则可以将默认语言环境硬编码为法语

Locale.setDefault( Locale.FRENCH );

有没有办法输入2,4而不是2.4

嗯，有几个问题

默认渲染器将显示“.”而不是“，”
默认编辑器将显示“.”，而不是“，”
当您尝试将值保存到TableModel时，默认编辑器不会将“，”识别为Double的有效字符
当您离开单元格时，输入的字符串必须转换为
Double
。但是，即使使用法语区域设置，
Double.parseDouble（…）
方法也无法识别“，”

默认的单元格编辑器意识到字符串无法正确转换，因此单元格用红色边框突出显示，以指示无效值

下面的解决方案使用自定义编辑器在将字符串解析为双精度之前在内部处理“，”到“.”的转换。它还会将“.”转换为“，”，以便在编辑器中正确显示该值

import java.awt.*;
import java.text.*;
import java.util.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.table.*;

public class LocaleEditor extends DefaultCellEditor
{
    private Object value;

    public LocaleEditor()
    {
        super( new JTextField() );
        ((JTextField)getComponent()).setHorizontalAlignment(JTextField.RIGHT);
    }

    @Override
    public Object getCellEditorValue()
    {
        return value;
    }

    @Override
    public boolean stopCellEditing()
    {
        try
        {
            String editingValue = (String)super.getCellEditorValue();

            //  Don't allow user to enter "."

            if (editingValue.contains("."))
            {
                JTextField textField = (JTextField)getComponent();
                textField.setBorder(new LineBorder(Color.red));
                return false;
            }

            // Replace local specific character

            int offset = editingValue.lastIndexOf(",");

            if (offset != -1)
            {
                StringBuilder sb = new StringBuilder(editingValue);
                sb.setCharAt(offset, '.');
                editingValue = sb.toString();
            }

            value = Double.parseDouble( editingValue );
        }
        catch(NumberFormatException exception)
        {
            JTextField textField = (JTextField)getComponent();
            textField.setBorder(new LineBorder(Color.red));
            return false;
        }

        return super.stopCellEditing();
    }

    @Override
    public Component getTableCellEditorComponent(
        JTable table, Object value, boolean isSelected, int row, int column)
    {
        Component c = super.getTableCellEditorComponent(table, value, isSelected, row, column);

        JTextField textField = (JTextField)c;
        textField.setBorder( new LineBorder(Color.BLACK) );

        String text = textField.getText();
        int offset = text.lastIndexOf(".");

        // Display local specific character

        if (offset != -1)
        {
            StringBuilder sb = new StringBuilder(text);
            sb.setCharAt(offset, ',');
            textField.setText( sb.toString() );
        }

        return c;
    }

    private static void createAndShowUI()
    {
        String[] columnNames = {"String", "Double", "Boolean"};

        Object[][] data =
        {
            {"A", new Double(1), Boolean.TRUE },
            {"B", new Double(2.25), Boolean.FALSE},
            {"C", new Double(12.34), Boolean.TRUE },
            {"D", new Double(1234.56), Boolean.FALSE}
        };

        DefaultTableModel model = new DefaultTableModel(data, columnNames)
        {
            //  Returning the Class of each column will allow different
            //  renderers and editors to be used based on Class

            public Class getColumnClass(int column)
            {
                for (int row = 0; row < getRowCount(); row++)
                {
                    Object o = getValueAt(row, column);

                    if (o != null)
                        return o.getClass();
                }

                return Object.class;
            }
        };

        JTable table = new JTable(model);
        table.setRowHeight(20);

        table.setPreferredScrollableViewportSize(table.getPreferredSize());
        JScrollPane scrollPane = new JScrollPane( table );
        scrollPane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);

        //  Use a custom renderer and editor

        NumberFormat nf = NumberFormat.getInstance(Locale.FRENCH);
        nf.setMinimumFractionDigits(2);
        TableCellRenderer renderer = new NumberRenderer( nf );
        table.setDefaultRenderer(Double.class, renderer);
        TableCellEditor fce = new LocaleEditor();
        table.setDefaultEditor(Double.class, fce);

        JFrame frame = new JFrame("Table Five Character Editor");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add( scrollPane );
        frame.pack();
        frame.setLocationByPlatform( true );
        frame.setVisible( true );
    }

    public static void main(String[] args)
    {
        EventQueue.invokeLater(new Runnable()
        {
            public void run()
            {
                createAndShowUI();
            }
        });
    }
}

import java.awt.*；
导入java.text.*；
导入java.util.*；
导入javax.swing.*；
导入javax.swing.border.*；
导入javax.swing.table.*；
公共类LocalEditor扩展了DefaultCellEditor
{
私人客体价值；
公共LocaleEditor（）
{
super（新JTextField（））；
（（JTextField）getComponent（））.setHorizontalAlignment（JTextField.RIGHT）；
}
@凌驾
公共对象getCellEditorValue（）
{
返回值；
}
@凌驾
公共布尔stopCellEditing（）
{
尝试
{
String editingValue=（String）super.getCellEditorValue（）；
//不允许用户输入“”
if（editingValue.contains（“.”）
{
JTextField textField=（JTextField）getComponent（）；
textField.setboorder（新行边框（颜色为红色））；
返回false；
}
//替换本地特定字符
int offset=editingValue.lastIndexOf（“，”）；
如果（偏移量！=-1）
{
StringBuilder sb=新StringBuilder（编辑值）；
sb.setCharAt（偏移量“.”）；
editingValue=sb.toString（）；
}
value=Double.parseDouble（编辑值）；
}
捕获（NumberFormatException异常）
{
JTextField textField=（JTextField）getComponent（）；
textField.setboorder（新行边框（颜色为红色））；
返回false；
}
返回super.stopCellEditing（）；
}
@凌驾
公共组件getTableCellEditorComponent(
JTable表，对象值，布尔值（选定，int行，int列）
{
组件c=super.getTableCellEditorComponent（表、值、isSelected、行、列）；
JTextField textField=（JTextField）c；
textField.setboorder（新行边框（颜色.黑色））；
String text=textField.getText（）；
int offset=text.lastIndexOf（“.”）；
//显示本地特定字符
如果（偏移量！=-1）
{
StringBuilder sb=新的StringBuilder（文本）；
sb.setCharAt（偏移量，，）；
setText（sb.toString（））；
}
返回c；
}
私有静态void createAndShowUI（）
{
String[]columnNames={“String”、“Double”、“Boolean”}；
对象[][]数据=
{
{“A”，新的双精度（1），Boolean.TRUE}，
{“B”，新的双精度（2.25），布尔值.FALSE}，
{“C”，新的双精度（12.34），Boolean.TRUE}，
{“D”，新的双精度（1234.56），布尔值.FALSE}
};
DefaultTableModel=新的DefaultTableModel（数据、列名）
{
//返回每个列的类将允许不同的
//基于类使用的渲染器和编辑器
公共类getColumnClass（int列）
{
对于（int row=0；row