Java oneliner для очистки списка

Question

Есть ли в java конструкция, которая делает что-то подобное (здесь реализовано на python):

[] = [item for item in oldList if item.getInt() > 5]

Сегодня я использую что-то вроде:

ItemType newList = new ArrayList();
for( ItemType item : oldList ) {
    if( item.getInt > 5) {
     newList.add(item);
    }
}

И мнепервый способ выглядит немного умнее.

Answer 1

Java 7 может или может не реализовывать замыкания и, следовательно, поддерживать такую ​​функциональность, как сейчас, но в настоящее время это не так, поэтому на Java VM у вас есть возможность сделать это в Groovy , Scala или Clojure (возможно, и другие), но в java вы можете приблизиться к этому только с помощью таких помощников, как Collections Гуавы2.фильтр () .

JDK 7 пример кода:

findItemsLargerThan(List<Integer> l, int what){
   return filter(boolean(Integer x) { x > what }, l);
}  
findItemsLargerThan(Arrays.asList(1,2,5,6,9), 5)

Groovy пример кода:

Arrays.asList(1,2,5,6,9).findAll{ it > 5}

Образец кода гуавы:

Collections2.filter(Arrays.asList(1, 2, 5, 6, 9),
    new Predicate<Integer>(){
        @Override
        public boolean apply(final Integer input){
            return input.intValue() > 5;
        }
    }
);

Образец кода Scala (спасибо Боло):

Array(1, 2, 5, 6, 9) filter (x => x > 5)

Answer 2

Вы можете взглянуть на лямбдай . Существует метод выбора, который можно использовать с условием подголовник .

Answer 3

Это можно сделать на чистом Java, но вам нужно написать класс поддержки Filter для следующего кода, который будет успешно выполняться:

    List<Integer> oldList = Arrays.asList(new Integer[] { 1, 2, 5, 6, 9 });
    List<Integer> newList = new Filter<Integer>(oldList) {
        {
            findAll(it > 5);
        }
    }.values();
    System.out.println(newList); // [6, 9] 

В случае, если вам интересно, почему этот код компилирует, обратите внимание на Скрытые возможности Java : инициализация с двойной скобкой. Это создает анонимный экземпляр класса Filter, который содержит переменную it и предоставляет метод findAll ().

У самого класса Filter есть один недостаток, заключающийся в том, что для каждого элемента списка создается новый экземпляр для оценки логического условия при findAll ():

public abstract class Filter<T> {

    protected List<T> values = new ArrayList<T>();

    protected T it;

    public Filter(List<T> values) {
        if (values != null) {
            this.values.addAll(values);
        }
        if (values.isEmpty()) {
            throw new RuntimeException("Not for empty collections!");
        }
        it = values.iterator().next();
        // instance initializer gets executed here, calls findAll
    }

    protected void findAll(boolean b) throws Throwable {
        // exit condition for future calls
        if (values.size() > 1) {
            // only repeat for each entry, if values has multiple entries
            Iterator<T> iterator = values.iterator();
            while (iterator.hasNext()) {
                // don't evalute again for the first entry
                if (!b) {
                    iterator.next();
                    iterator.remove();
                    b = true;
                } else {
                    // for each other entry create an argument with one element
                    List<T> next = new ArrayList<T>();
                    next.add(iterator.next());
                    // get constructor of anonymous class
                    Constructor<?> constructor = this.getClass().getDeclaredConstructors()[0];
                    // invoke constructor and thus execute instance initializer again
                    Filter<T> filtered = (Filter<T>) constructor.newInstance(new Object[] { null, next });
                    // if values is empty, the condition didn't match and the element can be removed
                    if (filtered.values.isEmpty()) {
                        iterator.remove();
                    }
                }
            }
        } else {
            // one element can be checked directly
            if (!b) {
                values.clear();
            }
        }
    }

    public List<T> values() {
        return values;
    }

}

Но поскольку создание экземпляров в наши дни довольно дешево, а класс Filter можно использовать для всех объектов, возможно, стоит включить его в свой пакет Utils.

Greetz, GHAD

Answer 4

Нет ничего невозможного (-:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ListCleaner {

    public static void main(String[] args) {

        final List<Integer> oldList = Arrays.asList(new Integer[] { 23, 4, 5,
                657 });
        System.out.println(oldList);

        List<Integer> newList = new ArrayList<Integer>() {
            {
                for (Integer element : oldList) {
                    if (element > 5) {
                        this.add(element);
                    }
                }
            }

        };
        System.out.println(newList);
    }
}

Единственным ограничением является то, что oldList должен быть окончательным.

Answer 5

Нет, этот вид динамической языковой конструкции еще не поддерживается в Java :-) Так что вам придется жить с вашим вариантом 2