Stack.ToArrayとは？ わかりやすく解説

.NET Framework クラス ライブラリ リファレンス
索引トップ 用語の索引 ランキング
日本マイクロソフト株式会社日本マイクロソフト株式会社

Stack.ToArray メソッド

メモ : このメソッドは、.NET Framework version 2.0 で新しく追加されたものです。

Stack を新しい配列にコピーします。

名前空間: System.Collections.Generic
アセンブリ: System (system.dll 内)
構文構文

Visual Basic (宣言)
Public Function ToArray As
 T()
Visual Basic (使用法)
Dim instance As Stack(Of
 T)
Dim returnValue As T()

returnValue = instance.ToArray
C#
public T[] ToArray ()
C++
public:
array<T>^ ToArray ()
J#
public T[] ToArray ()
JScript
public function ToArray () : T[]

戻り値
Stack の要素のコピーを格納する新しい配列。

解説解説

要素は、Pop の連続的な呼び出しによって返される要素の順序と同様に、後入れ先出し (LIFO) の順序で配列にコピーされます。

このメソッドは O(n) 操作です。ここで、n は Count です。

使用例使用例

ToArray メソッドを含む、Stack ジェネリック クラスのいくつかのメソッドを使用したコード例を次に示します。

このコード例では、既定の容量で文字列のスタックを作成し、Push メソッドを使用して 5 つの文字列をスタックにプッシュします。スタックの要素は列挙されますが、スタックの状態は変化しません。Pop メソッドを使用して、最初の文字列をスタックからポップします。Peek メソッドを使用してスタック内の次の項目を調べてから、Pop メソッドを使用してその項目をスタックからポップします。

ToArray メソッドを使用して配列を作成し、その配列にスタック要素をコピーしてから、IEnumerable を受け取る Stack コンストラクタに配列を渡して、要素の順序を反転したスタックのコピーを作成します。コピーの要素が表示されます。

スタックの 2 倍のサイズの配列が作成され、CopyTo メソッドを使用して配列の中央部で始まる配列要素をコピーします。Stack コンストラクタを再度使用して、要素の順序を反転したスタックのコピーを作成します。その結果、3 つの null 要素が末尾に配置されます。

Contains メソッドを使用して、文字列 "four" がスタックの最初のコピーにあることを示します。その後で、Clear メソッドがコピーをクリアすると、Count プロパティによってスタックが空であることが示されます。

Visual Basic
Imports System
Imports System.Collections.Generic

