ArrayList.Item[Int32] Property
Definition
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Gets or sets the element at the specified index.
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 ObjectParameters
- index
- Int32
The zero-based index of the element to get or set.
Property Value
The element at the specified index.
Implements
Exceptions
Examples
The following code example creates an ArrayList and adds several items. The example demonstrates accessing elements with the Item[] property (the indexer in C#), and changing an element by assigning a new value to the Item[] property for a specified index. The example also shows that the Item[] property cannot be used to access or add elements outside the current size of the list.
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
The following example uses the Item[] property explicitly to assign values to items in the list. The example defines a class that inherits an ArrayList and adds a method to scramble the list items.
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>
Remarks
The Item[] returns an Object, so you may need to cast the returned value to the original type in order to manipulate it. It is important to note that ArrayList is not a strongly-typed collection. For a strongly-typed alternative, see List<T>.
ArrayList accepts null as a valid value and allows duplicate elements.
This property provides the ability to access a specific element in the collection by using the following syntax: myCollection[index].
The C# language uses the this keyword to define the indexers instead of implementing the Item[] property. Visual Basic implements Item[] as a default property, which provides the same indexing functionality.
Retrieving the value of this property is an O(1) operation; setting the property is also an O(1) operation.
Applies to
See also
Colaborați cu noi pe GitHub
Sursa pentru acest conținut poate fi găsită pe GitHub, unde puteți, de asemenea, să creați și să consultați probleme și solicitări de tragere. Pentru mai multe informații, consultați ghidul nostru pentru colaboratori.
