Java 搜索3列字符串的范围

我有一套像下面这样的绳子 a、 不列颠哥伦比亚省

如果询问

a1.*

它应该返回从

a1开始的所有字符串。
如果询问
a1.b1
，则应返回从
a1.b1

所有输出都应以排序方式（字典式）

任何关于数据结构的建议，我都会考虑
后缀树
 此代码可能对您有所帮助

String stringarray[] = {"a1.b1.c1",
"a1.b1.c2",
"a1.b2.c3",
"a2.b1.c1",
"a2.b2.c2",
"a3.b3.c3"};
String startingfrom = "a1.b1";
for(int i = 0; i < stringarray.length;i++) {
     if(stringarray[i].startsWith(startingfrom))
              System.out.println("string is : " + stringarray[i]);
}

stringarray[]={“a1.b1.c1”，
“a1.b1.c2”，
“a1.b2.c3”，
“a2.b1.c1”，
“a2.b2.c2”，
“a3.b3.c3”}；
字符串startingfrom=“a1.b1”；
对于（int i=0；i
如果您的字符串集基本上是固定的（不经常更新），那么简单的排序列表就可以了。要查找带有前缀的所有字符串，请对该列表执行二进制搜索，查找第一个字符串。然后在字符串与前缀匹配时从该点迭代

就内置Java数据结构而言，我建议使用树集

SortedSet<String> data = new TreeSet<String>();

Set<String> findMatching(SortedSet<String> data, String prefix) {
    String prefix = prefix.replace("*", ""); // remove unnecessary *
    String nextPrefix = prefix + '\uffff'; // a string guaranteed to be after anything matching the prefix
    // get the subset after the prefix, and then get the subset of that before the prefix
    return data.tailSet(prefix).headSet(nextPrefix, false);
}

findMatching(data, "a1.b1.*");

SortedSet data=新树集（）；
设置FindMatch（分类数据集数据、字符串前缀）{
字符串前缀=前缀。替换（“*”，“”）；//删除不必要的*
String nextPrefix=prefix+'\uffff'；//保证在与前缀匹配的任何内容之后的字符串
//获取前缀后的子集，然后获取前缀前的子集
返回数据。tailSet（前缀）。耳机（nextPrefix，false）；
}
查找匹配（数据，“a1.b1.*）；

使用
nextPrefix
有点难看，因为我假设前缀总是由
分隔的部分组成的序列，并且附加FFFF字符是获得大于任何匹配前缀的字符串的最佳方法。可能有更好的方法来完成此部分。
NavigabeeSet可以快速完成类似的操作：

    NavigableSet<String> s = new TreeSet<>();
    s.addAll(Arrays.asList("a1.b1.c1", "a1.b1.c2", "a1.b2.c3", "a2.b1.c1"));
    System.out.println(s.subSet("a1.", true, "a2", false)); // a1.*
    System.out.println(s.tailSet("a1.b1"));                 // a1.b1

我的职能：

class Match
{
    public static ArrayList<String> match (String[] data, String regex)
    {
        ArrayList<String> m = new ArrayList<String>();

        for (String d : data)
        {
            if (d.matches(regex))
            {
                m.add(d);
            }
        }

        Collections.sort(m);

        return m;
    }
}

类匹配
{
公共静态ArrayList匹配（字符串[]数据，字符串正则表达式）
{
ArrayList m=新的ArrayList（）；
for（字符串d：数据）
{
if（d.matches（regex））
{
m、 加（d）；
}
}
集合。排序（m）；
返回m；
}
}

测试：

字符串数据[]=
{“a1.b1.c1”，
“a1.b1.c2”，
“a1.b2.c3”，
“a2.b1.c1”，
“a2.b2.c2”，
“a3.b3.c3”}；
//使用正则表达式进行匹配
ArrayList matched=匹配（数据“^a1\.b1.*）；
您可以创建3d树（kd树的特例）。然后要搜索类似于
a1.b1.*
，您需要在
a1.b1.c1_min
和
a1.b1.c1_max
上进行范围搜索。并对输出进行排序

这将为搜索提供
O（n^（2/3）+r）
，为排序提供
O（r log（r））
，其中
n
是所有节点的数量，
r
是找到的节点的数量

一般kd树的搜索复杂度如下：
O（n^（1-1/k）+r）
，对于3d树，
k
为3
^
的强大功能。
一个简单的列表和一些regexp模式匹配来过滤元素怎么样？
[a1.b1.c1, a1.b1.c2, a1.b2.c3]
[a1.b1.c1, a1.b1.c2, a1.b2.c3, a2.b1.c1]

class Match
{
    public static ArrayList<String> match (String[] data, String regex)
    {
        ArrayList<String> m = new ArrayList<String>();

        for (String d : data)
        {
            if (d.matches(regex))
            {
                m.add(d);
            }
        }

        Collections.sort(m);

        return m;
    }
}

String data [] =
{"a1.b1.c1",
 "a1.b1.c2",
 "a1.b2.c3",
 "a2.b1.c1",
 "a2.b2.c2",
 "a3.b3.c3"};

// match using a regular expression
ArrayList<String> matched = match (data, "^a1\.b1.*");