Bagaimana saya bisa mendapatkan nilai terakhir dari ArrayList?

Saya tidak tahu indeks terakhir dari ArrayList.

Berikut ini adalah bagian dari Listantarmuka (yang mengimplementasikan ArrayList):

E e = list.get(list.size() - 1);

Eadalah tipe elemen. Jika daftar kosong, getlemparkan a IndexOutOfBoundsException. Anda dapat menemukan seluruh dokumentasi API di sini .

Tidak ada cara yang elegan di vanilla Java.

Google Jambu

The Google Jambu perpustakaan besar - memeriksa mereka Iterableskelas . Metode ini akan melempar NoSuchElementExceptionjika daftar kosong, sebagai lawan dari IndexOutOfBoundsException, seperti dengan size()-1pendekatan khas - saya menemukan NoSuchElementExceptionjauh lebih bagus, atau kemampuan untuk menentukan default:

lastElement = Iterables.getLast(iterableList);

Anda juga dapat memberikan nilai default jika daftar kosong, bukan pengecualian:

lastElement = Iterables.getLast(iterableList, null);

atau, jika Anda menggunakan Opsi:

lastElementRaw = Iterables.getLast(iterableList, null);
lastElement = (lastElementRaw == null) ? Option.none() : Option.some(lastElementRaw);

ini harus dilakukan:

if (arrayList != null && !arrayList.isEmpty()) {
  T item = arrayList.get(arrayList.size()-1);
}

Saya menggunakan kelas utilitas mikro untuk mendapatkan elemen terakhir (dan pertama) dari daftar:

public final class Lists {

    private Lists() {
    }

    public static <T> T getFirst(List<T> list) {
        return list != null && !list.isEmpty() ? list.get(0) : null;
    }

    public static <T> T getLast(List<T> list) {
        return list != null && !list.isEmpty() ? list.get(list.size() - 1) : null;
    }
}

Sedikit lebih fleksibel:

import java.util.List;

/**
 * Convenience class that provides a clearer API for obtaining list elements.
 */
public final class Lists {

  private Lists() {
  }

  /**
   * Returns the first item in the given list, or null if not found.
   *
   * @param <T> The generic list type.
   * @param list The list that may have a first item.
   *
   * @return null if the list is null or there is no first item.
   */
  public static <T> T getFirst( final List<T> list ) {
    return getFirst( list, null );
  }

  /**
   * Returns the last item in the given list, or null if not found.
   *
   * @param <T> The generic list type.
   * @param list The list that may have a last item.
   *
   * @return null if the list is null or there is no last item.
   */
  public static <T> T getLast( final List<T> list ) {
    return getLast( list, null );
  }

  /**
   * Returns the first item in the given list, or t if not found.
   *
   * @param <T> The generic list type.
   * @param list The list that may have a first item.
   * @param t The default return value.
   *
   * @return null if the list is null or there is no first item.
   */
  public static <T> T getFirst( final List<T> list, final T t ) {
    return isEmpty( list ) ? t : list.get( 0 );
  }

  /**
   * Returns the last item in the given list, or t if not found.
   *
   * @param <T> The generic list type.
   * @param list The list that may have a last item.
   * @param t The default return value.
   *
   * @return null if the list is null or there is no last item.
   */
  public static <T> T getLast( final List<T> list, final T t ) {
    return isEmpty( list ) ? t : list.get( list.size() - 1 );
  }

  /**
   * Returns true if the given list is null or empty.
   *
   * @param <T> The generic list type.
   * @param list The list that has a last item.
   *
   * @return true The list is empty.
   */
  public static <T> boolean isEmpty( final List<T> list ) {
    return list == null || list.isEmpty();
  }
}

The size()Metode mengembalikan jumlah elemen dalam ArrayList. Nilai indeks elemen 0melalui (size()-1), jadi Anda akan gunakan myArrayList.get(myArrayList.size()-1)untuk mengambil elemen terakhir.

Menggunakan lambdas:

Function<ArrayList<T>, T> getLast = a -> a.get(a.size() - 1);

Tidak ada cara yang elegan untuk mendapatkan elemen terakhir dari daftar di Jawa (dibandingkan dengan misalnya items[-1]dengan Python).

Anda harus menggunakan list.get(list.size()-1).

Ketika bekerja dengan daftar yang diperoleh dengan panggilan metode yang rumit, solusinya terletak pada variabel sementara:

List<E> list = someObject.someMethod(someArgument, anotherObject.anotherMethod());
return list.get(list.size()-1);

Ini adalah satu-satunya pilihan untuk menghindari versi yang jelek dan sering mahal atau bahkan tidak berfungsi:

return someObject.someMethod(someArgument, anotherObject.anotherMethod()).get(
    someObject.someMethod(someArgument, anotherObject.anotherMethod()).size() - 1
);

Akan lebih baik jika perbaikan untuk cacat desain ini diperkenalkan ke Java API.

Jika Anda bisa, tukar keluar ArrayListuntuk ArrayDeque, yang memiliki metode nyaman seperti removeLast.

Seperti yang dinyatakan dalam solusi, jika Listkosong maka IndexOutOfBoundsExceptiondilemparkan. Solusi yang lebih baik adalah dengan menggunakan Optionaltipe:

