JXDatePicker à l'aide de SimpleDateFormat au format jj.MM.aa à jj.MM.aaaa avec le siècle en cours

Final (je l'espère 🙂

Résumé de la première édition:

• DatePickerFormatter déjà met en œuvre une stratégie de recherche (ou CompoundFormat, comme suggéré par @Robin)
• la recherche de séquence pour l'analyse est configurable par le client code
• l'idée est d'essayer d'analyser en commençant par la première (en général, le "plus long"), si cela échoue, essayez la prochaine (généralement "pas-si-long") et ainsi de suite jusqu'a réussi ou un parseException est jeté
• pour l'année de l'analyse, SimpleDateFormat a des règles qui sont en conflit avec que plus recherche premier: il exige que "yy" est essayé avant "aaaa"
• de le faire dans le datePicker a des effets pervers de la de la affiche toujours la date avec l'année court format

La raison en est DatePickerFormatter: il ne permet pas de spécifier la mise en forme format (utilise simplement la première). Le moyen de sortir est une coutume DatePickerFormatter, qui le supporte (dans l'extrait, c'est codé en dur à utiliser la deuxième):

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

Pas entièrement sûr si nous devons soutenir la configuration du formateur dans la classe de base. Le DatePickerFormatter est un peu étrange bête, ne s'étendant pas InternalFormatter et avec le processus de recherche d'être un peu en concurrence avec un FormatterFactory...

Original

Ce n'est pas exactement le datePicker qui s'occupe de ça, c'est la mise en forme de base (D1e déjà noté). Aucun défaut format/ter/s en charge deux formats en même temps: à voir, à essayer d'atteindre votre objectif avec un JFormattedTextField 🙂

La façon dont pourrait être un FormatterFactory: il permet d'utiliser des formats différents, selon le contexte: afficher et modifier ce dernier est utilisé lorsque le champ est concentré, l'ancien, à tous les autres moments. Comme le sélecteur de l'éditeur est un JFormattedTextField, vous pouvez le configurer directement (au lieu d'utiliser le setFormats méthodes)

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

Modifier

se cogner la tête après la lecture de Robin récente de réponse (+1!) - enfin, embarassingly après des années et des années, je comprends ce que SwingX' DatePickerFormatter est en train de faire: c'est à l'appui d'une chaîne de recherche de formateurs (du plus long au plus court), la plus longue utilisée après avoir commis le plus court pour faciliter la saisie par les utilisateurs.

Malheureusement cela ne fonctionne pas comme intuitivement attendu. Étant donné une séquence de formats, plus long au plus court (et correctement configuré pour le siècle):

"yyyy", "yy"

et compte tenu de l'entrée

"10"

se sent comme de passer de la première à la seconde, soit

 2010

mais n'est-ce pas. Comme l'a documenté (qui lit la documentation ... paresseux moi, toux ...) dans SimpleDateFormat

Année: [ ... ] Pour l'analyse, si le numéro de modèle de lettres de plus de 2, l'année est interprété littéralement, quel que soit le nombre de chiffres. Donc, en utilisant le format "MM/dd/yyyy", "01/11/12" analyse de Jan 11, 12 A. D.

À la fin de la journée - comme DatePickerFormatter tente de soutenir cette recherche, mais n'est pas efficace, cela pourrait être considéré comme un SwingX problème, après tout 🙂

OriginalL'auteur kleopatra

kleopatra déjà expliqué sur la façon de définir un Format sur le sélecteur de date. Pour ce cas d'utilisation, je voudrais appliquer une combinaison d'un CompositeFormat et ParseAllFormat au lieu d'avoir un format distinct pour l'édition et le mode régulier pour éviter la modification de la String lorsque vous commencez à modifier (comme vous l'avez déjà remarqué).

Composite format

Le composite format, comme son nom l'indique, est un composite de mise en œuvre de la Format classe, mais seulement pour l'analyse. Pour la mise en forme, il utilise un Format. Cela permet à l'utilisateur d'entrer sa date dans de nombreuses formes, alors qu'il est mis en forme de façon constante en utilisant un format spécifique pour le format.

Vous pouvez obtenir ce comportement, ainsi que par l'écriture d'un plus sophistiqué Format. Mais dans ce cas, il est plus facile d'utiliser la mise en forme/analyse des fonctionnalités proposées par les SimpleDateFormat classe du JDK.

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

Généralement une entrée de l'utilisateur que vous souhaitez que l'ensemble de la saisie de l'utilisateur peut être formaté/analysé afin d'éviter que l'utilisateur peut entrer une Chaîne de caractères qui est à moitié correct. Le ParseAllFormat est un décorateur pour une Format qui jette ParseExceptions lorsque seulement une partie de la String peut être analysé.

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

La combinaison de ces deux classes permet le code suivant

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

résultant dans la sortie suivante

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

Remarque qu'il y a un petit bonhomme pour lequel je n'ai pas trouvé une bonne solution. L'ordre dans lequel vous ajoutez Format instances de la CompositeFormat est aussi de l'ordre dans lequel ils sont évalués pour l'analyse. Dans ce cas, vous devez ajouter dans l'ordre correct, car même les new SimpleDateFormat( "dd.MM.yyyy" ) semble accepter la chaîne d'entrée 27.01.10 et peut analyser l'ensemble de la String à un Date objet équivalent à 27.01.0010.

OriginalL'auteur Robin