在本文中，您将会了解到关于不建议使用构造函数Integer的新资讯，同时我们还将为您解释int，Double的相关在本文中，我们将带你探索不建议使用构造函数Integer的奥秘，分析int，Doubl

在本文中，您将会了解到关于不建议使用构造函数Integer的新资讯，同时我们还将为您解释int，Double的相关在本文中，我们将带你探索不建议使用构造函数Integer的奥秘，分析int，Double的特点，并给出一些关于Android Log.v（），Log.d（），Log.i（），Log.w（），Log.e（） - 何时使用每一个？、assertEquals（Double，Double）和assertEquals（double，double，delta）之间的Junit差异、c – long double vs long int、C# int uint long ulong byte sbyte float double decimal 范围，及类型！的实用技巧。

• 不建议使用构造函数Integer（int），Double（double），Long（long）等（构造函数不能调用哪些函数）
• Android Log.v（），Log.d（），Log.i（），Log.w（），Log.e（） - 何时使用每一个？
• assertEquals（Double，Double）和assertEquals（double，double，delta）之间的Junit差异
• c – long double vs long int
• C# int uint long ulong byte sbyte float double decimal 范围，及类型！

不建议使用构造函数Integer（int），Double（double），Long（long）等（构造函数不能调用哪些函数）

在工作时，我得到了警告

The constructor Integer(int) is deprecated

而且我找不到在线替代构造函数/解决方案。我该如何解决这个问题？

更新

对于其他原始包装器类型的构造函数，我将收到类似的警告；例如

The constructor Boolean(boolean) is deprecatedThe constructor Byte(byte) is deprecatedThe constructor Short(short) is deprecatedThe constructor Character(char) is deprecatedThe constructor Long(long) is deprecatedThe constructor Float(float) is deprecatedThe constructor Double(double) is deprecated

是否对这些类适用相同的解决方案Integer？

答案1

您可以使用

Integer integer = Integer.valueOf(i);

从构造函数的javadoc中：

不推荐使用。很少适合使用此构造函数。通常，静态工厂valueOf（int）是更好的选择，因为它可能会产生明显更好的空间和时间性能。构造一个新分配的Integer对象，该对象表示指定的int值。

主要区别在于，valueOf由于Integer缓存了小型实例，因此您将不会总是获得新实例。

所有原始包装类型的（Boolean，Byte，Char，Short，Integer，Long，Float和Double）都采用了相同的模式。通常，替换为：

    new <WrapperType>(<primitiveType>)

与

    <WrapperType>.valueOf(<primitiveType>)

（请注意，上面提到的缓存行为随类型和Java平台而有所不同，但是尽管存在这些差异，Java 9+弃用仍然适用。）

Android Log.v（），Log.d（），Log.i（），Log.w（），Log.e（） - 何时使用每一个？

不同的LogCat方法是：

Log.v(); // Verbose
Log.d(); // Debug
Log.i(); // Info
Log.w(); // Warning
Log.e(); // Error

使用每种类型的日志记录的适当情况是什么？ 我知道也许这只是一些语义，也许它并不重要，但对于Android Studio和Eclipse中的LogCat过滤，我很高兴知道我在适当的时候使用了正确的方法。

#1楼

源代码提供了一些基本指导：

详细程度的顺序，从最小到最多，是ERROR，WARN，INFO，DEBUG，VERBOSE。 除了在开发期间，不应该将详细编译到应用程序中。 调试日志在运行时编译但被剥离。 始终保留错误，警告和信息日志。

更多细节，Kurtis的答案已经过去了。 我想补充一点：不要在INFO或以上（ WARN / ERROR ）记录任何个人身份信息或私人信息。 否则，错误报告或包含日志记录的任何其他内容可能会受到污染。

#2楼

Android Studio网站最近（我认为）提供了一些建议，从Kurtis的回答中可能有用的不同日志级别期望什么样的消息：

• 详细 - 显示所有日志消息（默认）。
• 调试 - 显示仅在开发期间有用的调试日志消息，以及此列表中较低的消息级别。
• 信息 - 显示常规使用的预期日志消息，以及此列表中较低的消息级别。
• 警告 - 显示尚未出现错误的可能问题，以及此列表中较低的消息级别。
• 错误 - 显示导致错误的问题，以及此列表中较低的消息级别。
• 断言 - 显示开发人员期望永远不会发生的问题。