Module Example

    Sub Main

        Dim numbers As New
 Stack(Of String)
        numbers.Push("one")
        numbers.Push("two")
        numbers.Push("three")
        numbers.Push("four")
        numbers.Push("five")

        ' A stack can be enumerated without disturbing its contents.
        For Each number As
 String In numbers
            Console.WriteLine(number)
        Next

        Console.WriteLine(vbLf & "Popping '{0}'", numbers.Pop())
        Console.WriteLine("Peek at next item to pop: {0}",
 _
            numbers.Peek())    
        Console.WriteLine("Popping '{0}'", numbers.Pop())

        ' Create another stack, using the ToArray method and the
        ' constructor that accepts an IEnumerable(Of T). Note that
        ' the order of items on the new stack is reversed.
        Dim stack2 As New
 Stack(Of String)(numbers.ToArray())

        Console.WriteLine(vbLf & "Contents of the first copy:")
        For Each number As
 String In stack2
            Console.WriteLine(number)
        Next
        
        ' Create an array twice the size of the stack, compensating
        ' for the fact that Visual Basic allocates an extra array 
        ' element. Copy the elements of the stack, starting at the
        ' middle of the array. 
        Dim array2((numbers.Count * 2) - 1) As
 String
        numbers.CopyTo(array2, numbers.Count)
        
        ' Create a second stack, using the constructor that accepts
 an
        ' IEnumerable(Of T). The elements are reversed, with the null
        ' elements appearing at the end of the stack when enumerated.
        Dim stack3 As New
 Stack(Of String)(array2)

        Console.WriteLine(vbLf & _
            "Contents of the second copy, with duplicates and
 nulls:")
        For Each number As
 String In stack3
            Console.WriteLine(number)
        Next

        Console.WriteLine(vbLf & "stack2.Contains(""four"")
 = {0}", _
            stack2.Contains("four"))

        Console.WriteLine(vbLf & "stack2.Clear()")
        stack2.Clear()
        Console.WriteLine(vbLf & "stack2.Count = {0}",
 _
            stack2.Count)
    End Sub
End Module

' This code example produces the following output:
'
'five
'four
'three
'two
'one
'
'Popping 'five'
'Peek at next item to pop: four
'Popping 'four'
'
'Contents of the first copy:
'one
'two
'three
'
'Contents of the second copy, with duplicates and nulls:
'one
'two
'three
'
'
'
'
'stack2.Contains("four") = False
'
'stack2.Clear()
'
'stack2.Count = 0
C#
using System;
using System.Collections.Generic;

class Example
{
    public static void Main()
    {
        Stack<string> numbers = new Stack<string>();
        numbers.Push("one");
        numbers.Push("two");
        numbers.Push("three");
        numbers.Push("four");
        numbers.Push("five");

        // A stack can be enumerated without disturbing its contents.
        foreach( string number in
 numbers )
        {
            Console.WriteLine(number);
        }

        Console.WriteLine("\nPopping '{0}'", numbers.Pop());
        Console.WriteLine("Peek at next item to destack: {0}", 
            numbers.Peek());
        Console.WriteLine("Popping '{0}'", numbers.Pop());

        // Create a copy of the stack, using the ToArray method and
 the
        // constructor that accepts an IEnumerable<T>.
        Stack<string> stack2 = new Stack<string>(numbers.ToArray());

        Console.WriteLine("\nContents of the first copy:");
        foreach( string number in
 stack2 )
        {
            Console.WriteLine(number);
        }
        
        // Create an array twice the size of the stack and copy the
        // elements of the stack, starting at the middle of the 
        // array. 
        string[] array2 = new string[numbers.Count
 * 2];
        numbers.CopyTo(array2, numbers.Count);
        
        // Create a second stack, using the constructor that accepts
 an
        // IEnumerable(Of T).
        Stack<string> stack3 = new Stack<string>(array2);

        Console.WriteLine("\nContents of the second copy, with duplicates and
 nulls:");
        foreach( string number in
 stack3 )
        {
            Console.WriteLine(number);
        }

        Console.WriteLine("\nstack2.Contains(\"four\") = {0}",
 
            stack2.Contains("four"));

        Console.WriteLine("\nstack2.Clear()");
        stack2.Clear();
        Console.WriteLine("\nstack2.Count = {0}", stack2.Count);
    }
}

/* This code example produces the following output:

five
four
three
two
one

Popping 'five'
Peek at next item to destack: four
Popping 'four'

Contents of the first copy:
one
two
three

Contents of the second copy, with duplicates and nulls:
one
two
three




stack2.Contains("four") = False

stack2.Clear()

stack2.Count = 0
 */
プラットフォームプラットフォーム

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報バージョン情報
.NET Framework
サポート対象 : 2.0
.NET Compact Framework
サポート対象 : 2.0
参照参照
関連項目
Stack ジェネリック クラス
Stack メンバ
System.Collections.Generic 名前空間
Stack.CopyTo メソッド
Stack.Pop メソッド

Stack.ToArray メソッド

Stack を新しい配列にコピーします。

名前空間: System.Collections
アセンブリ: mscorlib (mscorlib.dll 内)
構文構文

Visual Basic (宣言)
Public Overridable Function
 ToArray As Object()
Visual Basic (使用法)
Dim instance As Stack
Dim returnValue As Object()

returnValue = instance.ToArray
C#
public virtual Object[] ToArray ()
C++
public:
virtual array<Object^>^ ToArray ()
J#
public Object[] ToArray ()
JScript
public function ToArray () : Object[]

戻り値
Stack の要素のコピーを格納する新しい配列。

解説解説

要素は、Pop の連続的な呼び出しによって返される要素の順序と同様に、後入れ先出し (LIFO) の順序で配列にコピーされます。

このメソッドは O(n) 操作です。ここで、n は Count です。

使用例使用例

Stack を 1 次元の配列にコピーする方法の例を次に示します。

Visual Basic
Imports System
Imports System.Collections

Public Class SamplesStack    
    
    Public Shared Sub Main()
        
        ' Creates and initializes the source Stack.
        Dim mySourceQ As New
 Stack()
        mySourceQ.Push("barn")
        mySourceQ.Push("the")
        mySourceQ.Push("in")
        mySourceQ.Push("cats")
        mySourceQ.Push("napping")
        mySourceQ.Push("three")
        
        ' Creates and initializes the one-dimensional target Array.
        Dim myTargetArray As Array = Array.CreateInstance(GetType(String),
 15)
        myTargetArray.SetValue("The", 0)
        myTargetArray.SetValue("quick", 1)
        myTargetArray.SetValue("brown", 2)
        myTargetArray.SetValue("fox", 3)
        myTargetArray.SetValue("jumped", 4)
        myTargetArray.SetValue("over", 5)
        myTargetArray.SetValue("the", 6)
        myTargetArray.SetValue("lazy", 7)
        myTargetArray.SetValue("dog", 8)
        
        ' Displays the values of the target Array.
        Console.WriteLine("The target Array contains the "
 & _
           "following (before and after copying):")
        PrintValues(myTargetArray, " "c)
        
        ' Copies the entire source Stack to the target Array, starting
        ' at index 6.
        mySourceQ.CopyTo(myTargetArray, 6)
        
        ' Displays the values of the target Array.
        PrintValues(myTargetArray, " "c)
        
        ' Copies the entire source Stack to a new standard array.
        Dim myStandardArray As Object()
 = mySourceQ.ToArray()
        
        ' Displays the values of the new standard array.
        Console.WriteLine("The new standard array contains the
 following:")
        PrintValues(myStandardArray, " "c)
    End Sub    
    
    Overloads Public Shared
 Sub PrintValues(myArr As Array, _
       mySeparator As Char)
       
        Dim myObj As Object
        For Each myObj In
  myArr
            Console.Write("{0}{1}", mySeparator, myObj)
        Next myObj
        Console.WriteLine()
    End Sub

End Class


' This code produces the following output.
'
' The target Array contains the following (before and after copying):
'  The quick brown fox jumped over the lazy dog
'  The quick brown fox jumped over three napping cats in the barn
' The new standard array contains the following:
'  three napping cats in the barn
C#
using System;
using System.Collections;
public class SamplesStack  {

   public static void Main()
  {

      // Creates and initializes the source Stack.
      Stack mySourceQ = new Stack();
      mySourceQ.Push( "barn" );
      mySourceQ.Push( "the" );
      mySourceQ.Push( "in" );
      mySourceQ.Push( "cats" );
      mySourceQ.Push( "napping" );
      mySourceQ.Push( "three" );

      // Creates and initializes the one-dimensional target Array.
      Array myTargetArray=Array.CreateInstance( typeof(String), 15 );
      myTargetArray.SetValue( "The", 0 );
      myTargetArray.SetValue( "quick", 1 );
      myTargetArray.SetValue( "brown", 2 );
      myTargetArray.SetValue( "fox", 3 );
      myTargetArray.SetValue( "jumped", 4 );
      myTargetArray.SetValue( "over", 5 );
      myTargetArray.SetValue( "the", 6 );
      myTargetArray.SetValue( "lazy", 7 );
      myTargetArray.SetValue( "dog", 8 );

      // Displays the values of the target Array.
      Console.WriteLine( "The target Array contains the following (before and
 after copying):" );
      PrintValues( myTargetArray, ' ' );

      // Copies the entire source Stack to the target Array, starting
 at index 6.
      mySourceQ.CopyTo( myTargetArray, 6 );

      // Displays the values of the target Array.
      PrintValues( myTargetArray, ' ' );

      // Copies the entire source Stack to a new standard array.
      Object[] myStandardArray = mySourceQ.ToArray();

      // Displays the values of the new standard array.
      Console.WriteLine( "The new standard array contains
 the following:" );
      PrintValues( myStandardArray, ' ' );

   }


   public static void PrintValues(
 Array myArr, char mySeparator )  {
      foreach ( Object myObj in myArr )  {
         Console.Write( "{0}{1}", mySeparator, myObj );
      }
      Console.WriteLine();
   }

}


/* 
This code produces the following output.

The target Array contains the following (before and after copying):
 The quick brown fox jumped over the lazy dog      
 The quick brown fox jumped over three napping cats in the barn
   
The new standard array contains the following:
 three napping cats in the barn
*/
C++
using namespace System;
using namespace System::Collections;
void PrintValues( Array^ myArr, char mySeparator
 );
int main()
{
   // Creates and initializes the source Stack.
   Stack^ mySourceQ = gcnew Stack;
   mySourceQ->Push( "barn" );
   mySourceQ->Push( "the" );
   mySourceQ->Push( "in" );
   mySourceQ->Push( "cats" );
   mySourceQ->Push( "napping" );
   mySourceQ->Push( "three" );

   // Creates and initializes the one-dimensional target Array.
   Array^ myTargetArray = Array::CreateInstance( String::typeid, 15 );
   myTargetArray->SetValue( "The", 0 );
   myTargetArray->SetValue( "quick", 1 );
   myTargetArray->SetValue( "brown", 2 );
   myTargetArray->SetValue( "fox", 3 );
   myTargetArray->SetValue( "jumped", 4 );
   myTargetArray->SetValue( "over", 5 );
   myTargetArray->SetValue( "the", 6 );
   myTargetArray->SetValue( "lazy", 7 );
   myTargetArray->SetValue( "dog", 8 );

   // Displays the values of the target Array.
   Console::WriteLine( "The target Array contains the following (before and
 after copying):" );
   PrintValues( myTargetArray, ' ' );

   // Copies the entire source Stack to the target Array, starting at
 index 6.
   mySourceQ->CopyTo( myTargetArray, 6 );

   // Displays the values of the target Array.
   PrintValues( myTargetArray, ' ' );

   // Copies the entire source Stack to a new standard array.
   array<Object^>^myStandardArray = mySourceQ->ToArray();

   // Displays the values of the new standard array.
   Console::WriteLine( "The new standard array contains the
 following:" );
   PrintValues( myStandardArray, ' ' );
}

void PrintValues( Array^ myArr, char mySeparator
 )
{
   IEnumerator^ myEnum = myArr->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Object^ myObj = safe_cast<Object^>(myEnum->Current);
      Console::Write( "{0}{1}", mySeparator, myObj );
   }

   Console::WriteLine();
}

/* 
 This code produces the following output.
 
 The target Array contains the following (before and after copying):
  The quick brown fox jumped over the lazy dog      
  The quick brown fox jumped over three napping cats in the barn
   
 The new standard array contains the following:
  three napping cats in the barn
 */
J#
import System.*;
import System.Collections.*;

public class SamplesStack
{
    public static void main(String[]
 args)
    {
        // Creates and initializes the source Stack.
        Stack mySourceQ = new Stack();

        mySourceQ.Push("barn");
        mySourceQ.Push("the");
        mySourceQ.Push("in");
        mySourceQ.Push("cats");
        mySourceQ.Push("napping");
        mySourceQ.Push("three");

        // Creates and initializes the one-dimensional target Array.
        Array myTargetArray = Array.CreateInstance(String.class.ToType(),
 15);

        myTargetArray.SetValue("The", 0);
        myTargetArray.SetValue("quick", 1);
        myTargetArray.SetValue("brown", 2);
        myTargetArray.SetValue("fox", 3);
        myTargetArray.SetValue("jumped", 4);
        myTargetArray.SetValue("over", 5);
        myTargetArray.SetValue("the", 6);
        myTargetArray.SetValue("lazy", 7);
        myTargetArray.SetValue("dog", 8);

        // Displays the values of the target Array.
        Console.WriteLine("The target Array contains the following " +
 
            "(before and after copying):");
        PrintValues(myTargetArray, ' ');

        // Copies the entire source Stack to the target Array, starting
 at 
        // index 6.
        mySourceQ.CopyTo(myTargetArray, 6);

        // Displays the values of the target Array.
        PrintValues(myTargetArray, ' ');

        // Copies the entire source Stack to a new standard array.
        Object myStandardArray[] = mySourceQ.ToArray();

        // Displays the values of the new standard array.
        Console.WriteLine("The new standard array contains
 the following:");
        PrintValues(myStandardArray, ' ');
    } //main

    public static void PrintValues(Array
 myArr, char mySeparator)
    {
        IEnumerator objEnum = myArr.GetEnumerator();
        while (objEnum.MoveNext()) {
            Console.Write("{0}{1}", 
                System.Convert.ToString(mySeparator), 
                System.Convert.ToString(objEnum.get_Current()));
        }
        Console.WriteLine();
    } //PrintValues

} //SamplesStack

/* 
 This code produces the following output.
 
 The target Array contains the following (before and after copying):
  The quick brown fox jumped over the lazy dog      
  The quick brown fox jumped over three napping cats in the barn
   
 The new standard array contains the following:
  three napping cats in the barn
 */
プラットフォームプラットフォーム

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報バージョン情報
.NET Framework
サポート対象 : 2.0、1.1、1.0
.NET Compact Framework
サポート対象 : 2.0、1.0
参照参照
関連項目
Stack クラス
Stack メンバ
System.Collections 名前空間
CopyTo
Pop

急上昇のことば

沙也加 (AV女優)
続柄
ジム・スタインマン
DL site
受け取る
英和和英テキスト翻訳>> Weblio翻訳
英語⇒日本語日本語⇒英語
  

辞書ショートカット

カテゴリ一覧

全て

＋ ビジネス

＋ 業界用語

＋ コンピュータ

＋ 電車

＋ 自動車・バイク

＋ 船

＋ 工学

＋ 建築・不動産

＋ 学問

＋ 文化

＋ 生活

＋ ヘルスケア

＋ 趣味

＋ スポーツ

＋ 生物

＋ 食品

＋ 人名

＋ 方言

＋ 辞書・百科事典

すべての辞書の索引

あいうえお
かきくけこ
さしすせそ
たちつてと
なにぬねの
はひふへほ
まみむめも
やゆよ
らりるれろ
わをん
がぎぐげご
ざじずぜぞ
だぢづでど
ばびぶべぼ
ぱぴぷぺぽ
ＡＢＣＤＥ
ＦＧＨＩＪ
ＫＬＭＮＯ
ＰＱＲＳＴ
ＵＶＷＸＹ
Ｚ
１２３４５
６７８９０
記号

Weblioのサービス

Stack.ToArrayのお隣キーワード

Stack.Synchronized メソッド

Stack.System.Collections.Generic.IEnumerable<T>.GetEnumerator メソッド

Stack.System.Collections.ICollection.CopyTo メソッド

Stack.System.Collections.ICollection.IsSynchronized プロパティ

Stack.System.Collections.ICollection.SyncRoot プロパティ

Stack.System.Collections.IEnumerable.GetEnumerator メソッド

Stack.ToArray

Stack.ToArray メソッド

StackOverflowException コンストラクタ

StackOverflowException プロパティ

StackOverflowException メソッド

StackOverflowException メンバ

StackTrace クラス

検索ランキング

   

 英語⇒日本語
日本語⇒英語		    


Stack.ToArrayのページの著作権
Weblio 辞書 情報提供元は 参加元一覧 にて確認できます。

   
日本マイクロソフト株式会社日本マイクロソフト株式会社
© 2025 Microsoft.All rights reserved.

©2025 GRAS Group, Inc.RSS