Array.Copy Method

Definition

Zkopíruje rozsah prvků v jednom Array do jiného Array a v případě potřeby provede přetypování a zabalení typu.Copies a range of elements in one Array to another Array and performs type casting and boxing as required.

Overloads

Copy(Array, Int64, Array, Int64, Int64)

Zkopíruje rozsah prvků z Array počínaje zadaným indexem zdroje a vloží je do jiného Array počínaje zadaným indexem cíle.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. Délka a indexy jsou zadány jako čísla 64 bitů.The length and the indexes are specified as 64-bit integers.

Copy(Array, Int32, Array, Int32, Int32)

Zkopíruje rozsah prvků z Array počínaje zadaným indexem zdroje a vloží je do jiného Array počínaje zadaným indexem cíle.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. Délka a indexy jsou zadány jako čísla 32 bitů.The length and the indexes are specified as 32-bit integers.

Copy(Array, Array, Int64)

Zkopíruje rozsah prvků z Array počínaje prvním prvkem a vloží je do jiného Array počínaje prvním prvkem.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. Délka je určena jako 64 celé číslo.The length is specified as a 64-bit integer.

Copy(Array, Array, Int32)

Zkopíruje rozsah prvků z Array počínaje prvním prvkem a vloží je do jiného Array počínaje prvním prvkem.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. Délka je určena jako 32 celé číslo.The length is specified as a 32-bit integer.

Copy(Array, Int64, Array, Int64, Int64)

Zkopíruje rozsah prvků z Array počínaje zadaným indexem zdroje a vloží je do jiného Array počínaje zadaným indexem cíle.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. Délka a indexy jsou zadány jako čísla 64 bitů.The length and the indexes are specified as 64-bit integers.

public:
 static void Copy(Array ^ sourceArray, long sourceIndex, Array ^ destinationArray, long destinationIndex, long length);
public static void Copy (Array sourceArray, long sourceIndex, Array destinationArray, long destinationIndex, long length);
static member Copy : Array * int64 * Array * int64 * int64 -> unit
Public Shared Sub Copy (sourceArray As Array, sourceIndex As Long, destinationArray As Array, destinationIndex As Long, length As Long)

Parameters

sourceArray
Array

Array obsahující data ke zkopírování.The Array that contains the data to copy.

sourceIndex
Int64

64 celé číslo, které představuje index v sourceArray, ve kterém začíná kopírování.A 64-bit integer that represents the index in the sourceArray at which copying begins.

destinationArray
Array

Array, který přijímá data.The Array that receives the data.

destinationIndex
Int64

64 celé číslo, které představuje index v destinationArray, v němž začíná ukládání.A 64-bit integer that represents the index in the destinationArray at which storing begins.

length
Int64

64 celé číslo, které představuje počet prvků, které mají být zkopírovány.A 64-bit integer that represents the number of elements to copy. Celé číslo musí být mezi nulou a MaxValuevčetně.The integer must be between zero and MaxValue, inclusive.

Exceptions

sourceArray je null.sourceArray is null.

-nebo--or- destinationArray je null.destinationArray is null.

sourceArray a destinationArray mají odlišné pořadí.sourceArray and destinationArray have different ranks.

sourceArray a destinationArray jsou nekompatibilní typy.sourceArray and destinationArray are of incompatible types.

Nejméně jeden prvek v sourceArray nelze přetypovat na typ destinationArray.At least one element in sourceArray cannot be cast to the type of destinationArray.

sourceIndex je mimo rozsah platných indexů pro sourceArray.sourceIndex is outside the range of valid indexes for the sourceArray.

-nebo--or- destinationIndex je mimo rozsah platných indexů pro destinationArray.destinationIndex is outside the range of valid indexes for the destinationArray.

-nebo--or- length je menší než 0 nebo větší než MaxValue.length is less than 0 or greater than MaxValue.

length je větší než počet prvků od sourceIndex na konec sourceArray.length is greater than the number of elements from sourceIndex to the end of sourceArray.

-nebo--or- length je větší než počet prvků od destinationIndex na konec destinationArray.length is greater than the number of elements from destinationIndex to the end of destinationArray.

Examples

Následující příklad kódu ukazuje, jak kopírovat z jednoho Array typu Object do jiného Array typu Integer.The following code example shows how to copy from one Array of type Object to another Array of type integer.

using namespace System;
void PrintValues( Array^ myArr );
void main()
{
   
   // Creates and initializes a new Array instance of type Int32.
   Array^ myIntArray = Array::CreateInstance( Type::GetType(  "System.Int32" ), 5 );
   for ( int i = myIntArray->GetLowerBound( 0 ); i <= myIntArray->GetUpperBound( 0 ); i++ )
      myIntArray->SetValue( i + 1, i );
   
   // Creates and initializes a new Array instance of type Object.
   Array^ myObjArray = Array::CreateInstance( Type::GetType(  "System.Object" ), 5 );
   for ( int i = myObjArray->GetLowerBound( 0 ); i <= myObjArray->GetUpperBound( 0 ); i++ )
      myObjArray->SetValue( i + 26, i );
   
   // Displays the initial values of both arrays.
   Console::WriteLine(  "Int32 array:" );
   PrintValues( myIntArray );
   Console::WriteLine(  "Object array:" );
   PrintValues( myObjArray );
   
   // Copies the first element from the Int32 array to the Object array.
   Array::Copy( myIntArray, myIntArray->GetLowerBound( 0 ), myObjArray, myObjArray->GetLowerBound( 0 ), 1 );
   
   // Copies the last two elements from the Object array to the Int32 array.
   Array::Copy( myObjArray, myObjArray->GetUpperBound( 0 ) - 1, myIntArray, myIntArray->GetUpperBound( 0 ) - 1, 2 );
   
   // Displays the values of the modified arrays.
   Console::WriteLine(  "Int32 array - Last two elements should now be the same as Object array:" );
   PrintValues( myIntArray );
   Console::WriteLine(  "Object array - First element should now be the same as Int32 array:" );
   PrintValues( myObjArray );
}

