Using a Evaluating integrals over the positive real axis:

S = IntegrateChangeVariables[Inactive[Integrate][Abs[Sin[x^4]]/(Sqrt[x] + x^2), {x, 0, Infinity}], t, t == x^4];

int = LaplaceTransform[Numerator[S[[1]]], t, x]*InverseLaplaceTransform[1/Denominator[S[[1]]], t, x]

(* (x^(1/4) Coth[(\[Pi] x)/2] MittagLefflerE[3/8, 5/4, -x^(3/8)])/(4 (1 + x^2)) *)

NIntegrate[int, {x, 0, Infinity}, Method -> "GlobalAdaptive", WorkingPrecision -> 50, PrecisionGoal -> 25, MaxRecursion -> 25]

(* 0.61822293775804867431044812335205529689707962742130 *)

Regards M.I.

Using the method "DoubleExponentialOscillatory" works, at least to a point, but it is slow:

AbsoluteTiming@
 NIntegrate[Abs[Sin[x^4]]/(Sqrt[x] + x^2), {x, 0, \[Infinity]}, 
  Method -> {"DoubleExponentialOscillatory", 
    Method -> {"GlobalAdaptive", "MaxErrorIncreases" -> 10^6}, 
    "SymbolicProcessing" -> 0}, PrecisionGoal -> 4, 
  MaxRecursion -> 40]

NIntegrate::slwcon: Numerical integration converging too slowly; suspect one of the following: singularity, value of the integration is 0, highly oscillatory integrand, or WorkingPrecision too small.

NIntegrate::eincr: The global error of the strategy GlobalAdaptive has increased more than 1000000 times. The global error is expected to decrease monotonically after a number of integrand evaluations. Suspect one of the following: the working precision is insufficient for the specified precision goal; the integrand is highly oscillatory or it is not a (piecewise) smooth function; or the true value of the integral is 0. Increasing the value of the GlobalAdaptive option MaxErrorIncreases might lead to a convergent numerical integration. NIntegrate obtained 0.6184623212443172` and 0.0007604000503125842` for the integral and error estimates.

{117.819, 0.618462}

In[1]:= AbsoluteTiming@
 NIntegrate[Abs[Sin[x^4]]/(Sqrt[x] + x^2), {x, 0, \[Infinity]}, 
  Method -> {"DoubleExponentialOscillatory", 
    Method -> {"GlobalAdaptive", "MaxErrorIncreases" -> 10^6}, 
    "SymbolicProcessing" -> 0}, PrecisionGoal -> 4, 
  MaxRecursion -> 40, WorkingPrecision -> 30]

DynamicNIntegrate::slwcon: Numerical integration converging too slowly; suspect one of the following: singularity, value of the integration is 0, highly oscillatory integrand, or WorkingPrecision too small.Dynamic

DynamicNIntegrate::eincr: The global error of the strategy GlobalAdaptive has increased more than 1000000 times. The global error is expected to decrease monotonically after a number of integrand evaluations. Suspect one of the following: the working precision is insufficient for the specified precision goal; the integrand is highly oscillatory or it is not a (piecewise) smooth function; or the true value of the integral is 0. Increasing the value of the GlobalAdaptive option MaxErrorIncreases might lead to a convergent numerical integration. NIntegrate obtained 0.618315690550426459312705456807`30. and 0.00046796568836866222451442302407`30. for the integral and error estimates.Dynamic

{6215.76, 0.618315690550426459312705456807}

From the messages it seems that we can trust the first three significant digits, 0.618, and those results agree with the earlier posted results.

However, my attempts to use double exponential quadratures in MATHEMATICA were not successful.

In your attempts, did you use the methods "DoubleExponential" or "DoubleExponentialOscillatory"? Over this integral or (also) others?

After a change of variables, maybe integrate several cycles and then replace sine by its average. The change of variables may not be important, but I did it early in searching for a solution to make it easier (for my brain) to locate the singularities.

integrand = 
 Abs[Sin[x^4]]/(Sqrt[x] + x^2) Dt[x, u] /. x -> (Pi*u)^(1/4) // 
  Simplify[#, u > 0] &
avgSine = Integrate[Sin[\[Pi]  u], {u, 0, 1}];

(*  (\[Pi]^(1/8) Abs[Sin[\[Pi] u]])/((4 + 4 \[Pi]^(3/8) u^(3/8)) u^(7/8))  *)

Block[{n = 10000},
 NIntegrate[integrand, Evaluate@Flatten@{u, Range[0, n]}] + 
  avgSine*Integrate[ (\[Pi]^(1/8))/((4 + 4 \[Pi]^(3/8) u^(3/8)) u^(7/8)), {u, n, Infinity}]
 ]

(*  0.6182229377606695`  *)

The solution with n = 100000, which differs from the above in around the 11th digit:

(*  0.618222937758045`  *)

Very nice! This should be a separate Community post.

Yes, I tried for a long time, but the problem is still there. I don't have enough knowledge to solve it

I strongly suspect your are confusing WorkingPrecision with PrecisionGoal.

I tried to copy the learning document method, but it didn't work, so I would like to ask you to try. (I also tried Maple, but the results were disappointing)

thanks