public class ListUtils {
    public static <T> Optional<T> last(List<T> list) {
        return list.isEmpty() ? Optional.empty() : Optional.of(list.get(list.size() - 1));
    }
}

Seperti yang Anda harapkan, elemen terakhir dari daftar dikembalikan sebagai Optional:

var list = List.of(10, 20, 30);
assert ListUtils.last(list).orElse(-1) == 30;

Itu juga berurusan dengan anggun dengan daftar kosong juga:

var emptyList = List.<Integer>of();
assert ListUtils.last(emptyList).orElse(-1) == -1;

Jika Anda menggunakan LinkedList, Anda dapat mengakses elemen pertama dan terakhir dengan adil getFirst()dan getLast()(jika Anda menginginkan cara yang lebih bersih daripada ukuran () -1 dan dapatkan (0))

Penerapan

Deklarasikan LinkedList

LinkedList<Object> mLinkedList = new LinkedList<>();

Maka ini adalah metode yang dapat Anda gunakan untuk mendapatkan apa yang Anda inginkan, dalam hal ini kita berbicara tentang elemen PERTAMA dan TERAKHIR daftar

/**
     * Returns the first element in this list.
     *
     * @return the first element in this list
     * @throws NoSuchElementException if this list is empty
     */
    public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }

    /**
     * Returns the last element in this list.
     *
     * @return the last element in this list
     * @throws NoSuchElementException if this list is empty
     */
    public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }

    /**
     * Removes and returns the first element from this list.
     *
     * @return the first element from this list
     * @throws NoSuchElementException if this list is empty
     */
    public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

    /**
     * Removes and returns the last element from this list.
     *
     * @return the last element from this list
     * @throws NoSuchElementException if this list is empty
     */
    public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }

    /**
     * Inserts the specified element at the beginning of this list.
     *
     * @param e the element to add
     */
    public void addFirst(E e) {
        linkFirst(e);
    }

    /**
     * Appends the specified element to the end of this list.
     *
     * <p>This method is equivalent to {@link #add}.
     *
     * @param e the element to add
     */
    public void addLast(E e) {
        linkLast(e);
    }

Jadi, bisa Anda gunakan

mLinkedList.getLast(); 

untuk mendapatkan elemen terakhir dari daftar.

jambu biji menyediakan cara lain untuk mendapatkan elemen terakhir dari List:

last = Lists.reverse(list).get(0)

jika daftar yang disediakan kosong itu melempar IndexOutOfBoundsException

Karena pengindeksan di ArrayList dimulai dari 0 dan berakhir di satu tempat sebelum ukuran sebenarnya, maka pernyataan yang benar untuk mengembalikan elemen arraylist terakhir adalah:

int last = mylist.get (mylist.size () - 1);

Sebagai contoh:

jika ukuran daftar array adalah 5, maka size-1 = 4 akan mengembalikan elemen array terakhir.

Item terakhir dalam daftar adalah list.size() - 1. Koleksi didukung oleh array dan array mulai dari indeks 0.

Jadi elemen 1 dalam daftar adalah pada indeks 0 dalam array

Elemen 2 dalam daftar adalah pada indeks 1 dalam array

Elemen 3 dalam daftar adalah pada indeks 2 dalam array

dan seterusnya..

Bagaimana dengan ini .. Di suatu tempat di kelas Anda ...

List<E> list = new ArrayList<E>();
private int i = -1;
    public void addObjToList(E elt){
        i++;
        list.add(elt);
    }


    public E getObjFromList(){
        if(i == -1){ 
            //If list is empty handle the way you would like to... I am returning a null object
            return null; // or throw an exception
        }

        E object = list.get(i);
        list.remove(i); //Optional - makes list work like a stack
        i--;            //Optional - makes list work like a stack
        return object;
    }

Jika Anda memodifikasi daftar Anda, maka gunakan listIterator()dan lakukan iterate dari indeks terakhir ( size()-1masing - masing). Jika Anda gagal lagi, periksa struktur daftar Anda.

Yang perlu Anda lakukan adalah menggunakan size () untuk mendapatkan nilai terakhir dari Arraylist. Misalnya jika Anda ArrayList bilangan bulat, maka untuk mendapatkan nilai terakhir Anda harus

int lastValue = arrList.get(arrList.size()-1);

Ingat, elemen dalam Arraylist dapat diakses menggunakan nilai indeks. Karenanya, ArrayLists umumnya digunakan untuk mencari item.

array menyimpan ukurannya dalam variabel lokal yang disebut 'panjang'. Diberikan array bernama "a" Anda bisa menggunakan yang berikut untuk referensi indeks terakhir tanpa mengetahui nilai indeks

a [a.length-1]

untuk menetapkan nilai 5 pada indeks terakhir ini, Anda akan menggunakan:

a [a.length-1] = 5;

Alternatif menggunakan Stream API:

list.stream().reduce((first, second) -> second)

Menghasilkan Opsional dari elemen terakhir.

Di Kotlin, Anda dapat menggunakan metode ini last:

val lastItem = list.last()