You can make your object comparable:

public static class MyObject implements Comparable<MyObject> {

  private Date dateTime;

  public Date getDateTime() {
    return dateTime;
  }

  public void setDateTime(Date datetime) {
    this.dateTime = datetime;
  }

  @Override
  public int compareTo(MyObject o) {
    return getDateTime().compareTo(o.getDateTime());
  }
}

And then you sort it by calling:

Collections.sort(myList);

However sometimes you don't want to change your model, like when you want to sort on several different properties. In that case, you can create comparator on the fly:

Collections.sort(myList, new Comparator<MyObject>() {
  public int compare(MyObject o1, MyObject o2) {
      return o1.getDateTime().compareTo(o2.getDateTime());
  }
});

However, the above works only if you're certain that dateTime is not null at the time of comparison. It's wise to handle null as well to avoid NullPointerExceptions:

public static class MyObject implements Comparable<MyObject> {

  private Date dateTime;

  public Date getDateTime() {
    return dateTime;
  }

  public void setDateTime(Date datetime) {
    this.dateTime = datetime;
  }

  @Override
  public int compareTo(MyObject o) {
    if (getDateTime() == null || o.getDateTime() == null)
      return 0;
    return getDateTime().compareTo(o.getDateTime());
  }
}

Or in the second example:

Collections.sort(myList, new Comparator<MyObject>() {
  public int compare(MyObject o1, MyObject o2) {
      if (o1.getDateTime() == null || o2.getDateTime() == null)
        return 0;
      return o1.getDateTime().compareTo(o2.getDateTime());
  }
});

You can do this with Comparator interface. I prefer to convert the string into date first.

For dd/MM/yyyy (01/01/1970) pattern example (without conversion):

List<Ticket> list = new LinkedList<Ticket>();
... //fill the list.
Collections.sort(list, new Comparator<Ticket>() {
        public int compare(Ticket t1, Ticket t2) {
            String[] dateParts1 = t1.date.split("/");
            String[] dateParts2 = t2.date.split("/");
            
            int yearResult = dateParts1[2].compareTo(dateParts2[2]);
            if (yearResult != 0) {
                return yearResult;
            }
            
            int monthResult = dateParts1[1].compareTo(dateParts2[1]);
            if (monthResult != 0) {
                return monthResult;
            }
            
            int dayResult = dateParts1[0].compareTo(dateParts2[0]);
            if (dayResult != 0) {
                return dayResult;
            }
            
            return 0;
        }
    });

or (with conversion):

List<Ticket> list = new LinkedList<Ticket>();
... //fill the list.
Collections.sort(list2, new Comparator<Ticket>() {
        public int compare(Ticket t1, Ticket t2) {
            String pattern = "dd/MM/yyyy";
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
            try {
                Date date1 = simpleDateFormat.parse(t1.date);
                Date date2 = simpleDateFormat.parse(t2.date);
                return date1.compareTo(date2);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return 0;
        }
    });

Also, you can do same thing in class with Comparable interface.

public class Ticket **implements Comparable<Ticket>** {

int id;
String city;
String date;
int days;
float price;
String vehicle;

Ticket(int i, String c, String y, int d, float p, String v) {
    id = i;
    city = c;
    date = y;
    days = d;
    price = p;
    vehicle = v;
}

**@Override
public int compareTo(Ticket o) {
    String[] dateParts1 = this.date.split("/");
    String[] dateParts2 = o.date.split("/");
    int yearResult = dateParts1[2].compareTo(dateParts2[2]);
    if (yearResult != 0) {
        return yearResult;
    }
    int monthResult = dateParts1[1].compareTo(dateParts2[1]);
    if (monthResult != 0) {
        return monthResult;
    }
    int dayResult = dateParts1[0].compareTo(dateParts2[0]);
    if (dayResult != 0) {
        return dayResult;
    }
    return 0;
}**
}

Then:

List<Ticket> list = new LinkedList<Ticket>();
... //fill the list.
Collections.sort(list);

You would need to create class say Data and then implement Comparable in that like:

public class Data implements Comparable<Data> {
     private String name;
     private Date startDate;
     ...//other fields
     ...//getter setter
     public int compareTo(Data otherData) {
          return this.startDate.compareTo(otherData.startDate);
     }
}

Then read and create a list of records like:

List<Data> dataList = ....
//read file and add data to list
Collections.sort(dataList);

I think that you can create a custom comparator with an structure similar to the below:

Collections.sort(datestring, new Comparator<String>() {
    DateFormat df = new SimpleDateFormat("your format");
    @Override
    public int compare(String s1, String s2) {
       try {
            return df.parse(s1).compareTo(df.parse(s2));
        } catch (ParseException e) {
            throw new IllegalArgumentException(e);
        }
    }
});

I assume you have two different classes and both having Date objects. Instead of keeping list of objects I would suggest you creating a base interface like for example:

interface Dated {
   Date getDate();
}

Make your two classes implements this interface:

class A implements Dated {
 int id;
 Date date;

 @Override
 public Date getDate() {
    return date;
 }
}

class B implements Dated {
  int id;
  Date date;

  @Override
  public Date getDate() {
    return date;
  }
}

Create a Comparator like:

class DatedComparator implements Comparator<Dated> {
  @Override
  public int compare(Dated o1, Dated o2) {
    return o1.getDate().compareTo(o2.getDate());
  }
}

Then you can hold a list of Dated objects:

List<Dated> finalList = new ArrayList<Dated>();

which can be easily sorted by using your comparator:

Collections.sort(finalList, new DatedComparator());