#3楼

你可以使用LOG如：

Log.e(String, String) (error)
Log.w(String, String) (warning)
Log.i(String, String) (information)
Log.d(String, String) (debug)
Log.v(String, String) (verbose)

示例代码：

private static final String TAG = "MyActivity";
...
Log.i(TAG, "MyClass.getView() — get item number " + position);

#4楼

虽然这个问题已经回答了，但我觉得答案中有缺少的例子。

因此，我将把我在博客文章“Android Log Levels”中写的内容带到这里

详细

是最低级别的日志记录。 如果你想坚持记录，那么你就可以使用这个级别了。 我从来不知道何时使用Verbose以及何时使用Debug。 差别对我来说非常武断。 一旦我指出Android¹的源代码，我终于理解了“除了在开发过程中，不应该将Verbose编译成应用程序。”现在我很清楚，无论何时开发并想要添加可删除的日志来帮助你开发有用的是详细级别，这有助于您在投入生产之前删除所有这些日志。

调试

用于调试目的。 这是生产中应该达到的最低水平。 这里的信息是在开发过程中提供帮助。 大多数情况下，您将禁用此生产日志，以便发送较少的信息，并且只有在出现问题时才启用此日志。 我喜欢登录调试应用程序从服务器发送/接收的所有信息（注意不要记录密码!!!）。 这对于了解错误是在服务器还是应用程序中非常有帮助。 我还会记录进入和退出重要功能的日志。

信息

有关突出显示应用程序进度的信息性消息。 例如，当应用程序的初始化完成时。 当用户在活动和片段之间移动时添加信息。 记录每个API调用，但只记录URL，状态和响应时间等信息。

警告

当存在潜在的有害情况时。

这个日志在我的经历中是一个棘手的水平。 你什么时候有潜在的有害情况？ 一般情况下或它是好的或它是一个错误。 我个人不太喜欢这个级别。 我使用它的例子通常是多次发生的事情。 例如，用户的密码错误超过3次。 这可能是因为他错误地输入了3次密码，也可能是因为我们的系统中没有接受某个字符存在问题。 网络连接问题也是如此。

错误

错误事件。 错误后应用程序仍可继续运行。 这可能是例如当我得到一个空指针，我不应该得到一个。 解析服务器的响应时出错。 从服务器收到错误。

WTF（多么可怕的失败）

致命是导致应用程序退出的严重错误事件。 在Android中，致命的是实际上的错误级别，不同之处在于它还添加了fullstack。

#5楼

我们按相反顺序进行：

• Log.e ：这是为了发生坏事。 在catch语句中使用此标记。 您知道发生了错误 ，因此您正在记录错误。

• Log.w ：当你怀疑阴影正在发生时使用它。 您可能无法在错误模式下完全完整，但也许您从某些意外行为中恢复过来。 基本上，使用它来记录您不希望发生的事情，但不一定是错误。 有点像“嘿，这发生了，而且很奇怪 ，我们应该调查它。”

• Log.i ：使用此命令将有用信息发布到日志中。 例如：您已成功连接到服务器。 基本上用它来报告成功。

• Log.d ：用于调试目的。 如果要打印出大量消息，以便记录程序的确切流程，请使用此方法。 如果要保留变量值的日志，请使用此选项。

• Log.v ：当您想要完全记录日志时使用此选项。 如果由于某种原因您决定在应用程序的特定部分记录每个小东西，请使用Log.v标记。

作为奖励......

• Log.wtf ：当东西绝对可怕时，使用这个，可怕的，神圣的错误。 你知道那些捕获块，你捕获的错误，你永远不会得到...是的，如果你想记录它们使用Log.wtf

assertEquals（Double，Double）和assertEquals（double，double，delta）之间的Junit差异

我进行了一个junit测试，使用以下命令声明了两个Double对象：

Assert.assertEquals(Double expected, Double result);

很好，然后我决定将其更改为使用原始double，除非您也提供了增量，否则该结果被弃用了。

所以我想知道在assertEquals中使用Double对象还是原始类型有什么区别？为什么不使用不带增量的对象，但不推荐使用不带增量的基元呢？Java是否在后台执行了已经考虑了默认增量值的操作？

谢谢。

答案1

没有断言方法的JUnit与签名

assertEquals(Double expected, Double result);

