Int32 结构

定义

表示 32 位带符号整数。Represents a 32-bit signed integer.

public value class Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable
type int = struct
    interface IFormattable
    interface IConvertible
Public Structure Int32
Implements IComparable, IComparable(Of Integer), IConvertible, IEquatable(Of Integer), IFormattable
继承
属性
实现

注解

Int32是一个不可变的值类型,它表示值范围从负2147483648(由Int32.MinValue常数表示)到正2147483647( Int32.MaxValue由常数表示)的有符号整数。Int32 is an immutable value type that represents signed integers with values that range from negative 2,147,483,648 (which is represented by the Int32.MinValue constant) through positive 2,147,483,647 (which is represented by the Int32.MaxValue constant. .NET Framework 还包括一个未签名的32位整数值类型, UInt32该类型表示范围为0到4294967295的值。The .NET Framework also includes an unsigned 32-bit integer value type, UInt32, which represents values that range from 0 to 4,294,967,295.

实例化 Int32 值Instantiating an Int32 Value

可以通过多种方式Int32实例化值:You can instantiate an Int32 value in several ways:

  • 您可以声明一个Int32变量,并为其分配一个Int32数据类型范围内的文本整数值。You can declare an Int32 variable and assign it a literal integer value that is within the range of the Int32 data type. 下面的示例声明了Int32两个变量,并以这种方式为它们赋值。The following example declares two Int32 variables and assigns them values in this way.

    int number1 = 64301;
    int number2 = 25548612;
    
    Dim number1 As Integer = 64301
    Dim number2 As Integer = 25548612
    
  • 可以分配一个整数类型的值,该类型的范围是Int32类型的子集。You can assign the value of an integer type whose range is a subset of the Int32 type. 这是一种扩大转换,不需要在中C#使用强制转换运算符,也不需要 Visual Basic 中的转换方法。This is a widening conversion that does not require a cast operator in C# or a conversion method in Visual Basic.

    sbyte value1 = 124;
    short value2 = 1618;
    
    int number1 = value1;
    int number2 = value2;
    
    Dim value1 As SByte = 124
    Dim value2 As Int16 = 1618
    
    Dim number1 As Integer = value1
    Dim number2 As Integer = value2
    
  • 可以指定数值类型的值,该数值类型的范围超出Int32了该类型的范围。You can assign the value of a numeric type whose range exceeds that of the Int32 type. 这是一个收缩转换,因此在中C#需要强制转换运算符,并在 Visual Basic Option Strict中使用转换方法。This is a narrowing conversion, so it requires a cast operator in C# and a conversion method in Visual Basic if Option Strict is on. 如果数值是Single包含小数部分的Double、或Decimal值,则其小数部分的处理取决于执行转换的编译器。If the numeric value is a Single, Double, or Decimal value that includes a fractional component, the handling of its fractional part depends on the compiler performing the conversion. 下面的示例执行收缩转换,以将多个数值Int32赋给变量。The following example performs narrowing conversions to assign several numeric values to Int32 variables.

    long lNumber = 163245617;
    try {
       int number1 = (int) lNumber;
       Console.WriteLine(number1);
    }
    catch (OverflowException) {
       Console.WriteLine("{0} is out of range of an Int32.", lNumber);
    }
    
    double dbl2 = 35901.997;
    try {
       int number2 = (int) dbl2;
       Console.WriteLine(number2);
    }   
    catch (OverflowException) {
       Console.WriteLine("{0} is out of range of an Int32.", dbl2);
    }
       
    BigInteger bigNumber = 132451;
    try {
       int number3 = (int) bigNumber;
       Console.WriteLine(number3);
    }
    catch (OverflowException) {
       Console.WriteLine("{0} is out of range of an Int32.", bigNumber);
    }    
    // The example displays the following output:
    //       163245617
    //       35902
    //       132451
    
    Dim lNumber As Long = 163245617
    Try
       Dim number1 As Integer = CInt(lNumber)
       Console.WriteLine(number1)
    Catch e As OverflowException
       Console.WriteLine("{0} is out of range of an Int32.", lNumber)
    End Try
    
    Dim dbl2 As Double = 35901.997
    Try
       Dim number2 As Integer = CInt(dbl2)
       Console.WriteLine(number2)
    Catch e As OverflowException
       Console.WriteLine("{0} is out of range of an Int32.", dbl2)
    End Try
       
    Dim bigNumber As BigInteger = 132451
    Try
       Dim number3 As Integer = CInt(bigNumber)
       Console.WriteLine(number3)
    Catch e As OverflowException
       Console.WriteLine("{0} is out of range of an Int32.", bigNumber)
    End Try    
    ' The example displays the following output:
    '       163245617
    '       35902
    '       132451
    
  • 可以调用Convert类的方法将任何支持的Int32类型转换为值。You can call a method of the Convert class to convert any supported type to an Int32 value. 这是可能的Int32 IConvertible ,因为支持接口。This is possible because Int32 supports the IConvertible interface. 下面的示例演示如何将Decimal值数组转换为Int32值。The following example illustrates the conversion of an array of Decimal values to Int32 values.

    decimal[] values= { Decimal.MinValue, -1034.23m, -12m, 0m, 147m,
                        199.55m, 9214.16m, Decimal.MaxValue };
    int result;
    
    foreach (decimal value in values)
    {
       try {
          result = Convert.ToInt32(value);
          Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                            value.GetType().Name, value,
                            result.GetType().Name, result);
       }
       catch (OverflowException) {
          Console.WriteLine("{0} is outside the range of the Int32 type.",
                            value);
       }   
    }                                  
    // The example displays the following output:
    //    -79228162514264337593543950335 is outside the range of the Int32 type.
    //    Converted the Decimal value '-1034.23' to the Int32 value -1034.
    //    Converted the Decimal value '-12' to the Int32 value -12.
    //    Converted the Decimal value '0' to the Int32 value 0.
    //    Converted the Decimal value '147' to the Int32 value 147.
    //    Converted the Decimal value '199.55' to the Int32 value 200.
    //    Converted the Decimal value '9214.16' to the Int32 value 9214.
    //    79228162514264337593543950335 is outside the range of the Int32 type.
    
    Dim values() As Decimal = { Decimal.MinValue, -1034.23d, -12d, 0d, 147d, _
                                199.55d, 9214.16d, Decimal.MaxValue }
    Dim result As Integer
    
    For Each value As Decimal In values
       Try
          result = Convert.ToInt32(value)
          Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.", _
                            value.GetType().Name, value, _
                            result.GetType().Name, result)
       Catch e As OverflowException
          Console.WriteLine("{0} is outside the range of the Int32 type.", _
                            value)
       End Try   
    Next                                  
    ' The example displays the following output:
    '    -79228162514264337593543950335 is outside the range of the Int32 type.
    '    Converted the Decimal value '-1034.23' to the Int32 value -1034.
    '    Converted the Decimal value '-12' to the Int32 value -12.
    '    Converted the Decimal value '0' to the Int32 value 0.
    '    Converted the Decimal value '147' to the Int32 value 147.
    '    Converted the Decimal value '199.55' to the Int32 value 200.
    '    Converted the Decimal value '9214.16' to the Int32 value 9214.
    '    79228162514264337593543950335 is outside the range of the Int32 type.
    
  • 可以调用ParseTryParse方法将Int32值的字符串表示形式转换为Int32You can call the Parse or TryParse method to convert the string representation of an Int32 value to an Int32. 字符串可以包含 decimal 或十六进制数字。The string can contain either decimal or hexadecimal digits. 下面的示例通过使用 decimal 和十六进制字符串说明了分析操作。The following example illustrates the parse operation by using both a decimal and a hexadecimal string.

    string string1 = "244681";
    try {
       int number1 = Int32.Parse(string1);
       Console.WriteLine(number1);
    }
    catch (OverflowException) {
       Console.WriteLine("'{0}' is out of range of a 32-bit integer.", string1);
    }
    catch (FormatException) {
       Console.WriteLine("The format of '{0}' is invalid.", string1);
    }
    
    string string2 = "F9A3C";
    try {
       int number2 = Int32.Parse(string2,
                                System.Globalization.NumberStyles.HexNumber);
       Console.WriteLine(number2);
    }
    catch (OverflowException) {
       Console.WriteLine("'{0}' is out of range of a 32-bit integer.", string2);
    }
    catch (FormatException) {
       Console.WriteLine("The format of '{0}' is invalid.", string2);
    }
    // The example displays the following output:
    //       244681
    //       1022524
    
    Dim string1 As String = "244681"
    Try
       Dim number1 As Integer = Int32.Parse(string1)
       Console.WriteLine(number1)
    Catch e As OverflowException
       Console.WriteLine("'{0}' is out of range of a 32-bit integer.", string1)
    Catch e As FormatException
       Console.WriteLine("The format of '{0}' is invalid.", string1)
    End Try
    
    Dim string2 As String = "F9A3C"
    Try
       Dim number2 As Integer = Int32.Parse(string2,
                                System.Globalization.NumberStyles.HexNumber)
       Console.WriteLine(number2)
    Catch e As OverflowException
       Console.WriteLine("'{0}' is out of range of a 32-bit integer.", string2)
    Catch e As FormatException
       Console.WriteLine("The format of '{0}' is invalid.", string2)
    End Try
    ' The example displays the following output:
    '       244681
    '       1022524
    