void PrintValues( Array^ myArr )
{
   System::Collections::IEnumerator^ myEnumerator = myArr->GetEnumerator();
   int i = 0;
   int cols = myArr->GetLength( myArr->Rank - 1 );
   while ( myEnumerator->MoveNext() )
   {
      if ( i < cols )
      {
         i++;
      }
      else
      {
         Console::WriteLine();
         i = 1;
      }

      Console::Write(  "\t{0}", myEnumerator->Current );
   }

   Console::WriteLine();
}

/*
 This code produces the following output.
 
 Int32 array:
     1    2    3    4    5
 Object array:
     26    27    28    29    30
 Int32 array - Last two elements should now be the same as Object array:
     1    2    3    29    30
 Object array - First element should now be the same as Int32 array:
     1    27    28    29    30
 */
using System;
public class SamplesArray  {

   public static void Main()  {

      // Creates and initializes a new Array of type Int32.
      Array myIntArray=Array.CreateInstance( typeof(System.Int32), 5 );
      for ( int i = myIntArray.GetLowerBound(0); i <= myIntArray.GetUpperBound(0); i++ )
         myIntArray.SetValue( i+1, i );

      // Creates and initializes a new Array of type Object.
      Array myObjArray = Array.CreateInstance( typeof(System.Object), 5 );
      for ( int i = myObjArray.GetLowerBound(0); i <= myObjArray.GetUpperBound(0); i++ )
         myObjArray.SetValue( i+26, i );

      // Displays the initial values of both arrays.
      Console.WriteLine( "Int32 array:" );
      PrintValues( myIntArray );
      Console.WriteLine( "Object array:" );
      PrintValues( myObjArray );

      // Copies the first element from the Int32 array to the Object array.
      Array.Copy( myIntArray, myIntArray.GetLowerBound(0), myObjArray, myObjArray.GetLowerBound(0), 1 );

      // Copies the last two elements from the Object array to the Int32 array.
      Array.Copy( myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, myIntArray.GetUpperBound(0) - 1, 2 );

      // Displays the values of the modified arrays.
      Console.WriteLine( "Int32 array - Last two elements should now be the same as Object array:" );
      PrintValues( myIntArray );
      Console.WriteLine( "Object array - First element should now be the same as Int32 array:" );
      PrintValues( myObjArray );
   }

   public static void PrintValues( Array myArr )  {
      System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
      int i = 0;
      int cols = myArr.GetLength( myArr.Rank - 1 );
      while ( myEnumerator.MoveNext() )  {
         if ( i < cols )  {
            i++;
         } else  {
            Console.WriteLine();
            i = 1;
         }
         Console.Write( "\t{0}", myEnumerator.Current );
      }
      Console.WriteLine();
   }
}
/*
This code produces the following output.

Int32 array:
    1    2    3    4    5
Object array:
    26    27    28    29    30
Int32 array - Last two elements should now be the same as Object array:
    1    2    3    29    30
Object array - First element should now be the same as Int32 array:
    1    27    28    29    30
*/
Public Class SamplesArray    
    
    Public Shared Sub Main()
        
        ' Creates and initializes a new Array of type Int32.
        Dim myIntArray As Array = _
           Array.CreateInstance(GetType(System.Int32), 5)
        Dim i As Integer
        For i = myIntArray.GetLowerBound(0) To myIntArray.GetUpperBound(0)
            myIntArray.SetValue(i + 1, i)
        Next i 
        ' Creates and initializes a new Array of type Object.
        Dim myObjArray As Array = _
           Array.CreateInstance(GetType(System.Object), 5)
        For i = myObjArray.GetLowerBound(0) To myObjArray.GetUpperBound(0)
            myObjArray.SetValue(i + 26, i)
        Next i 
        ' Displays the initial values of both arrays.
        Console.WriteLine("Int32 array:")
        PrintValues(myIntArray)
        Console.WriteLine("Object array:")
        PrintValues(myObjArray)
        
        ' Copies the first element from the Int32 array to the Object array.
        Array.Copy(myIntArray, myIntArray.GetLowerBound(0), myObjArray, _
           myObjArray.GetLowerBound(0), 1)
        
        ' Copies the last two elements from the Object array to the Int32 array.
        Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, _
           myIntArray.GetUpperBound(0) - 1, 2)
        
        ' Displays the values of the modified arrays.
        Console.WriteLine("Int32 array - Last two elements should now be " _
           + "the same as Object array:")
        PrintValues(myIntArray)
        Console.WriteLine("Object array - First element should now be the " _
           + "same as Int32 array:")
        PrintValues(myObjArray)
    End Sub
    
    Public Shared Sub PrintValues(myArr As Array)
        Dim myEnumerator As System.Collections.IEnumerator = _
           myArr.GetEnumerator()
        Dim i As Integer = 0
        Dim cols As Integer = myArr.GetLength((myArr.Rank - 1))
        While myEnumerator.MoveNext()
            If i < cols Then
                i += 1
            Else
                Console.WriteLine()
                i = 1
            End If
            Console.Write(ControlChars.Tab + "{0}", myEnumerator.Current)
        End While
        Console.WriteLine()
    End Sub
End Class

' This code produces the following output.
' 
' Int32 array:
'     1    2    3    4    5
' Object array:
'     26    27    28    29    30
' Int32 array - Last two elements should now be the same as Object array:
'     1    2    3    29    30
' Object array - First element should now be the same as Int32 array:
'     1    27    28    29    30

Remarks

Parametry sourceArray a destinationArray musí mít stejný počet rozměrů.The sourceArray and destinationArray parameters must have the same number of dimensions. Kromě toho musí být destinationArray již dimenze a musí mít dostatečný počet prvků od destinationIndex pozice pro umístění kopírovaných dat.In addition, destinationArray must already have been dimensioned and must have a sufficient number of elements starting from the destinationIndex position to accommodate the copied data.

Při kopírování mezi multidimenzionálními poli se pole chová jako dlouhé jednorozměrné pole, kde jsou řádky (nebo sloupce) koncepčně rozloženy na konec.When copying between multidimensional arrays, the array behaves like a long one-dimensional array, where the rows (or columns) are conceptually laid end-to-end. Obsahuje-li pole například tři řádky (nebo sloupce) po čtyřech prvcích, při kopírování šesti prvků od začátku pole budou zkopírovány všechny čtyři prvky z prvního řádku (nebo sloupce) a první dva prvky z druhého řádku (nebo sloupce).For example, if an array has three rows (or columns) with four elements each, copying six elements from the beginning of the array would copy all four elements of the first row (or column) and the first two elements of the second row (or column). Chcete-li začít kopírovat z druhého prvku třetího řádku (nebo sloupce), sourceIndex musí být horní mezí prvního řádku (nebo sloupce) a také délka druhého řádku (nebo sloupce) a dvou.To start copying from the second element of the third row (or column), sourceIndex must be the upper bound of the first row (or column) plus the length of the second row (or column) plus two.