但是，有一个通用的对象：

assertEquals(Object expected, Object result);

这将调用对象的equals方法，并且您可以预期，不建议使用此方法来比较Double对象。

如您所见，对于双精度数，绝对有必要使用增量进行比较，以避免浮点舍入的问题（在其他一些答案中已有说明）。如果您使用assertEquals带有double参数的3参数版本

assertEquals(double expected, double actual, double delta);

您的Doubles会被自动取消装箱，double并且一切都会正常运行（并且测试不会意外失败:-）。

c – long double vs long int

#include <iostream>long int choose(unsigned n,unsigned k);long int factorial(unsigned n);int main(){    using namespace std;    long int regularProb,megaProb;    regularProb = choose(47,5);    megaProb = choose(27,1);    cout << "The probability of the correct number is 1 out of " << (regularProb * megaProb) << endl;    return 0;}long int choose(unsigned n,unsigned k){        return factorial(n) / (factorial(k) * factorial(n-k));}long int factorial(unsigned n){    long int result = 1;    for (int i=2;i<=n;i++) result *= i;    return result;}

47!  == 2.58623242e+592^64 == 1.84467441e+19

47 * 46 * 45 * 44 * 43  C  = ----------------------47 5    5 *  4 *  3 *  2 *  1

47! = (0b10100100110011011110001010000100011110111001100100100 << 145) ± (1 << 144)42! = (0b11110000010101100000011101010010010001101100101001000 << 117) ± (1 << 116)

0b101110110011111110011 = 1533939                       53 bits                                                              vmax = 0b101110110011111110011.000000000000000000000000000000001001111...val = 0b101110110011111110010.111111111111111111111111111111111010100...min = 0b101110110011111110010.111111111111111111111111111111101011010...

C# int uint long ulong byte sbyte float double decimal 范围，及类型！

static void Main(string[] args)
        {
            Console.WriteLine("   byte  {0,7:g}{1,32:g}{2,32:g}",typeof(byte).Name, byte.MinValue, byte.MaxValue);
            Console.WriteLine("  sbyte  {0,7:g}{1,32:g}{2,32:g}",typeof(sbyte).Name, sbyte.MinValue, sbyte.MaxValue);
            Console.WriteLine("  short  {0,7:g}{1,32:g}{2,32:g}", typeof(short).Name, short.MinValue, short.MaxValue);
            Console.WriteLine(" ushort  {0,7:g}{1,32:g}{2,32:g}", typeof(ushort).Name, ushort.MinValue, ushort.MaxValue);
            Console.WriteLine("    int  {0,7:g}{1,32:g}{2,32:g}",typeof(int).Name, int.MinValue, int.MaxValue);
            Console.WriteLine("   uint  {0,7:g}{1,32:g}{2,32:g}",typeof(uint).Name, uint.MinValue, uint.MaxValue);
            Console.WriteLine("   long  {0,7:g}{1,32:g}{2,32:g}",typeof(long).Name, long.MinValue, long.MaxValue);
            Console.WriteLine("  ulong  {0,7:g}{1,32:g}{2,32:g}",typeof(ulong).Name, ulong.MinValue, ulong.MaxValue);
            Console.WriteLine("  float  {0,7:g}{1,32:g}{2,32:g}", typeof(float).Name, float.MinValue, float.MaxValue);
            Console.WriteLine(" double  {0,7:g}{1,32:g}{2,32:g}", typeof(double).Name, double.MinValue, double.MaxValue);
            Console.WriteLine("decimal  {0,7:g}{1,32:g}{2,32:g}",typeof(decimal).Name, decimal.MinValue, decimal.MaxValue);
}

输出：

byte     Byte                               0                             255
  sbyte    SByte                            -128                             127
  short    Int16                          -32768                           32767
 ushort   UInt16                               0                           65535
    int    Int32                     -2147483648                      2147483647
   uint   UInt32                               0                      4294967295
   long    Int64            -9223372036854775808             9223372036854775807
  ulong   UInt64                               0            18446744073709551615
  float   Single                   -3.402823e+38                    3.402823e+38
 double   Double          -1.79769313486232e+308           1.79769313486232e+308
decimal  Decimal  -79228162514264337593543950335   79228162514264337593543950335

 整数型类型

可以看出，关键字与其类型命名显得有点乱！

double a = 12.3;
System.Double b = 12.3;