Array.Reverse Metoda
Ważne
Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.
| 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. |
- Ź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 -> unitPublic Shared Sub Reverse (array As Array)Parametry
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
.NET 9 i inne wersje
| Produkt | Wersje |
|---|---|
| .NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
| .NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
| .NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
| UWP | 10.0 |
- Ź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 -> unitPublic Shared Sub Reverse (array As Array, index As Integer, length As Integer)Parametry
- 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
.NET 9 i inne wersje
| Produkt | Wersje |
|---|---|
| .NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
| .NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
| .NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
| UWP | 10.0 |
- Ź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[] -> unitPublic 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
.NET 9 i inne wersje
| Produkt | Wersje |
|---|---|
| .NET | Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
| .NET Standard | 2.1 |
- Ź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 -> unitPublic 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
.NET 9 i inne wersje
| Produkt | Wersje |
|---|---|
| .NET | Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
| .NET Standard | 2.1 |
Współpracuj z nami w serwisie GitHub
Źródło tej zawartości można znaleźć w witrynie GitHub, gdzie można również tworzyć i przeglądać problemy i żądania ściągnięcia. Więcej informacji znajdziesz w naszym przewodniku dla współtwórców.
Opinia o produkcie .NET
.NET to projekt typu open source. Wybierz link, aby przekazać opinię: