Double.parseDouble方法是把数字类型的字符串，转换成double类型
Double.valueOf方法是把数字类型的字符串，转换成Double类型
		double a = 0.009;
		String b = "1993";
		
		double parseDouble = Double.parseDouble(b);
		System.out.println(parseDouble);
		Double valueOf = Double.valueOf(a); 
		Double valueOf2 = Double.valueOf(b); //1993.0
		System.out.println(valueOf);//0.009
		System.out.println(valueOf2);//1993.0

结果是：
1993.0
0.009
1993.0

可以看出大体是没有任何区别，就是返回值的类型区别！
Double.parseDouble()方法的源码：
public static double parseDouble(String s) throws NumberFormatException {
        return FloatingDecimal.readJavaFormatString(s).doubleValue();
}

Double.valueOf()方法的源码：
  public static Double valueOf(String s) throws NumberFormatException {
	      return new Double(FloatingDecimal.readJavaFormatString(s).doubleValue());
  }

valueOf方法在返回的时候new Double()，所以返回的是Double。

public final class Double extends Number implements Comparable<Double>, Constable, ConstantDesc {
   
    @java.io.Serial
    private static final long serialVersionUID = -9172774392245257468L; //序列化版本号
    private final double value; // 实际存储double数据的地方
    public static final double POSITIVE_INFINITY = 1.0 / 0.0;   // 正无穷常量
    public static final double NEGATIVE_INFINITY = -1.0 / 0.0;  // 负无穷常量
    public static final double NaN = 0.0d / 0.0;                // NaN 值
    public static final double MAX_VALUE = 0x1.fffffffffffffP+1023; // 最大值： 1.7976931348623157e+308
    public static final double MIN_NORMAL = 0x1.0p-1022; // 最大正常值：2.2250738585072014E-308
    public static final double MIN_VALUE = 0x0.0000000000001P-1022; // 最小值：4.9e-324
    public static final int MAX_EXPONENT = 1023;
    public static final int MIN_EXPONENT = -1022;
    public static final int SIZE = 64;              // 底层double占用的位数
    public static final int BYTES = SIZE / Byte.SIZE;
    public static final Class<Double>   TYPE = (Class<Double>) Class.getPrimitiveClass("double");

    /**
     * 构造方法
     */
    @Deprecated(since="9")
    public Double(double value) {}  // 传入的是一个double
    @Deprecated(since="9")
    public Double(String s) throws NumberFormatException {} // 传入的是一个字符串
    
    public boolean isNaN() {}           // 是否为NaN
    public boolean isInfinite() {}      // 当前值是否为无穷数（正、负都可以）
    public int compareTo(Double anotherDouble) {} // 当前值和anotherDouble比较大小
    public String toString() {}     // double转换为字符串

    /**
     * double转化为其它基本类型的数据
     */
    public byte byteValue() {}      // 得到byte类型
    public short shortValue() {}    // 得到short类型
    public int intValue() {}        // 得到int类型
    public float floatValue() {}    // 得到float类型
    public long longValue() {}      // 得到long类型
    @HotSpotIntrinsicCandidate
    public double doubleValue() {}  // 返回double的值
    @Override
    public int hashCode() {}        // 当前double值得hash值
    public boolean equals(Object obj) {} // 当前double值和obj是否相等


    /**
     * 静态方法是做工具对外提供使用的
     * 功能无非是两double数和、最大值、最小值、比较大小、double值得hash值
     */
    public static int hashCode(double value) {}         // 得到value的hash值
    public static boolean isNaN(double v) {}            // v是否为NaN
    public static boolean isInfinite(double v) {}       // v是否为无穷数
    public static boolean isFinite(double d) {}
    public static double sum(double a, double b) {}     // a、b求和
    public static double max(double a, double b) {}     // a、b最大值
    public static double min(double a, double b) {}     // a、b最小值
    public static int compare(double d1, double d2) {}  // a、b两数比大小
    public static String toString(double d) {}          // d 转字符串
    public static String toHexString(double d) {}       // d 转16进制字符串
    @HotSpotIntrinsicCandidate
    public static Double valueOf(double d) {}           // double转Double
    public static Double valueOf(String s) throws NumberFormatException {}  // 字符串转Double
    public static double parseDouble(String s) throws NumberFormatException {} // 解析字符串转为double
    
    
    @HotSpotIntrinsicCandidate
    public static long doubleToLongBits(double value) {}        // double转换为2进制
    @HotSpotIntrinsicCandidate
    public static native long doubleToRawLongBits(double value);// double转换为2进制的数字   
    @HotSpotIntrinsicCandidate
    public static native double longBitsToDouble(long bits);    // 2进制数转换为double
    
