Ykhjuy

I have a queue<Integer> declared as Queue<Integer> queue=new LinkedList();, I need to reverse the elments order in it, and then convert it into an int array. I wrote below code:

Collections.reverse((List)queue);

int res=queue.stream().mapToInt(Integer::intValue).toArray();

This code has two problems:

1. the explict casting (List)queue;


2. I wonder if there is a one line solution.

So do we have any more elegant way to do this?

clearify the problem:

whether the queue is reversed is not important. An int array of the reversed elements is what I need.

The Collections.reverse implies only to List which is just one type of Collection, you cannot cast a Queue to a List. But you can try casting it to a LinkedList as:

Collections.reverse((LinkedList)queue);

Details:

I doubt that there is a built-in API for reversing the queue. You could still follow a conventional way of doing that using a Stack as :

Stack<Integer> stack = new Stack<>();

while (!queue.isEmpty()) {

    stack.add(queue.remove());

}

while (!stack.isEmpty()) {

    queue.add(stack.pop());

}

and then convert to an array as you will

int res = queue.stream().mapToInt(Integer::intValue).toArray();

On the other hand, if a Deque satisfies your needs currently, you can simply rely on the LinkedList itself since it implements a Deque as well. Then your current implementation would be as simple as :

LinkedList<Integer> dequeue = new LinkedList<>();

Collections.reverse(dequeue);

int res = dequeue.stream().mapToInt(Integer::intValue).toArray();

whether the queue is reversed is not important. An int array of the
reversed elements is what I need.

Another solution from what others have already suggested is to reverse the Stream of the queue and then mapToInt to convert to an array as :

Queue<Integer> queue = new LinkedList<>();

int res = reverse(queue.stream()).mapToInt(Integer::intValue).toArray();

This uses a utility reverse suggested by Stuart Marks in this answer such that:

@SuppressWarnings("unchecked")

static <T> Stream<T> reverse(Stream<T> input) {

    Object temp = input.toArray();

    return (Stream<T>) IntStream.range(0, temp.length)

            .mapToObj(i -> temp[temp.length - i - 1]);

}

In Java8 version you can use Stream API to help you.

The skeleton of code like this：

int reversedQueue = queue.stream()

    .collect(Collector.of(() -> new ArrayDeque<Integer>(), ArrayDeque::addFirst, (a,b)->a))

    .stream().mapToInt(Integer::intValue).toArray();

First, please don't use raw types (do use the diamond operator). Not quite a one liner, but you could first convert to an int and then use commons lang ArrayUtils.reverse(int) like

Queue<Integer> queue = new LinkedList<>();

// ...

int arr = queue.stream().mapToInt(Integer::intValue).toArray();

ArrayUtils.reverse(arr);

You could also write your own int reverse method that allowed for a fluent interface (e.g. return the int) then you could make it a one liner. Like,

public static int reverse(int arr) {

    for (int i = 0; i < arr.length / 2; i++) {

        int temp = arr[i];

        arr[i] = arr[arr.length - i - 1];

        arr[arr.length - i - 1] = temp;

    }

    return arr;

}

And then

int arr = reverse(queue.stream().mapToInt(Integer::intValue).toArray());

This should work with Eclipse Collections

int res = LazyIterate.adapt(queue)

        .collectInt(Integer::intValue)

        .toList()

        .asReversed()

        .toArray();

Note: I am a committer for Eclipse Collections.

This is one line, but it may not be very efficient:

int res = queue.stream()

                 .collect(LinkedList::new, (l, e) -> l.addLast(e), (l1, l2) -> l1.addAll(l2))

                 .stream()

                 .mapToInt(Integer::intValue)

                 .toArray();

If you want to be efficient and readable, you should continue using what you have now.

I think your are right, A raw type should not put in your code. the following is the best I can do.

Integer intArray = queue.stream().collect(Collectors.collectingAndThen(Collectors.toList(), list -> {

        Collections.reverse(list);

        return list;

    })).toArray(new Integer[queue.size()]);