创建自定义方法以在Java中缓慢打印文本

我正在尝试用Java创建一个方法，该方法将接受一个字符串慢慢打印出来。我找到了在here（）上执行慢速打印的代码，并一直试图从中生成一个方法，但我对Java还是非常陌生。这是我的密码

public class propago
{
    public static void main(String[] args)
    {
        String strMessage;  
        strMessage = "Testing 1 2 3";
        slowPrint(strMessage);
    }//end main(String[])

    public static void slowPrint(String[] args) throws InterruptedException
    {
        char[] chars = strMessage.toCharArrray();

        for (int i = 0; i < chars.length; i++)
        {
            System.out.print(chars[i]);
            Thread.sleep(100);
        }
    }//end slowPrint(String[])
}//end propago

在应用建议的更改（希望正确）后，不兼容类型错误得到解决，但我仍然收到以下错误

propago.java:10: error: cannot find symbol
                char[] chars = strMessage.toCharArray();
                               ^
  symbol:   variable strMessage
  location: class propago
1 error

这是我当前的代码和所做的更改

public class propago
{
    public static void main(String[] args)
    {
        String strMessage;  
        strMessage = "Testing 1 2 3";
        slowPrint(strMessage);
    }//end main(String[])

    public static void slowPrint(String args)
    {
        char[] chars = strMessage.toCharArray();

        for (int i = 0; i < chars.length; i++)
        {
            System.out.print(chars[i]);
            try {
            Thread.sleep(100);
            } catch (InterruptedException e){
                //Should not happen
            }
        }
    }//end slowPrint(String[])
}//end propago

公共类propago
{
公共静态void main（字符串[]args）
{
字符串消息；
strMessage=“测试1 2 3”；
慢打印（strMessage）；
}//末端干管（字符串[]）
公共静态void slowPrint（字符串参数）
{
char[]chars=strMessage.toCharArray（）；
for（int i=0；i

您应该纠正以下问题：

• slowPrint

  方法应采用

  String

  而不是

  String[]

• 在

  slowPrint

  方法中使用

  args

  参数
• 方法

  tochararray

  无效。改为

  tocharray

• 调用

  slowPrint

  方法时捕获

  InterruptedException

  异常

---

您的问题是

slowPrint

接受

字符串

数组，并可能引发未经检查的异常，即

InterruptedException

要解决

String

数组的问题，只需将方法更改为获取

String

，而不是

String[]

在您的代码中，没有理由相信有人会中断您的代码（仅在多线程代码中发生），因此您可以通过捕获异常来忽略它：

try {
    Thread.sleep(100);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    return;
}

然后从声明

slowPrint

中删除

throws InterruptedException

，尝试以下操作：

public class propago
{
    public static void main(String[] args)
    {
        String strMessage;  
        strMessage = "Testing 1 2 3";
        slowPrint(strMessage);
    }//end main(String[])

    public static void slowPrint()
    {
        char[] chars = this.strMessage.toCharArray();

        for (int i = 0; i < chars.length; i++)
        {
            System.out.print(chars[i]);
            try {
            Thread.sleep(100);
            } catch (InterruptedException e){
                //Should not happen
            }
        }
    }//end slowPrint(String[])
}//end propago

公共类propago
{
公共静态void main（字符串[]args）
{
字符串消息；
strMessage=“测试1 2 3”；
慢打印（strMessage）；
}//末端干管（字符串[]）
公共静态void slowPrint（）
{
char[]chars=this.strMessage.toCharArray（）；
for（int i=0；i

这有点超出了所需的答案，但我想定义我将如何处理它：为您的呼叫提供线程安全的接收器。这样就可以在另一个线程中以适当的延迟将消息排队：

public class MyLogger {

    private final Logger logger; //some logger
    private final Deque<String> out = new ArrayDeque();
    private final long msgDelayMS; //how long of a time must exist between messages

    public MyLogger(long msgDelayMS) {
        this.msgDelayMS = msgDelayMS;
    }

    public void log(String simpleString) {
        //Use a ReadWriteLock on `out` or somesuch to synchronize the data safely
        this.out.add(simpleString);
    }

    public ScheduledFuture<?> start(ScheduledExecutorService executor) {
        return executor.scheduleAtFixedRate(this::printNext, 0, this.msgDelayMS, TimeUnit.MILLISECONDS);
    }

    private void printNext() {
        //again, synchronize with a `lock` field or somesuch
        String next = this.out.poll();
        if (next == null) {
            return;
        }
        System.out.println(next); //prints however we like our valid queue'd item
    }
}

---

这将日志的“执行”与实际的程序逻辑分开。因此，如果您在特定时间内记录了30条消息，则可能会记录过去30秒内发生的事情。但它确实使您的日志记录无阻塞，从这个意义上说，您不必等待它成为适当的打印时间，您只需将它放在一边，让另一个线程处理即可。我想这个答案是为了吸引一点编程精神，也是因为我当时脑子里也在想一个类似的想法。

问题出在哪里？它有用吗？如果运行它，是否会显示一些错误？如果编译它，它会显示错误吗？请回答您的问题，以添加有关错误的详细信息。如果你能说明什么是错的，这会有很大帮助。我知道我忘了在我的问题中添加一些东西，谢谢你为什么要接受字符串数组作为单个字符串使用？从

slowPrint（String[]args）

中删除那些

[]

。

slowPrint

的参数命名为

args

而不是

strMessage

。这些是独立的变量，它们属于不同的代码块。相关（我不会将其标记为重复，因为我不确定您是否想知道错误背后的原因或只是得到有效的解决方案）：非常感谢您的澄清，本学期我刚开始在我的大学学习Java，我假设就我们目前所涉及的内容而言，我们不需要担心使用“String”和“String[]”之间的区别。现在我只有以下错误：``propago.java:10:error:找不到symbol char[]chars=strMessage.ToCharray（）；^symbol:variable strMessage location:class propago``请参见列表中的第二项，您正在尝试使用

strMessage

，它未在

slowPrint

范围中的任何位置声明。将其更改为

args

，这是您传递给此方法的参数。噢！谢谢你，我甚至没想过把“strMessage.toCharArray（）”改成“args.toCharArray（）”。它现在工作得很好！建议

catch（InterruptedException e）{Thread.currentThread（）.interrupt（）；break；}

public class MyLogger {

    private final Logger logger; //some logger
    private final Deque<String> out = new ArrayDeque();
    private final long msgDelayMS; //how long of a time must exist between messages

    public MyLogger(long msgDelayMS) {
        this.msgDelayMS = msgDelayMS;
    }

    public void log(String simpleString) {
        //Use a ReadWriteLock on `out` or somesuch to synchronize the data safely
        this.out.add(simpleString);
    }

    public ScheduledFuture<?> start(ScheduledExecutorService executor) {
        return executor.scheduleAtFixedRate(this::printNext, 0, this.msgDelayMS, TimeUnit.MILLISECONDS);
    }

    private void printNext() {
        //again, synchronize with a `lock` field or somesuch
        String next = this.out.poll();
        if (next == null) {
            return;
        }
        System.out.println(next); //prints however we like our valid queue'd item
    }
}

MyLogger logger = new MyLogger(1000L); //1000ms delay == 1 second
logger.start(Executors.newSingleThreadScheduledExecutor()); //should keep the executor somewhere
//elsewheres, from any thread, without having to keep track of time or sleep the thread
logger.log("Hello world!");