比较 2 组字符串

Question

I have one list of Objects, that I iterate, and I need to compare one property of the object which is a String, and if that String ends with any value of a Given array y must save this object to be used later.

I need a optimal way to this check, any help?

Here is a example of what i want to do.

List<TObject> itemList;
List<TObject> resultItemList;
String[] aSufix;

for(TObject item : itemList){
   for(String sufix : aSufix){
     if(item.name.endsWith(sufix)){
       resultItemList.add(item);
       break;
     }
   }
}

I was thinking of using a stream().anyMatch to check, but I am worried about creating too many Instances of Stream to do the comparative.

The Lists we are talking about 100+ suffixes, and the list of objects to check about 5000.

Answer 1

This is a hard problem, and it's not clear just how badly you need to optimize this. I'm going to assume you need the heavy stuff.

It's almost going to simplify your task and allow you to use libraries more easily to treat this as a problem about prefixes, not suffixes. So you'll need to reverse your strings, especially the suffixes.

static String reverse(String s) { 
   return new StringBuilder(s).reverse().toString();
}

If the list of prefixes is a constant, you can offload the heavy performance work to regex compilation. This has slower setup time, but works faster on the objects to check.

StringBuilder patternBuilder = new StringBuilder("^("); // match at the start only
boolean first = true;
for (String suffix : suffixes) {
  if(!first) patternBuilder.append('|');
  patternBuilder.append(Pattern.quote(reverse(suffix)));
}
Pattern pattern = Pattern.compile(patternBuilder.append(')').toString());

Then to check if a given string has one of the suffixes,

boolean hasOneOfTheSuffixes = pattern.matcher(reverse(str)).find();

A fancier version of this would create a specialized CharSequence implementation to reverse the string lazily, to avoid having to scan for the whole suffix. I'd only use this if your strings are really long.

You could rewrite the regex to look for a suffix instead of a prefix in the reversed string, but that'd play less to the regex engine's strengths, costing more time looking for matches that aren't going to happen but start midway through the string.

If the list of prefixes is not a constant, then you probably want a sorted list of them.

List<String> prefixes = new ArrayList<>();
for (String suffix : suffixes) {
  prefixes.add(reverse(suffix));
}
Collections.sort(prefixes);

Then to test if a string has one of the given suffixes,

String reversed = reverse(str);
int index = Collections.binarySearch(prefixes, reversed);
if (index >= 0) return true; // the string *is* one of the suffixes
index = ~index - 1; // the prefix *before* where the string goes in lex order
return index >= 0 && reversed.startsWith(prefixes.get(index));
  // check if the prefix at that index matches