Array 类

最新推荐文章于 2023-02-03 20:01:46 发布
最新推荐文章于 2023-02-03 20:01:46 发布
阅读量799 收藏
点赞数 1
分类专栏： ASP.NET 文章标签： integer object properties class basic system
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/quanweiru/article/details/4411527
版权

 

Array 类

 

提供创建、操作、搜索和排序数组的方法，因而在公共语言运行库中用作所有数组的基类。

命名空间：   System
程序集：   mscorlib（在 mscorlib.dll 中）
 语法
Visual Basic（声明） 
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
Public MustInherit Class Array _
    Implements ICloneable, IList, ICollection, IEnumerable
Visual Basic (用法) 
Dim instance As Array
C# 
[SerializableAttribute]
[ComVisibleAttribute(true)]
public abstract class Array : ICloneable, 
    IList, ICollection, IEnumerable
Visual C++ 
[SerializableAttribute]
[ComVisibleAttribute(true)]
public ref class Array abstract : ICloneable, 
    IList, ICollection, IEnumerable
J# 
/** @attribute SerializableAttribute */ 
/** @attribute ComVisibleAttribute(true) */
public abstract class Array implements ICloneable, 
    IList, ICollection, IEnumerable
JScript 
public abstract class Array implements ICloneable, IList, ICollection, IEnumerable
 备注

Array 类是支持数组的语言实现的基类。但是，只有系统和编译器能够从 Array 类显式派生。用户应当使用由语言提供的数组构造。

一个元素就是 Array 中的一个值。Array 的长度是它可包含的元素总数。Array 的秩是 Array 中的维数。Array 中维度的下限是 Array 中该维度的起始索引，多维 Array 的各个维度可以有不同的界限。

czz5hkty.alert_caution(zh-cn,VS.90).gif重要说明：

在 .NET Framework 2.0 版中，Array 类实现 System.Collections.Generic..::.IList<(Of <(T>)>) 、System.Collections.Generic..::.ICollection<(Of <(T>)>) 和 System.Collections.Generic..::.IEnumerable<(Of <(T>)>) 泛型接口。由于实现是在运行时提供给数组的，因而对于文档生成工具不可见。因此，泛型接口不会出现在 Array 类的声明语法中，也不会有关于只能通过将数组强制转换为泛型接口类型（显式接口实现）才可访问的接口成员的参考主题。将某一数组强制转换为这三种接口之一时需要注意的关键一点是，添加、插入或移除元素的成员会引发 NotSupportedException。

Type 对象提供有关数组类型声明的信息。具有相同数组类型的 Array 对象共享同一 Type 对象。

Type..::.IsArray 和 Type..::.GetElementType 可能不返回所预期的 Array 形式的结果，因为如果某个数组被强制转换为 Array 类型，则结果是对象，而非数组。即，typeof(System.Array).IsArray 返回 false，而 typeof(System.Array).GetElementType 返回 nullNothingnullptrnull 引用（在 Visual Basic 中为 Nothing）。

与大多数类不同，Array 提供 CreateInstance 方法，以便允许后期绑定访问，而不是提供公共构造函数。

Array..::.Copy 方法不仅可在同一类型的数组之间复制元素，而且可在不同类型的标准数组之间复制元素；它会自动处理强制类型转换。

有些方法，如 CreateInstance、 Copy、 CopyTo、 GetValue 和 SetValue，提供重载（接受 64 位整数作为参数），以适应大容量数组。 LongLength 和 GetLongLength 返回指示数组长度的 64 位整数。

不保证会对 Array 进行排序。 在执行需要对 Array 进行排序的操作（如 BinarySearch）之前，必须对 Array 进行排序。

 示例

下面的代码示例说明 Array..::.Copy 如何在 integer 类型的数组和 Object 类型的数组之间复制元素。