对 Int32 值执行运算Performing Operations on Int32 Values

Int32类型支持标准数学运算,如加法、减法、除法、乘法、求反和一元求反。The Int32 type supports standard mathematical operations such as addition, subtraction, division, multiplication, negation, and unary negation. 与其他整型类型类似,该Int32类型还支持按位ANDORXOR、左移和右移运算符。Like the other integral types, the Int32 type also supports the bitwise AND, OR, XOR, left shift, and right shift operators.

可以使用标准数字运算符比较两个Int32值,也可以CompareTo调用或Equals方法。You can use the standard numeric operators to compare two Int32 values, or you can call the CompareTo or Equals method.

您还可以调用Math类的成员来执行各种数值运算,包括获取数字的绝对值、计算除整数相除所得的商和余数、确定两个的最大值或最小值整数,获取数字的符号并舍入数字。You can also call the members of the Math class to perform a wide range of numeric operations, including getting the absolute value of a number, calculating the quotient and remainder from integral division, determining the maximum or minimum value of two integers, getting the sign of a number, and rounding a number.

将 Int32 表示为字符串Representing an Int32 as a String

Int32类型为标准和自定义数字格式字符串提供完全支持。The Int32 type provides full support for standard and custom numeric format strings. (有关详细信息,请参阅格式设置类型标准数字格式字符串自定义数字格式字符串。)(For more information, see Formatting Types, Standard Numeric Format Strings, and Custom Numeric Format Strings.)

