BigInteger.CompareTo 方法

定义

将此实例的值与另一个值进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于另一个值。Compares the value of this instance with another value and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the other value.

重载

CompareTo(Object)

将此实例与指定对象进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于指定对象的值。Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

CompareTo(UInt64)

将此实例与 64 位无符号整数进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于 64 位无符号整数的值。Compares this instance to an unsigned 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the unsigned 64-bit integer.

CompareTo(Int64)

将此实例与 64 位带符号整数进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于 64 位带符号整数的值。Compares this instance to a signed 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the signed 64-bit integer.

CompareTo(BigInteger)

将此实例与另一个 BigInteger 进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于指定对象的值。Compares this instance to a second BigInteger and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

CompareTo(Object)

将此实例与指定对象进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于指定对象的值。Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

public:
 virtual int CompareTo(System::Object ^ obj);
public int CompareTo (object obj);
abstract member CompareTo : obj -> int
override this.CompareTo : obj -> int
Public Function CompareTo (obj As Object) As Integer

参数

obj
Object

要比较的对象。The object to compare.

返回

Int32

一个带符号整数,指示当前实例与 obj 参数的关系,如下表所示。A signed integer that indicates the relationship of the current instance to the obj parameter, as shown in the following table.

返回值Return value 说明Description
小于零Less than zero 当前实例小于 objThe current instance is less than obj.
Zero 当前实例等于 objThe current instance equals obj.
大于零Greater than zero 当前实例大于 obj,或者 obj 参数为 nullThe current instance is greater than obj, or the obj parameter is null.

实现

例外

obj 不是 BigIntegerobj is not a BigInteger.

示例

下面的示例调用 CompareTo(Object) 方法,将 BigInteger 值与对象数组中的每个元素进行比较:The following example calls the CompareTo(Object) method to compare a BigInteger value with each element in an object array:

object[] values = { BigInteger.Pow(Int64.MaxValue, 10), null,
                    12.534, Int64.MaxValue, BigInteger.One };
BigInteger number = UInt64.MaxValue;

foreach (object value in values)
{
   try {
      Console.WriteLine("Comparing {0} with '{1}': {2}", number, value,
                        number.CompareTo(value));
   }
   catch (ArgumentException) {
      Console.WriteLine("Unable to compare the {0} value {1} with a BigInteger.",
                        value.GetType().Name, value);
   }
}
// The example displays the following output:
//    Comparing 18446744073709551615 with '4.4555084156466750133735972424E+189': -1
//    Comparing 18446744073709551615 with '': 1
//    Unable to compare the Double value 12.534 with a BigInteger.
//    Unable to compare the Int64 value 9223372036854775807 with a BigInteger.
//    Comparing 18446744073709551615 with '1': 1
Dim values() As Object = { BigInteger.Pow(Int64.MaxValue, 10), Nothing, 
                           12.534, Int64.MaxValue, BigInteger.One }
Dim number As BigInteger = UInt64.MaxValue

For Each value As Object In values
   Try
      Console.WriteLine("Comparing {0} with '{1}': {2}", number, value, 
                        number.CompareTo(value))
   Catch e As ArgumentException
      Console.WriteLine("Unable to compare the {0} value {1} with a BigInteger.",
                        value.GetType().Name, value)
   End Try                     
Next                                 
' The example displays the following output:
'    Comparing 18446744073709551615 with '4.4555084156466750133735972424E+189': -1
'    Comparing 18446744073709551615 with '': 1
'    Unable to compare the Double value 12.534 with a BigInteger.
'    Unable to compare the Int64 value 9223372036854775807 with a BigInteger.
'    Comparing 18446744073709551615 with '1': 1

注解

CompareTo 方法的此重载实现 IComparable.CompareTo 方法。This overload of the CompareTo method implements the IComparable.CompareTo method. 它由非泛型集合对象用于对集合中的项进行排序。It is used by non-generic collection objects to order the items in the collection.

obj 参数必须为以下参数之一:The obj parameter must be one of the following:

  • BigInteger其运行时类型的对象。An object whose run-time type is BigInteger.

  • 值为 nullObject 变量。An Object variable whose value is null. 如果 null``obj 参数的值,则该方法将返回1,指示当前实例大于 objIf the value of the obj parameter is null, the method returns 1, which indicates that the current instance is greater than obj.

另请参阅

CompareTo(UInt64)

重要

此 API 不符合 CLS。

将此实例与 64 位无符号整数进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于 64 位无符号整数的值。Compares this instance to an unsigned 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the unsigned 64-bit integer.

public:
 int CompareTo(System::UInt64 other);
[System.CLSCompliant(false)]
public int CompareTo (ulong other);
member this.CompareTo : uint64 -> int
Public Function CompareTo (other As ULong) As Integer

参数

other
UInt64

要比较的 64 位无符号整数。The unsigned 64-bit integer to compare.

返回

Int32

一个带符号整数,指示此实例和 other 的相对值,如下表所示。A signed integer that indicates the relative value of this instance and other, as shown in the following table.

