Export (0) Print
Expand All

Array.Reverse Method

Reverses the order of the elements in a one-dimensional Array or in a portion of the Array.

Overload List

Reverses the sequence of the elements in the entire one-dimensional Array.

[Visual Basic] Overloads Public Shared Sub Reverse(Array)
[C#] public static void Reverse(Array);
[C++] public: static void Reverse(Array*);
[JScript] public static function Reverse(Array);

Reverses the sequence of the elements in a section of the one-dimensional Array.

Supported by the .NET Compact Framework.

[Visual Basic] Overloads Public Shared Sub Reverse(Array, Integer, Integer)
[C#] public static void Reverse(Array, int, int);
[C++] public: static void Reverse(Array*, int, int);
[JScript] public static function Reverse(Array, int, int);

Example

The following code example shows how to reverse the sort of the values in a section of an Array.

[Visual Basic] 
Imports System
Imports Microsoft.VisualBasic

Public Class SamplesArray    
    
    Public Shared Sub Main()
        
        ' Creates and initializes a new Array.
        Dim myArray As Array = Array.CreateInstance(GetType(String), 9)
        myArray.SetValue("The", 0)
        myArray.SetValue("QUICK", 1)
        myArray.SetValue("BROWN", 2)
        myArray.SetValue("FOX", 3)
        myArray.SetValue("jumps", 4)
        myArray.SetValue("over", 5)
        myArray.SetValue("the", 6)
        myArray.SetValue("lazy", 7)
        myArray.SetValue("dog", 8)
        
        ' Displays the values of the Array.
        Console.WriteLine("The Array initially contains the " _
           + "following values:")
        PrintIndexAndValues(myArray)
        
        ' Reverses the sort of the values of the Array.
        Array.Reverse(myArray, 1, 3)
        
        ' Displays the values of the Array.
        Console.WriteLine("After reversing:")
        PrintIndexAndValues(myArray)
    End Sub    
    
    
    Public Shared Sub PrintIndexAndValues(myArray As Array)
        Dim i As Integer
        For i = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
            Console.WriteLine(ControlChars.Tab + "[{0}]:" + ControlChars.Tab _
               + "{1}", i, myArray.GetValue(i))
        Next i
    End Sub
End Class

' This code produces the following output.
' 
' The Array initially contains the following values:
'     [0]:    The
'     [1]:    QUICK
'     [2]:    BROWN
'     [3]:    FOX
'     [4]:    jumps
'     [5]:    over
'     [6]:    the
'     [7]:    lazy
'     [8]:    dog
' After reversing:
'     [0]:    The
'     [1]:    FOX
'     [2]:    BROWN
'     [3]:    QUICK
'     [4]:    jumps
'     [5]:    over
'     [6]:    the
'     [7]:    lazy
'     [8]:    dog 

[C#] 
using System;
public class SamplesArray  {

   public static void Main()  {

      // Creates and initializes a new Array.
      Array myArray=Array.CreateInstance( typeof(String), 9 );
      myArray.SetValue( "The", 0 );
      myArray.SetValue( "QUICK", 1 );
      myArray.SetValue( "BROWN", 2 );
      myArray.SetValue( "FOX", 3 );
      myArray.SetValue( "jumps", 4 );
      myArray.SetValue( "over", 5 );
      myArray.SetValue( "the", 6 );
      myArray.SetValue( "lazy", 7 );
      myArray.SetValue( "dog", 8 );

      // Displays the values of the Array.
      Console.WriteLine( "The Array initially contains the following values:" );
      PrintIndexAndValues( myArray );

      // Reverses the sort of the values of the Array.
      Array.Reverse( myArray, 1, 3 );

      // Displays the values of the Array.
      Console.WriteLine( "After reversing:" );
      PrintIndexAndValues( myArray );
   }


   public static void PrintIndexAndValues( Array myArray )  {
      for ( int i = myArray.GetLowerBound(0); i <= myArray.GetUpperBound(0); i++ )
         Console.WriteLine( "\t[{0}]:\t{1}", i, myArray.GetValue( i ) );
   }
}
/* 
This code produces the following output.

The Array initially contains the following values:
    [0]:    The
    [1]:    QUICK
    [2]:    BROWN
    [3]:    FOX
    [4]:    jumps
    [5]:    over
    [6]:    the
    [7]:    lazy
    [8]:    dog
After reversing:
    [0]:    The
    [1]:    FOX
    [2]:    BROWN
    [3]:    QUICK
    [4]:    jumps
    [5]:    over
    [6]:    the
    [7]:    lazy
    [8]:    dog
*/ 

[C++] 
#using <mscorlib.dll>
using namespace System;

void PrintIndexAndValues( Array* myArray );
 
void main()  {
 
       // Creates and initializes a new Array instance.
       Array* myArray = Array::CreateInstance( __typeof(String), 9 );
       myArray->SetValue( S"The", 0 );
       myArray->SetValue( S"QUICK", 1 );
       myArray->SetValue( S"BROWN", 2 );
       myArray->SetValue( S"FOX", 3 );
       myArray->SetValue( S"jumped", 4 );
       myArray->SetValue( S"over", 5 );
       myArray->SetValue( S"the", 6 );
       myArray->SetValue( S"lazy", 7 );
       myArray->SetValue( S"dog", 8 );
 
       // Displays the values of the Array.
       Console::WriteLine( "The Array instance initially contains the following values:" );
       PrintIndexAndValues( myArray );
 
       // Reverses the sort of the values of the Array.
       Array::Reverse( myArray, 1, 3 );
 
       // Displays the values of the Array.
       Console::WriteLine( "After reversing:" );
       PrintIndexAndValues( myArray );
}
 
 
void PrintIndexAndValues( Array* myArray )  {
    for ( int i = myArray->GetLowerBound(0); i <= myArray->GetUpperBound(0); i++ )
        Console::WriteLine( "\t[{0}]:\t{1}", __box(i), myArray->GetValue( i ) );
}

 /* 
 This code produces the following output.
 
 The Array instance initially contains the following values:
     [0]:    The
     [1]:    QUICK
     [2]:    BROWN
     [3]:    FOX
     [4]:    jumped
     [5]:    over
     [6]:    the
     [7]:    lazy
     [8]:    dog
 After reversing:
     [0]:    The
     [1]:    FOX
     [2]:    BROWN
     [3]:    QUICK
     [4]:    jumped
     [5]:    over
     [6]:    the
     [7]:    lazy
     [8]:    dog
 */ 

[JScript] 
import System;

// Creates and initializes a new Array.
var myArray : System.Array= System.Array.CreateInstance( System.String, 9 );
myArray.SetValue( "The", 0 );
myArray.SetValue( "QUICK", 1 );
myArray.SetValue( "BROWN", 2 );
myArray.SetValue( "FOX", 3 );
myArray.SetValue( "jumped", 4 );
myArray.SetValue( "over", 5 );
myArray.SetValue( "the", 6 );
myArray.SetValue( "lazy", 7 );
myArray.SetValue( "dog", 8 );

// Displays the values of the Array.
Console.WriteLine( "The Array initially contains the following values:" );
PrintIndexAndValues( myArray );

// Reverses the sort of the values of the Array.
System.Array.Reverse( myArray, 1, 3 );

// Displays the values of the Array.
Console.WriteLine( "After reversing:" );
PrintIndexAndValues( myArray );
 
 
function PrintIndexAndValues( myArray : System.Array )  {
   for ( var i : int = myArray.GetLowerBound(0); i <= myArray.GetUpperBound(0); i++ )
      Console.WriteLine( "\t[{0}]:\t{1}", i, myArray.GetValue( i ) );
}
 /* 
 This code produces the following output.
 
 The Array initially contains the following values:
     [0]:    The
     [1]:    QUICK
     [2]:    BROWN
     [3]:    FOX
     [4]:    jumped
     [5]:    over
     [6]:    the
     [7]:    lazy
     [8]:    dog
 After reversing:
     [0]:    The
     [1]:    FOX
     [2]:    BROWN
     [3]:    QUICK
     [4]:    jumped
     [5]:    over
     [6]:    the
     [7]:    lazy
     [8]:    dog
 */ 

See Also

Array Class | Array Members | System Namespace

Show:
© 2014 Microsoft