ArrayList.Item[Int32] Proprietà

public:
 virtual property System::Object ^ default[int] { System::Object ^ get(int index); void set(int index, System::Object ^ value); };

public virtual object this[int index] { get; set; }

member this.Item(int) : obj with get, set

Default Public Overridable Property Item(index As Integer) As Object

Parametri

Valore della proprietà

Elemento in corrispondenza dell'indice specificato.

Implementazioni

Eccezioni

Esempio

Nell'esempio di codice seguente viene creato un oggetto ArrayList e vengono aggiunti diversi elementi. Nell'esempio viene illustrato l'accesso agli elementi con la Item[] proprietà (l'indicizzatore in C#) e la modifica di un elemento assegnando un nuovo valore alla Item[] proprietà per un indice specificato. Nell'esempio viene inoltre illustrato che la Item[] proprietà non può essere utilizzata per accedere o aggiungere elementi esterni alle dimensioni correnti dell'elenco.

using System;
using System.Collections;

public class Example
{
    public static void Main()
    {
        // Create an empty ArrayList, and add some elements.
        ArrayList stringList = new ArrayList();

        stringList.Add("a");
        stringList.Add("abc");
        stringList.Add("abcdef");
        stringList.Add("abcdefg");

        // The Item property is an indexer, so the property name is
        // not required.
        Console.WriteLine("Element {0} is \"{1}\"", 2, stringList[2]);

        // Assigning a value to the property changes the value of
        // the indexed element.
        stringList[2] = "abcd";
        Console.WriteLine("Element {0} is \"{1}\"", 2, stringList[2]);

        // Accessing an element outside the current element count
        // causes an exception.
        Console.WriteLine("Number of elements in the list: {0}",
            stringList.Count);
        try
        {
            Console.WriteLine("Element {0} is \"{1}\"",
                stringList.Count, stringList[stringList.Count]);
        }
        catch(ArgumentOutOfRangeException aoore)
        {
            Console.WriteLine("stringList({0}) is out of range.",
                stringList.Count);
        }

        // You cannot use the Item property to add new elements.
        try
        {
            stringList[stringList.Count] = "42";
        }
        catch(ArgumentOutOfRangeException aoore)
        {
            Console.WriteLine("stringList({0}) is out of range.",
                stringList.Count);
        }

        Console.WriteLine();
        for (int i = 0; i < stringList.Count; i++)
        {
            Console.WriteLine("Element {0} is \"{1}\"", i,
                stringList[i]);
        }

        Console.WriteLine();
        foreach (object o in stringList)
        {
            Console.WriteLine(o);
        }
    }
}
/*
 This code example produces the following output:

Element 2 is "abcdef"
Element 2 is "abcd"
Number of elements in the list: 4
stringList(4) is out of range.
stringList(4) is out of range.

Element 0 is "a"
Element 1 is "abc"
Element 2 is "abcd"
Element 3 is "abcdefg"

a
abc
abcd
abcdefg
 */

Imports System.Collections

Public Class Example

    Public Shared Sub Main

        ' Create an empty ArrayList, and add some elements.
        Dim stringList As New ArrayList

        stringList.Add("a")
        stringList.Add("abc")
        stringList.Add("abcdef")
        stringList.Add("abcdefg")

        ' Item is the default property, so the property name is
        ' not required.
        Console.WriteLine("Element {0} is ""{1}""", 2, stringList(2))

        ' Assigning a value to the property changes the value of
        ' the indexed element.
        stringList(2) = "abcd"
        Console.WriteLine("Element {0} is ""{1}""", 2, stringList(2))

        ' Accessing an element outside the current element count
        ' causes an exception. The ArrayList index is zero-based,
        ' so the index of the last element is (Count - 1). 
        Console.WriteLine("Number of elements in the list: {0}", _
            stringList.Count)
        Try
            Console.WriteLine("Element {0} is ""{1}""", _
                stringList.Count, _
                stringList(stringList.Count))
        Catch aoore As ArgumentOutOfRangeException
            Console.WriteLine("stringList({0}) is out of range.", _
                stringList.Count)
        End Try

        ' You cannot use the Item property to add new elements.
        Try
            stringList(stringList.Count) = "42"
        Catch aoore As ArgumentOutOfRangeException
            Console.WriteLine("stringList({0}) is out of range.", _
                stringList.Count)
        End Try

        Console.WriteLine()
        For i As Integer = 0 To stringList.Count - 1
            Console.WriteLine("Element {0} is ""{1}""", i, stringList(i))
        Next

        Console.WriteLine()
        For Each o As Object In stringList
            Console.WriteLine(o)
        Next

    End Sub