Visual Basic
复制代码 
Public Class SamplesArray    

    Public Shared Sub Main()

        ' Creates and initializes a new integer array and a new Object array.
        Dim myIntArray() As Integer = {1, 2, 3, 4, 5}
        Dim myObjArray() As Object = {26, 27, 28, 29, 30}

        ' Prints the initial values of both arrays.
        Console.WriteLine("Initially,")
        Console.Write("integer array:")
        PrintValues(myIntArray)
        Console.Write("Object array: ")
        PrintValues(myObjArray)

        ' Copies the first two elements from the integer array to the Object array.
        System.Array.Copy(myIntArray, myObjArray, 2)

        ' Prints the values of the modified arrays.
        Console.WriteLine(ControlChars.NewLine + "After copying the first two" _
           + " elements of the integer array to the Object array,")
        Console.Write("integer array:")
        PrintValues(myIntArray)
        Console.Write("Object array: ")
        PrintValues(myObjArray)

        ' Copies the last two elements from the Object array to the integer array.
        System.Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, _
           myIntArray.GetUpperBound(0) - 1, 2)

        ' Prints the values of the modified arrays.
        Console.WriteLine(ControlChars.NewLine + "After copying the last two" _
           + " elements of the Object array to the integer array,")
        Console.Write("integer array:")
        PrintValues(myIntArray)
        Console.Write("Object array: ")
        PrintValues(myObjArray)
    End Sub

    Overloads Public Shared Sub PrintValues(myArr() As Object)
        Dim i As Object
        For Each i In  myArr
            Console.Write(ControlChars.Tab + "{0}", i)
        Next i
        Console.WriteLine()
    End Sub    

    Overloads Public Shared Sub PrintValues(myArr() As Integer)
        Dim i As Integer
        For Each i In  myArr
            Console.Write(ControlChars.Tab + "{0}", i)
        Next i
        Console.WriteLine()
    End Sub
End Class

' This code produces the following output.
' 
' Initially,
' integer array:  1       2       3       4       5
' Object array:   26      27      28      29      30
' 
' After copying the first two elements of the integer array to the Object array,
' integer array:  1       2       3       4       5
' Object array:   1       2       28      29      30
' 
' After copying the last two elements of the Object array to the integer array,
' integer array:  1       2       3       29      30
' Object array:   1       2       28      29      30
C#
复制代码 
public class SamplesArray  {

   public static void Main()  {

      // Creates and initializes a new integer array and a new Object array.
      int[] myIntArray = new int[5] { 1, 2, 3, 4, 5 };
      Object[] myObjArray = new Object[5] { 26, 27, 28, 29, 30 };

      // Prints the initial values of both arrays.
      Console.WriteLine( "Initially," );
      Console.Write( "integer array:" );
      PrintValues( myIntArray );
      Console.Write( "Object array: " );
      PrintValues( myObjArray );

      // Copies the first two elements from the integer array to the Object array.
      System.Array.Copy( myIntArray, myObjArray, 2 );

      // Prints the values of the modified arrays.
      Console.WriteLine( "/nAfter copying the first two elements of the integer array to the Object array," );
      Console.Write( "integer array:" );
      PrintValues( myIntArray );
      Console.Write( "Object array: " );
      PrintValues( myObjArray );

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

      // Prints the values of the modified arrays.
      Console.WriteLine( "/nAfter copying the last two elements of the Object array to the integer array," );
      Console.Write( "integer array:" );
      PrintValues( myIntArray );
      Console.Write( "Object array: " );
      PrintValues( myObjArray );
   }


   public static void PrintValues( Object[] myArr )  {
      foreach ( Object i in myArr )  {
         Console.Write( "/t{0}", i );
      }
      Console.WriteLine();
   }