若要将Int32值设置为不带前导零的整数字符串,可以调用无参数ToString()方法。To format an Int32 value as an integral string with no leading zeros, you can call the parameterless ToString() method. 通过使用 "D" 格式说明符,还可以在字符串表示形式中包含指定数目的前导零。By using the "D" format specifier, you can also include a specified number of leading zeros in the string representation. 通过使用 "N" 格式说明符,你可以包含组分隔符,并指定要在数字的字符串表示形式中显示的小数位数。By using the "N" format specifier, you can include group separators and specify the number of decimal digits to appear in the string representation of the number. 通过使用 "X" 格式说明符,可将Int32值表示为十六进制字符串。By using the "X" format specifier, you can represent an Int32 value as a hexadecimal string. 下面的示例采用这四种方式设置Int32值数组中的元素的格式。The following example formats the elements in an array of Int32 values in these four ways.

int[] numbers = { -1403, 0, 169, 1483104 };
foreach (int number in numbers) {
   // Display value using default formatting.
   Console.Write("{0,-8}  -->   ", number.ToString());
   // Display value with 3 digits and leading zeros.
   Console.Write("{0,11:D3}", number);
   // Display value with 1 decimal digit.
   Console.Write("{0,13:N1}", number);
   // Display value as hexadecimal.
   Console.Write("{0,12:X2}", number);
   // Display value with eight hexadecimal digits.
   Console.WriteLine("{0,14:X8}", number);
}   
// The example displays the following output:
//    -1403     -->         -1403     -1,403.0    FFFFFA85      FFFFFA85
//    0         -->           000          0.0          00      00000000
//    169       -->           169        169.0          A9      000000A9
//    1483104   -->       1483104  1,483,104.0      16A160      0016A160
Dim numbers() As Integer = { -1403, 0, 169, 1483104 }
For Each number As Integer In numbers
   ' Display value using default formatting.
   Console.Write("{0,-8}  -->   ", number.ToString())
   ' Display value with 3 digits and leading zeros.
   Console.Write("{0,11:D3}", number) 
   ' Display value with 1 decimal digit.
   Console.Write("{0,13:N1}", number) 
   ' Display value as hexadecimal.
   Console.Write("{0,12:X2}", number) 
   ' Display value with eight hexadecimal digits.
   Console.WriteLine("{0,14:X8}", number)