Pokud se sourceArray a destinationArray překrývají, tato metoda se chová, jako by původní hodnoty sourceArray byly zachovány v dočasném umístění před přepsáním destinationArray.If sourceArray and destinationArray overlap, this method behaves as if the original values of sourceArray were preserved in a temporary location before destinationArray is overwritten.

[C++][C++]

Tato metoda je ekvivalentní standardnímu memmoveC/C++ Function, nikoli memcpy.This method is equivalent to the standard C/C++ function memmove, not memcpy.

Pole mohou být odkazového nebo hodnotového typu.The arrays can be reference-type arrays or value-type arrays. Podle potřeby je provedeno přetypování na nižší typ.Type downcasting is performed, as required.

  • Při kopírování z pole typu odkazu do pole typu hodnoty je každý prvek nejprve vybalen a poté zkopírován.When copying from a reference-type array to a value-type array, each element is unboxed and then copied. Při kopírování z pole typu hodnoty do pole typu odkazu je každý prvek nejprve zabalen a poté zkopírován.When copying from a value-type array to a reference-type array, each element is boxed and then copied.

  • Při kopírování z pole typu odkazu nebo hodnoty do Object pole je vytvořena Object pro uchování každé hodnoty nebo odkazu a následné zkopírování.When copying from a reference-type or value-type array to an Object array, an Object is created to hold each value or reference and then copied. Při kopírování z Object pole do pole typu odkazu nebo hodnoty a přiřazení není možné, je vyvolána InvalidCastException.When copying from an Object array to a reference-type or value-type array and the assignment is not possible, an InvalidCastException is thrown.

  • Pokud sourceArray a destinationArray jsou obě pole typu odkazu nebo se jedná o pole typu Object, provede se kopie bez podstruktury.If sourceArray and destinationArray are both reference-type arrays or are both arrays of type Object, a shallow copy is performed. Kopie Array bez podstruktury je nová Array obsahující odkazy na stejné prvky jako původní Array.A shallow copy of an Array is a new Array containing references to the same elements as the original Array. Nekopírují se samotné prvky ani objekty, na které odkazují.The elements themselves or anything referenced by the elements are not copied. Naproti tomu hluboká kopie Array kopíruje prvky a vše přímo nebo nepřímo odkazované prvky.In contrast, a deep copy of an Array copies the elements and everything directly or indirectly referenced by the elements.

Je-li pole nekompatibilních typů, je vyvolána ArrayTypeMismatchException.An ArrayTypeMismatchException is thrown if the arrays are of incompatible types. Kompatibilita typů je definována takto:Type compatibility is defined as follows:

  • Typ je kompatibilní sám se sebou.A type is compatible with itself.

  • Typ hodnoty je kompatibilní s Object a s typem rozhraní implementovaným tímto typem hodnoty.A value type is compatible with Object and with an interface type implemented by that value type. Typ hodnoty je považován za připojený k rozhraní jen tehdy, když toto rozhraní přímo implementuje.A value type is considered connected to an interface only if it implements that interface directly. Odpojené typy nejsou kompatibilní.Disconnected types are not compatible.

  • Dva vnitřní (předdefinované) typy hodnot jsou kompatibilní, pokud platí, že kopírování ze zdrojového do cílového typu je rozšiřující převod.Two intrinsic (predefined) value types are compatible if copying from the source type to the destination type is a widening conversion. Při rozšiřujícím převodu nikdy nedochází ke ztrátě informací, zatímco u zužujícího převodu k ní dojít může.A widening conversion never loses information, whereas a narrowing conversion can lose information. Převod 32bitového celého čísla se znaménkem na 64bitové celé číslo se znaménkem je rozšiřující; převod 64bitového celého čísla se znaménkem na 32bitové celé číslo se znaménkem je zužující.For example, converting a 32-bit signed integer to a 64-bit signed integer is a widening conversion, and converting a 64-bit signed integer to a 32-bit signed integer is a narrowing conversion. Další informace o převodech naleznete v tématu Convert.For more information about conversions, see Convert.

  • Jiný než vnitřní typ hodnoty (definovaný uživatelem) je kompatibilní pouze sám se sebou.A nonintrinsic (user-defined) value type is compatible only with itself.

  • Výčty mají implicitní převod na Enum a na jejich podkladový typ.Enumerations have an implicit conversion to Enum and to their underlying type.

Pokud každý prvek v sourceArray vyžaduje přetypování (například ze základní třídy na odvozenou třídu nebo z rozhraní na objekt) a jeden nebo více prvků nelze přetypovat na odpovídající typ v destinationArray, je vyvolána InvalidCastException.If every element in sourceArray requires a downcast (for example, from a base class to a derived class or from an interface to an object) and one or more elements cannot be cast to the corresponding type in destinationArray, an InvalidCastException is thrown.

Pokud tato metoda vyvolá výjimku při kopírování, stav destinationArray není definován.If this method throws an exception while copying, the state of destinationArray is undefined.

Tato metoda je operace O (n), kde n je length.This method is an O(n) operation, where n is length.

See also

Copy(Array, Int32, Array, Int32, Int32)

Zkopíruje rozsah prvků z Array počínaje zadaným indexem zdroje a vloží je do jiného Array počínaje zadaným indexem cíle.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. Délka a indexy jsou zadány jako čísla 32 bitů.The length and the indexes are specified as 32-bit integers.

public:
 static void Copy(Array ^ sourceArray, int sourceIndex, Array ^ destinationArray, int destinationIndex, int length);
public static void Copy (Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length);
static member Copy : Array * int * Array * int * int -> unit
Public Shared Sub Copy (sourceArray As Array, sourceIndex As Integer, destinationArray As Array, destinationIndex As Integer, length As Integer)

Parameters

sourceArray
Array

