Java 这两种方法中哪一种更适合创建和销毁对象？

我在第26行和第27行有个问题：

String dumb = input.nextLine();
output.println(dumb.replaceAll(REMOVE, ADD));

我希望我能把它缩小到一行，节省空间，所以我做到了：

output.println(new String(input.nextLine()).replaceAll(REMOVE, ADD));

但现在我想知道性能。我知道这个程序非常简单，不需要优化，但我想学习这个。
从我的角度来看，在第一个场景中，我创建了一个字符串对象dumb，但一旦我离开循环，对象就会被放弃，JVM应该清理它，对吗？但是JVM清理废弃对象的速度比程序通过循环的速度快吗？或者程序完成后，会有几个字符串对象等待垃圾收集吗

我的逻辑正确吗？在第二个场景中，字符串对象是动态创建的，一旦程序通过该行，它就会被销毁？这实际上是一种性能提升吗

如果你能帮我澄清一下，我将不胜感激

谢谢,

p、 如果你想知道这个程序（我假设它是直截了当的），它接收一个输入文件和一个输出文件，两个字，程序接收输入文件，用第二个字替换第一个字，并将其写入第二个文件。如果您真的已经阅读了这篇文章，并且想建议我如何改进代码，请这样做。我将非常感激

import java.io.File;
import java.util.Scanner;
import java.io.PrintWriter;

public class RW {

    public static void main(String[] args) throws Exception{
        String INPUT_FILE = args[0];
        String OUTPUT_FILE = args[1];
        String REMOVE = args[2];
        String ADD = args[3];

        File ifile = new File(INPUT_FILE);
        File ofile = new File(OUTPUT_FILE);

        if (ifile.exists() == false) {
            System.out.println("the input file does not exists in the current folder");
            System.out.println("please provide the input file");
            System.exit(0);
        }

        Scanner input = new Scanner(ifile);
        PrintWriter output = new PrintWriter(ofile);

        while(input.hasNextLine()) {
            String dumb = input.nextLine();
            output.println(dumb.replaceAll(REMOVE, ADD));
        }
        input.close();
        output.close();


    }
}

---

一旦本地对象超出范围，它们就有资格使用GC。这并不意味着GC会在那一刻清理它们。符合条件的对象经历了一个生命周期。GC可能立即收集，也可能不立即收集

就您的程序而言，除了一两行代码外，没有什么需要优化的。下面是一个重组的计划

import java.io.File;
import java.util.Scanner;
import java.io.PrintWriter;

public class Test {
    public static void main(String[] args) throws Exception {
        String INPUT_FILE = args[0];
        String OUTPUT_FILE = args[1];
        String REMOVE = args[2];
        String ADD = args[3];

        File ifile = new File(INPUT_FILE);
        File ofile = new File(OUTPUT_FILE);
        if (ifile.exists() == false) {
            System.out.println("the input file does not exists in the current folder\nplease provide the input file"); 
            System.exit(0);
        }
        Scanner input = null;
        PrintWriter output = null;
        try {
            input = new Scanner(ifile);
            output = new PrintWriter(ofile);
            while (input.hasNextLine()) {
                output.println(input.nextLine().replaceAll(REMOVE, ADD));
            }
        } finally {
            if (input != null)
                input.close();
            if(output != null)
                output.close();
        }
    }
}

---

一旦本地对象超出范围，它们就有资格使用GC。这并不意味着GC会在那一刻清理它们。符合条件的对象经历了一个生命周期。GC可能立即收集，也可能不立即收集

就您的程序而言，除了一两行代码外，没有什么需要优化的。下面是一个重组的计划

import java.io.File;
import java.util.Scanner;
import java.io.PrintWriter;

public class Test {
    public static void main(String[] args) throws Exception {
        String INPUT_FILE = args[0];
        String OUTPUT_FILE = args[1];
        String REMOVE = args[2];
        String ADD = args[3];

        File ifile = new File(INPUT_FILE);
        File ofile = new File(OUTPUT_FILE);
        if (ifile.exists() == false) {
            System.out.println("the input file does not exists in the current folder\nplease provide the input file"); 
            System.exit(0);
        }
        Scanner input = null;
        PrintWriter output = null;
        try {
            input = new Scanner(ifile);
            output = new PrintWriter(ofile);
            while (input.hasNextLine()) {
                output.println(input.nextLine().replaceAll(REMOVE, ADD));
            }
        } finally {
            if (input != null)
                input.close();
            if(output != null)
                output.close();
        }
    }
}

---

我首先要说的是：

不要担心过早优化性能。Java编译器是智能的，它会为您优化很多这方面的内容，即使它没有，您也会在极短的时间内进行优化。你要去那里的信息流已经运行了几个数量级，比你所说的时间长

最重要的是代码的易懂程度。从你的例子来看，你有一个很好的代码风格，所以继续保持下去。这两个代码段中，哪一个对您以外的人来说更容易阅读？这是最好的选择

也就是说，以下是对您的问题的一些更具体的回答：

垃圾收集绝对会拾取在循环范围内实例化的对象。它在循环中实例化的事实意味着一旦它超出范围，Java就已经将其标记为清理。下次GC运行时，它将清理所有标记为清理的内容

内联创建对象仍将创建对象。构造函数仍然被调用，内存仍然被分配。。。在引擎盖下，他们真的，真的很相似。只是在一种情况下，对象有一个名称，而在另一种情况下则没有。通过将两行代码组合成一行，您不会节省任何实际资源

“input.nextLine（）”已返回一个字符串，因此不需要将其包装为新字符串（）。（是的，删除它实际上会减少实例化一个对象！）

---

我首先要说的是：

不要担心过早优化性能。Java编译器是智能的，它会为您优化很多这方面的内容，即使它没有，您也会在极短的时间内进行优化。你要去那里的信息流已经运行了几个数量级，比你所说的时间长

最重要的是代码的易懂程度。从你的例子来看，你有一个很好的代码风格，所以继续保持下去。这两个代码段中，哪一个对您以外的人来说更容易阅读？这是最好的选择

也就是说，以下是对您的问题的一些更具体的回答：

垃圾收集绝对会拾取在循环范围内实例化的对象。它在循环中实例化的事实意味着一旦它超出范围，Java就已经将其标记为清理。下次GC运行时，它将清理所有标记为清理的内容

内联创建对象仍将创建对象。构造函数仍然被调用，内存仍然被分配。。。在引擎盖下，他们真的，真的很相似。只是在一种情况下，对象有一个名称，而在另一种情况下则没有。通过将两行代码组合成一行，您不会节省任何实际资源

“input.nextLine（）”已返回一个字符串，因此不需要将其包装为新字符串（）。（是的，删除它实际上会减少实例化一个对象！）

---

如果您关心obejct的创建和性能，请使用探查器测量代码。请记住，执行

newstring（input.nextLine（））

是毫无意义的，因为

input.nextLine（）

返回一个不可变的字符串实例。所以只需执行

output.println（input.nextLine（）.replaceAll（REMOVE，ADD））
如果您关心obejct的创建和性能，请使用探查器测量代码。请记住，执行
newstring（input.nextLine（））
是毫无意义的，因为
input.nextLine（）
返回一个不可变的字符串实例。所以只需执行
output.println（input.nextLine