Next   
' The example displays the following output:
'    -1403     -->         -1403     -1,403.0    FFFFFA85      FFFFFA85
'    0         -->           000          0.0          00      00000000
'    169       -->           169        169.0          A9      000000A9
'    1483104   -->       1483104  1,483,104.0      16A160      0016A160

还可以通过ToString(Int32, Int32)调用方法Int32并提供作为方法的第二个参数的基数,将值的格式设置为二进制、八进制、十进制或十六进制字符串。You can also format an Int32 value as a binary, octal, decimal, or hexadecimal string by calling the ToString(Int32, Int32) method and supplying the base as the method's second parameter. 下面的示例调用此方法以显示整数值数组的二进制、八进制和十六进制表示形式。The following example calls this method to display the binary, octal, and hexadecimal representations of an array of integer values.

int[] numbers = { -146, 11043, 2781913 };
Console.WriteLine("{0,8}   {1,32}   {2,11}   {3,10}", 
                  "Value", "Binary", "Octal", "Hex");
foreach (int number in numbers) {
   Console.WriteLine("{0,8}   {1,32}   {2,11}   {3,10}", 
                     number, Convert.ToString(number, 2), 
                     Convert.ToString(number, 8), 
                     Convert.ToString(number, 16));
}      
// The example displays the following output:
//       Value                             Binary         Octal          Hex
//        -146   11111111111111111111111101101110   37777777556     ffffff6e
//       11043                     10101100100011         25443         2b23
//     2781913             1010100111001011011001      12471331       2a72d9
Dim numbers() As Integer = { -146, 11043, 2781913 }
Console.WriteLine("{0,8}   {1,32}   {2,11}   {3,10}", _
                  "Value", "Binary", "Octal", "Hex")
For Each number As Integer In numbers
   Console.WriteLine("{0,8}   {1,32}   {2,11}   {3,10}", _
                     number, Convert.ToString(number, 2), _
                     Convert.ToString(number, 8), _
                     Convert.ToString(number, 16))
Next      
' The example displays the following output:
'       Value                             Binary         Octal          Hex
'        -146   11111111111111111111111101101110   37777777556     ffffff6e
'       11043                     10101100100011         25443         2b23
'     2781913             1010100111001011011001      12471331       2a72d9

使用非十进制32位整数值Working with Non-Decimal 32-Bit Integer Values

除了使用单个整数作为十进制值,还可以使用整数值执行位运算,或使用整数值的二进制或十六进制表示形式。In addition to working with individual integers as decimal values, you may want to perform bitwise operations with integer values, or work with the binary or hexadecimal representations of integer values. Int32值用31位表示,使用三十秒位作为符号位。Int32 values are represented in 31 bits, with the thirty-second bit used as a sign bit. 正值是使用符号和量表示法表示的。Positive values are represented by using sign-and-magnitude representation. 负值的表示形式分为两种。Negative values are in two's complement representation. 当你对Int32值执行按位运算或使用单个位时,这一点很重要。This is important to keep in mind when you perform bitwise operations on Int32 values or when you work with individual bits. 若要对任意两个非十进制值执行数字、布尔或比较运算,这两个值必须使用相同的表示形式。In order to perform a numeric, Boolean, or comparison operation on any two non-decimal values, both values must use the same representation.

字段

MaxValue

表示 Int32 的最大可能值。Represents the largest possible value of an Int32. 此字段为常数。This field is constant.

MinValue

表示 Int32 的最小可能值。Represents the smallest possible value of Int32. 此字段为常数。This field is constant.

方法

CompareTo(Int32)

将此实例与指定的 32 位有符号整数进行比较并返回对其相对值的指示。Compares this instance to a specified 32-bit signed integer and returns an indication of their relative values.

CompareTo(Object)

将此实例与指定对象进行比较并返回一个对二者的相对值的指示。Compares this instance to a specified object and returns an indication of their relative values.

Equals(Int32)

返回一个值,该值指示此实例是否等于指定的 Int32 值。Returns a value indicating whether this instance is equal to a specified Int32 value.

Equals(Object)