返回值Return value说明Description
小于零Less than zero当前实例小于 otherThe current instance is less than other.
Zero当前实例等于 otherThe current instance equals other.
大于零Greater than zero当前实例大于 otherThe current instance is greater than other.
属性

CompareTo(Int64)

将此实例与 64 位带符号整数进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于 64 位带符号整数的值。Compares this instance to a signed 64-bit integer and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the signed 64-bit integer.

public:
 int CompareTo(long other);
public int CompareTo (long other);
member this.CompareTo : int64 -> int
Public Function CompareTo (other As Long) As Integer

参数

other
Int64

要比较的 64 位带符号整数。The signed 64-bit integer to compare.

返回

Int32

一个带符号整数值,指示此实例与 other 的关系,如下表所示。A signed integer value that indicates the relationship of this instance to other, as shown in the following table.

返回值Return value 说明Description
小于零Less than zero 当前实例小于 otherThe current instance is less than other.
Zero 当前实例等于 otherThe current instance equals other.
大于零Greater than zero 当前实例大于 otherThe current instance is greater than other.

示例

下面的示例演示了通过整数值调用 CompareTo(Int64) 方法的结果。The following example illustrates the result of calling the CompareTo(Int64) method with integral values.

BigInteger bigIntValue = BigInteger.Parse("3221123045552");

