Как получить перевернутое представление списка в списке на Java?
Я хочу иметь обратный вид списка в списке (аналогично, чем List#sublist
обеспечивает представление подсписка в списке). Есть ли какая-то функция, которая обеспечивает эту функциональность?
Я не хочу делать какие-либо копии списка или изменять список.
было бы достаточно, если бы я мог получить хотя бы обратный итератор на список, в этом случае.
кроме того, я знаю, как реализовать это сам. Я просто спрашиваю, предоставляет ли Java уже что-то вроде этого.
демо реализации:
static <T> Iterable<T> iterableReverseList(final List<T> l) {
return new Iterable<T>() {
public Iterator<T> iterator() {
return new Iterator<T>() {
ListIterator<T> listIter = l.listIterator(l.size());
public boolean hasNext() { return listIter.hasPrevious(); }
public T next() { return listIter.previous(); }
public void remove() { listIter.remove(); }
};
}
};
}
Я только что узнал, что некоторые List
реализация descendingIterator()
что мне нужно. Хотя общей такой реализации для List
. Что немного странно, потому что реализация, которую я видел в LinkedList
достаточно общий, чтобы работать с любым List
.
12 ответов
гуавы предоставляет этого: списки.обратный(список)
List<String> letters = ImmutableList.of("a", "b", "c");
List<String> reverseView = Lists.reverse(letters);
System.out.println(reverseView); // [c, b, a]
в отличие от Collections.reverse
, это чисто посмотреть... оно не изменяет порядок элементов в исходном списке. Кроме того, при наличии изменяемого исходного списка изменения исходного списка и представления отражаются в другом списке.
использовать .метод clone () в вашем списке. Он вернет мелкую копию, что означает, что он будет содержать указатели на те же объекты, поэтому вам не придется копировать список. Тогда просто используйте коллекции.
Ergo,
Collections.reverse(list.clone());
если вы используете List
и не имеют доступа к clone()
можно использовать subList()
:
List<?> shallowCopy = list.subList(0, list.size());
Collections.reverse(shallowCopy);
Это не совсем элегантно, но если вы используете List.listIterator (индекс int) вы можете получить двунаправленный ListIterator в конце списка:
//Assume List<String> foo;
ListIterator li = foo.listIterator(foo.size());
while (li.hasPrevious()) {
String curr = li.previous()
}
сборники.обратный(нумс) ... Это фактически меняет порядок элементов. Ниже код должен быть высоко оценен -
List<Integer> nums = new ArrayList<Integer>();
nums.add(61);
nums.add(42);
nums.add(83);
nums.add(94);
nums.add(15);
//Tosort the collections uncomment the below line
//Collections.sort(nums);
Collections.reverse(nums);
System.out.println(nums);
выход: 15,94,83,42,61
Я знаю, это старый пост, но сегодня я искал что-то подобное. В конце концов я сам написал код:--2-->
private List reverseList(List myList) {
List invertedList = new ArrayList();
for (int i = myList.size() - 1; i >= 0; i--) {
invertedList.add(myList.get(i));
}
return invertedList;
}
Не рекомендуется для длинных списков, это не оптимизирован вообще. Это простое решение для контролируемых сценариев (списки, которые я обрабатываю, имеют не более 100 элементов).
надеюсь, это кому-то поможет.
Я использую этот:
public class ReversedView<E> extends AbstractList<E>{
public static <E> List<E> of(List<E> list) {
return new ReversedView<>(list);
}
private final List<E> backingList;
private ReversedView(List<E> backingList){
this.backingList = backingList;
}
@Override
public E get(int i) {
return backingList.get(backingList.size()-i-1);
}
@Override
public int size() {
return backingList.size();
}
}
такой:
ReversedView.of(backingList) // is a fully-fledged generic (but read-only) list
вы также можете сделать это:
static ArrayList<String> reverseReturn(ArrayList<String> alist)
{
if(alist==null || alist.isEmpty())
{
return null;
}
ArrayList<String> rlist = new ArrayList<>(alist);
Collections.reverse(rlist);
return rlist;
}
вы также можете инвертировать позицию при запросе объекта:
Object obj = list.get(list.size() - 1 - position);
для небольшого размера списка мы можем создать LinkedList
а затем можно использовать нисходящий итератор как:
List<String> stringList = new ArrayList<>(Arrays.asList("One", "Two", "Three"));
stringList.stream().collect(Collectors.toCollection(LinkedList::new))
.descendingIterator().
forEachRemaining(System.out::println); // Four, Three, Two, One
System.out.println(stringList); // One, Two, Three, Four
использовать reverse(...)
способы java.util.Collections
класса. Передайте свой список в качестве параметра, и ваш список будет отменен.
Collections.reverse(list);