Java 优化字符串操作代码

我正在尝试从给定主机删除所有可能的子域。我已经编写了以下代码。这是可行的，但我唯一担心的是性能

是否需要进一步优化此代码：

import java.util.Arrays;
import java.util.Collections;

public class DemoExtractHostArray {
    public static  String[] createHostArray(String host) {
        String[] stringArr = host.split("\\.");
        String[] hostArray = new String[stringArr.length];
        int hostIndex = 0;

        for(int index = stringArr.length-1; index>=0;index--){
            if(hostIndex==0){ 
                hostArray[hostIndex] = stringArr[index];
            }
            else{
                hostArray[hostIndex] = stringArr[index]+"."+hostArray[hostIndex-1];
            }
            hostIndex++;
        }
        Collections.reverse(Arrays.asList(hostArray));
        return hostArray;
    }

    public static void main(String a[]){
        for(String s: createHostArray("a.b.c.d.e.f")){
            System.out.println(s);
        }

    }
}

输出：

a.b.c.d.e.f
b.c.d.e.f
c.d.e.f
d.e.f
e.f
f

---

对代码的唯一潜在改进是删除此调用：

Collections.reverse(Arrays.asList(hostArray));

由于您正在创建

主机阵列

，然后对其进行反转，因此您最好立即更改循环以反转顺序创建阵列，以便不再需要显式反转：

// hostIndex is no longer required - remove the line below:
// int hostIndex = 0;
for(int index = stringArr.length-1 ; index>=0 ; index--){
    if(index == stringArr.length-1) {
        hostArray[index] = stringArr[index];
    }
    else{
        hostArray[index] = stringArr[index]+"."+hostArray[index+1];
    }
}

---

我个人会使用回避。这个实现不需要反转数组，在我看来，可能更容易执行

package com.poachit.utility.web；
导入java.util.array；
导入java.util.Collections；
公共类DemoExtractHostArray{
公共静态void createHostArray（字符串[]根，字符串[]结果，整数索引）{
字符串host=“”；
int i=指数；
如果（索引==根长度）{
返回；
}
对于（；i；
}
if（i<根长度）{
主机+=根[i]；
}
结果[指标]=宿主；
createHostArray（根、结果、++索引）；
}
公共静态void main（字符串[]args）引发java.lang.Exception
{
字符串host=“a.b.c.d.e.f”；
String[]tokens=host.split（“\\”）；
字符串[]结果=新字符串[tokens.length]；
createHostArray（令牌，结果，0）；
for（字符串s:结果）{
系统输出打印项次；
}
}
}

您可以像这样优化代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Test {
    public static  String[] createHostArray(String host) {
        String[] stringArr = host.split("\\.");
        String[] hostArray = new String[stringArr.length];
        int hostIndex = 0;

        for(int index = stringArr.length-1; index>=0;index--){
            if(hostIndex==0){ 
                hostArray[hostIndex] = stringArr[index];
            }
            else{
                hostArray[hostIndex] = stringArr[index]+"."+hostArray[hostIndex-1];
            }
            hostIndex++;
        }
        Collections.reverse(Arrays.asList(hostArray));
        return hostArray;
    }

    public static  String[] betterCreateHostArray(String host) {
        List<String> hostList = new ArrayList<String>();
        do {
            if(!host.contains(".")) {
                hostList.add(host);
                break;
            } else {
                hostList.add(host);
                host = host.substring(host.indexOf('.')+1);
            }
        } while(host.length() > 0);

        return hostList.toArray(new String[hostList.size()]);
    }

    public static void main(String a[]){
        long startTime = System.nanoTime();
        String[] array = createHostArray("a.b.c.d.e.f");
        long endTime = System.nanoTime();
        long timeByFirstApproach = endTime - startTime;

        for(String s: array){
            System.out.println(s);
        }
        System.out.println("=====");
        startTime = System.nanoTime();
        array = betterCreateHostArray("a.b.c.d.e.f");
        endTime = System.nanoTime();
        long timeBySecondApproach = endTime - startTime;
        for(String s: array){
            System.out.println(s);
        }
        System.out.println(String.format("Time taken by first approach=[%d] nano seconds and\n"
                + "Time taken by second approach=[%d] nano seconds", timeByFirstApproach,timeBySecondApproach));
    }
}