   public static void PrintValues( int[] myArr )  {
      foreach ( int i in myArr )  {
         Console.Write( "/t{0}", i );
      }
      Console.WriteLine();
   }
}
/* 
This code produces the following output.

Initially,
integer array:  1       2       3       4       5
Object array:   26      27      28      29      30

After copying the first two elements of the integer array to the Object array,
integer array:  1       2       3       4       5
Object array:   1       2       28      29      30

After copying the last two elements of the Object array to the integer array,
integer array:  1       2       3       29      30
Object array:   1       2       28      29      30
*/
Visual C++
复制代码 
using namespace System;
void main1();
void main2();
void main()
{
   main1();
   Console::WriteLine();
   main2();
}

void PrintValues( array<Object^>^myArr );
void PrintValues( array<int>^myArr );
void main1()
{
   // Creates and initializes a new int array and a new Object array.
   array<int>^myIntArray = {1,2,3,4,5};
   array<Object^>^myObjArray = {26,27,28,29,30};

   // Prints the initial values of both arrays.
   Console::WriteLine(  "Initially," );
   Console::Write(  "int array:   " );
   PrintValues( myIntArray );
   Console::Write(  "Object array:" );
   PrintValues( myObjArray );

   // Copies the first two elements from the int array to the Object array.
   System::Array::Copy( myIntArray, myObjArray, 2 );

   // Prints the values of the modified arrays.
   Console::WriteLine(  "/nAfter copying the first two elements of the int array to the Object array," );
   Console::Write(  "int array:   " );
   PrintValues( myIntArray );
   Console::Write(  "Object array:" );
   PrintValues( myObjArray );

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

   // Prints the values of the modified arrays.
   Console::WriteLine(  "/nAfter copying the last two elements of the Object array to the int array," );
   Console::Write(  "int array:   " );
   PrintValues( myIntArray );
   Console::Write(  "Object array:" );
   PrintValues( myObjArray );
}

void PrintValues( array<Object^>^myArr )
{
   for ( int i = 0; i < myArr->Length; i++ )
   {
      Console::Write(  "/t{0}", myArr[ i ] );

   }
   Console::WriteLine();
}

void PrintValues( array<int>^myArr )
{
   for ( int i = 0; i < myArr->Length; i++ )
   {
      Console::Write(  "/t{0}", myArr[ i ] );

   }
   Console::WriteLine();
}


/* 
 This code produces the following output.

 Initially,
 int array:       1    2    3    4    5
 Object array:    26    27    28    29    30
 After copying the first two elements of the int array to the Object array,
 int array:       1    2    3    4    5
 Object array:    1    2    28    29    30
 After copying the last two elements of the Object array to the int array,
 int array:       1    2    3    29    30
 Object array:    1    2    28    29    30
 */
J#
复制代码 
public class SamplesArray
{
    public static void main(String[] args)
    {
        // Creates and initializes a new integer array and a new Object array.
        int myIntArray[] = new int[] { 1, 2, 3, 4, 5 };
        Object myObjArray[] = new Object[] { (Int32)26, (Int32)27, (Int32)28, 
            (Int32)29, (Int32)30};
        // Prints the initial values of both arrays.
        Console.WriteLine("Initially,");
        Console.Write("integer array:");
        PrintValues(myIntArray);
        Console.Write("Object array: ");
        PrintValues(myObjArray);
        // Copies the first two elements from the integer array to the 
        // Object array.
        System.Array.Copy(myIntArray, myObjArray, 2);
        // Prints the values of the modified arrays.
        Console.WriteLine("/nAfter copying the first two elements of the"
            + " integer array to the Object array,");
        Console.Write("integer array:");
        PrintValues(myIntArray);
        Console.Write("Object array: ");
        PrintValues(myObjArray);
        // Copies the last two elements from the Object array to the
        // integer array.
        System.Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, 
            myIntArray.GetUpperBound(0) - 1, 2);
        // Prints the values of the modified arrays.
        Console.WriteLine("/nAfter copying the last two elements of the Object"
            + " array to the integer array,");
        Console.Write("integer array:");
        PrintValues(myIntArray);
        Console.Write("Object array: ");
        PrintValues(myObjArray);
    } //main

    public static void PrintValues(Object myArr[])
    {
        Object i = null;
        for (int iCtr = 0; iCtr < myArr.get_Length(); iCtr++) {
            i = myArr[iCtr];
            Console.Write("/t{0}", i);
        }
        Console.WriteLine();
    } //PrintValues

    public static void PrintValues(int myArr[])
    { 
        int i = 0;
        for (int iCtr = 0; iCtr < myArr.get_Length(); iCtr++) {
            i = myArr[iCtr];
            Console.Write("/t{0}", (Int32)i);
        }
        Console.WriteLine();
    } //PrintValues
} //SamplesArray