    @Override
    public Optional<Double> describeConstable() {
        return Optional.of(this);				// 将当前double值包装为Optional对象
    }
    @Override
    public Double resolveConstantDesc(MethodHandles.Lookup lookup) {
        return this;
    }
}

我有一个朋友，叫老刘，戴着度数比我还高的近视镜，显得格外的“程序员”；穿着也非常“不拘一格”，上半身是衬衣西服，下半身是牛仔裤运动鞋。
我和老刘的感情非常好，每周末我们都要在一起吃顿饭。这周，我们吃的是洛阳有名的吴家刀削面，席间他聊了一件蛮有趣的面试经历；我听得津津有味。
散席的时候，老刘特意叮嘱我把他和面试者的对话整理一下发出来，因为他觉得这段对话非常的精彩，值得推荐给更多初学Java的年轻人。
注：以下是老刘和面试者东丰的真实对话。如有雷同，请勿对号入座。
老刘：“东丰，你长期从事金融软件的开发，记录存款和金额之类的有关数据用哪种数据类型啊？”
东丰：“当然用float啊，精确度比double高嘛。”
老刘：“东丰，你确定double精度比float低吗？”
东丰：“那当然啊，double只精确到小数点后两位，double这个单词的意思不就是二的意思吗？”
老刘：“东丰，你右手边刚好有一本《Java核心技术卷1》，你翻到第35页，看一下。”
东丰：“…哦，刘经理，不用了。不好意思，刚刚开个玩笑，为了缓和一下面试的紧张气氛。看您厚厚的眼镜片下藏着一双深邃的眼睛，我觉得您一定大有学问。在金融计算中，必须要使用BigDecimal，double和float都不适合。因为单单一个精度问题就能把人整晕了。”
“我记得有一次，我碰巧要计算一个表达式a - b，a的值为2，b的值为1.1，我侄女五岁半都知道答案应该是0.9，结果程序算出来的结果竟然是0.89999…，我当时又气又激动，气的是计算机还没有我侄女靠谱，激动的是我竟然第一次找到了Java的bug。”
“我赶紧把这个bug反馈到了沉默王二的青铜时代群，以为我要被大家点赞表扬了。结果收到了大佬们一致的无情的嘲笑！”
“好在，群主二哥及时地安慰了我。他发我私信说：‘首先，计算机进行的是二进制运算，我们输入的十进制数字会先转换成二进制，进行运算后再转换为十进制输出。double和float提供了快速的运算，然而问题在于转换为二进制的时候，有些数字不能完全转换，只能无限接近于原本的值，这就导致了你看到的不正确的结果。’”
“看到二哥的信息后，我沮丧的心情得到了很大的安慰。我于是就对使用浮点数和小数中的问题进行了深入地研究。”
“BigDecimal可以表示任意精度的小数，并对它们进行计算。但要小心使用 BigDecimal(double) 构造函数，因为它会在计算的过程中产生舍入误差。最好要使用基于整数或 String 的构造函数来创建BigDecimal对象。”
老刘：“哇，你回答得很好。那我们来看下一个问题。你应该知道2 / 0的时候程序会报java.lang.ArithmeticException的错误，那么你知道2.0 / 0的结果吗？”
东丰：“刘经理，您这个问题难不倒我。结果是Infinity（英菲尼迪），不好意思，我的英语口语能力有限啊。其实就是无穷的意思。不仅有正无穷大，还有负无穷大，甚至还有一个叫做NaN的特殊值。NaN代表‘不是一个数字’。这些值的存在是为了在出现错误条件时，程序还可以用特定的值来表示所产生的结果。这些错误的情况包括算术溢出、给负数开平方根，还有您说的除以 0 等。”
老刘：“东丰啊，你的发音比我好啊，挺准确的。”
东丰：“刘经理您见笑了。”
老刘：“我这还有一道关于数组的问题，你稍等一下，我在纸上写一下。”
int[] a = {1, 2, 3, 4}
int[] b = {2, 4}
int[] c = {1, 3}
int[] d = {2}

