Resolving empty string in java

There's no one single good approach to validate data except that one should before using it. Instead of splitting your data string and then individually converting them to the right data types possibly running into exceptions, I suggest parsing your data string as a whole using Scanner which would lend you type safety as well.

Double reputation = null;
String type = null, edge = null;

String dataString = "domain::foo::127";
Scanner scanner = new Scanner(dataString).useDelimiter("::");

if (scanner.hasNext()) {
    type = scanner.next();
} else
  throw new IllegalArgumentException("Type not found!");
if (scanner.hasNext()) {
    edge = scanner.next();
} else
  throw new IllegalArgumentException("Edge not found!");
if (scanner.hasNextDouble()) {
    reputation = scanner.nextDouble();
} else
  throw new IllegalArgumentException("Reputation not found!");

System.out.println(type); // domain
System.out.println(edge); // foo
System.out.println(reputation); // 127.0

Pattern pattern = Pattern.compile("(\\w+)::(\\w+)::(\\d+)");
Matcher matcher = pattern.matcher(dataString);

if (matcher.matches()) {
    type = matcher.group(1);
    edge = matcher.group(2);
    reputation = Double.valueOf(matcher.group(3));
} else
  throw new IllegalArgumentException("Invalid input data");

You need to handle the case where you have malformed data. This isn't exactly an exhaustive validation, but it might be a place to start:

String[] format = "domain::foo::127".split("::");

...

boolean validateFormat(String[] format) {
  // Check for anything that you don't want coming through as data
  return format.length == 3;
}

With regex, you can verify if the input string is valid or not!

String pattern = "[a-z]+::{1}[a-z]+::{1}[0-9]+(\\.[0-9][0-9]?)?";

String type, edge;
double reputation;

if(input.matches(pattern)){
    String[] typeChunks = input.split("::");
    type = typeChunks[0];
    edge = typeChunks[1];
    reputation = Double.parseDouble(typeChunks[2].trim());
}
else
    throw new IllegalArgumentException();

This regex will check for

1. Alphabetic type
2. Alphabetic edge
3. Numeric reputation with or without decimal
4. "::" between all three

use if (!input.equals("")){ before String[] typeChunks = input.split("::"); and don't forget close }

You can validate before parse the string value:

double reputation = (typeChunks[2].trim() != null && 
                    !typeChunks[2].trim().isEmpty()) ? 
                     Double.parseDouble(typeChunks[2].trim()) : 0;

The error message is due to handling empty data.

double reputation = 0;
final String reputStr = typeChunks[2];
if ((reputStr != null) && !("").equals(reputStr.trim()))
{
   reputation = Double.parseDouble(typeChunks[2].trim());
}

What about creating a simple helper class to check your string ... something like

public class StringUtil {

public static boolean isNullOrEmpty(final String string)

{
return string == null || string.isEmpty() || string.trim().isEmpty();

}

}

So in this way you don't need to use trim(). Because if you use trim() on an empty string you will get an exception. But you still have to deal with NumberFormatException in Double.parseDouble.

So if you don't wanna add try and catch blocks every time you can create a simple wrapper for Double.parseDouble to catch exception and deal with them in your way (let's say return -1).

double reputation = StringUtil.isNullOrEmpty(typeChunks[2])== true ? 0 : YourClass.methodToParseDoubleAndHandleException(typeChunks[2]);