You don't need to have a separate patterns for integer and floating point numbers. Just make the decimal part as optional and you could get both type of numbers from a single group.

(\d+(?:\.\d+)?)

Use the above pattern and get the numbers from group index 1.

DEMO

Code:

String s = "Oats     124   0.99        V    1.65";
Pattern regex = Pattern.compile("(\\d+(?:\\.\\d+)?)");
 Matcher matcher = regex.matcher(s);
 while(matcher.find()){
        System.out.println(matcher.group(1));
}

Output:

124
0.99
1.65

Pattern explanation:

• () capturing group .
• \d+ matches one or more digits.
• (?:) Non-capturing group.
• (?:\.\d+)? Matches a dot and the following one or more digits. ? after the non-capturing group makes the whole non-capturing group as optional.

OR

Your regex will also work only if you change the order of the patterns.

(\d+\.\d+|\d+)

DEMO

Considering the input "114.8 43801", you would want to use a white space as your delimiter. By using '\D+' as your delimiter, your split the string at any non digit as per the Java documentation: https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html

Hence, you are splitting at the dot of '114.8'.

Try to use the default whitespace delimiter (Do no set one..) and it should work.

Assuming that there may be no dot (.) between the string transaction number and the number you're searching for, use

Pattern regex = Pattern.compile("(?i)transaction number [^.]*\\b(\\d+)\\.");
Matcher regexMatcher = regex.matcher(subjectString);
if (regexMatcher.find()) {
    ResultString = regexMatcher.group(1);
} 

Explanation:

(?i)    # case insensitive matching mode
transaction\ number  # Match this literal text
[^.]*   # Match any number of characters except dots
\b      # Match the position at the start of a number
(\d+)   # Match a number (1 digit or more), capture the result in group 1
\.      # Match a dot

If you simply want to find the very first number after transaction number, then use

Pattern.compile("(?i)transaction number\\D*(\\d+)")

\D matches any character that is not a digit.

You can try following regex:

(?:class="priceValue">\s*)(\d*\.\d+)

It looks for a class="priceValue"string followed by a price

Here is DEMO and explanation

This line is your problem:

litersOfPetrol = Float.parseFloat(df.format(litersOfPetrol));

There you formatted your float to string as you wanted, but but then that string got transformed again to a float, and then what you printed in stdout was your float that got a standard formatting. Take a look at this code

import java.text.DecimalFormat;

String stringLitersOfPetrol = "123.00";
System.out.println("string liters of petrol putting in preferences is "+stringLitersOfPetrol);
Float litersOfPetrol=Float.parseFloat(stringLitersOfPetrol);
DecimalFormat df = new DecimalFormat("0.00");
df.setMaximumFractionDigits(2);
stringLitersOfPetrol = df.format(litersOfPetrol);
System.out.println("liters of petrol before putting in editor : "+stringLitersOfPetrol);

And by the way, when you want to use decimals, forget the existence of double and float as others suggested and just use BigDecimal object, it will save you a lot of headache.

double number = 12345.6789; // you have this
int decimal = (int) number; // you have 12345
double fractional = number - decimal // you have 0.6789

The problem here is that the fractional part is not written in memory as "0.6789", but may have certain "offsets", so to say. For example 0.6789 can be stored as 0.67889999291293929991.

I think your main concern here isn't getting the fractional part, but getting the fractional part with a certain precision.

If you'd like to get the exact values you assigned it to, you may want to consider this (altho, it's not a clean solution):

String doubleAsText = "12345.6789";
double number = Double.parseDouble(doubleAsText);
int decimal = Integer.parseInt(doubleAsText.split("\.")[0]);
int fractional = Integer.parseInt(doubleAsText.split("\.")[1]);

But, as I said, this is not the most efficient and cleanest solution.

When you give String.format("%02x",...), you are telling the compiler to give you a Hexadecimal number.

But then you are trying to parse it as a decimal number. Hence the issue.

You should do either of these,

file.write(Integer.parseInt(String.format("%02d", Integer.reverseBytes(str)), 10));

or,

file.write(Integer.parseInt(String.format("%02x", Integer.reverseBytes(str)), 16));

Use DecimalFormat

String formattedNumber = new DecimalFormat("0.00").format(x);