Udostępnij za pośrednictwem


Array.Reverse Metoda

Definicja

Odwraca kolejność elementów w jednowymiarowym Array lub w części Array.

Przeciążenia

Reverse(Array)

Odwraca sekwencję elementów w całym jednowymiarowym Arrayobiekcie .

Reverse(Array, Int32, Int32)

Odwraca sekwencję podzestawu elementów w jednowymiarowym Arrayobiekcie .

Reverse<T>(T[])

Odwraca sekwencję elementów w jednowymiarowej tablicy ogólnej.

Reverse<T>(T[], Int32, Int32)

Odwraca sekwencję podzestawu elementów w tablicy ogólnej jednowymiarowej.

Reverse(Array)

Źródło:
Array.cs
Źródło:
Array.cs
Źródło:
Array.cs

Odwraca sekwencję elementów w całym jednowymiarowym Arrayobiekcie .

public:
 static void Reverse(Array ^ array);
public static void Reverse (Array array);
static member Reverse : Array -> unit
Public Shared Sub Reverse (array As Array)

Parametry

array
Array

Jednowymiarowy Array do odwrócenia.

Wyjątki

array to null.

Parametr array jest wielowymiarowy.

Przykłady

W poniższym przykładzie kodu pokazano, jak odwrócić rodzaj wartości w elemecie Array.

using namespace System;
void PrintIndexAndValues( Array^ myArray );
void main()
{
   // Creates and initializes a new Array instance.
   Array^ myArray = Array::CreateInstance( String::typeid, 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 instance initially contains the following values:" );
   PrintIndexAndValues( myArray );

   // Reverses the sort of the values of the Array.
   Array::Reverse( myArray );
   
   // 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}", 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]:    jumps
     [5]:    over
     [6]:    the
     [7]:    lazy
     [8]:    dog
 After reversing:
     [0]:    dog
     [1]:    lazy
     [2]:    the
     [3]:    over
     [4]:    jumps
     [5]:    fox
     [6]:    brown
     [7]:    quick
     [8]:    The
 */
open System

let printIndexAndValues (arr: 'a []) =
    for i = arr.GetLowerBound 0 to arr.GetUpperBound 0 do
        printfn $"\t[{i}]:\t{arr[i]}"

// Creates and initializes a new Array.
let myArray = 
    [| "The"; "quick"; "brown"; "fox"
       "jumps"; "over"; "the"; "lazy"; "dog" |]

// Displays the values of the Array.
printfn "The Array initially contains the following values:" 
printIndexAndValues myArray 

// Reverses the sort of the values of the Array.
Array.Reverse myArray 

// Displays the values of the Array.
printfn "After reversing:"
printIndexAndValues myArray 

(*
 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]:    dog
     [1]:    lazy
     [2]:    the
     [3]:    over
     [4]:    jumps
     [5]:    fox
     [6]:    brown
     [7]:    quick
     [8]:    The
 *)
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 );

      // 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]:    dog
    [1]:    lazy
    [2]:    the
    [3]:    over
    [4]:    jumps
    [5]:    fox
    [6]:    brown
    [7]:    quick
    [8]:    The
*/
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)
        
        ' 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]:    dog
'     [1]:    lazy
'     [2]:    the
'     [3]:    over
'     [4]:    jumps
'     [5]:    fox
'     [6]:    brown
'     [7]:    quick
'     [8]:    The

Uwagi

Po wywołaniu tej metody element w myArray[i]lokalizacji , gdzie i jest dowolnym indeksem w tablicy, przechodzi do myArray[j]metody , gdzie j równa (myArray.Length + myArray.GetLowerBound(0)) - (i - myArray.GetLowerBound(0)) - 1się .

Ta metoda jest operacją O(), gdzie n jest wartością Lengtharray.n

W języku F# można zamiast tego użyć funkcji Array.rev .

Jak pokazano w poniższym przykładzie, Reverse można użyć metody do odwrócenia tablicy poszarpanej. Inicjuje poszarpaną tablicę z jednym elementem dla każdego miesiąca bieżącego roku w kalendarzu bieżącej kultury. Każdy element zawiera tablicę z dowolną liczbą elementów w danym miesiącu. W przykładzie wyświetlana jest zawartość tablicy, wywołuje metodę Reverse , a następnie wyświetla zawartość odwróconej tablicy.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      int nMonths = DateTimeFormatInfo.CurrentInfo.Calendar.GetMonthsInYear(DateTime.Now.Year);
      int[][] months = new int[nMonths][];

      // Populate elements with number of days in month.
      for (int ctr = 0; ctr <= months.GetUpperBound(0); ctr++) {
         int daysInMonth = DateTime.DaysInMonth(DateTime.Now.Year, ctr + 1);
         months[ctr] = new int[daysInMonth] ;
         for (int ctr2 = 1; ctr2 <= daysInMonth; ctr2++)
            months[ctr][ctr2 - 1] = ctr2;
      }

      foreach (var month in months) {
         foreach (var day in month)
            Console.Write("{0} ", day);

         Console.WriteLine();
      }
      Console.WriteLine();

      Console.WriteLine("About to reverse array.\n");
      Array.Reverse(months);

      foreach (var month in months) {
         foreach (var day in month)
            Console.Write("{0} ", day);

         Console.WriteLine();
      }
   }
}
// The example displays output similar to the following:
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
//
//    About to reverse array.
//
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
open System
open System.Globalization

let nMonths = DateTimeFormatInfo.CurrentInfo.Calendar.GetMonthsInYear DateTime.Now.Year