Array obsahující data ke zkopírování.The Array that contains the data to copy.

sourceIndex
Int32

32 celé číslo, které představuje index v sourceArray, ve kterém začíná kopírování.A 32-bit integer that represents the index in the sourceArray at which copying begins.

destinationArray
Array

Array, který přijímá data.The Array that receives the data.

destinationIndex
Int32

32 celé číslo, které představuje index v destinationArray, v němž začíná ukládání.A 32-bit integer that represents the index in the destinationArray at which storing begins.

length
Int32

32 celé číslo, které představuje počet prvků, které mají být zkopírovány.A 32-bit integer that represents the number of elements to copy.

Exceptions

sourceArray je null.sourceArray is null.

-nebo--or- destinationArray je null.destinationArray is null.

sourceArray a destinationArray mají odlišné pořadí.sourceArray and destinationArray have different ranks.

sourceArray a destinationArray jsou nekompatibilní typy.sourceArray and destinationArray are of incompatible types.

Nejméně jeden prvek v sourceArray nelze přetypovat na typ destinationArray.At least one element in sourceArray cannot be cast to the type of destinationArray.

sourceIndex je menší než dolní mez prvního rozměru sourceArray.sourceIndex is less than the lower bound of the first dimension of sourceArray.

-nebo--or- destinationIndex je menší než dolní mez prvního rozměru destinationArray.destinationIndex is less than the lower bound of the first dimension of destinationArray.

-nebo--or- Hodnota length je menší než nula.length is less than zero.

length je větší než počet prvků od sourceIndex na konec sourceArray.length is greater than the number of elements from sourceIndex to the end of sourceArray.

-nebo--or- length je větší než počet prvků od destinationIndex na konec destinationArray.length is greater than the number of elements from destinationIndex to the end of destinationArray.

Examples

Následující příklad kódu ukazuje, jak kopírovat z jednoho Array typu Object do jiného Array typu Integer.The following code example shows how to copy from one Array of type Object to another Array of type integer.

using namespace System;
void PrintValues( Array^ myArr );
void main()
{
   
   // Creates and initializes a new Array instance of type Int32.
   Array^ myIntArray = Array::CreateInstance( Type::GetType(  "System.Int32" ), 5 );
   for ( int i = myIntArray->GetLowerBound( 0 ); i <= myIntArray->GetUpperBound( 0 ); i++ )
      myIntArray->SetValue( i + 1, i );
   
   // Creates and initializes a new Array instance of type Object.
   Array^ myObjArray = Array::CreateInstance( Type::GetType(  "System.Object" ), 5 );
   for ( int i = myObjArray->GetLowerBound( 0 ); i <= myObjArray->GetUpperBound( 0 ); i++ )
      myObjArray->SetValue( i + 26, i );
   
   // Displays the initial values of both arrays.
   Console::WriteLine(  "Int32 array:" );
   PrintValues( myIntArray );
   Console::WriteLine(  "Object array:" );
   PrintValues( myObjArray );
   
   // Copies the first element from the Int32 array to the Object array.
   Array::Copy( myIntArray, myIntArray->GetLowerBound( 0 ), myObjArray, myObjArray->GetLowerBound( 0 ), 1 );
   
   // Copies the last two elements from the Object array to the Int32 array.
   Array::Copy( myObjArray, myObjArray->GetUpperBound( 0 ) - 1, myIntArray, myIntArray->GetUpperBound( 0 ) - 1, 2 );
   
   // Displays the values of the modified arrays.
   Console::WriteLine(  "Int32 array - Last two elements should now be the same as Object array:" );
   PrintValues( myIntArray );
   Console::WriteLine(  "Object array - First element should now be the same as Int32 array:" );
   PrintValues( myObjArray );
}

void PrintValues( Array^ myArr )
{
   System::Collections::IEnumerator^ myEnumerator = myArr->GetEnumerator();
   int i = 0;
   int cols = myArr->GetLength( myArr->Rank - 1 );
   while ( myEnumerator->MoveNext() )
   {
      if ( i < cols )
      {
         i++;
      }
      else
      {
         Console::WriteLine();
         i = 1;
      }

      Console::Write(  "\t{0}", myEnumerator->Current );
   }

   Console::WriteLine();
}

/*
 This code produces the following output.
 
 Int32 array:
     1    2    3    4    5
 Object array:
     26    27    28    29    30
 Int32 array - Last two elements should now be the same as Object array:
     1    2    3    29    30
 Object array - First element should now be the same as Int32 array:
     1    27    28    29    30
 */
using System;
public class SamplesArray  {

   public static void Main()  {

      // Creates and initializes a new Array of type Int32.
      Array myIntArray=Array.CreateInstance( typeof(System.Int32), 5 );
      for ( int i = myIntArray.GetLowerBound(0); i <= myIntArray.GetUpperBound(0); i++ )
         myIntArray.SetValue( i+1, i );

      // Creates and initializes a new Array of type Object.
      Array myObjArray = Array.CreateInstance( typeof(System.Object), 5 );
      for ( int i = myObjArray.GetLowerBound(0); i <= myObjArray.GetUpperBound(0); i++ )
         myObjArray.SetValue( i+26, i );

      // Displays the initial values of both arrays.
      Console.WriteLine( "Int32 array:" );
      PrintValues( myIntArray );
      Console.WriteLine( "Object array:" );
      PrintValues( myObjArray );

      // Copies the first element from the Int32 array to the Object array.
      Array.Copy( myIntArray, myIntArray.GetLowerBound(0), myObjArray, myObjArray.GetLowerBound(0), 1 );

      // Copies the last two elements from the Object array to the Int32 array.
      Array.Copy( myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, myIntArray.GetUpperBound(0) - 1, 2 );

      // Displays the values of the modified arrays.
      Console.WriteLine( "Int32 array - Last two elements should now be the same as Object array:" );
      PrintValues( myIntArray );
      Console.WriteLine( "Object array - First element should now be the same as Int32 array:" );
      PrintValues( myObjArray );
   }

