Sorting objects using compareTo (multiple types)

If the type is not null, you replace it by 0, whatever its value is. So comparing "paper" with "online" leads to comparing 0 with 0, which is obviously wrong.

My first advice would be to use proper types instead of String for everything. month and year should be ints, and type should be an enum. You should also strive to make them non-nullable.

Once done, the comparison method would reduce to

public int compareTo(Article other) {
    int result = this.type.compareTo(other.type);
    if (result == 0) {
        result = Integer.compare(this.year, other.year);
    }
    if (result == 0) {
        result = Integer.compare(this.month, other.month);
    }
    return result;
}

Note that using an enum allows you to dictate specify the way types compare, simply by listing the values in the order you want.

Or even better, with Guava:

public int compareTo(Article other) {
    return ComparisonChain.start()
                          .compare(this.type, other.type)
                          .compare(this.year, other.year)
                          .compare(this.month, other.month)
                          .result();
}

If the values are nullable, the above code would have to be changed to

public int compareTo(Article other) {
    return ComparisonChain.start()
                .compare(this.type, other.type, Ordering.natural().nullsLast())
                .compare(this.year, other.year, Ordering.natural().nullsLast())
                .compare(this.month, other.month, Ordering.natural().nullsLast())
                .result();
}

To answer your question, you can simply use compareTo() to compare two String objects. You just have to make sure that you compare them in the order that you want. Doing

x = type2.compareTo(type1);

compares the Strings in descending order. If you want to sort in ascending order, you need to do

x = type1.compareTo(type2);

In adition, I am curious about all the == null or != null checks. Since this is your own class, you should control whether or not the member fields can be null. If I were writing a similar class, I would require that all fields are initialized by the constructor so that I don't need to check for null values. This can greatly simplify all the other methods in the class, including this compareTo() method.

Also, you should prefer built-in types over wrapper classes. In other words, use ints for the year and month fields rather than Integers. This can also help simplify your code in a couple of ways. First, you won't have to worry about null values. Second, you can compare to ints with a simple subtraction:

int compareYears = this.year - rs.year;
if (compareYears != 0) {
    return compareYears;
}

With these suggestions, you can not only fix the current problem, but you can also reduce the number of lines of code by at least half.

(Note that in general, you must be careful about comparing ints using subtraction due to overflow. In this case, since we are comparing years, neither value should be negative, so there shouldn't be a problem. Of course, the rest of your class should enforce that the year field is in fact a valid year.)