ArrayList.Item[Int32] Proprietà
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Ottiene o imposta l'elemento in corrispondenza dell'indice specificato.
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; }public virtual object? this[int index] { get; set; }member this.Item(int) : obj with get, setDefault Public Overridable Property Item(index As Integer) As ObjectParametri
- index
- Int32
Indice in base zero dell'elemento da ottenere o impostare.
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à (indicizzatore in C#) e la modifica di un elemento assegnando un nuovo valore alla Item[] proprietà per un indice specificato. L'esempio mostra anche che la Item[] proprietà non può essere usata per accedere o aggiungere elementi esterni alle dimensioni correnti dell'elenco.
using namespace System;
using namespace System::Collections;
public ref class Example
{
public:
static void Main()
{
// Create an empty ArrayList, and add some elements.
ArrayList^ stringList = gcnew 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();
for each (Object^ o in stringList)
{
Console::WriteLine(o);
}
}
};
int main()
{
Example::Main();
}
/*
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
*/
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 usata in modo esplicito la Item[] proprietà per assegnare valori agli elementi dell'elenco. L'esempio definisce una classe che eredita un ArrayList oggetto e aggiunge un metodo per eseguire lo scramble degli elementi dell'elenco.
using namespace System;
using namespace System::Collections;
public ref class ScrambleList : public ArrayList
{
public:
static void Main()
{
// Create an empty ArrayList, and add some elements.
ScrambleList^ integerList = gcnew ScrambleList();
for (int i = 0; i < 10; i++)
{
integerList->Add(i);
}
Console::WriteLine("Ordered:\n");
for each (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();
for each (int value in integerList)
{
Console::Write("{0}, ", value);
}
Console::WriteLine("<end>\n");
}
void Scramble()
{
int limit = this->Count;
int temp;
int swapindex;
Random^ rnd = gcnew Random();
for (int i = 0; i < limit; i++)
{
// The Item property of ArrayList is the default indexer. Thus,
// this->default[i] and this[i] are used interchangeably.
temp = (int)this->default[i];
swapindex = rnd->Next(0, limit - 1);
this[i] = this->default[swapindex];
this[swapindex] = temp;
}
}
};
int main()
{
ScrambleList::Main();
}
// 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>
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
Item[] restituisce Object, pertanto potrebbe essere necessario eseguire il cast del valore restituito nel tipo originale per modificarlo. È importante notare che la 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 nella raccolta utilizzando la sintassi seguente: myCollection[index].
Nel linguaggio C# viene utilizzata la parola chiave this per definire gli indicizzatori anziché implementare la proprietà Item[]. In Visual Basic la proprietà Item[] viene implementata come predefinita per fornire 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) .
Si applica a
Vedi anche
Collabora con noi su GitHub
L'origine di questo contenuto è disponibile in GitHub, in cui è anche possibile creare ed esaminare i problemi e le richieste pull. Per ulteriori informazioni, vedere la guida per i collaboratori.