“有这样四个数组，要求每个数组只留一个唯一的元素。也就是说，a、b、c、d四个数组之间的元素不能相同，你打算怎么做呢？”
东丰：“刘经理，我能用一下您的凌美钢笔吗？”
老刘：“可以啊，你请用。”
东丰：“我大致演算了一下。说一下我的思路。d只能是2，b只能是4，a是1或者3，c是3或者1。遍历长数组，剔除长数组中含有的最短数组的元素。b中剔除d中的2还剩下4，a中剔除d中的2还剩下1、3、4，c中不含d中元素，所以不用剔除。剔除后b中还剩下一个4，d中是一个2。再次遍历剔除a中的4。最后a和c中只剩下1和3了，再分别剔除互异的数就行了。”
“我觉得比较笨的作法，刘经理您觉得可行吗？”
老刘：“可行，没有问题。那，你对变量和方法的命名有什么看法呢？请随意发挥啊。”
东丰：“我在博客园上曾看到一个有意思的投票统计——选出平常工作时自己认为最难的事情，选项大致有：”

写各种文档
与客户沟通
预估工作量
给变量命名

“投票结果完全出乎我的意料，排在第一的竟然是‘给变量命名’！变量命名实在是软件开发中最常见的一件事了，但这件事要想做好，还真是不容易啊。”
“阿里巴巴Java开发手册中「强制」规定，方法名、参数名、成员变量、局部变量要统一使用lowerCamelCase风格，必须遵从驼峰形式。”
localValue // 变量
getHttpMessage() // 方法

“有很长一段时间，我总是在纠结究竟是用拼音好还是用英语单词好的问题。后来我下定了决心：要么用拼音要么用英语单词，只要看到名字就能知道这个变量或者方法的用意就行了。”
“有时候，确实很难给变量取一个好名字。这时候，我就会选择一种省时省力省心的做法——将变量名命名为类型名。比如说：”
Map map;
List list;

“最好，变量声明的地方要离第一次使用的地方近。否则的话，代码阅读起来会很困难，因为人眼睛接受的屏幕高度是有限的。”
老刘：“东丰啊，你非常的优秀。恭喜你，你的面试过了。你回去准备一下，下周一就可以来上班了。”
再注：以上是老刘和面试者东丰的真实对话。如有雷同，请勿对号入座。

上一篇：对《Java核心技术卷一》读者的一些建议
下一篇：请用面向对象的思想，谈一谈这次面试的过程
谢谢大家的阅读，原创不易，喜欢就随手点个赞👍，这将是我最强的写作动力。如果觉得文章对你有点帮助，还挺有趣，就关注一下我的公众号「沉默王二」。

double是基本数据类型，Double是原始数据类型
double没有方法，Double有自己的属性和方法
double只创建引用，Double创建对象
集合类不能存放double，只能存放Double
double存放在栈中，Double存放在堆中
栈的存取速度要高于堆，另外栈中的数据可以共享
如：
double a = 0;
double b = 0;
不会创建对象，只会建立两个引用，同时指向变量“0”（栈数据共享）
而
Double a = new Double(0);
Double b = new Double(0);
会创建两个对象，即使对象所代表的值一样（堆数据不共享）
所以从效率来讲用double合适，而Double提供的属性和方法会使操作各种操作更加方便和灵活