/* 
 This code produces the following output.

 Initially,
 integer array:  1       2       3       4       5
 Object array:   26      27      28      29      30

 After copying the first two elements of the integer array to the Object array,
 integer array:  1       2       3       4       5
 Object array:   1       2       28      29      30

 After copying the last two elements of the Object array to the integer array,
 integer array:  1       2       3       29      30
 Object array:   1       2       28      29      30
 */

下面的代码示例创建并初始化一个 Array，然后显示其属性和元素。

Visual Basic
复制代码 
Public Class SamplesArray2    

    Public Shared Sub Main()

        ' Creates and initializes a new three-dimensional Array of
        ' type Int32.
        Dim myArr As Array = Array.CreateInstance(GetType(Int32), 2, 3, 4)
        Dim i As Integer
        For i = myArr.GetLowerBound(0) To myArr.GetUpperBound(0)
            Dim j As Integer
            For j = myArr.GetLowerBound(1) To myArr.GetUpperBound(1)
                Dim k As Integer
                For k = myArr.GetLowerBound(2) To myArr.GetUpperBound(2)
                    myArr.SetValue(i * 100 + j * 10 + k, i, j, k)
                Next k
            Next j 
        Next i ' Displays the properties of the Array.
        Console.WriteLine("The Array has {0} dimension(s) and a " _
           + "total of {1} elements.", myArr.Rank, myArr.Length)
        Console.WriteLine(ControlChars.Tab + "Length" + ControlChars.Tab _
           + "Lower" + ControlChars.Tab + "Upper")
        For i = 0 To myArr.Rank - 1
            Console.Write("{0}:" + ControlChars.Tab + "{1}", i, _
               myArr.GetLength(i))
            Console.WriteLine(ControlChars.Tab + "{0}" + ControlChars.Tab _
               + "{1}", myArr.GetLowerBound(i), myArr.GetUpperBound(i))
        Next i

        ' Displays the contents of the Array.
        Console.WriteLine("The Array contains the following values:")
        PrintValues(myArr)
    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.
' 
' The Array has 3 dimension(s) and a total of 24 elements.
'     Length    Lower    Upper
' 0:    2    0    1
' 1:    3    0    2
' 2:    4    0    3
' The Array contains the following values:
'     0    1    2    3
'     10    11    12    13
'     20    21    22    23
'     100    101    102    103
'     110    111    112    113
'     120    121    122    123
C#
复制代码 
public class SamplesArray2{

