Gradle on Eclipse, diamond operator not recognized?

I have a code that I am migrating to Gradle, when I run it on Eclipse (without Gradle it runs fine), but when I use the Eclipse plugin or try to run it trhough command line I have problems with the diamond operator.

For example, for this class:

import java.util.SortedSet;

/**
* Holds inventory of currency, calculates balance, makes change.
* Immutable.
*/
public final class Bank {
/**
 * Inventory of currencies for the bank.
 */
private final Inventory<Currency> inventory;

public Inventory<Currency> getInventory() {
    return inventory;
}

/**
 * Calculate the balance (in cents) of the currently held currencies.
 *
 * @return the current balance (in cents)
 */
public long calculateBalance() {
    long balance = 0L;
    for (Currency currency : Currency.values()) {
        balance += currency.getCents() * inventory.quantity(currency);
    }
    return balance;
}

/**
 * Create a bank made up of currencies from this bank that add up as close
 * as possible to the change amount requested.  Exact change is not
 * guaranteed.  It's a good idea to check that the calculated balance is
 * the same as the amount you expect.
 *
 * @param amount the amount of change needed
 * @return a bank of change made from as much currency that could be used
 */
public Bank makeChange(final long amount) {
    long change = amount;
    Bank changeBank = new Bank();
    final SortedSet<Currency> descending = Currency.descending();
    for (Currency largest : descending) {
        int quantity = inventory.quantity(largest);
        final long cents = largest.getCents();
        while (quantity > 0 && change >= cents) {
            change = change - cents;
            quantity = quantity - 1;
            changeBank = changeBank.deposit(largest);
        }
    }
    return changeBank;
}

/**
 * Bank constructor.  Fills out a new Bank with 0 amounts for each currency.
 */
public Bank()
{
    this.inventory = new Inventory <> (Currency.values());
}

/**
 * Private Bank constructor.  Used for returning new, modified instances.
 *
 * @param inventory the new inventory
 */
private Bank(final Inventory<Currency> inventory) {
    this.inventory = new Inventory<>(Currency.values()).add(inventory);
}

/**
 * Deposit the currencies from the incoming Bank into this Bank.
 *
 * @param bank incoming Bank
 * @return new Bank with this Bank's currencies, incoming Bank's currencies
 */
public Bank deposit(final Bank bank) {
    if (bank == null) {
        return this;
    }
    return new Bank(inventory.add(bank.getInventory()));
}

/**
 * Deposit the currency incoming into this Bank.
 *
 * @param currency incoming currency
 * @return new Bank with this Bank's currencies, incoming currency
 */
public Bank deposit(final Currency currency) {
    if (currency == null) {
        return this;
    }
    return new Bank(inventory.add(currency));
}

/**
 * Withdraws the currencies from the passed in Bank from this Bank.  If
 * there aren't enough of any particular currency, set the quantity to 0.
 *
 * @param bank the Bank of currencies to withdraw
 * @return a Bank with the currencies of the passed Bank withdrawn
 */
public Bank withdraw(final Bank bank) {
    if (bank == null) {
        return this;
    }
    return new Bank(inventory.subtract(bank.getInventory()));
}

}

I get an illegat start of type error:

illegal start of type this.inventory <> (Currency.values());
                                      ^

I know that the diamond operator can be used since JDK7 to have type inference with generics, so I am perplexed on why I get this error. Can you help me to fix it please?

Thanks in advance

Unless you specify the version of Java to use, Gradle will compile your code using the version of the JVM currently in use. If you're seeing that error message about the diamond operator, it probably means the version of Java you're using on the command line is older than 1.7. You'll need to upgrade to a later version (or if multiple versions are installed, make another version active).

It's almost always a good idea to explicitly specify the version by adding these lines to your build.gradle file:

sourceCompatibility = 1.7
targetCompatibility = 1.7

Reference: https://docs.gradle.org/current/userguide/java_plugin.html