My adventures as a "proper" programmer continue apace. Yesterday I created a custom class in Java that implements the Comparable interface and now feel quite smug about it. Probably undeservedly so.

I was writing a Domino-based reporting Agent in Java which need to loop a set of invoice documents for a given user and report back a sorted list of each unique billing addresses they'd supplied over the years, so that a data audit could take place.

Here's the use case code for the class:

ArrayList addresses = new ArrayList();

Document d = dc.getFirstDocument();
    
while (null!=d){
    BillingAddress address = new BillingAddress();
                        
    address.setAddress("AddressLine1");
    address.setTown(d.getItemValueString("AddressTown"));
    address.setCounty(d.getItemValueString("AddressCounty"));
    address.setPostCode(d.getItemValueString("AddressPostCode"));
              
    //Make sure the address is isn't in the array.          
    if(!addresses.contains(address)){
        addresses.add(address);
    }
                        
    d = dc.getNextDocument(d);
}

//Sort our addresses before output
Collections.sort(addresses);

//For each address convert to HTML string.
for (int i=0; i<addresses.size(); i++){
    _html+=("<p>"+((BillingAddress)addresses.get(i)).toString().replace("\\n", "<br/>")+"</p>");
}

As you can see I'm able to check whether a BillingAddress is already in the ArrayList and I'm able to sort them. The former is due to the existence of the equals() method in the class and the latter because of the compareTo() method.

Here's the class itself:

public class BillingAddress implements Comparable {

    private String _address;
    private String _town;
    private String _county;
    private String _postCode;
    
    
    public int compareTo(Object address) throws ClassCastException {
        if (!(address instanceof BillingAddress))
              throw new ClassCastException("A BillingAddress object expected.");
            
        return (_address.compareTo(
                ((BillingAddress)address).getAddress()
            ));
    }
    
    public boolean equals(BillingAddress address){
        return (
            address!=null &&
            address.getAddress().equalsIgnoreCase(_address) &&
            address.getPostCode().equalsIgnoreCase(_postCode)
        );
    }

    public void setAddress(String address){
        _address = address;
    }
    
    public String getAddress(){
        return _address;
    }
    
    public void setTown(String town){
        _town = town;
    }
    
    public String getTown(){
        return _town;
    }
    
    public void setCounty(String county){
        _county = county;
    }
    
    public String getCounty(){
        return _county;
    }
        
    public void setPostCode(String postCode){
        _postCode = postCode;
    }
        
    public String getPostCode(){
        return _postCode;
    }
    
    public String toString(){
        String out = "<p>";
        if (!_address.equals("")){
            out+=_address+"\n";
        }
        if (!_town.equals("")){
            out+=_town+"\n";
        }
        if (!_county.equals("")){
            out+=_county+"\n";
        }
        if (!_postCode.equals("")){
            out+=_postCode;
        }
        return out;
    }

}

Inside the equals() method you can see I've deemed any address where the first line and the post code (ZIP) match to be the same. Whether this holds true or not I don't know yet. But it's easy to change this logic. As is the case for changing how the compareTo() method sorts your addresses. You could choose to sort by Town/City or Post Code rather than by the first line. It's all up to you.

As you can probably tell I'm writing the code in Java 1.3 (ouch!) because the client is still on Domino 6.5.5 (double ouch!!). If you were using a later version of Java you could make the above code a lot simpler, but the theory still holds true and the principles are the same.