एक ArrayList का अंतिम मान कैसे प्राप्त करें

Question

मैं एक ArrayList का अंतिम मूल्य कैसे प्राप्त कर सकता हूं?

मैं ArrayList के अंतिम सूचकांक को नहीं जानता।

Comments

मैंने इस सवाल को उठाया, क्योंकि मैं सोच रहा था कि ऐसा कोई तरीका क्यों नहीं है: getLastItem () और देखने के लिए कि क्या कोई जवाब था। list.size () - 1 सुंदर नहीं है।

— नूनो गोंकोलेव्स

@ NunoGonçalves आप हमेशा इसे उपवर्ग कर सकते हैं!

— टिम

आप हमेशा एक getLast()

— लिंक्डलिस्ट का

लिंक्ड लिस्टिंग में यह ओवरहेड का एक पूरा ढेर जोड़ता है। नीचे दिखाए अनुसार अमरूद का उपयोग करें: lastElement = Iterables.getLast (iterableList); या बस एक इंडेक्स प्राप्त करें () आकार के साथ कॉल करें () - 1. इसकी नहीं है कि जब इसकी आवश्यकता नहीं है तो लिंक की गई सूची का उपयोग करने की तुलना में यह बदसूरत है। सामान्य शर्तें अपवाद स्थितियों के संबंध में लागू होती हैं - एरियर लवाडॉक देखें।

— रिचीएच

List.size () -1 का उपयोग करना बहुत अच्छा नहीं है, लेकिन इसके लिए सिर्फ एक 3rd पार्टी एपीआई का उपयोग करना बदतर है

— Javo

Answer 1

निम्नलिखित Listइंटरफ़ेस का हिस्सा है (जो ArrayList लागू करता है):

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

Eतत्व प्रकार है। सूची खाली है, तो getएक फेंकता है IndexOutOfBoundsException। आप यहां संपूर्ण एपीआई प्रलेखन पा सकते हैं ।

Comments

क्या इससे सूची का पुनरावृत्ति होगा? वह मुझे बहुत कुशल नहीं लगता। मैं सी ++ से आता हूं, जहां सूची ऑब्जेक्ट पर वास्तविक फ्रंट () और बैक () तरीके हैं, जो आंतरिक रूप से सिर और पूंछ के संदर्भों के साथ कार्यान्वित किए जाते हैं। क्या जावा में एक समान तंत्र है?

— ब्रैडी

काम नहीं करेगा। यदि सूची खाली है, तो list.size () 0. वापस आ जाएगी और आप list.get (-1) के साथ समाप्त हो जाएंगे;

— एफआरआर

@ हेसर हह। वह सूची में अंतिम मूल्य प्राप्त करना चाहता है। निश्चित रूप से इसका मतलब है कि आकार () है> 0. यह किसी भी प्रकार के कार्यान्वयन के लिए सही होगा। अंत करने के लिए के माध्यम से पढ़ना बार जब आप अपनी टिप्पणी और जवाब देने के लिए :) मेरा जवाब अंत में कहते हैं मेरा समय लिखने के लिए की जरूरत को बचाया है | "यदि सूची खाली है, प्राप्त एक IndexOutOfBoundsException फेंकता है"

— Johannes Schaub - litb

@ Brady यह एक ArrayList के लिए O (n) पुनरावृत्ति का कारण नहीं होगा, क्योंकि जैसा कि आप अनुमान लगा सकते हैं, यह एक सरणी द्वारा समर्थित है। तो एक साधारण मिलता है (<सूचकांक>) एक सरणी से केवल एक निरंतर समय में परिणाम। (JDK स्रोत इसकी पुष्टि करता है) अन्य सूची कार्यान्वयनों के लिए, इसकी गारंटी नहीं है, इसलिए, उदाहरण के लिए, लिंक्डलिस्ट में एक गेटलैस्ट () विधि है जो निरंतर समय है।

— पीटर

मुझे समझ नहीं आ रहा है कि उन्होंने lastElement()अपने लिए एक सरल तरीका लागू करने का फैसला क्यों किया Vectorलेकिन इसके लिए नहीं ArrayList। उस असंगति के साथ क्या हो रहा है?

— स्टीफन दिमित्रोव

Answer 2

वेनिला जावा में एक सुंदर तरीका नहीं है।

Google अमरूद

