相关疑难解决方法(0)

我想知道哪个程序变量更好运行时？
两种变体看起来都很容易实现.但什么是更好的使用和在哪些情况下？

字符串反转:

public static String reverse(String s)
{
    String rev = "";
    for (int i = s.length() - 1; i >= 0; i--)
        rev += s.charAt(i);
    return rev;
}

StringBuilder反向:

public static String reverse(String s)
{
    StringBuilder rev = new StringBuilder();
    for (int i = s.length() - 1; i >= 0; i--)
        rev.append(s.charAt(i));
    return rev.toString();
}

ArrayList<String[]> writtenClasses = new ArrayList<String[]>();
// usually there is functional code here that populates
// ArrayList<String[]> writtenClasses with variably 3000
// String[] objects always of exactly 8 lines each

ArrayList<String> processedClasses = new ArrayList<String>();
for(String[] classLines: writtenClasses)
{
    for(String classLine: classLines)
    {
        processedClasses.add(classLine);
    }
}

String result = "";
for(String fileLine: processedClasses)
{
    result += fileLine + "\n";
}

我的代码在上面.它工作正常,产生我想要的结果,只是缓慢.每个项目的ArrayList书写类需要大约10毫秒,这是好的,直到我给它更大的工作.我怀疑与ArrayLists有关的事情花了这么长时间,但是在每次运行后,计时器和打印到控制台工作统计数据都显得很少.

上面的代码是对早期代码的改编,希望提高效率.它的成功率约为4%.下面的代码是我使用的旧方法,它比上面的方法稍微长一些.

for(String[] classLines: writtenClasses)
{
    for(String classLine: classLines)
    {
        result += classLine + "\n";
    }
    writtenClasses.set(writtenClasses.indexOf(classLines), null);
}

我writtenClasses.set(writtenClasses.indexOf(classLines), …

当我注意到有关字符串连接的这一点时,我正在查看StringJavadoc:

Java语言为字符串连接运算符(+)提供特殊支持,并为其他对象转换为字符串.String通过StringBuilder(或StringBuffer)实现连接

从Java 8 JLS 15.8.1开始,它是编译器的选择(强调我的):

实现可以选择在一个步骤中执行转换和连接,以避免创建然后丢弃中间String对象.为了提高重复字符串连接的性能,Java编译器可以使用StringBuffer类或类似技术来减少通过计算表达式创建的中间String对象的数量.

我制作了一个小程序来查看它编写的内容

public class Tester {

    public static void main(String[] args) {
        System.out.println("hello");
        for (int i = 1; i < 5; i++) {
            String s = "hi " + i;
            System.out.println(s);
        }
        String t = "me";
        for (int i = 1; i < 5; i++) {
            t += i;
            System.out.println(t);
        }
        System.out.println(t);
    }
}

运行时的输出javap -c Tester显示StringBuilder正在使用的输出:

Compiled …

public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str = "abcdaa";
        dups(str);
    }
    public static void dups(String str){
        HashSet hs = new HashSet();
        char[] ch = str.toCharArray();
        for(int i=0; i < ch.length;i++){
            hs.add(ch[i]);
        }
        System.out.println(hs);
    }

上面的代码返回输出：[a,b,c,d]

但我想将 Set 值打印到一个字符串中，以便我可以返回一个字符串值返回值如下所示：预期输出：abcd

我正在尝试将我的流知识应用于一些 leetcode 算法问题。以下是问题的一般摘要：

给定一个只包含小写字母的字符串，删除重复的字母，使每个字母只出现一次。您必须确保您的结果在所有可能的结果中按字典顺序最小。

例子：

Input: "bcabc"
Output: "abc"

另一个例子：

Input: "cbacdcbc"
Output: "acdb"

这似乎是一个简单的问题，只需将值从字符串流式传输到新列表中，对值进行排序，找到不同的值，然后将其扔回列表中，并将列表的值附加到字符串中。这是我想出的：

public String removeDuplicateLetters(String s)
{
    char[] c = s.toCharArray();
    List<Character> list = new ArrayList<>();
    for(char ch : c) 
    {
        list.add(ch);
    }
    
    List<Character> newVal = list.stream().distinct().collect(Collectors.toList()); 
    String newStr = "";
    for(char ch : newVal) 
    {
        newStr += ch;
    }
    
    return newStr;
}

第一个示例运行良好，但第二个输出不是“acdb”，而是“abcd”。为什么 abcd 不是最小的字典顺序？谢谢！

我在java中使用过String,StringBuilder和StringBuffer.
我想到了这个问题,而我从效率的角度思考.

字符串连接中的"+"是否会影响效率？

我正在编写一个拼写纠正器,为用户提供建议.要做到这一点,我正在使用一个和两个编辑距离的单词.有四种技巧:

• 删除该单词的一个字母,
• 转置两个相邻的字母,
• 改变一个字母的单词,和
• 在单词中插入一个字母.

其中一些需要通过单词进行多次迭代,并执行诸如交换两个字母或在字符串中间添加字母之类的操作.

我知道String在java中是不可变的,并且字符串生成器中的插入可能会根据需要创建字符串的副本,所以我想知道char数组是否会使这更快.

在 Java 8 中，我编写了一些示例代码。

String s1 = "Hello";  
String s2 = "world";  
String s3 = s1 + s2;  

反编译 .class 文件后，我发现了第三条语句

 String s3 = s1 + s2;  

取而代之

 String s3 = new StringBuilder(s1).append(s2).toString();

这是否意味着不再需要使用显式 StringBuilder 进行优化而只需使用“+”运算符而不是？

我下面的方法需要返回一个由字符串连接而成的字符串。

StringBuilder sb = new StringBuilder();
sb.append("count: ").append(this.count()).append( "\n");

return sb.toString();

在 IntelliJ 中，代码检查建议我用如下所示的字符串替换此 StringBuilder：

String sb = "count: " + this.count() + "\n";
return sb

我的印象是 StringBuilder 应该与append方法一起使用，以用加号替换字符串连接。这个代码检查建议在 IntelliJ 中有意义吗？

您可以为使用一个或另一个更好,更快,更正确的变体提供什么参数.

第一个变种:

StringBuffer sql = new StringBuffer("SELECT DISTINCT f.ID ")
    .append("FROM FIRST_TABLE F ")
        .append("LEFT JOIN SECOND_TABLE s ON f.ID = s.F_ID ")
    .append("WHERE ")
        .append("F.BOOL = 1 ")
        .append("AND S.DATE IS NOT NULL ")
        .append("AND S.CLOSED = 0 ");

第二种变体:

String sql = "SELECT DISTINCT f.ID " +
             "FROM FIRST_TABLE F " +
                "LEFT JOIN SECOND_TABLE s ON f.ID = s.F_ID " +
             "WHERE "
                "F.BOOL = 1 " +
                "AND S.DATE IS NOT NULL " +
                "AND S.CLOSED …