Как реализовать SQL как оператор 'LIKE' в Java?

You could turn '%string%' to contains(), 'string%' to startsWith() and '%string"' to endsWith().

You should also run toLowerCase() on both the string and pattern as LIKE is case-insenstive.

Not sure how you'd handle '%string%other%' except with a Regular Expression though.

If you're using Regular Expressions:

• Quote the string before you replace the % characters
• Watch out for escaped characters in the LIKE String

.* will match any characters in regular expressions

I think the java syntax would be

"digital".matches(".*ital.*");

And for the single character match just use a single dot.

"digital".matches(".*gi.a.*");

And to match an actual dot, escape it as slash dot

\.

Строки Java имеют методы .startsWith () и .contains (), которые помогут вам в большинстве случаев. Для чего-то более сложного вам придется использовать регулярное выражение или написать свой собственный метод.

Да, это можно сделать с помощью регулярного выражения. Имейте в виду, что синтаксис регулярных выражений Java отличается от синтаксиса подобия SQL. Вместо «% » у вас будет «. * », а вместо «? » - «. ".

Что делает его несколько сложным, так это то, что вам также придется экранировать любые символы, которые Java рассматривает как особые. Поскольку вы пытаетесь сделать это аналогом SQL, я предполагаю, что ^ $ [] {} \ не должно появляться в строке регулярного выражения. Но вам придется заменить «. » на « \\. » перед выполнением любых других замен. ( Редактировать: Паттерн. quote (String) экранирует все, заключая в строку символы « \ Q » и « \ E », что приведет к тому, что все в выражении будет рассматриваться как литерал ( вообще без подстановочных знаков). Так что вы определенно не хотите его использовать.)

Кроме того, как говорит Дэйв Уэбб, вам также нужно игнорировать регистр.

Имея это в виду, вот пример того, что он может выглядит так:

public static boolean like(String str, String expr) {
    expr = expr.toLowerCase(); // ignoring locale for now
    expr = expr.replace(".", "\\."); // "\\" is escaped to "\" (thanks, Alan M)
    // ... escape any other potentially problematic characters here
    expr = expr.replace("?", ".");
    expr = expr.replace("%", ".*");
    str = str.toLowerCase();
    return str.matches(expr);
}

Я не знаю точно о жадной проблеме, но попробуйте это, если это сработает для вас:

public boolean like(final String str, String expr)
  {
    final String[] parts = expr.split("%");
    final boolean traillingOp = expr.endsWith("%");
    expr = "";
    for (int i = 0, l = parts.length; i < l; ++i)
    {
      final String[] p = parts[i].split("\\\\\\?");
      if (p.length > 1)
      {
        for (int y = 0, l2 = p.length; y < l2; ++y)
        {
          expr += p[y];
          if (i + 1 < l2) expr += ".";
        }
      }
      else
      {
        expr += parts[i];
      }
      if (i + 1 < l) expr += "%";
    }
    if (traillingOp) expr += "%";
    expr = expr.replace("?", ".");
    expr = expr.replace("%", ".*");
    return str.matches(expr);
}

Apache Cayanne ORM имеет " Оценка памяти "

Это может не работать для несопоставленных объектов, но выглядит многообещающе:

Expression exp = ExpressionFactory.likeExp("artistName", "A%");   
List startWithA = exp.filterObjects(artists); 

Регулярные выражения являются наиболее универсальными. Однако некоторые функции LIKE могут быть сформированы без регулярных выражений. например,

String text = "digital";
text.startsWith("dig"); // like "dig%"
text.endsWith("tal"); // like "%tal"
text.contains("gita"); // like "%gita%"

Каждая ссылка на SQL, которую я могу найти, говорит, что подстановочный знак «любой отдельный символ» является подчеркиванием ( _ ), не вопросительный знак (? ). Это немного упрощает, поскольку подчеркивание не является метасимволом регулярного выражения. Однако вы по-прежнему не можете использовать Pattern.quote () по причине, указанной mmyers. У меня есть еще один способ избежать регулярных выражений, когда я, возможно, захочу их отредактировать позже. После этого метод like () становится довольно простым:

public static boolean like(final String str, final String expr)
{
  String regex = quotemeta(expr);
  regex = regex.replace("_", ".").replace("%", ".*?");
  Pattern p = Pattern.compile(regex,
      Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
  return p.matcher(str).matches();
}

public static String quotemeta(String s)
{
  if (s == null)
  {
    throw new IllegalArgumentException("String cannot be null");
  }

  int len = s.length();
  if (len == 0)
  {
    return "";
  }

  StringBuilder sb = new StringBuilder(len * 2);
  for (int i = 0; i < len; i++)
  {
    char c = s.charAt(i);
    if ("[](){}.*+?$^|#\\".indexOf(c) != -1)
    {
      sb.append("\\");
    }
    sb.append(c);
  }
  return sb.toString();
}

Если вы действительно хотите использовать ? для подстановочного знака, лучше всего удалить его. из списка метасимволов в методе quotemeta () . Замена его экранированной формы - replace ("\\?", ".") - небезопасна, потому что в исходном выражении может быть обратная косая черта.

И это подводит нас к реальные проблемы: большинство разновидностей SQL, похоже, поддерживают классы символов в формах [az] и [^ jm] или [! jm] , и все они предоставляют способ escape-символы подстановки. Последнее обычно выполняется с помощью ключевого слова ESCAPE , которое позволяет вам каждый раз определять другой escape-символ. Как вы понимаете, это немного усложняет ситуацию. Преобразование в регулярное выражение, вероятно, по-прежнему является лучшим вариантом, но анализ исходного выражения будет намного сложнее - фактически, первое, что вам нужно сделать, это формализовать синтаксис самих LIKE -подобных выражений. .

Последнее обычно выполняется с помощью ключевого слова ESCAPE , которое позволяет вам каждый раз определять другой escape-символ. Как вы понимаете, это немного усложняет ситуацию. Преобразование в регулярное выражение, вероятно, по-прежнему является лучшим вариантом, но анализ исходного выражения будет намного сложнее - фактически, первое, что вам нужно сделать, это формализовать синтаксис самих LIKE -подобных выражений. .

Последнее обычно выполняется с помощью ключевого слова ESCAPE , которое позволяет вам каждый раз определять другой escape-символ. Как вы понимаете, это немного усложняет ситуацию. Преобразование в регулярное выражение, вероятно, по-прежнему является лучшим вариантом, но разобрать исходное выражение будет намного сложнее - фактически, первое, что вам нужно сделать, это формализовать синтаксис самих LIKE -подобных выражений. .

Интерфейсы Comparator и Comparable здесь, скорее всего, неприменимы. Они занимаются сортировкой и возвращают целые числа либо со знаком, либо со знаком 0. Ваша операция заключается в поиске совпадений и возврате истинного / ложного. Это другое.