गूगल अमरूद पुस्तकालय महान है - उनकी की जाँच Iterablesवर्ग । यह विधि तब फेंकेगी NoSuchElementExceptionयदि सूची खाली है, जैसा कि ए के विपरीत है IndexOutOfBoundsException, जैसा कि विशिष्ट size()-1दृष्टिकोण के साथ है - मुझे NoSuchElementExceptionबहुत अच्छा लगता है , या डिफ़ॉल्ट निर्दिष्ट करने की क्षमता:

lastElement = Iterables.getLast(iterableList);

अपवाद के बजाय यदि सूची खाली है, तो आप एक डिफ़ॉल्ट मान भी प्रदान कर सकते हैं:

lastElement = Iterables.getLast(iterableList, null);

या, यदि आप विकल्प का उपयोग कर रहे हैं:

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

Comments

क्या आप जानते हैं कि क्या यह विधि अंतिम तत्व को खोजने के लिए सूची के माध्यम से एक रैखिक चलना है?

— बिलमैन

@BillMan हैशसेट के मामले में हाँ, ArrayList सं।

— साइमन

आपको उस Iterables.getLastजाँच को जोड़ना चाहिए कि क्या RandomAccessलागू किया गया है और इसलिए यदि यह आइटम को O (1) में एक्सेस करता है।

— कार्ल रिक्टर

इसके बजाय Option, आप मूल जावा का उपयोग कर सकते हैं Optional। यह थोड़ा क्लीनर भी होगा lastElement = Optional.ofNullable(lastElementRaw);:।

— लिटिल हेल्पर

Answer 3

यह करना चाहिए:

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

Comments

वहाँ यह करने के लिए कोई चिकना तरीका है? : /

— कोमराधोमर

आपको शायद इसे प्रदर्शित करने का कम से कम प्रदर्शन करना चाहिए ... ArrayList.get साइड-इफ़ेक्ट फ्री है।

— एंटनी स्टब्स

क्या यह इंगित करना भी क्षुद्र है कि ऊपर वाला कुछ भी नहीं बताता / वापस नहीं करता है?

— ब्रायन एग्न्यू

अगर एक ArrayList में केवल एक रिकॉर्ड होता है, तो अपवाद होता है। समाधान क्या होगा?

— hasnain_ahmad

@hasnain_ahmad, जब ArraList में 1 तत्व ठीक से काम करता है, तो आपको शून्य रिकॉर्ड के साथ गैर-आरंभिक ArrayList और ArrayList के बारे में चिंता करनी चाहिए। और यह जवाब दोनों मामलों को संभालता है

— फरीद

Answer 4

मैं सूची के अंतिम (और पहले) तत्व प्राप्त करने के लिए माइक्रो-उपयोग वर्ग का उपयोग करता हूं:

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;
    }
}

---

थोड़ा और अधिक लचीला:

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();
  }
}

Comments

बस अमरूद का उपयोग करें। फिर से आविष्कार न

— करें

@ClickUpvote केवल एक छोटी विधि के लिए अमरूद का उपयोग करना कई मामलों में एक ओवरकिल है। मेरा जवाब वेनिला जावा समाधान की तलाश कर रहे लोगों के लिए है । यदि आप पहले से ही अपनी परियोजना में अमरूद का उपयोग कर रहे हैं, तो अमरूद-आधारित समाधान के लिए अन्य उत्तर देखें।

— 1811 बजे user11153

यदि आप अमरूद का उपयोग नहीं करते हैं, तो आप इस तरह के बहुत सारे उपयोगिता वर्ग लिखते हैं।

— अपवोट

कभी-कभी किसी एकल-मूल जावा वर्ग को जोड़ने की तुलना में तीसरे पक्ष के पुस्तकालय को जोड़ने की अनुमति बहुत अधिक हो सकती है। उदाहरण के लिए, सरकारी अनुबंध जहां वे तृतीय-पक्ष पुस्तकालयों को सीमित और स्क्रीन करते हैं।

— डेव जार्विस

isEmpty जाँच नहीं करता है कि सूची खाली है और इस प्रकार होनी चाहिए isNullOrEmpty और यह सवाल का हिस्सा नहीं है - या तो आप उत्तर के सेट को बढ़ाने की कोशिश करें या आप उपयोगिता कक्षाएं प्रदान करें (जो एक पुन: आविष्कार हैं)।

— कार्ल रिक्टर

Answer 5

size()विधि ArrayList में तत्वों की संख्या देता है। तत्वों के सूचकांक मान के 0माध्यम से होते हैं (size()-1), इसलिए आप myArrayList.get(myArrayList.size()-1)अंतिम तत्व को पुनः प्राप्त करने के लिए उपयोग करेंगे ।