   public static void PrintValues( Array myArr )  {
      System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
      int i = 0;
      int cols = myArr.GetLength( myArr.Rank - 1 );
      while ( myEnumerator.MoveNext() )  {
         if ( i < cols )  {
            i++;
         } else  {
            Console.WriteLine();
            i = 1;
         }
         Console.Write( "\t{0}", myEnumerator.Current );
      }
      Console.WriteLine();
   }
}
/*
This code produces the following output.

Int32 array:
    1    2    3    4    5
Object array:
    26    27    28    29    30
Int32 array - Last two elements should now be the same as Object array:
    1    2    3    29    30
Object array - First element should now be the same as Int32 array:
    1    27    28    29    30
*/
Public Class SamplesArray    
    
    Public Shared Sub Main()
        
        ' Creates and initializes a new Array of type Int32.
        Dim myIntArray As Array = _
           Array.CreateInstance(GetType(System.Int32), 5)
        Dim i As Integer
        For i = myIntArray.GetLowerBound(0) To myIntArray.GetUpperBound(0)
            myIntArray.SetValue(i + 1, i)
        Next i 
        ' Creates and initializes a new Array of type Object.
        Dim myObjArray As Array = _
           Array.CreateInstance(GetType(System.Object), 5)
        For i = myObjArray.GetLowerBound(0) To myObjArray.GetUpperBound(0)
            myObjArray.SetValue(i + 26, i)
        Next i 
        ' Displays the initial values of both arrays.
        Console.WriteLine("Int32 array:")
        PrintValues(myIntArray)
        Console.WriteLine("Object array:")
        PrintValues(myObjArray)
        
        ' Copies the first element from the Int32 array to the Object array.
        Array.Copy(myIntArray, myIntArray.GetLowerBound(0), myObjArray, _
           myObjArray.GetLowerBound(0), 1)
        
        ' Copies the last two elements from the Object array to the Int32 array.
        Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, _
           myIntArray.GetUpperBound(0) - 1, 2)
        
        ' Displays the values of the modified arrays.
        Console.WriteLine("Int32 array - Last two elements should now be " _
           + "the same as Object array:")
        PrintValues(myIntArray)
        Console.WriteLine("Object array - First element should now be the " _
           + "same as Int32 array:")
        PrintValues(myObjArray)
    End Sub
    
    Public Shared Sub PrintValues(myArr As Array)
        Dim myEnumerator As System.Collections.IEnumerator = _
           myArr.GetEnumerator()
        Dim i As Integer = 0
        Dim cols As Integer = myArr.GetLength((myArr.Rank - 1))
        While myEnumerator.MoveNext()
            If i < cols Then
                i += 1
            Else
                Console.WriteLine()
                i = 1
            End If
            Console.Write(ControlChars.Tab + "{0}", myEnumerator.Current)
        End While
        Console.WriteLine()
    End Sub
End Class

' This code produces the following output.
' 
' Int32 array:
'     1    2    3    4    5
' Object array:
'     26    27    28    29    30
' Int32 array - Last two elements should now be the same as Object array:
'     1    2    3    29    30
' Object array - First element should now be the same as Int32 array:
'     1    27    28    29    30

Remarks

Parametry sourceArray a destinationArray musí mít stejný počet rozměrů.The sourceArray and destinationArray parameters must have the same number of dimensions. Kromě toho musí být destinationArray již dimenze a musí mít dostatečný počet prvků od destinationIndex pozice pro umístění kopírovaných dat.In addition, destinationArray must already have been dimensioned and must have a sufficient number of elements starting from the destinationIndex position to accommodate the copied data.

Při kopírování mezi multidimenzionálními poli se pole chová jako dlouhé jednorozměrné pole, kde jsou řádky (nebo sloupce) koncepčně rozloženy na konec.When copying between multidimensional arrays, the array behaves like a long one-dimensional array, where the rows (or columns) are conceptually laid end-to-end. Obsahuje-li pole například tři řádky (nebo sloupce) po čtyřech prvcích, při kopírování šesti prvků od začátku pole budou zkopírovány všechny čtyři prvky z prvního řádku (nebo sloupce) a první dva prvky z druhého řádku (nebo sloupce).For example, if an array has three rows (or columns) with four elements each, copying six elements from the beginning of the array would copy all four elements of the first row (or column) and the first two elements of the second row (or column). Chcete-li začít kopírovat z druhého prvku třetího řádku (nebo sloupce), sourceIndex musí být horní mezí prvního řádku (nebo sloupce) a také délka druhého řádku (nebo sloupce) a dvou.To start copying from the second element of the third row (or column), sourceIndex must be the upper bound of the first row (or column) plus the length of the second row (or column) plus two.

Pokud se sourceArray a destinationArray překrývají, tato metoda se chová, jako by původní hodnoty sourceArray byly zachovány v dočasném umístění před přepsáním destinationArray.If sourceArray and destinationArray overlap, this method behaves as if the original values of sourceArray were preserved in a temporary location before destinationArray is overwritten.

[C++][C++]

Tato metoda je ekvivalentní standardnímu memmoveC/C++ Function, nikoli memcpy.This method is equivalent to the standard C/C++ function memmove, not memcpy.

Pole mohou být odkazového nebo hodnotového typu.The arrays can be reference-type arrays or value-type arrays. Podle potřeby je provedeno přetypování na nižší typ.Type downcasting is performed, as required.

  • Při kopírování z pole typu odkazu do pole typu hodnoty je každý prvek nejprve vybalen a poté zkopírován.When copying from a reference-type array to a value-type array, each element is unboxed and then copied. Při kopírování z pole typu hodnoty do pole typu odkazu je každý prvek nejprve zabalen a poté zkopírován.When copying from a value-type array to a reference-type array, each element is boxed and then copied.

  • Při kopírování z pole typu odkazu nebo hodnoty do Object pole je vytvořena Object pro uchování každé hodnoty nebo odkazu a následné zkopírování.When copying from a reference-type or value-type array to an Object array, an Object is created to hold each value or reference and then copied. Při kopírování z Object pole do pole typu odkazu nebo hodnoty a přiřazení není možné, je vyvolána InvalidCastException.When copying from an Object array to a reference-type or value-type array and the assignment is not possible, an InvalidCastException is thrown.

  • Pokud sourceArray a destinationArray jsou obě pole typu odkazu nebo se jedná o pole typu Object, provede se kopie bez podstruktury.If sourceArray and destinationArray are both reference-type arrays or are both arrays of type Object, a shallow copy is performed. Kopie Array bez podstruktury je nová Array obsahující odkazy na stejné prvky jako původní Array.A shallow copy of an Array is a new Array containing references to the same elements as the original Array. Nekopírují se samotné prvky ani objekty, na které odkazují.The elements themselves or anything referenced by the elements are not copied. Naproti tomu hluboká kopie Array kopíruje prvky a vše přímo nebo nepřímo odkazované prvky.In contrast, a deep copy of an Array copies the elements and everything directly or indirectly referenced by the elements.

