import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Date;

public class FuckenEntity {

    private BigInteger account;
    private String clientName;
    private Date clientActivityDate;
    private String clientSubType;
    private BigDecimal clientBalance;

    public BigInteger getAccount() {
        return account;
    }

    public void setAccount(BigInteger account) {
        this.account = account;
    }

    public String getClientName() {
        return clientName;
    }

    public void setClientName(String clientName) {
        this.clientName = clientName;
    }

    public Date getClientActivityDate() {
        return clientActivityDate;
    }

    public void setClientActivityDate(Date clientActivityDate) {
        this.clientActivityDate = clientActivityDate;
    }

    public String getClientSubType() {
        return clientSubType;
    }

    public void setClientSubType(String clientSubType) {
        this.clientSubType = clientSubType;
    }

    public BigDecimal getClientBalance() {
        return clientBalance;
    }

    public void setClientBalance(BigDecimal clientBalance) {
        this.clientBalance = clientBalance;
    }
}

import org.apache.log4j.Logger;
import org.springframework.beans.factory.BeanNameAware;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import static java.lang.String.format;
import static java.lang.String.format;

public class FuckenEntityProcessor implements BeanNameAware {

    private static Logger logger = Logger.getLogger(FuckenEntityProcessor.class);

    /**
     *
     * @param FuckenEntitys - fucken collection to sort (out)
     * @param nField - number of field (Just like SELECT .... FROM ... ORDER by nField )
     * @param direction - direction of sorting like { ASC | DESC }
     */
    public static void sort(List<FuckenEntity> FuckenEntitys, int nField, int direction) {
        if (direction == 0 || direction == 1) {
            if (FuckenEntitys != null && FuckenEntitys.size() > 0) {
                try {
                    if (nField == 0) {
                        Collections.sort(FuckenEntitys, new Comparator<FuckenEntity>() {
                            @Override
                            public int compare(FuckenEntity o1, FuckenEntity o2) {
                                if (o1.getAccount()==null && o2.getAccount()==null) return 0;
                                if (o1.getAccount()==null) return 1;
                                if (o2.getAccount()==null) return -1;
                                return o1.getAccount().compareTo(o2.getAccount());
                            }
                        });
                    } else if (nField == 1) {
                        Collections.sort(FuckenEntitys, new Comparator<FuckenEntity>() {
                            @Override
                            public int compare(FuckenEntity o1, FuckenEntity o2) {
                                if (o1.getClientName()==null && o2.getClientName()==null) return 0;
                                if (o1.getClientName()==null) return 1;
                                if (o2.getClientName()==null) return -1;
                                return o1.getClientName().compareTo(o2.getClientName());
                            }
                        });
                    } else if (nField == 2) {
                        Collections.sort(FuckenEntitys, new Comparator<FuckenEntity>() {
                            @Override
                            public int compare(FuckenEntity o1, FuckenEntity o2) {
                                if (o1.getClientActivityDate()==null && o2.getClientActivityDate()==null) return 0;
                                if (o1.getClientActivityDate()==null) return 1;
                                if (o2.getClientActivityDate()==null) return -1;
                                return o1.getClientActivityDate().compareTo(o2.getClientActivityDate());
                            }
                        });
                    } else if (nField == 3) {
                        Collections.sort(FuckenEntitys, new Comparator<FuckenEntity>() {
                            @Override
                            public int compare(FuckenEntity o1, FuckenEntity o2) {
                                if (o1.getClientSubType()==null && o2.getClientSubType()==null) return 0;
                                if (o1.getClientSubType()==null) return 1;
                                if (o2.getClientSubType()==null) return -1;
                                return o1.getClientSubType().compareTo(o2.getClientSubType());
                            }
                        });
                    } else if (nField == 4) {
                        Collections.sort(FuckenEntitys, new Comparator<FuckenEntity>() {
                            @Override
                            public int compare(FuckenEntity o1, FuckenEntity o2) {
                                if (o1.getClientBalance()==null && o2.getClientBalance()==null) return 0;
                                if (o1.getClientBalance()==null) return 1;
                                if (o2.getClientBalance()==null) return -1;
                                return o1.getClientBalance().compareTo(o2.getClientBalance());
                            }
                        });
                    }
                    if (direction==1) Collections.reverse(FuckenEntitys);
                } catch (Exception ex) {
                    logger.error(
                            format("Exception while sorting FuckenEntitys param = %d,dir = %d",
                                    nField, direction), ex
                    );
                }
            }
        }
    }

    ................
}