Answer 6

लंबोदर का उपयोग करना:

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

Answer 7

यदि आप कर सकते हैं, ArrayListएक के लिए स्वैप करें ArrayDeque, जिसमें सुविधाजनक तरीके हैं removeLast।

Comments

प्रत्यक्ष पहुंच के लिए निरंतर लागत की तुलना में इसका मतलब कम से कम रैखिक लागत है, लेकिन ध्यान देने योग्य है।

— कार्ल रिक्टर

@ कर्लरिचर हां। यह ArrayDeque के इंटरफ़ेस में प्राप्त (int) जैसी विधियों की अनुपस्थिति से मेल खाती है। यह मेरा सुझाव है कि "यदि आप कर सकते हैं"; यदि सूची को अनुक्रमणिका द्वारा एक्सेस नहीं किया जा रहा है, तो शायद इसे सूची बनाने की आवश्यकता नहीं है।

— जॉन ग्लासमेयर

Answer 8

जावा में सूची के अंतिम तत्व को प्राप्त करने का कोई सुंदर तरीका नहीं है (उदाहरण items[-1]के लिए पायथन में)।

आपको उपयोग करना होगा list.get(list.size()-1)।

जटिल विधि कॉल द्वारा प्राप्त सूचियों के साथ काम करते समय, वर्कअराउंड अस्थायी चर में होता है:

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

यह बदसूरत और अक्सर महंगा या यहां तक ​​कि काम नहीं करने वाले संस्करण से बचने का एकमात्र विकल्प है:

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

यह अच्छा होगा यदि इस डिजाइन दोष के लिए जावा जावा एपीआई को ठीक किया गया था।

Comments

मुझे यहां "डिज़ाइन दोष" नहीं दिखता है, जो आप लाते हैं वह एक दुर्लभ उपयोग का मामला है जो Listइंटरफ़ेस में जोड़ा जाने लायक नहीं है । यदि आप केवल अंतिम तत्व में रुचि रखते हैं, तो आप किसी सूची को वापस करने की विधि क्यों कह सकते हैं? मुझे याद नहीं कि मैंने ऐसा पहले कभी देखा हो।

— डोरियन ग्रे

@DorianGray एक सूची से अंतिम तत्व पढ़ना एक बहुत ही सामान्य ऑपरेशन है और list.get(list.size()-1)इस मुद्दे को दिखाने वाला न्यूनतम उदाहरण है। मैं सहमत हूं कि "उन्नत" उदाहरण विवादास्पद हो सकता है और संभवतः एक किनारे का मामला हो सकता है, मैं सिर्फ यह दिखाना चाहता था कि इस मुद्दे को और कैसे प्रचारित किया जा सकता है। मान someObjectलेते हैं कि बाहरी पुस्तकालय से आने वाला वर्ग विदेशी है।

— Tregoreg

मैं नहीं देखता कि यह कहाँ बहुत आम है, और अगर यह है, तो आप ArrayDequeइसके बजाय बेहतर उपयोग करते हैं।

— डोरियन ग्रे

@ डोरियनग्रे इस सवाल में बहुत सारे अप्रोच और विचार हैं, इसलिए बहुत से लोगों को अंतिम मूल्य प्राप्त करने में दिलचस्पी है ArrayList।

— ट्रेगोरग

Answer 9

जैसा कि समाधान में कहा गया है, यदि Listखाली है तो IndexOutOfBoundsExceptionफेंक दिया जाता है। एक बेहतर समाधान Optionalप्रकार का उपयोग करना है :

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

जैसा कि आप उम्मीद करेंगे, सूची का अंतिम तत्व एक के रूप में वापस आ गया है Optional:

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

यह खाली सूचियों के साथ भी इनायत से पेश आता है:

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

Answer 10

यदि आप इसके बजाय एक लिंक्डलिस्ट का उपयोग करते हैं, तो आप पहले तत्व और अंतिम को सिर्फ getFirst()और getLast()(यदि आप आकार की तुलना में एक क्लीनर तरीका चाहते हैं) का उपयोग कर सकते हैं (-1) और प्राप्त करें (0))

कार्यान्वयन

एक लिंक्डलिस्ट घोषित करें

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