Je-li pole nekompatibilních typů, je vyvolána ArrayTypeMismatchException.An ArrayTypeMismatchException is thrown if the arrays are of incompatible types. Kompatibilita typů je definována takto:Type compatibility is defined as follows:

  • Typ je kompatibilní sám se sebou.A type is compatible with itself.

  • Typ hodnoty je kompatibilní s Object a s typem rozhraní implementovaným tímto typem hodnoty.A value type is compatible with Object and with an interface type implemented by that value type. Typ hodnoty je považován za připojený k rozhraní jen tehdy, když toto rozhraní přímo implementuje.A value type is considered connected to an interface only if it implements that interface directly. Odpojené typy nejsou kompatibilní.Disconnected types are not compatible.

  • Dva vnitřní (předdefinované) typy hodnot jsou kompatibilní, pokud platí, že kopírování ze zdrojového do cílového typu je rozšiřující převod.Two intrinsic (predefined) value types are compatible if copying from the source type to the destination type is a widening conversion. Při rozšiřujícím převodu nikdy nedochází ke ztrátě informací, zatímco u zužujícího převodu k ní dojít může.A widening conversion never loses information, whereas a narrowing conversion can lose information. Převod 32bitového celého čísla se znaménkem na 64bitové celé číslo se znaménkem je rozšiřující; převod 64bitového celého čísla se znaménkem na 32bitové celé číslo se znaménkem je zužující.For example, converting a 32-bit signed integer to a 64-bit signed integer is a widening conversion, and converting a 64-bit signed integer to a 32-bit signed integer is a narrowing conversion. Další informace o převodech naleznete v tématu Convert.For more information about conversions, see Convert.

  • Jiný než vnitřní typ hodnoty (definovaný uživatelem) je kompatibilní pouze sám se sebou.A nonintrinsic (user-defined) value type is compatible only with itself.

  • Výčty mají implicitní převod na Enum a na jejich podkladový typ.Enumerations have an implicit conversion to Enum and to their underlying type.

Pokud každý prvek v sourceArray vyžaduje přetypování (například ze základní třídy na odvozenou třídu nebo z rozhraní na objekt) a jeden nebo více prvků nelze přetypovat na odpovídající typ v destinationArray, je vyvolána InvalidCastException.If every element in sourceArray requires a downcast (for example, from a base class to a derived class or from an interface to an object) and one or more elements cannot be cast to the corresponding type in destinationArray, an InvalidCastException is thrown.

Pokud tato metoda vyvolá výjimku při kopírování, stav destinationArray není definován.If this method throws an exception while copying, the state of destinationArray is undefined.

Tato metoda je operace O (n), kde n je length.This method is an O(n) operation, where n is length.

See also

Copy(Array, Array, Int64)

Zkopíruje rozsah prvků z Array počínaje prvním prvkem a vloží je do jiného Array počínaje prvním prvkem.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. Délka je určena jako 64 celé číslo.The length is specified as a 64-bit integer.

public:
 static void Copy(Array ^ sourceArray, Array ^ destinationArray, long length);
public static void Copy (Array sourceArray, Array destinationArray, long length);
static member Copy : Array * Array * int64 -> unit
Public Shared Sub Copy (sourceArray As Array, destinationArray As Array, length As Long)

Parameters

sourceArray
Array

Array obsahující data ke zkopírování.The Array that contains the data to copy.

destinationArray
Array

Array, který přijímá data.The Array that receives the data.

length
Int64

64 celé číslo, které představuje počet prvků, které mají být zkopírovány.A 64-bit integer that represents the number of elements to copy. Celé číslo musí být mezi nulou a MaxValuevčetně.The integer must be between zero and MaxValue, inclusive.

Exceptions

sourceArray je null.sourceArray is null.

-nebo--or- destinationArray je null.destinationArray is null.

sourceArray a destinationArray mají odlišné pořadí.sourceArray and destinationArray have different ranks.

sourceArray a destinationArray jsou nekompatibilní typy.sourceArray and destinationArray are of incompatible types.

Nejméně jeden prvek v sourceArray nelze přetypovat na typ destinationArray.At least one element in sourceArray cannot be cast to the type of destinationArray.

length je menší než 0 nebo větší než MaxValue.length is less than 0 or greater than MaxValue.

length je větší než počet prvků v sourceArray.length is greater than the number of elements in sourceArray.

-nebo--or- length je větší než počet prvků v destinationArray.length is greater than the number of elements in destinationArray.

Remarks

Parametry sourceArray a destinationArray musí mít stejný počet rozměrů.The sourceArray and destinationArray parameters must have the same number of dimensions. Kromě toho musí být destinationArray již dimenze a musí mít dostatečný počet prvků pro přizpůsobení kopírovaných dat.In addition, destinationArray must already have been dimensioned and must have a sufficient number of elements to accommodate the copied data.

Při kopírování mezi multidimenzionálními poli se pole chová jako dlouhé jednorozměrné pole, kde jsou řádky (nebo sloupce) koncepční a končí.When copying between multidimensional arrays, the array behaves like a long one-dimensional array, where the rows (or columns) are conceptually laid end to end. Obsahuje-li pole například tři řádky (nebo sloupce) po čtyřech prvcích, při kopírování šesti prvků od začátku pole budou zkopírovány všechny čtyři prvky z prvního řádku (nebo sloupce) a první dva prvky z druhého řádku (nebo sloupce).For example, if an array has three rows (or columns) with four elements each, copying six elements from the beginning of the array would copy all four elements of the first row (or column) and the first two elements of the second row (or column).

Pokud se sourceArray a destinationArray překrývají, tato metoda se chová, jako by původní hodnoty sourceArray byly zachovány v dočasném umístění před přepsáním destinationArray.If sourceArray and destinationArray overlap, this method behaves as if the original values of sourceArray were preserved in a temporary location before destinationArray is overwritten.

