Object类型的数组，并比较数组中的对象

Question

I am creating an array of type Object. I have two different classes, Employee and Person which have simple attributes like name, salary (Employee) first name, date of birth (Person). I need to add some Employee and Person objects into my array and compare certain things within the array. Ex, retrieving the youngest Person from the array.

public class Driver {

public static void main(String[] args) {
    Employee e1 = new Employee("Den", 2000);

    Employee e2 = new Employee("Jon", 1004);

    Person p1 = new Person("Pen", "Tel", "1993");
    Person p2 = new Person("Jon", "Smith", "1933");

    Object [] crr;
    crr = new Object[4];
    crr[0] = e1;
    crr[1] = p1;
    crr[2] = p2;
    crr[3] = e2;
    System.out.println();
    new Driver().printObjectArray("array crr", crr);

}
public void printObjectArray(String arrayName, Object [] array){
    for (int i = 0; i < array.length; i++){
        System.out.println(arrayName + "["+ i +"]" + array[i].toString());
    }
    System.out.println("--------------------");
}   
}

How would I compare certain things on the array. Like printing the youngest person,, which means I have to look through the array and see if its a Person object then getDateOfBirth on those objects and print the oldest person.

Answer 1

public Person getYoungestPerson(Object [] arr){

    int i=0; Person youngest;
    while(person == null){
      if(arr[i] instanceof Person) youngest = arr[i];
      i++;
      }
     for(i=0;i<arr.length;i++){ if (arr[i] instanceof Person) 
            if(arr[i].getDateOfBirth()<youngest.getDateOfBirth()) 
               youngest= arr[i];}
   return youngest;
}

Ideally, Employee should be a child class from Person, and you would have a Person array. You have to be careful if you want only Persons, because instanceof also returns true for all child classes, this is not your case, because Employee does not extends Person, just a heads up to the future.

Answer 2

Write some get methods in your Employee and Person classes. For example,

in your Employee class, create:

public int getSalary(){
  return salary; // Make salary as a global variable
}

In your Person class, do

public int getYear(){
  return year; // same here
}

So in you main code, you can do

for (int i = 1; i < array.length; i++){
  Object youngest;
  if (crr[i].getYear() < crr[i+1].getYear())){
    youngest = crr[i];
  }
}

However, I actually would like to recommend you to use ArrayList instead of array. And Creat two arrays/ArrayLists instead of putting e and p in one array. Easier to manage.

Answer 3

Don't use arrays of type Object. Java excels at strong typing, so take advantage of that. If Person extends Employee, or Employee extends Person, exploit that. Initialise your array with the top class:

Person[] people = {new Employee(...), new Employee(...),
  new Person(...), new Person(...)};

or

Person[] people;
...
people = new People[]{new Employee(...), 
  new Employee(...), new Person(...), new Person(...)};

or

Person[] people = new People[<some number>];
...
people[0] = new Employee(...);
people[1] = new Person(...);
...

And then we can sort the array by making sure Person (or Employee) implements Comparable (or Employee), implementing compareTo(Person other) {...} (or Employee), and calling Arrays.sort(people). Because we made them comparable, Java will know how to sort them.

There's a lot of things Java can do for you, but you'll have to play by its rules. Not using "Object" containers is one of them, implementing the Comparable interface is another (a third one is to use generics on containers like ArrayList, HashMap, etc, so that Java knows what you're putting in them, rather than the catch-all "Object")

Answer 4

If Person isn't "related" to Employee through extension you could force both classes to implement the same interface. Create and array of that interface type and put Employee and Person objects into it. Then use the interface methods to compare Employee and Person objects. I think the best option here is to have Employee extend Person, but interfaces can provide a nice alternative.