फिर यह वे विधियाँ हैं जिनका आप उपयोग कर सकते हैं कि आप क्या चाहते हैं, इस मामले में हम एक सूची के सबसे पहले और पिछले तत्व के बारे में बात कर रहे हैं

/**
     * 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);
    }

तो, फिर आप उपयोग कर सकते हैं

mLinkedList.getLast(); 

सूची का अंतिम तत्व प्राप्त करने के लिए।

Answer 11

अमरूद अंतिम तत्व को प्राप्त करने का एक और तरीका प्रदान करता है List:

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

यदि प्रदान की गई सूची खाली है तो यह फेंकता है a IndexOutOfBoundsException

Comments

java.util.Collections#reverseयह भी करता है।

— RoBeaToZ

@RoBeaToZ, यह करता है, लेकिन यह इसके माध्यम से पुनरावृत्ति करके मूल सूची को बदल देता है और शून्य देता है, इसलिए यह इस उद्देश्य के लिए फिट नहीं है।

— pero_hero

Answer 12

चूंकि ArrayList में अनुक्रमण 0 से शुरू होता है और वास्तविक आकार से पहले एक जगह समाप्त होता है इसलिए अंतिम सरणी सूची तत्व को वापस करने के लिए सही कथन होगा:

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

उदाहरण के लिए:

यदि सरणी सूची का आकार 5 है, तो आकार -1 = 4 अंतिम सरणी तत्व को लौटाएगा।

Answer 13

सूची का अंतिम आइटम है list.size() - 1। संग्रह एक सरणी द्वारा समर्थित है और अनुक्रमणिका 0 पर प्रारंभ होती है।

तो सूची में तत्व 1 सरणी में इंडेक्स 0 पर है

सूची में तत्व 2 सरणी में सूचकांक 1 पर है

सूची में तत्व 3 सरणी में सूचकांक 2 पर है

और इसी तरह..

Comments

@ जोहान्सचैब के पहले उत्तर का कोई अतिरिक्त मूल्य नहीं

— कार्ल रिक्टर

Answer 14

यह कैसे .. कहीं आपकी कक्षा में ...

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;
    }

Answer 15

यदि आप अपनी सूची को संशोधित करते हैं, तो listIterator()अंतिम इंडेक्स (जो size()-1क्रमशः है) से उपयोग और पुनरावृति करें । यदि आप फिर से विफल होते हैं, तो अपनी सूची संरचना की जांच करें।

Answer 16

Arraylist का अंतिम मान प्राप्त करने के लिए आपको बस इतना करना है कि आकार () का उपयोग करें। पूर्व के लिए। यदि आप पूर्णांकों की श्रेणीबद्धता करते हैं, तो अंतिम मूल्य प्राप्त करने के लिए आपको करना होगा

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

याद रखें, एक Arraylist में तत्वों को सूचकांक मूल्यों का उपयोग करके पहुँचा जा सकता है। इसलिए, ArrayLists आमतौर पर आइटम खोजने के लिए उपयोग किया जाता है।

Comments

@ जोहान्सचैब के पहले उत्तर का कोई अतिरिक्त मूल्य नहीं

— कार्ल रिक्टर

Answer 17

सरणियाँ 'लंबाई' नामक एक स्थानीय चर में अपने आकार को संग्रहीत करती हैं। "A" नामक एक सरणी को देखते हुए आप सूचकांक मूल्य को जाने बिना अंतिम सूचकांक को संदर्भित करने के लिए निम्नलिखित का उपयोग कर सकते हैं

एक [a.length-1]

आपके द्वारा उपयोग किए जाने वाले इस अंतिम सूचकांक में 5 का मान निर्दिष्ट करने के लिए:

एक [a.length-1] = 5;

Comments

यह ArrayListएक सरणी नहीं है।

— glee8e

Answer 18

स्ट्रीम API का उपयोग करके वैकल्पिक:

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

अंतिम तत्व के एक वैकल्पिक में परिणाम।

Answer 19

कोटलिन में, आप इस विधि का उपयोग कर सकते हैं last:

val lastItem = list.last()

Comments

हालांकि यह जावा है

— Jachdich

कोटलिन बनाने के पीछे के विचारों में से एक जावा के छोटे असहज पक्षों को कवर करना था। इसलिए मुझे लगता है कि यह कोटलिन पर विचार करने की सिफारिश करने के लिए समझ में आता है, कम से कम एप्लिकेशन के उन हिस्सों के लिए जो डेटा एनालिसिस करते हैं।

— एरिक स्वेन प्यूडिस्ट 21