[C++][C++]

Tato metoda je ekvivalentní standardnímu memmoveC/C++ Function, nikoli memcpy.This method is equivalent to the standard C/C++ function memmove, not memcpy.

Pole mohou být odkazového nebo hodnotového typu.The arrays can be reference-type arrays or value-type arrays. Podle potřeby je provedeno přetypování na nižší typ.Type downcasting is performed, as required.

  • Při kopírování z pole typu odkazu do pole typu hodnoty je každý prvek nejprve vybalen a poté zkopírován.When copying from a reference-type array to a value-type array, each element is unboxed and then copied. Při kopírování z pole typu hodnoty do pole typu odkazu je každý prvek nejprve zabalen a poté zkopírován.When copying from a value-type array to a reference-type array, each element is boxed and then copied.

  • Při kopírování z pole typu odkazu nebo hodnoty do Object pole je vytvořena Object pro uchování každé hodnoty nebo odkazu a následné zkopírování.When copying from a reference-type or value-type array to an Object array, an Object is created to hold each value or reference and then copied. Při kopírování z Object pole do pole typu odkazu nebo hodnoty a přiřazení není možné, je vyvolána InvalidCastException.When copying from an Object array to a reference-type or value-type array and the assignment is not possible, an InvalidCastException is thrown.

  • Pokud sourceArray a destinationArray jsou obě pole typu odkazu nebo se jedná o pole typu Object, provede se kopie bez podstruktury.If sourceArray and destinationArray are both reference-type arrays or are both arrays of type Object, a shallow copy is performed. Kopie Array bez podstruktury je nová Array obsahující odkazy na stejné prvky jako původní Array.A shallow copy of an Array is a new Array containing references to the same elements as the original Array. Nekopírují se samotné prvky ani objekty, na které odkazují.The elements themselves or anything referenced by the elements are not copied. Naproti tomu hluboká kopie Array kopíruje prvky a vše přímo nebo nepřímo odkazované prvky.In contrast, a deep copy of an Array copies the elements and everything directly or indirectly referenced by the elements.

Je-li pole nekompatibilních typů, je vyvolána ArrayTypeMismatchException.An ArrayTypeMismatchException is thrown if the arrays are of incompatible types. Kompatibilita typů je definována takto:Type compatibility is defined as follows:

  • Typ je kompatibilní sám se sebou.A type is compatible with itself.

  • Typ hodnoty je kompatibilní s Object a s typem rozhraní implementovaným tímto typem hodnoty.A value type is compatible with Object and with an interface type implemented by that value type. Typ hodnoty je považován za připojený k rozhraní jen tehdy, když toto rozhraní přímo implementuje.A value type is considered connected to an interface only if it implements that interface directly. Odpojené typy nejsou kompatibilní.Disconnected types are not compatible.

  • Dva vnitřní (předdefinované) typy hodnot jsou kompatibilní, pokud platí, že kopírování ze zdrojového do cílového typu je rozšiřující převod.Two intrinsic (predefined) value types are compatible if copying from the source type to the destination type is a widening conversion. Při rozšiřujícím převodu nikdy nedochází ke ztrátě informací, zatímco u zužujícího převodu k ní dojít může.A widening conversion never loses information, whereas a narrowing conversion can lose information. Převod 32bitového celého čísla se znaménkem na 64bitové celé číslo se znaménkem je rozšiřující; převod 64bitového celého čísla se znaménkem na 32bitové celé číslo se znaménkem je zužující.For example, converting a 32-bit signed integer to a 64-bit signed integer is a widening conversion, and converting a 64-bit signed integer to a 32-bit signed integer is a narrowing conversion. Další informace o převodech naleznete v tématu Convert.For more information about conversions, see Convert.

  • Jiný než vnitřní typ hodnoty (definovaný uživatelem) je kompatibilní pouze sám se sebou.A nonintrinsic (user-defined) value type is compatible only with itself.

  • Výčty mají implicitní převod na Enum a na jejich podkladový typ.Enumerations have an implicit conversion to Enum and to their underlying type.

Pokud každý prvek v sourceArray vyžaduje přetypování (například ze základní třídy na odvozenou třídu nebo z rozhraní na objekt) a jeden nebo více prvků nelze přetypovat na odpovídající typ v destinationArray, je vyvolána InvalidCastException.If every element in sourceArray requires a downcast (for example, from a base class to a derived class or from an interface to an object) and one or more elements cannot be cast to the corresponding type in destinationArray, an InvalidCastException is thrown.

Pokud tato metoda vyvolá výjimku při kopírování, stav destinationArray není definován.If this method throws an exception while copying, the state of destinationArray is undefined.

Tato metoda je operace O (n), kde n je length.This method is an O(n) operation, where n is length.

See also

Copy(Array, Array, Int32)

Zkopíruje rozsah prvků z Array počínaje prvním prvkem a vloží je do jiného Array počínaje prvním prvkem.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. Délka je určena jako 32 celé číslo.The length is specified as a 32-bit integer.

public:
 static void Copy(Array ^ sourceArray, Array ^ destinationArray, int length);
public static void Copy (Array sourceArray, Array destinationArray, int length);
static member Copy : Array * Array * int -> unit
Public Shared Sub Copy (sourceArray As Array, destinationArray As Array, length As Integer)

Parameters

sourceArray
Array

Array obsahující data ke zkopírování.The Array that contains the data to copy.

destinationArray
Array

Array, který přijímá data.The Array that receives the data.

length
Int32

32 celé číslo, které představuje počet prvků, které mají být zkopírovány.A 32-bit integer that represents the number of elements to copy.

Exceptions

sourceArray je null.sourceArray is null.

-nebo--or- destinationArray je null.destinationArray is null.

sourceArray a destinationArray mají odlišné pořadí.sourceArray and destinationArray have different ranks.

sourceArray a destinationArray jsou nekompatibilní typy.sourceArray and destinationArray are of incompatible types.

Nejméně jeden prvek v sourceArray nelze přetypovat na typ destinationArray.At least one element in sourceArray cannot be cast to the type of destinationArray.

Hodnota length je menší než nula.length is less than zero.

length je větší než počet prvků v sourceArray.length is greater than the number of elements in sourceArray.