byte byteValue = 16;
sbyte sbyteValue = -16;
short shortValue = 1233;
ushort ushortValue = 1233;
int intValue = -12233;
uint uintValue = 12233;
long longValue = 12382222;
ulong ulongValue = 1238222;

Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, byteValue,
                  bigIntValue.CompareTo(byteValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, sbyteValue,
                  bigIntValue.CompareTo(sbyteValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, shortValue,
                  bigIntValue.CompareTo(shortValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, ushortValue,
                  bigIntValue.CompareTo(ushortValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, intValue,
                  bigIntValue.CompareTo(intValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, uintValue,
                  bigIntValue.CompareTo(uintValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, longValue,
                  bigIntValue.CompareTo(longValue));
Console.WriteLine("Comparing {0} with {1}: {2}",
                  bigIntValue, ulongValue,
                  bigIntValue.CompareTo(ulongValue));
// The example displays the following output:
//       Comparing 3221123045552 with 16: 1
//       Comparing 3221123045552 with -16: 1
//       Comparing 3221123045552 with 1233: 1
//       Comparing 3221123045552 with 1233: 1
//       Comparing 3221123045552 with -12233: 1
//       Comparing 3221123045552 with 12233: 1
//       Comparing 3221123045552 with 12382222: 1
//       Comparing 3221123045552 with 1238222: 1
Dim bigIntValue As BigInteger = BigInteger.Parse("3221123045552")

Dim byteValue As Byte = 16
Dim sbyteValue As SByte = -16
Dim shortValue As Short = 1233      
Dim ushortValue As UShort = 1233
Dim intValue As Integer = -12233
Dim uintValue As UInteger = 12233
Dim longValue As Long = 12382222
Dim ulongValue As Integer = 1238222

Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, byteValue, _
                  bigIntValue.CompareTo(byteValue))
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, sbyteValue, _
                  bigIntValue.CompareTo(sbyteValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, shortValue, _
                  bigIntValue.CompareTo(shortValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, ushortValue, _
                  bigIntValue.CompareTo(ushortValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, intValue, _
                  bigIntValue.CompareTo(intValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, uintValue, _
                  bigIntValue.CompareTo(uintValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, longValue, _
                  bigIntValue.CompareTo(longValue)) 
Console.WriteLine("Comparing {0} with {1}: {2}", _
                  bigIntValue, ulongValue, _
                  bigIntValue.CompareTo(ulongValue))
' The example displays the following output:
'       Comparing 3221123045552 with 16: 1
'       Comparing 3221123045552 with -16: 1
'       Comparing 3221123045552 with 1233: 1
'       Comparing 3221123045552 with 1233: 1
'       Comparing 3221123045552 with -12233: 1
'       Comparing 3221123045552 with 12233: 1
'       Comparing 3221123045552 with 12382222: 1
'       Comparing 3221123045552 with 1238222: 1

注解

如果 otherByteInt16Int32SByteUInt16UInt32 值,则在调用 Int64 方法时,它将隐式转换为 CompareTo(Int64) 值。If other is a Byte, Int16, Int32, SByte, UInt16, or UInt32 value, it is implicitly converted to an Int64 value when the CompareTo(Int64) method is called.

CompareTo(BigInteger)

将此实例与另一个 BigInteger 进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于指定对象的值。Compares this instance to a second BigInteger and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

public:
 virtual int CompareTo(System::Numerics::BigInteger other);
public int CompareTo (System.Numerics.BigInteger other);
abstract member CompareTo : System.Numerics.BigInteger -> int
override this.CompareTo : System.Numerics.BigInteger -> int
Public Function CompareTo (other As BigInteger) As Integer

参数

other
BigInteger

要比较的对象。The object to compare.

返回

Int32

一个带符号整数值,指示此实例与 other 的关系,如下表所示。A signed integer value that indicates the relationship of this instance to other, as shown in the following table.

返回值Return value 说明Description
小于零Less than zero 当前实例小于 otherThe current instance is less than other.
Zero 当前实例等于 otherThe current instance equals other.
大于零Greater than zero 当前实例大于 otherThe current instance is greater than other.

实现

示例

下面的示例演示如何使用 CompareTo(BigInteger) 方法对 StarInfo 对象的列表进行排序。The following example illustrates the use of the CompareTo(BigInteger) method to order a list of StarInfo objects. 每个 StarInfo 对象均提供有关星形名称及其与地球距离的信息(英里)。Each StarInfo object provides information about a star's name and its distance from the Earth in miles. StarInfo 实现 IComparable<T> 接口,该接口启用按泛型集合类排序 StarInfo 对象。StarInfo implements the IComparable<T> interface, which enables StarInfo objects to be sorted by generic collection classes. 它的 IComparable<T>.CompareTo 实现仅包装对 CompareTo(BigInteger)的调用。Its IComparable<T>.CompareTo implementation just wraps a call to CompareTo(BigInteger).

using System;
using System.Collections.Generic;
using System.Numerics;

public struct StarInfo : IComparable<StarInfo>
{
   // Define constructors.
   public StarInfo(string name, double lightYears)
   {
      this.Name = name;

      // Calculate distance in miles from light years.
      this.Distance = (BigInteger) Math.Round(lightYears * 5.88e12);
   }

   public StarInfo(string name, BigInteger distance)
   {
      this.Name = name;
      this.Distance = distance;
   }

   // Define public fields.
   public string Name;
   public BigInteger Distance;

   // Display name of star and its distance in parentheses.
   public override string ToString()
   {
      return String.Format("{0,-10} ({1:N0})", this.Name, this.Distance);
   }

   // Compare StarInfo objects by their distance from Earth.
   public int CompareTo(StarInfo other)
   {
      return this.Distance.CompareTo(other.Distance);
   }
}
Imports System.Collections.Generic
Imports System.Numerics

Public Structure StarInfo : Implements IComparable(Of StarInfo)
   ' Define constructors.
   Public Sub New(name As String, lightYears As Double)
      Me.Name = name
      ' Calculate distance in miles from light years.
      Me.Distance = CType(Math.Round(lightYears * 5.88e12), BigInteger)
   End Sub
   
   Public Sub New(name As String, distance As BigInteger)
      Me.Name = name
      Me.Distance = distance
   End Sub
   
   ' Define public fields.
   Public Name As String
   Public Distance As BigInteger

   ' Display name of star and its distance in parentheses.
   Public Overrides Function ToString() As String
      Return String.Format("{0,-10} ({1:N0})", Me.Name, Me.Distance)
   End Function

   ' Compare StarInfo objects by their distance from Earth.
   Public Function CompareTo(other As starInfo) As Integer _
                   Implements IComparable(Of StarInfo).CompareTo
      Return Me.Distance.CompareTo(other.Distance)
   End Function                
End Structure

然后,以下代码实例化四个 StarInfo 对象,并将它们存储在泛型 List<T> 对象中。The following code then instantiates four StarInfo objects and stores them in a generic List<T> object. 调用 List<T>.Sort 方法后,StarInfo 对象将按其与地球的距离顺序显示。After the List<T>.Sort method is called, StarInfo objects are displayed in order of their distance from the Earth.

public class Example
{
   public static void Main()
   {
      StarInfo star;
      List<StarInfo> stars = new List<StarInfo>();

      star = new StarInfo("Sirius", 8.6d);
      stars.Add(star);
      star = new StarInfo("Rigel", 1400d);
      stars.Add(star);
      star = new StarInfo("Castor", 49d);
      stars.Add(star);
      star = new StarInfo("Antares", 520d);
      stars.Add(star);

      stars.Sort();

      foreach (StarInfo sortedStar in stars)
         Console.WriteLine(sortedStar);
   }
}
// The example displays the following output:
//       Sirius     (50,568,000,000,000)
//       Castor     (288,120,000,000,000)
//       Antares    (3,057,600,000,000,000)
//       Rigel      (8,232,000,000,000,000)
Module Example
   Public Sub Main()
      Dim star As StarInfo
      Dim stars As New List(Of StarInfo)
      
      star = New StarInfo("Sirius", 8.6d)
      stars.Add(star)
      star = New StarInfo("Rigel", 1400d)
      stars.Add(star)
      star = New StarInfo("Castor", 49d)
      stars.Add(star)
      star = New StarInfo("Antares", 520d)
      stars.Add(star)
      
      stars.Sort()
      
      For Each star In stars
         Console.WriteLine(star)
      Next   
   End Sub
End Module
' The example displays the following output:
'       Sirius     (50,568,000,000,000)
'       Castor     (288,120,000,000,000)
'       Antares    (3,057,600,000,000,000)
'       Rigel      (8,232,000,000,000,000)

注解

CompareTo 方法的此重载实现 IComparable<T>.CompareTo 方法。This overload of the CompareTo method implements the IComparable<T>.CompareTo method. 泛型集合对象使用它对集合中的项进行排序。It is used by generic collection objects to order the items in the collection.

另请参阅

适用于