let months = Array.init nMonths (fun i -> 
    // Populate elements with number of days in month.
    let daysInMonth = DateTime.DaysInMonth(DateTime.Now.Year, i + 1)
    Array.init daysInMonth (fun i -> i + 1 ) )

for month in months do
    for day in month do
        printf $"{day} "
    printfn ""

printfn "\nAbout to reverse array.\n"
Array.Reverse months

for month in months do
    for day in month do
        printf $"{day} "
    printfn ""

// The example displays output similar to the following:
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
//    
//    About to reverse array.
//    
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 
//    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim nMonths As Integer = DateTimeFormatInfo.CurrentInfo.Calendar.GetMonthsInYear(Date.Now.Year)
      Dim months()() As Integer = New Integer(nMonths - 1)() {}

      ' Populate elements with number of days in month.
      For ctr As Integer = 0 To months.GetUpperBound(0)
         Dim daysInMonth As Integer = DateTime.DaysInMonth(Date.Now.Year, ctr + 1)
         months(ctr) = New Integer(daysInMonth - 1) {}
         For ctr2 As Integer = 1 To daysInMonth
            months(ctr)(ctr2 - 1) = ctr2
         Next
      Next

      For Each _month In months
         For each _day In _month
            Console.Write("{0} ", _day)
         Next   
         Console.WriteLine()
      Next
      Console.WriteLine()
               
      Console.WriteLine("About to reverse array.")
      Console.WriteLine()
      Array.Reverse(months)

      For Each _month In months
         For each _day In _month
            Console.Write("{0} ", _day)
         Next   
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays output similar to the following:
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
'    
'    About to reverse array.
'    
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
'    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

Dotyczy

Reverse(Array, Int32, Int32)

Źródło:
Array.cs
Źródło:
Array.cs
Źródło:
Array.cs

Odwraca sekwencję podzestawu elementów w jednowymiarowym Arrayobiekcie .

public:
 static void Reverse(Array ^ array, int index, int length);
public static void Reverse (Array array, int index, int length);
static member Reverse : Array * int * int -> unit
Public Shared Sub Reverse (array As Array, index As Integer, length As Integer)

Parametry

array
Array

Jednowymiarowy Array do odwrócenia.

index
Int32

Indeks początkowy sekcji do odwrócenia.

length
Int32

Liczba elementów w sekcji do odwrócenia.

Wyjątki

array to null.

Parametr array jest wielowymiarowy.

indexjest mniejsza niż niższa granica .array

-lub-

Parametr length ma wartość niższą niż zero.

index i length nie określają prawidłowego zakresu w arrayelemecie .

Przykłady

W poniższym przykładzie kodu pokazano, jak odwrócić rodzaj wartości w zakresie elementów w elemecie Array.

using namespace System;
void PrintIndexAndValues( Array^ myArray );
void main()
{
   // Creates and initializes a new Array instance.
   Array^ myArray = Array::CreateInstance( String::typeid, 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 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}", 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]:    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
 */
open System

let printIndexAndValues (arr: 'a []) =
    for i = arr.GetLowerBound 0 to arr.GetUpperBound 0 do
        printfn $"\t[{i}]:\t{arr[i]}"

// Creates and initializes a new Array.
let myArray = 
    [| "The"; "QUICK"; "BROWN"; "FOX"
       "jumps"; "over"; "the"; "lazy"; "dog" |]

// Displays the values of the Array.
printfn "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.
printfn "After reversing:"
printIndexAndValues myArray 

(*
 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
 *)
using System;
public class SamplesArray1  {

   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
*/
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

Uwagi

Po wywołaniu tej metody element w myArray[i]lokalizacji , gdzie i jest dowolnym indeksem w tablicy, przechodzi do myArray[j]metody , gdzie j równa (myArray.Length + myArray.GetLowerBound(0)) - (i - myArray.GetLowerBound(0)) - 1się .

Metoda Reverse może służyć do odwrócenia poszarpanej tablicy.

Ta metoda jest operacją O(n), gdzie n to length.

Dotyczy

Reverse<T>(T[])

Źródło:
Array.cs
Źródło:
Array.cs
Źródło:
Array.cs

Odwraca sekwencję elementów w jednowymiarowej tablicy ogólnej.

public:
generic <typename T>
 static void Reverse(cli::array <T> ^ array);
public static void Reverse<T> (T[] array);
static member Reverse : 'T[] -> unit
Public Shared Sub Reverse(Of T) (array As T())

Parametry typu

T

Typ elementów w elemecie array.

Parametry

array
T[]

Jednowymiarowa tablica elementów do odwrócenia.

Wyjątki

array to null.

Parametr array jest wielowymiarowy.

Dotyczy

Reverse<T>(T[], Int32, Int32)

Źródło:
Array.cs
Źródło:
Array.cs
Źródło:
Array.cs

Odwraca sekwencję podzestawu elementów w tablicy ogólnej jednowymiarowej.

public:
generic <typename T>
 static void Reverse(cli::array <T> ^ array, int index, int length);
public static void Reverse<T> (T[] array, int index, int length);
static member Reverse : 'T[] * int * int -> unit
Public Shared Sub Reverse(Of T) (array As T(), index As Integer, length As Integer)

Parametry typu

T

Typ elementów w elemecie array.

Parametry

array
T[]

Jednowymiarowa tablica elementów do odwrócenia.

index
Int32

Indeks początkowy sekcji do odwrócenia.

length
Int32

Liczba elementów w sekcji do odwrócenia.

Wyjątki

array to null.

Parametr array jest wielowymiarowy.

indexjest mniejsza niż niższa granica .array

-lub-

Parametr length ma wartość niższą niż zero.

index i length nie określają prawidłowego zakresu w arrayelemecie .

Dotyczy