-nebo--or- length je větší než počet prvků v destinationArray.length is greater than the number of elements in destinationArray.

Remarks

Parametry sourceArray a destinationArray musí mít stejný počet rozměrů.The sourceArray and destinationArray parameters must have the same number of dimensions. Kromě toho musí být destinationArray již dimenze a musí mít dostatečný počet prvků pro přizpůsobení kopírovaných dat.In addition, destinationArray must already have been dimensioned and must have a sufficient number of elements to accommodate the copied data.

Při kopírování mezi multidimenzionálními poli se pole chová jako dlouhé jednorozměrné pole, kde jsou řádky (nebo sloupce) koncepční a končí.When copying between multidimensional arrays, the array behaves like a long one-dimensional array, where the rows (or columns) are conceptually laid end to end. Obsahuje-li pole například tři řádky (nebo sloupce) po čtyřech prvcích, při kopírování šesti prvků od začátku pole budou zkopírovány všechny čtyři prvky z prvního řádku (nebo sloupce) a první dva prvky z druhého řádku (nebo sloupce).For example, if an array has three rows (or columns) with four elements each, copying six elements from the beginning of the array would copy all four elements of the first row (or column) and the first two elements of the second row (or column).

Pokud se sourceArray a destinationArray překrývají, tato metoda se chová, jako by původní hodnoty sourceArray byly zachovány v dočasném umístění před přepsáním destinationArray.If sourceArray and destinationArray overlap, this method behaves as if the original values of sourceArray were preserved in a temporary location before destinationArray is overwritten.

[C++][C++]

Tato metoda je ekvivalentní standardnímu memmoveC/C++ Function, nikoli memcpy.This method is equivalent to the standard C/C++ function memmove, not memcpy.

Pole mohou být odkazového nebo hodnotového typu.The arrays can be reference-type arrays or value-type arrays. Podle potřeby je provedeno přetypování na nižší typ.Type downcasting is performed, as required.

  • Při kopírování z pole typu odkazu do pole typu hodnoty je každý prvek nejprve vybalen a poté zkopírován.When copying from a reference-type array to a value-type array, each element is unboxed and then copied. Při kopírování z pole typu hodnoty do pole typu odkazu je každý prvek nejprve zabalen a poté zkopírován.When copying from a value-type array to a reference-type array, each element is boxed and then copied.

  • Při kopírování z pole typu odkazu nebo hodnoty do Object pole je vytvořena Object pro uchování každé hodnoty nebo odkazu a následné zkopírování.When copying from a reference-type or value-type array to an Object array, an Object is created to hold each value or reference and then copied. Při kopírování z Object pole do pole typu odkazu nebo hodnoty a přiřazení není možné, je vyvolána InvalidCastException.When copying from an Object array to a reference-type or value-type array and the assignment is not possible, an InvalidCastException is thrown.

  • Pokud sourceArray a destinationArray jsou obě pole typu odkazu nebo se jedná o pole typu Object, provede se kopie bez podstruktury.If sourceArray and destinationArray are both reference-type arrays or are both arrays of type Object, a shallow copy is performed. Kopie Array bez podstruktury je nová Array obsahující odkazy na stejné prvky jako původní Array.A shallow copy of an Array is a new Array containing references to the same elements as the original Array. Nekopírují se samotné prvky ani objekty, na které odkazují.The elements themselves or anything referenced by the elements are not copied. Naproti tomu hluboká kopie Array kopíruje prvky a vše přímo nebo nepřímo odkazované prvky.In contrast, a deep copy of an Array copies the elements and everything directly or indirectly referenced by the elements.

Je-li pole nekompatibilních typů, je vyvolána ArrayTypeMismatchException.An ArrayTypeMismatchException is thrown if the arrays are of incompatible types. Kompatibilita typů je definována takto:Type compatibility is defined as follows:

  • Typ je kompatibilní sám se sebou.A type is compatible with itself.

  • Typ hodnoty je kompatibilní s Object a s typem rozhraní implementovaným tímto typem hodnoty.A value type is compatible with Object and with an interface type implemented by that value type. Typ hodnoty je považován za připojený k rozhraní jen tehdy, když toto rozhraní přímo implementuje.A value type is considered connected to an interface only if it implements that interface directly. Odpojené typy nejsou kompatibilní.Disconnected types are not compatible.

  • Dva vnitřní (předdefinované) typy hodnot jsou kompatibilní, pokud platí, že kopírování ze zdrojového do cílového typu je rozšiřující převod.Two intrinsic (predefined) value types are compatible if copying from the source type to the destination type is a widening conversion. Při rozšiřujícím převodu nikdy nedochází ke ztrátě informací, zatímco u zužujícího převodu k ní dojít může.A widening conversion never loses information, whereas a narrowing conversion can lose information. Převod 32bitového celého čísla se znaménkem na 64bitové celé číslo se znaménkem je rozšiřující; převod 64bitového celého čísla se znaménkem na 32bitové celé číslo se znaménkem je zužující.For example, converting a 32-bit signed integer to a 64-bit signed integer is a widening conversion, and converting a 64-bit signed integer to a 32-bit signed integer is a narrowing conversion. Další informace o převodech naleznete v tématu Convert.For more information about conversions, see Convert.

  • Jiný než vnitřní typ hodnoty (definovaný uživatelem) je kompatibilní pouze sám se sebou.A nonintrinsic (user-defined) value type is compatible only with itself.

  • Výčty mají implicitní převod na Enum a na jejich podkladový typ.Enumerations have an implicit conversion to Enum and to their underlying type.

Pokud každý prvek v sourceArray vyžaduje přetypování (například ze základní třídy na odvozenou třídu nebo z rozhraní na objekt) a jeden nebo více prvků nelze přetypovat na odpovídající typ v destinationArray, je vyvolána InvalidCastException.If every element in sourceArray requires a downcast (for example, from a base class to a derived class or from an interface to an object) and one or more elements cannot be cast to the corresponding type in destinationArray, an InvalidCastException is thrown.

Pokud tato metoda vyvolá výjimku při kopírování, stav destinationArray není definován.If this method throws an exception while copying, the state of destinationArray is undefined.

Tato metoda je operace O (n), kde n je length.This method is an O(n) operation, where n is length.

See also

Applies to