返回一个值,该值指示此实例是否等于指定的对象。Returns a value indicating whether this instance is equal to a specified object.

GetHashCode()

返回此实例的哈希代码。Returns the hash code for this instance.

GetTypeCode()

返回值类型 TypeCodeInt32Returns the TypeCode for value type Int32.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
Parse(String)

将数字的字符串表示形式转换为它的等效 32 位有符号整数。Converts the string representation of a number to its 32-bit signed integer equivalent.

Parse(String, IFormatProvider)

将指定的区域性特定格式的数字的字符串表示形式转换为它的等效 32 位有符号整数。Converts the string representation of a number in a specified culture-specific format to its 32-bit signed integer equivalent.

Parse(String, NumberStyles)

将指定样式的数字的字符串表示形式转换为它的等效 32 位有符号整数。Converts the string representation of a number in a specified style to its 32-bit signed integer equivalent.

Parse(String, NumberStyles, IFormatProvider)

将指定样式和区域性特定格式的数字的字符串表示形式转换为它的等效 32 位有符号整数。Converts the string representation of a number in a specified style and culture-specific format to its 32-bit signed integer equivalent.

ToString()

将此实例的数值转换为其等效的字符串表示形式。Converts the numeric value of this instance to its equivalent string representation.

ToString(IFormatProvider)

使用指定的区域性特定格式信息,将此实例的数值转换为它的等效字符串表示形式。Converts the numeric value of this instance to its equivalent string representation using the specified culture-specific format information.

ToString(String)

使用指定的格式,将此实例的数值转换为它的等效字符串表示形式。Converts the numeric value of this instance to its equivalent string representation, using the specified format.

ToString(String, IFormatProvider)

使用指定的格式和区域性特定格式信息,将此实例的数值转换为它的等效字符串表示形式。Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
TryParse(ReadOnlySpan<Char>, Int32)
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int32)
TryParse(String, Int32)

将数字的字符串表示形式转换为它的等效 32 位有符号整数。Converts the string representation of a number to its 32-bit signed integer equivalent. 一个指示转换是否成功的返回值。A return value indicates whether the conversion succeeded.

TryParse(String, NumberStyles, IFormatProvider, Int32)

将指定样式和区域性特定格式的数字的字符串表示形式转换为它的等效 32 位有符号整数。Converts the string representation of a number in a specified style and culture-specific format to its 32-bit signed integer equivalent. 一个指示转换是否成功的返回值。A return value indicates whether the conversion succeeded.

显式界面实现

IComparable.CompareTo(Object)
IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider)

有关此成员的说明,请参见 ToBoolean(IFormatProvider)For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

有关此成员的说明,请参见 ToByte(IFormatProvider)For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

有关此成员的说明,请参见 ToChar(IFormatProvider)For a description of this member, see ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider)

不支持此转换。This conversion is not supported. 尝试使用此方法将引发 InvalidCastExceptionAttempting to use this method throws an InvalidCastException.

IConvertible.ToDecimal(IFormatProvider)

有关此成员的说明,请参见 ToDecimal(IFormatProvider)For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

有关此成员的说明,请参见 ToDouble(IFormatProvider)For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

有关此成员的说明,请参见 ToInt16(IFormatProvider)For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

有关此成员的说明,请参见 ToInt32(IFormatProvider)For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

有关此成员的说明,请参见 ToInt64(IFormatProvider)For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

有关此成员的说明,请参见 ToSByte(IFormatProvider)For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

有关此成员的说明,请参见 ToSingle(IFormatProvider)For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToType(Type, IFormatProvider)

有关此成员的说明,请参见 ToType(Type, IFormatProvider)For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

有关此成员的说明,请参见 ToUInt16(IFormatProvider)For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

有关此成员的说明,请参见 ToUInt32(IFormatProvider)For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

有关此成员的说明,请参见 ToUInt64(IFormatProvider)For a description of this member, see ToUInt64(IFormatProvider).

适用于

线程安全性

此类型的所有成员都是线程安全的。All members of this type are thread safe. 看似修改实例状态的成员实际上返回用新值初始化的新实例。Members that appear to modify instance state actually return a new instance initialized with the new value. 与任何其他类型一样,读取和写入包含此类型的实例的共享变量时,必须通过锁保护以保证线程安全。As with any other type, reading and writing to a shared variable that contains an instance of this type must be protected by a lock to guarantee thread safety.

另请参阅