正如我已经解释过的那样，当用户在JXDatePicker中编辑日期时，他可以选择，天气他再次以相同的格式输入它，默认情况下是dd.MM.yyyy或者只是dd。 MM.yy.当他使用短形式时，我希望Picker选择当前的世纪。
示例：
27.01.2012 edited to 27.01.10 should result in 27.01.2010
以及：
27.01.2012 edited to 27.01.2010 should also result in 27.01.2010
默认情况下，JXDatePicker以下列方式处理它：
27.01.2012 edited to 27.01.10 results in 27.01.0010
这不是我希望它工作的方式。经过一些简短的研究后，我在SimpleDateFormat中找到了以下方法
/**
* Sets the 100-year period 2-digit years will be interpreted as being in
* to begin on the date the user specifies.
*
* @param startDate During parsing, two digit years will be placed in the range
* <code>startDate</code> to <code>startDate + 100 years</code>.
*/
public void set2DigitYearStart(Date startDate)
在第一个视图中，这听起来就像我需要的那样。所以我测试了它，不幸的是它没有像我希望的那样工作。这是因为我想使用dd.MM.yyyy作为格式来显示日期，并希望它在editmode中显示。例如，当用户点击像27.01.2012这样的日期时，我也希望它在editmode中也是如此，而不仅仅是简短形式：27.01.12。
我现在的问题是，当我选择在editmode中使用shortform时，set2DigitYearStart（Date）不幸地起作用。我做了一个小例子来展示这种情况（需要SwingX库，因为jxdatepicker，可以找到here）。
public class DatePickerExample extends JPanel
{
static JFrame frame;
public DatePickerExample()
{
JXDatePicker picker = new JXDatePicker();
JTextField field = new JTextField( 10 );
add( field );
add( picker );
final Calendar instance = Calendar.getInstance();
instance.set( 2012, 01, 26 );
Date date = instance.getTime();
picker.setDate( date );
// SimpleDateFormat format = new SimpleDateFormat( "dd.MM.yy" );//Works, but I wonna display and edit it with dd.MM.yyyy
SimpleDateFormat format = new SimpleDateFormat( "dd.MM.yyyy" );
final Date startDate = new Date( 0 );//01.01.1970
format.set2DigitYearStart( startDate );
picker.setFormats( format );
}
public static void main( String[] args )
{
frame = new JFrame();
frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
frame.setBounds( 400, 400, 400, 400 );
frame.setLayout( new BorderLayout() );
frame.add( new DatePickerExample() );
frame.setVisible( true );
}
}
任何人都有相同的要求，可以告诉我如何使这项工作？欢迎任何想法。非常感谢你提前。 ymene
答案 0 :(得分：5)
最终（希望如此:)
第一次编辑摘要：
原因是DatePickerFormatter：它不允许指定格式化格式（只使用第一种格式）。出路是一个自定义的DatePickerFormatter，它支持它（在代码片段中，硬编码使用第二个）：
SimpleDateFormat longFormat = new SimpleDateFormat( "dd.MM.yyyy" );
SimpleDateFormat shortFormat = new SimpleDateFormat( "dd.MM.yy" );
Date startDate = new Date( 0 );//01.01.1970
shortFormat.set2DigitYearStart( startDate );
DatePickerFormatter formatter = new DatePickerFormatter(
// invers sequence for parsing to satisfy the year parsing rules
new DateFormat[] {shortFormat, longFormat}) {
@Override
public String valueToString(Object value) throws ParseException {
if (value == null) return null;
return getFormats()[1].format(value);
}
} ;
DefaultFormatterFactory factory = new DefaultFormatterFactory(formatter );
picker.getEditor().setFormatterFactory(factory);
不完全确定我们是否应该支持在基类中配置格式化程序。 DatePickerFormatter是一个有点奇怪的野兽，没有扩展InternalFormatter，并且查找过程与FormatterFactory有点竞争......
<强>原始
不正是datePicker以这种方式处理它，它是核心格式（正如D1e已经指出的那样）。默认格式/ ter / s都不支持同时使用两种格式：要查看，尝试使用核心JFormattedTextField实现目标： - ）
出路可能是FormatterFactory：它允许使用不同的格式，具体取决于上下文：显示和编辑 - 后者在场聚焦时使用，前者在所有其他时间使用。由于选择器的编辑器是一个JFormattedTextField，你可以直接配置它（而不是使用setFormats方法）
SimpleDateFormat format = new SimpleDateFormat( "dd.MM.yyyy" );
SimpleDateFormat editFormat = new SimpleDateFormat( "dd.MM.yy" );
final Date startDate = new Date( 0 );//01.01.1970
instance.setTime(startDate);
editFormat.set2DigitYearStart( instance.getTime() );
DefaultFormatterFactory factory = new DefaultFormatterFactory(
new DatePickerFormatter(new DateFormat[] {format}),
new DatePickerFormatter(new DateFormat[] {format}),
new DatePickerFormatter(new DateFormat[] {editFormat})
);
picker.getEditor().setFormatterFactory(factory);
修改
在阅读了Robin最近的回答（+1！）之后敲头敲门 - 最后，经过多年和多年的尴尬，我明白了SwingX'DatePickerFormatter正在尝试做什么：那就是支持格式化程序的查找链（从更长到更短） ），提交后使用时间最长，用户可以轻松打字。不幸的是，这并不像预期的那样直观。给定一系列格式，从长到短（并适当配置到世纪）：
"yyyy", "yy"
并给出输入
"10"
感觉就像从第一个传递到第二个，导致
2010
但不是。正如在SimpleDateFormat
中记录的那样（谁读了文档......懒惰我，咳嗽......）年份：[...]对于解析，如果模式字母的数量大于2，则无论数字位数如何，都将按字面解释年份。所以使用“MM / dd / yyyy”模式，“01/11/12”解析到公元12年1月11日
在一天结束时 - 由于DatePickerFormatter尝试支持该查找但不成功 - 毕竟这可能被认为是一个SwingX问题： - ）
答案 1 :(得分：2)
我并不是特别了解JXDatePicker，但如果要模拟的具体功能是：用户输入27.01.2010和27.01.10独立应该导致27.01.2010
然后这将有效：
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Main {
public static void main(String[] args) throws ParseException {
String inputLiteralDateYY = "27.01.10"; //Also works with "27.01.97"
String inputLiteralDateYYYY = "27.01.2010"; //Also works with "27.01.1997"
DateFormat dfYYYY = new SimpleDateFormat("dd.MM.yyyy");
DateFormat dfYY = new SimpleDateFormat("dd.MM.yy");
Date dateFromYY = dfYY.parse(inputLiteralDateYY);
Date dateFromYYYY = dfYY.parse(inputLiteralDateYYYY);
String outputLiteralDateFromYY = dfYYYY.format(dateFromYY);
String outputLiteralDateFromYYYY = dfYYYY.format(dateFromYYYY);
System.out.println(outputLiteralDateFromYY);
System.out.println(outputLiteralDateFromYYYY);
}
}
事情首先用“dd.MM.yy”模式解析输入，然后用“dd.MM.yyyy”模式返回格式。
希望这有助于或帮助将其应用到您的方案中。
答案 2 :(得分：1)
kleopatra已经解释了如何在日期选择器上设置Format。对于此用例，我会应用CompositeFormat和ParseAllFormat的组合，而不是使用单独的格式进行编辑和常规模式，以避免在开始编辑时更改String（如你已经注意到了。）
复合格式
复合格式，顾名思义，是Format类的composite implementation，但仅用于解析。对于格式设置，它使用一个Format。这允许用户以多种形式输入他/她的日期，同时使用一种特定格式进行格式化。
您也可以通过编写一个更复杂的Format来获得此行为。但在这种情况下，更容易使用JDK的SimpleDateFormat类提供的格式化/解析功能。
import java.text.FieldPosition;
import java.text.Format;
import java.text.ParsePosition;
import java.util.ArrayList;
import java.util.List;
/**
* <p>Composite form of {@link java.text.Format Format}. It uses multiple formats for parsing, and
* only one format for formatting.</p>
*
* <p>A possible use-case is the formatting of user input (e.g. in a {@code JFormattedTextField}).
* Multiple formats for parsing allows accepting multiple forms of user input without having to
* write a complicated format.</p>
*/
public class CompositeFormat extends Format {
private List<Format> fFormats = new ArrayList<>();
private Format fFormattingFormat;
/**
* Create a new
*/
public CompositeFormat() {
}
/**
* Add a format to this composite format
*
* @param aFormat The format to add
*/
public void addFormat( Format aFormat ) {
assertNotNull( aFormat, "You cannot add a null Format" );
if ( !( fFormats.contains( aFormat ) ) ) {
fFormats.add( aFormat );
}
}
/**
* Remove a format from this composite format
*
* @param aFormat The format to remove
*/
public void removeFormat( Format aFormat ) {
assertNotNull( aFormat, "You cannot remove a null Format" );
fFormats.remove( aFormat );
updateFormattingFormat();
}
/**
* Sets <code>aFormat</code> as the format which will be used for formatting the
* objects. The format will also be added to the list of available formats.
* @param aFormat The format which will be used for formatting
*/
public void setFormattingFormat( Format aFormat ){
assertNotNull( aFormat, "Formatting format may not be null" );
addFormat( aFormat );
fFormattingFormat = aFormat;
}
private void assertNotNull( Object aObjectToCheck, String aMessage ) {
if ( aObjectToCheck == null ) {
throw new NullPointerException( aMessage );
}
}
private void updateFormattingFormat(){
if ( !( fFormats.contains( fFormattingFormat ) ) ){
fFormattingFormat = null;
if ( !( fFormats.isEmpty() ) ){
fFormattingFormat = fFormats.iterator().next();
}
}
}
@Override
public StringBuffer format( Object obj, StringBuffer toAppendTo, FieldPosition pos ) {
assertNotNull( fFormattingFormat, "Set a formatting format before using this format" );
return fFormattingFormat.format( obj, toAppendTo, pos );
}
@Override
public Object parseObject( String source, ParsePosition pos ) {
if ( fFormats.isEmpty() ){
throw new UnsupportedOperationException( "Add at least one format before using this composite format" );
}
Format formatToUse = fFormats.iterator().next();
int maxIndex = pos.getIndex();
for ( Format format : fFormats ) {
ParsePosition tempPos = new ParsePosition( pos.getIndex() );
tempPos.setErrorIndex( pos.getErrorIndex() );
format.parseObject( source, tempPos );
if ( tempPos.getIndex() > maxIndex ){
maxIndex = tempPos.getIndex();
formatToUse = format;
if( maxIndex == source.length() ){
//found a format which parses the whole string
break;
}
}
}
return formatToUse.parseObject( source, pos );
}
}
<强> ParseAllFormat
通常，对于用户输入，您希望可以格式化/解析整个用户输入，以避免用户输入半正确的字符串。对于常规ParseAllFormat，Format是decorator，只有ParseException的一部分可以被解析时，String会抛出import java.text.AttributedCharacterIterator;
import java.text.FieldPosition;
import java.text.Format;
import java.text.ParseException;
import java.text.ParsePosition;
/**
* <p>Decorator for a {@link Format Format} which only accepts values which can be completely parsed
* by the delegate format. If the value can only be partially parsed, the decorator will refuse to
* parse the value.</p>
*/
public class ParseAllFormat extends Format {
private final Format fDelegate;
/**
* Decorate <code>aDelegate</code> to make sure if parser everything or nothing
*
* @param aDelegate The delegate format
*/
public ParseAllFormat( Format aDelegate ) {
fDelegate = aDelegate;
}
@Override
public StringBuffer format( Object obj, StringBuffer toAppendTo, FieldPosition pos ) {
return fDelegate.format( obj, toAppendTo, pos );
}
@Override
public AttributedCharacterIterator formatToCharacterIterator( Object obj ) {
return fDelegate.formatToCharacterIterator( obj );
}
@Override
public Object parseObject( String source, ParsePosition pos ) {
int initialIndex = pos.getIndex();
Object result = fDelegate.parseObject( source, pos );
if ( result != null && pos.getIndex() < source.length() ) {
int errorIndex = pos.getIndex();
pos.setIndex( initialIndex );
pos.setErrorIndex( errorIndex );
return null;
}
return result;
}
@Override
public Object parseObject( String source ) throws ParseException {
//no need to delegate the call, super will call the parseObject( source, pos ) method
return super.parseObject( source );
}
}
。
import java.text.Format;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class FormattingDemo {
private static Format createCompositeDateFormat(){
Format formattingFormat = new ParseAllFormat( new SimpleDateFormat( "dd.MM.yyyy" ) );
SimpleDateFormat shortFormat = new SimpleDateFormat( "dd.MM.yy" );
Format otherFormat = new ParseAllFormat( shortFormat );
CompositeFormat compositeFormat = new CompositeFormat();
compositeFormat.addFormat( otherFormat );
compositeFormat.addFormat( formattingFormat );
compositeFormat.setFormattingFormat( formattingFormat );
return compositeFormat;
}
public static void main( String[] args ) throws ParseException {
Format dateFormat = createCompositeDateFormat();
System.out.println( dateFormat.parseObject( "27.01.2010" ) );
System.out.println( dateFormat.parseObject( "27.01.10" ) );
System.out.println( dateFormat.parseObject( "27.01.2012" ) );
System.out.println(dateFormat.format( dateFormat.parseObject( "27.01.2010" ) ));
System.out.println(dateFormat.format( dateFormat.parseObject( "27.01.10" ) ));
System.out.println(dateFormat.format( dateFormat.parseObject( "27.01.2012" ) ));
}
}
这两个类的组合允许以下代码
Wed Jan 27 00:00:00 CET 2010
Wed Jan 27 00:00:00 CET 2010
Fri Jan 27 00:00:00 CET 2012
27.01.2010
27.01.2010
27.01.2012
产生以下输出
Format请注意，我找不到合适的解决方案。将CompositeFormat个实例添加到new SimpleDateFormat( "dd.MM.yyyy" )的顺序也是评估它们进行解析的顺序。在这种情况下，您需要以正确的顺序添加它们，因为即使27.01.10似乎接受输入字符串String并且可以将整个Date解析为等效的27.01.0010对象到{{1}}。