   public static void Main()  {

      // Creates and initializes a new three-dimensional Array of type Int32.
      Array myArr = Array.CreateInstance( typeof(Int32), 2, 3, 4 );
      for ( int i = myArr.GetLowerBound(0); i <= myArr.GetUpperBound(0); i++ )
         for ( int j = myArr.GetLowerBound(1); j <= myArr.GetUpperBound(1); j++ )
            for ( int k = myArr.GetLowerBound(2); k <= myArr.GetUpperBound(2); k++ )  {
               myArr.SetValue( (i*100)+(j*10)+k, i, j, k );
            }

      // Displays the properties of the Array.
      Console.WriteLine( "The Array has {0} dimension(s) and a total of {1} elements.", myArr.Rank, myArr.Length );
      Console.WriteLine( "/tLength/tLower/tUpper" );
      for ( int i = 0; i < myArr.Rank; i++ )  {
         Console.Write( "{0}:/t{1}", i, myArr.GetLength(i) );
         Console.WriteLine( "/t{0}/t{1}", myArr.GetLowerBound(i), myArr.GetUpperBound(i) );
      }

      // Displays the contents of the Array.
      Console.WriteLine( "The Array contains the following values:" );
      PrintValues( myArr );
   }


   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.

The Array has 3 dimension(s) and a total of 24 elements.
    Length    Lower    Upper
0:    2    0    1
1:    3    0    2
2:    4    0    3
The Array contains the following values:
    0    1    2    3
    10    11    12    13
    20    21    22    23
    100    101    102    103
    110    111    112    113
    120    121    122    123
*/
Visual C++
复制代码 
void PrintValues( Array^ myArr );
void main2()
{
   // Creates and initializes a new three-dimensional Array instance of type Int32.
   Array^ myArr = Array::CreateInstance( Int32::typeid, 2, 3, 4 );
   for ( int i = myArr->GetLowerBound( 0 ); i <= myArr->GetUpperBound( 0 ); i++ )
   {
      for ( int j = myArr->GetLowerBound( 1 ); j <= myArr->GetUpperBound( 1 ); j++ )
      {
         for ( int k = myArr->GetLowerBound( 2 ); k <= myArr->GetUpperBound( 2 ); k++ )
            myArr->SetValue( (i * 100) + (j * 10) + k, i, j, k );

      }
   }

   // Displays the properties of the Array.
   Console::WriteLine(  "The Array instance has {0} dimension(s) and a total of {1} elements.", myArr->Rank, myArr->Length );
   Console::WriteLine(  "/tLength/tLower/tUpper" );
   for ( int i = 0; i < myArr->Rank; i++ )
   {
      Console::Write(  "{0}:/t{1}", i, myArr->GetLength( i ) );
      Console::WriteLine(  "/t{0}/t{1}", myArr->GetLowerBound( i ), myArr->GetUpperBound( i ) );

   }
   Console::WriteLine(  "The Array instance contains the following values:" );
   PrintValues( myArr );
}

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.

 The Array instance has 3 dimension(s) and a total of 24 elements.
     Length    Lower    Upper
 0:    2    0    1
 1:    3    0    2
 2:    4    0    3
 The Array instance contains the following values:
     0    1    2    3
     10    11    12    13
     20    21    22    23
     100    101    102    103
     110    111    112    113
     120    121    122    123
 */
J#
复制代码 
public class SamplesArray2
{
    public static void main(String[] args)
    {
        // Creates and initializes a new three-dimensional Array of type Int32.
        Array myArr = Array.CreateInstance(Int32.class.ToType(), 2, 3, 4);
        for (int i = myArr.GetLowerBound(0); i <= myArr.GetUpperBound(0); i++) {
            for (int j = myArr.GetLowerBound(1); j <= myArr.GetUpperBound(1);
                j++) {
                for (int k = myArr.GetLowerBound(2); k <= myArr.
                    GetUpperBound(2); k++) {
                    myArr.SetValue((Int32)(i * 100 + j * 10 + k), i, j, k);
                }
            }
        }  // Displays the properties of the Array.
        Console.WriteLine("The Array has {0} dimension(s) and a total of"
            + " {1} elements.", System.Convert.ToString(myArr.get_Rank()), 
            System.Convert.ToString(myArr.get_Length()));
        Console.WriteLine("/tLength/tLower/tUpper");
        for (int i = 0; i < myArr.get_Rank(); i++) {
            Console.Write("{0}:/t{1}", System.Convert.ToString(i), 
                System.Convert.ToString(myArr.GetLength(i)));
            Console.WriteLine("/t{0}/t{1}", System.Convert.ToString(myArr.
                GetLowerBound(i)), System.Convert.ToString(myArr.
                GetUpperBound(i)));
        }
        // Displays the contents of the Array.
        Console.WriteLine("The Array contains the following values:");
        PrintValues(myArr);
    } //main