End Class
'
' This code example produces the following output:
'
'Element 2 is "abcdef"
'Element 2 is "abcd"
'Number of elements in the list: 4
'stringList(4) is out of range.
'stringList(4) is out of range.
'
'Element 0 is "a"
'Element 1 is "abc"
'Element 2 is "abcd"
'Element 3 is "abcdefg"
'
'a
'abc
'abcd
'abcdefg

Nell'esempio seguente viene utilizzata la Item[] proprietà in modo esplicito per assegnare valori agli elementi nell'elenco. Nell'esempio viene definita una classe che eredita un ArrayList oggetto e viene aggiunto un metodo per eseguire lo scramble degli elementi di elenco.

using System;
using System.Collections;

public class ScrambleList : ArrayList
{
    public static void Main()
    {
        // Create an empty ArrayList, and add some elements.
        ScrambleList integerList = new ScrambleList();

        for (int i = 0; i < 10; i++)
        {
            integerList.Add(i);
        }

        Console.WriteLine("Ordered:\n");
        foreach (int value in integerList)
        {
            Console.Write("{0}, ", value);
        }
        Console.WriteLine("<end>\n\nScrambled:\n");

        // Scramble the order of the items in the list.
        integerList.Scramble();

        foreach (int value in integerList)
        {
            Console.Write("{0}, ", value);
        }
        Console.WriteLine("<end>\n");
    }

    public void Scramble()
    {
        int limit = this.Count;
        int temp;
        int swapindex;
        Random rnd = new Random();
        for (int i = 0; i < limit; i++)
        {
            // The Item property of ArrayList is the default indexer. Thus,
            // this[i] is used instead of Item[i].
            temp = (int)this[i];
            swapindex = rnd.Next(0, limit - 1);
            this[i] = this[swapindex];
            this[swapindex] = temp;
        }
    }
}

// The program produces output similar to the following:
//
// Ordered:
//
// 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, <end>
//
// Scrambled:
//
// 5, 2, 8, 9, 6, 1, 7, 0, 4, 3, <end>

Imports System.Collections

Public Class ScrambleList
    Inherits ArrayList

    Public Shared Sub Main()
        ' Create an empty ArrayList, and add some elements.
        Dim integerList As New ScrambleList()

        For i As Integer = 0 To 9
            integerList.Add(i)
        Next i

        Console.WriteLine("Ordered:" + Environment.NewLine)
        For Each value As Integer In integerList
            Console.Write("{0}, ", value)
        Next value
        Console.WriteLine("<end>" + Environment.NewLine + Environment.NewLine + "Scrambled:" + Environment.NewLine)

        ' Scramble the order of the items in the list.
        integerList.Scramble()

        For Each value As Integer In integerList
            Console.Write("{0}, ", value)
        Next value
        Console.WriteLine("<end>" + Environment.NewLine)
    End Sub

    Public Sub Scramble()
        Dim limit As Integer = MyClass.Count
        Dim temp As Integer
        Dim swapindex As Integer
        Dim rnd As New Random()
        For i As Integer = 0 To limit - 1
            ' The Item property of ArrayList is the default indexer. Thus,
            ' Me(i) and MyClass.Item(i) are used interchangeably.
            temp = CType(Me(i), Integer)
            swapindex = rnd.Next(0, limit - 1)
            MyClass.Item(i) = Me(swapindex)
            MyClass.Item(swapindex) = temp
        Next i
    End Sub
End Class

' The program produces output similar to the following:
'
' Ordered:
'
' 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, <end>
'
' Scrambled:
'
' 5, 2, 8, 9, 6, 1, 7, 0, 4, 3, <end>

Commenti

Restituisce Item[] un Objectoggetto , pertanto potrebbe essere necessario eseguire il cast del valore restituito al tipo originale per modificarlo. È importante notare che ArrayList non è una raccolta fortemente tipizzata. Per un'alternativa fortemente tipizzata, vedere List<T>.

ArrayList accetta null come valore valido e consente elementi duplicati.

Questa proprietà consente di accedere a un elemento specifico dell'insieme usando la sintassi seguente: myCollection[index].

Il linguaggio C# usa la this parola chiave per definire gli indicizzatori anziché implementare la Item[] proprietà . Visual Basic implementa Item[] come proprietà predefinita, che fornisce la stessa funzionalità di indicizzazione.

Il recupero del valore di questa proprietà è un'operazione O(1) . L'impostazione della proprietà è anche un'operazione O(1) .

Vedi anche

• Count