Thread: Comparing a list against another list, and storing it back into a list. Java

The simplest approach is to just lay out the minimum criterion for a contestant, inside a Contestant object. Then you create two Lists, one holding every contestant and another storing only the ones who get through to the next round. After that, all you need to do is loop through the list with every contestant, compare against the criterion object and put the contestant through to the next round (into the new list) or send them home (do nothing). Once the loop has ended, you can discard the original list and only carry on with the new list.

A short SSCCE demonstrating what I mean.

import java.util.ArrayList;
import java.util.List;
 
 
public class Contestant{
 
	private final float height;
 
	public Contestant(float height){
		this.height = height;
	}
 
	public float getHeight(){
		return this.height;
	}
 
	public static void main(String[] args){
		List<Contestant> nextRound = new ArrayList<Contestant>();
		List<Contestant> contestants = new ArrayList<Contestant>();
 
		contestants.add(new Contestant(2.0f));
		contestants.add(new Contestant(4.0f));
 
 
		Contestant minRequirement = new Contestant(3.0f);
 
		for(Contestant contestant : contestants){
			if(contestant.getHeight() >= minRequirement.getHeight()){
				System.out.println("Contestant got through!");
				nextRound.add(contestant);
			}
		}
	}
}

Note: It is not my belief that people under 3 foot should not be allowed to progress further in beauty pagents!

When comparing two different lists, then the approach laid out is the main way to go about it really. If you just wanted to sort the contestants in a single list easily by their height say, then you would use the Comparable interface. However, this doesn't really do the behaviour you need for comparing two lists, unless you use it for sorting and then finding values quicker using a binary search etc.


If you're interested in this idea anyway, let me show you what the API states:

This interface imposes a total ordering on the objects of each class that implements it. This ordering is referred to as the class's natural ordering, and the class's compareTo method is referred to as its natural comparison method.

and

Lists (and arrays) of objects that implement this interface can be sorted automatically by Collections.sort (and Arrays.sort).

What this means, is that you implement the only method of Comparable, which has a signatue of:

public int compareTo(Object other){}

where object will be the generic type you specific and int will be the indicator for the natural ordering. If the value of the object is less than the value of the `other` object, then -1 will be returned. If they're equal, 0 will be returned. In the case of member variable being greater than `other`, then you guessed it, 1 is returned.

If you implement the interface and the method alike, then using Collections.sort(), you pass in your List and bobs your uncle; your objects will now be order based on the natural ordering you defined.

To help you better understand, I've concocted a quick and workable example which you can find below.

Best of luck, and be sure to come back if you have any further questions.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
 
public class Contestant implements Comparable<Contestant>{
 
	private final float height;
 
	public Contestant(float height){
		this.height = height;
	}
 
	public float getHeight(){
		return this.height;
	}
 
	@Override
	public int compareTo(Contestant other) {
		if(this.height < other.getHeight()){
			return -1;
		}else if(this.height > other.getHeight()){
			return 1;
		}
		return 0;
	}
 
 
	public static void main(String[] args){
		List<Contestant> contestants = new ArrayList<Contestant>();
		contestants.add(new Contestant(2.0f));
		contestants.add(new Contestant(4.0f));
		contestants.add(new Contestant(1.0f));
		contestants.add(new Contestant(3.0f));
 
		Collections.sort(contestants);
 
		for(Contestant contestant : contestants){
			System.out.println(contestant.getHeight());
		}
 
	}
}

This code gives the output of:

HTML Code:

1.0
2.0
3.0
4.0