Jak iterować w Javie po LinkedLiście?

Question

Cześć, mam dosyć banalny problem - mam jakąś kolejkę w Javie (może być LinkLista) i chcę po niej iterować w sposób najbardziej efektywny tak, aby mieć dostęp do obecnego i następnego elementu (chcę na obecnym elemencie wykonać funkcję porównującą go w jakiś sposób z następnym). W C++ załatwił bym to wskaźnikami, ale w Javie nie wiem jak się do tego zabrać, bo Iterator nie daje mi dostępu do aktualnego elementu, tylko do następnego, a iterowanie używając metody .get() LinkedListy w taki sposób jest mega nieefektywne. Jak więc takie coś zrobić?

Answer 1

Najpewniej streamami. Co dokładniej chcesz osiągnąć? Pod jakim kątem to ma być porównanie.

Taki przykład:

List<Integer> linkedList = new LinkedList<>();

linkedList.add(1);
linkedList.add(1);
linkedList.add(2);
linkedList.add(10);
linkedList.add(5);

List<Integer> collect = linkedList.stream()
                .filter(e -> e > 1)
                .filter(e -> e < 10)
                .collect(Collectors.toList());

System.out.println(collect);

Wynik:

[2, 5]

 

Comments

 po takie rzeczy nie sięgałem - strasznie to skomplikowane jak na tak prostą operację. Chodzi po prostu o to, że mam listę obiektów jakiejś klasy (powiedzmy K) i w tej klasie mam funkcję zwracającą booleana (powiedzmy compare) i chcę być w stanie zrobić coś w stylu:

LinkedList<K> list = ...

Iterator i = list.iterator();
while(i.hasNext()) {
if(i.compare(i.next())) ...
}

tylko z iteratorem tego nie zrobię

---

Uwierz to nie jest skomplikowane, bo piszesz co ma być zrobione nie jak.

Co do twojego problemu to rzeczywiście jeśli chodzi o streamy, przeynajmniej wedlug mojej wiedzy, do takich operacji się średnio nadają. Poniżej przykład ze streamem i bez:

class Foo
{
    private int value;

    public Foo(int value)
    {
        this.value = value;
    }


    public boolean compare(Foo foo)
    {
        return foo.value == this.value;
    }

    @Override
    public String toString()
    {
        return "Foo{" +
                "value=" + value +
                '}';
    }
}


public class StreamExample
{
    public static void main(String[] args)
    {
        LinkedList<Foo> linkedList = new LinkedList<>();

        linkedList.add(new Foo(1));
        linkedList.add(new Foo(1));
        linkedList.add(new Foo(2));
        linkedList.add(new Foo(10));
        linkedList.add(new Foo(5));

        linkedList.stream().reduce((current, next) -> {

            if (current.compare(next))
              operation(current);

          return next;
        });


        //mozna tez
        Iterator<Foo> iterator = linkedList.iterator();
        if (iterator.hasNext())
        {
                Foo previous = iterator.next();
                while (iterator.hasNext())
                {
                    Foo current = iterator.next();
                    if (previous.compare(current))
                        operation(previous);
                    previous = current;
                }
            }
    }

    public static void operation(Foo foo)
    {
        System.out.println("Operacja na: " + foo);
    }
}

 

---

Ta wersja z iteratorem niestety omija elementy tzn. current.compare(next) wykoa się dla elementów 0 i 1 potem 2 i 3 potem 4 i 5 ... a mi trzeba czegoś co wykona się dla 0 i 1, 1 i 2, 2 i 3, ale pokombinuję z dwoma iteratorami- dzięki

---

O kurr.. rzeczywiscie, sorry za wprowadzenie w błąd, ten przykład ze Streamem na pewno tego nie robi.

---

Jest jeszcze coś takiego:

        ListIterator<Foo> iterator = linkedList.listIterator();

        while (iterator.hasNext())
        {
            Foo current = iterator.next();
            if (iterator.hasNext())
            {
                Foo next = iterator.next();
                if (current.compare(next) )
                    operation(current);
                iterator.previous();
            }
        }

Lub

        Iterator<Foo> iterator = linkedList.iterator();

        if (iterator.hasNext())
        {
            Foo previous = iterator.next();
            while (iterator.hasNext())
            {
                Foo current = iterator.next();
                if (previous.compare(current))
                    operation(previous);
                previous = current;
            }
        }

Podmieniłem wersje z iteratorem w pierwszym listningu, żeby ktoś z błędem nie skopiował.