What is the language? Java? You can use the split() function of String if you just want to keep numbers before "." :

String mystring = "34.000000";
String correctstring[] = mystring.split(".");
System.out.println(correctstring[0]);
// display : 34

it will delete all digits after "." !

You need to escape the ., as it is a special character in Regex that matches any character. You also have to remove the ^, which anchors at the beginning of the number.

str.replaceAll("\\.0*$", "");

You can use a lookbehind if you want to make sure there is a number in front of the dot, like this:

str.replaceAll("(?<=^\\d+)\\.0*$", "");

The lookbehind (the (?<=...) part) is not a part of the match, so it will not be replaced, but it still has to match for the rest of the regex to match.

Nice and simple. Add this snippet in whatever you're outputting to:

String.format("%.0f", percentageValue)

It's because cellSONum.getNumericCellValue() is returning a floating point type. If you force it to an integer before calling valueOf(), you should get the string representation in an integral form, if indeed that's what you want for all possibilities:

SONum = String.valueOf((int)cellSONum.getNumericCellValue());

You can see this in the following code:

class Test {
    public static void main(String[]args) {
        double d = 1234;
        System.out.println(String.valueOf(d));
        System.out.println(String.valueOf((int)d));
    }
}

which outputs:

1234.0
1234

However, if you want to just get rid of .0 at the end of any string but allow non-integral values to survive, you can just remove the trailing text yourself:

class Test {
    public static void main(String[]args) {
        double d1 = 1234;
        double d2 = 1234.567;
        System.out.println(String.valueOf(d1).replaceFirst("\\.0+$", ""));
        System.out.println(String.valueOf(d2).replaceFirst("\\.0+$", ""));
    }
}

That snippet outputs:

1234
1234.567

replaceAll replaces a regex. You should use replace instead:

String s2 = s.replace(".", "");

The Java library has a built-in class that can do this for it. It's BigDecimal.

Here is an example usage:

BigDecimal number = new BigDecimal("10.2270");  
System.out.println(number.stripTrailingZeros().toPlainString());

Output:

10.227

Note: It is important to use the BigDecimal constructor that takes a String. You probably don't want the one that takes a double.

Here's a method that will take a Collection<String> and return another Collection<String> of numbers with trailing zeros removed, gift wrapped.

public static Collection<String> stripZeros(Collection<String> numbers) {
    if (numbers == null) { 
        throw new NullPointerException("numbers is null");
    }

    ArrayList<String> value = new ArrayList<>(); 

    for (String number : numbers) { 
        value.add(new BigDecimal(number).stripTrailingZeros().toPlainString());
    }

    return Collections.unmodifiableList(value);
}

Example usage:

ArrayList<String> input = new ArrayList<String>() {{ 
    add("10.0"); add("10.00"); add("10.10"); add("10.2270"); 
}};

Collection<String> output = stripZeros(input);
System.out.println(output);

Outputs:

[10, 10, 10.1, 10.227]