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;
    }
}

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提供的属性和方法会使操作各种操作更加方便和灵活

1、Double是java定义的类，而double是预定义数据类型（8种中的一种）
2、Double就好比是对double类型的封装，内置很多方法可以实现String到double的转换，以及获取各种double类型的属性值（MAX_VALUE、SIZE等等）
基于上述两点，如果你在普通的定义一个浮点类型的数据，两者都可以，但是Double是类所以其对象是可以为NULL的，而double定义的不能为NULL，如果你要将一些数字字符串，那么就应该使用Double类型了，其内部帮你实现了强转。