    public static void PrintValues(Array myArr)
    {
        System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
        int i = 0;
        int cols = myArr.GetLength(myArr.get_Rank() - 1);
        while (myEnumerator.MoveNext()) {
            if (i < cols) {
                i++;
            }
            else {
                Console.WriteLine();
                i = 1;
            }
            Console.Write("/t{0}", myEnumerator.get_Current());
        }
        Console.WriteLine();
    } //PrintValues
} //SamplesArray2

/* 
 This code produces the following output.

 The Array has 3 dimension(s) and a total of 24 elements.
     Length    Lower    Upper
 0:    2    0    1
 1:    3    0    2
 2:    4    0    3
 The Array contains the following values:
     0    1    2    3
     10    11    12    13
     20    21    22    23
     100    101    102    103
     110    111    112    113
     120    121    122    123
 */
 继承层次结构
System . . :: .Object
   System..::.Array
 线程安全

此类型的公共静态（在 Visual Basic 中为 Shared）成员是线程安全的。但不能保证任何实例成员是线程安全的。

此实现不提供 Array 的同步（线程安全）包装；但是，基于 Array 的 .NET Framework 类使用 SyncRoot 属性提供它们自己的集合同步版本。

通过集合枚举在本质上不是一个线程安全的过程。即使一个集合已进行同步，其他线程仍可以修改该集合，这将导致枚举数引发异常。若要在枚举过程中保证线程安全，可以在整个枚举过程中锁定集合，或者捕捉由于其他线程进行的更改而引发的异常。

quanweiru
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C 语言编程 — 构造数据类型 — 数组（array）
烟云的计算
04-03 2798
目录 文章目录目录前文列表数组声明数组初始化数据访问数组元素二维数组指向数组的指针将数组指针作为实参传入函数从函数返回一个数组指针指针数组 前文列表 数组 C 语言支持数组数据结构，它可以存储一个固定大小的、具有相同数据类型的元素的有序集合。数组都是由连续的内存空间组成的，最低的地址对应第一个元素，最高的地址对应最后一个元素。数组中的特定元素可以通过索引访问，数组的索引从 0 开始。 声明数组 ...
PHP数组array类常见操作示例
10-15
主要介绍了PHP数组array类常见操作,结合实例形式分析了PHP数组array常见函数使用技巧与相关注意事项,需要的朋友可以参考下
Array类
weixin_69143897的博客
02-03 409
arrays
Array数组求和
TongStyles
03-25 4947
Array数组求和，用return返回值Sum /*编写程序，完成下面功能： 1）设计一个Array类，添加一个整型数组，添加构造方法以对数组赋初值。 2）为Array类添加数组的求和方法，添加返回求和值的方法。 3）编写Application程序利用Array计算数组的求和值并输出。 */ public class Array{ public static void main(String ar...
数组类（II）
fighting123678的博客
04-21 669
Description 封装一个模板数组类，用于存储数组和处理的相关功能，支持以下操作： 1. Array::Array(int l)构造方法：创建一个长度为l的组对象。 2. Array::size()方法：返回Array对象中元素个数。 3. Array::put(int n)方法：按从大到小的顺序输出前n大元素，若数组长度小于n则从大到小输出全部元素。 4. 下标运算符：返回下标所...
Array类测试程序
10-11
#include using std::cout; using std::cin; using std::endl; #include "Array.h" int main(){...}
Javascript array类 数组操作方法
12-08
一个 Array 对象。 item, item2,. . . itemN 可选项。该 Array 的新元素。 说明 push 方法将以新元素出现的顺序添加这些元素。如果参数之一为数组，那么该数组将作为单个元素添加到数组中。如果要合并两个或多个数组...
AcArray类模板
07-14
AcArray类模板提供了动态数组存取数据。
《JavaScript高级程序设计》读书笔记 ---Array 类型
weixin_30952103的博客
07-26 146
除了Object 之外，Array 类型恐怕是ECMAScript 中最常用的类型了。而且，ECMAScript 中的数组与其他多数语言中的数组有着相当大的区别。虽然ECMAScript 数组与其他语言中的数组都是数据的有序列表，但与其他语言不同的是，ECMAScript 数组的每一项可以保存任何类型的数据。也就是说，可以用数组的第一个位置来保存字符串，用第二位置来保存数值，用第三个位置来保存对象...
找出一个整型数组中的元素的最大值
09-30
c语言中找出一个整型数组中的元素的最大值。源码
java面向对象代码题_2016年java面向对象编程题库及答案
weixin_39762838的博客
02-13 206
2016年java面向对象编程题库及答案java在面向对象的编程方式中，对象拥有多种特性，如手机有高度、宽度、厚度、颜色、重量等特性，这些特性被称为对象的属性。那么java面向对象编程试题有哪些?一起来看看吧!阅读下面的代码：Public class Parent{Public int addValue(int a,int b){Int s;S=a+b;Return s;}}Class Child...
程序设计二（面向对象）_实训9_复杂类的实现_Array类的实现——头歌平台作业
m0_69011137的博客
07-10 2926
程序设计二（面向对象）_实训9_复杂类的实现_Array类的实现——头歌平台作业
C++采用模板技术设计动态数组类 Array
qmyxhs的博客
05-19 1504
题目要求： 类模板成员包括：数组长度、元素个数、数据指针。 （3）通过构造函数创建数组默认包含10个元素，通过析构函数释放数组数据。 （4）添加数组元素：int AddItem(T aData); 返回类型为添加元素的下标号，如果数组长度不够，需要动态扩展。 （5）删除数据元素：bool RemoveAt(int index); 返回是否删除成功。 （6）插入数组元素 void InsertItem( int index, T aData); 在数组的第index的位置插入元素aData。 （7）数组元素
Java 数组（Arrays）
m0_59564690的博客
01-06 1179
Java 数组
C++ 有界数组模板类（类模板）
hhhertzzz的博客
06-19 2020
题目描述 编写有界数组模板BoundArray（即检查对数组元素下标引用并在下标越界时终止程序的执行），能够存储各种类型的数据。要求实现对数组进行排序的方法sort，及对排序后的数组进行查找的方法search。 输入 第一行先输入t，表示有t个测试用例 从第二行开始输入每个测试用例的数据。 首先输入数据类型，I表示int，D表示double，C表示char，接着输入数组的元素个数 然后输入每个元素 最后输入要查找的元素 输出 首先输出从小到大排序的元素 然后输出查找元素的结果，找到则输出下标，没找到则输出.
Array类的构造函数动态分配一个int类型数组
mhgjddev的博客
01-16 579
#include <iostream> using namespace std; class Array { public: Array(int size) // 构造函数 { _p = new int[size]; _size = size; } ~Array() { delete [] _p; } // 析构函数 void SetValue(int index, int value) // 设置指定元素的值 { if ( IsOutOfR
自写动态数组——参考《C++语言程序设计》(清华大学第4版)
qq_42615475的博客
10-08 432
自写实现一个动态数组，并且介绍了重载各类运算符的一些讲究的地方，什么时候用const，为啥返回类型是引用？深复制、浅复制等问题
c++自行实现array类
最新发布
08-26
array类的自行实现是指在编程语言中，我们可以自己编写一个类来实现数组的功能。在这个array类中，我们可以使用一些常见的数组操作，比如添加元素、删除元素、查找元素等。 首先，我们需要定义一个数组的数据结构，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值