Hi, Well, if you look at the code, you'll see that's what I've done : I used some of the already available comparators in the commons (Null, Bean and ComparatorChain) and arranged them in the way I described.
So, there's no big difference between what you say and what I did. I just wrote a Comparator instead and did it in a class, cause hey, that's OOP :). Thanks. Baptiste -------- Message d'origine-------- De: James Carman [mailto:[EMAIL PROTECTED] Date: ven. 17/03/2006 04:56 À: 'Jakarta Commons Users List' Objet : RE: [collections] [beanutils] Multi property BeanComparator What about using a "chained" comparator? Wouldn't that do what you want? Yes, it's not fun to set up, but you could create a helper method... public void sort( List beans, String[] properties ) { // Create a bean comparator for each property. // Create a chained comparator from the bean comparators. // Sort the list ... } -----Original Message----- From: Stephen Colebourne [mailto:[EMAIL PROTECTED] Sent: Thursday, March 16, 2006 7:06 PM To: Jakarta Commons Users List Subject: Re: [collections] [beanutils] Multi property BeanComparator This is an interesting idea, to group multiple property comparisons in one. It no longer fits in [collections] however as the bean code from collections has moved to [beanutils] in their bean-collections jar. The problem with beanutils is that it is not well maintained at the moment. I recommend that you raise a bugzilla enhancement request for beanutils and attach your code as a patch. That way the idea can be looked at when someone has a chance. Stephen MATHUS Baptiste wrote: > Hi everybody, > > I recently needed to be able to sort a list of beans on many properties. So I thought I would try and pick one of the collections comparators. > > I had to to the sorting close to the sql way : be able to sort on n properties, some ascending, some descending. > > I haven't found what I'm looking for (:p), but I found some comparators I used to do this : I used BeanComparator, NullComparator and ComparatorChain to create a class : MultiPropertyBeanComparator. > > Is there already something in one of the commons package that could be used instead of it ? > > If not, I'd be glad to contribute the small piece of code if wanted. It has dependencies against commons-beanutils (BeanComparator, which is moving from one package to another at the moment, no ?) and commons-lang (StringUtils.isBlank()). I think some things might not satisfactory for everybody, but hey, could still be improved without problems, that's not big work :p. > > Here it is : > > ======================================= > import java.io.Serializable; > import java.util.ArrayList; > import java.util.Comparator; > import java.util.List; > > import org.apache.commons.beanutils.BeanComparator; > import org.apache.commons.collections.ComparatorUtils; > import org.apache.commons.collections.comparators.NullComparator; > import org.apache.commons.collections.comparators.ReverseComparator; > import org.apache.commons.lang.StringUtils; > > /** > * This comparator lets you sort a list using a list of properties. You can specify ascending or > * descending order on these properties. > * <p> > * For example, if you want to sort with natural order a list of beans with properties firstname, > * nickname and address, sorting the firstname descending, you can do it this way: > * </p> > * <code>List l = ...</code> > * <code>...</code> > * <code>MultiPropertyBeanComparator multiPropBeanComp = new MultiPropertyBeanComparator();</code> > * <code>multiPropBeanComp.append("firstname", true).append("nickname").append("address");</code> > * <code>Collections.sort(l,multiPropBeanComp);</code> > * > * @author Baptiste MATHUS > */ > public class MultiPropertyBeanComparator implements Comparator, Serializable > { > private static final long serialVersionUID = -1431852774261001458L; > > private List comparatorList = new ArrayList(); > > /** > * Use this method to add a comparator to the list. > * > * @param property > * the property on which to apply the given comparator. > * @param comparator > * the comparator to be added. If null, natural order will be used. > * @param reverse > * <p> > * must be true if the given comparator must be used in opposite order to sort. For > * example, if the comparator is designed to sort in ascending order, put this > * parameter to <code>true</code> if you want descending order. > * </p> > * <p> > * If the comparator is null, then the reversed natural order is used. > * </p> > */ > public MultiPropertyBeanComparator append(String property, Comparator comparator, > boolean reverse) > { > if (StringUtils.isBlank(property)) > { > throw new IllegalArgumentException("The given property is blank"); > } > > // If the comparator is null, then compare only on the given property > // with a natural sort. > if (comparator == null) > { > comparator = new BeanComparator(property, new NullComparator(false)); > } > // Else : compare on the property, but with given comparator. > else > { > comparator = new BeanComparator(property, comparator); > } > // Here, the comparator cannot be null anymore, so reverse it if > // necessary. > if (reverse) > { > comparator = new ReverseComparator(comparator); > } > > comparatorList.add(comparator); > > return this; > } > > public MultiPropertyBeanComparator append(String property, Comparator c) > { > return append(property, c, false); > } > > public MultiPropertyBeanComparator append(String property) > { > return append(property, null, false); > } > > public MultiPropertyBeanComparator append(String property, boolean reverse) > { > return append(property, null, reverse); > } > > /** > * Use this method to clear the > */ > public void clear() > { > comparatorList.clear(); > } > > /** > * Considered to be equal when all properties and comparators equal. > * > * @see java.lang.Object#equals(java.lang.Object) > * @overrides > */ > public boolean equals(Object obj) > { > MultiPropertyBeanComparator comp = (MultiPropertyBeanComparator) obj; > > if (this.comparatorList.size() != comp.comparatorList.size()) > { > return false; > } > > for (int i = 0; i < comparatorList.size(); ++i) > { > if (!this.comparatorList.get(i).equals(comp.comparatorList.get(i))) > { > return false; > } > } > return true; > } > > /** > * @see Comparator#compare(T, T) > * @overrides > */ > public int compare(Object arg0, Object arg1) > { > return getComparator().compare(arg0, arg1); > } > > private Comparator getComparator() > { > return ComparatorUtils.chainedComparator(comparatorList); > } > } > ======================================= > > Thanks for the answers. > > Baptiste > --------------------------------------------------------------------- To unsubscribe, e-mail: [EMAIL PROTECTED] For additional commands, e-mail: [EMAIL PROTECTED] --------------------------------------------------------------------- To unsubscribe, e-mail: [EMAIL PROTECTED] For additional commands, e-mail: [EMAIL PROTECTED]
--------------------------------------------------------------------- To unsubscribe, e-mail: [EMAIL PROTECTED] For additional commands, e-mail: [EMAIL PROTECTED]