import java.util.ArrayList；
导入java.util.array；
导入java.util.Collections；
导入java.util.List；
公开课考试{
公共静态字符串[]createHostArray（字符串主机）{
String[]stringArr=host.split（“\\”）；
String[]hostArray=新字符串[stringArr.length]；
int hostIndex=0；
对于（int index=stringArr.length-1；index>=0；index--）{
如果（hostIndex==0）{
hostArray[hostIndex]=stringArr[index]；
}
否则{
hostArray[hostIndex]=stringArr[index]+“+hostArray[hostIndex-1]；
}
hostIndex++；
}
Collections.reverse（Arrays.asList（hostArray））；
返回主机阵列；
}
公共静态字符串[]betterCreateHostArray（字符串主机）{
List hostList=new ArrayList（）；
做{
如果（！host.contains（“.”）{
hostList.add（主机）；
打破
}否则{
hostList.add（主机）；
host=host.substring（host.indexOf（'.'）+1）；
}
}while（host.length（）>0）；
返回hostList.toArray（新字符串[hostList.size（）]）；
}
公共静态void main（字符串a[]{
long startTime=System.nanoTime（）；
字符串[]数组=createHostArray（“a.b.c.d.e.f”）；
long-endTime=System.nanoTime（）；
long-timeByFirstApproach=结束时间-开始时间；
for（字符串s:数组）{
系统输出打印项次；
}
System.out.println（“==”）；
startTime=System.nanoTime（）；
数组=betterCreateHostArray（“a.b.c.d.e.f”）；
endTime=System.nanoTime（）；
long-timeBySecondApproach=结束时间-开始时间；
for（字符串s:数组）{
系统输出打印项次；
}
System.out.println（String.format（“第一次接近所花费的时间=[%d]纳秒和\n”
+“第二次进近所用时间=[%d]纳秒”，TimeByFirst进近，timeBySecondApproach）；
}
}

这里是性能结果

a、 b.c.d.e.f
b、 c.d.e.f
c、 d.e.f
d、 e.f
e、 f
f
=======
a、 b.c.d.e.f
b、 c.d.e.f
c、 d.e.f
d、 e.f
e、 f
f
第一次进近所用时间=[1625572]纳秒和 秒进近所用时间=[308289]纳秒

---

第二种方法的速度比您正在采用的方法快5倍以上。

那么，它的性能差吗？您是否分析了应用程序并发现这是一个热点？优化不是“必需的”，除非它将用于某个性能关键的循环中。提示：不要试图猜测性能问题，这是一种非常低效的查找方法。此代码将被调用数百万次。基于流量。如果性能确实是一个很大的问题，您可以始终将方法声明为“本机”，并使用Java本机接口实现它们。您还可以创建

StringBuilder[]

而不是

String[]

。

if

语句中的源代码可以如下所示：

hostArray[index].append（…）想想看。@MichałZiober这不会有多大改进，因为每个连接只执行一次，所有中间结果都保留下来。这是一个尾部调用。对于这个任务来说，递归是不必要的，而且过于昂贵；您可以简单地循环，每次通过循环递增索引，直到
index==root.length
。甚至更简单、更容易阅读，性能也更高。除非他在做数十万台主机，否则性能真的可以忽略不计。您不会注意到通过递归在堆栈上添加几个帧所带来的执行时间命中。这确实是一个偏好的问题。绝对同意。但提出的问题是性能。对于初学者来说，循环比尾声更清晰。
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Test {
    public static  String[] createHostArray(String host) {
        String[] stringArr = host.split("\\.");
        String[] hostArray = new String[stringArr.length];
        int hostIndex = 0;

        for(int index = stringArr.length-1; index>=0;index--){
            if(hostIndex==0){ 
                hostArray[hostIndex] = stringArr[index];
            }
            else{
                hostArray[hostIndex] = stringArr[index]+"."+hostArray[hostIndex-1];
            }
            hostIndex++;
        }
        Collections.reverse(Arrays.asList(hostArray));
        return hostArray;
    }

    public static  String[] betterCreateHostArray(String host) {
        List<String> hostList = new ArrayList<String>();
        do {
            if(!host.contains(".")) {
                hostList.add(host);
                break;
            } else {
                hostList.add(host);
                host = host.substring(host.indexOf('.')+1);
            }
        } while(host.length() > 0);

        return hostList.toArray(new String[hostList.size()]);
    }

    public static void main(String a[]){
        long startTime = System.nanoTime();
        String[] array = createHostArray("a.b.c.d.e.f");
        long endTime = System.nanoTime();
        long timeByFirstApproach = endTime - startTime;

        for(String s: array){
            System.out.println(s);
        }
        System.out.println("=====");
        startTime = System.nanoTime();
        array = betterCreateHostArray("a.b.c.d.e.f");
        endTime = System.nanoTime();
        long timeBySecondApproach = endTime - startTime;
        for(String s: array){
            System.out.println(s);
        }
        System.out.println(String.format("Time taken by first approach=[%d] nano seconds and\n"
                + "Time taken by second approach=[%d] nano seconds", timeByFirstApproach,timeBySecondApproach));
    }
}