从字符堆栈构造String的有效且简洁的方法是什么？

Question

Suppose I have a stack -

O (stack top)
L
L
E
H (stack bottom)

What is the concise way to convert it to "HELLO"

Now I am doing this way -

private static String getString(Stack<Character> charStack) {
  StringBuilder output = new StringBuilder();

  while (!charStack.isEmpty()) {
      output.append(charStack.pop());    
  }

  return output.reverse().toString();
}

Answer 1

Using map and Collectors , one way of doing what the code in question intend would be:

return charStack.stream().map(Object::toString).collect(Collectors.joining());

Edit : As visible from comments (1) and (2) , if emptying the stack is an intentional action, you can update the code to include the behaviour as follows:

String output = charStack.stream().map(Object::toString).collect(Collectors.joining());
charStack.clear();
return output;

Answer 2

Note

I accidentally thought you are searching for a faster version . However I decided to leave the discussion here as it could be useful for future readers.

---

Analysis

You can not achieve a better version with the given input, at least when talking about complexity classes. Your Stack can only be traversed from last to first item, not in the correct order for a String .

You can not directly use the knowledge that your final String needs to be reversed first.

Let's take a look at your code, let's denote by n the size of your stack:

private static String getString(Stack<Character> charStack) {
    StringBuilder output = new StringBuilder();

    // Yields n iterations
    while (!charStack.isEmpty()) {
        output.append(charStack.pop());    
    }

    // reverse creates n iterations
    // toString creates n iterations
    return output.reverse().toString();
}

In total we have 3 * n iterations yielding O(n) .

---

Size known

If you know the size of the stack you could experiment with arrays ( Stack has no size method). The advantage of them is that they can be traversed and edited in any direction at no additional cost. Take a look at the following example:

int size = ...
char[] textChars = new char[size];

// Yields n iterations
for (int i = 0; i < size; i++) {
    // Reversely set the array
    // Setting is done in constant time
    textChars[size - i - 1] = charStack.pop();
}

// Convert the textChars to String
// without using reverse methods
// Yields n iterations
String text = String.valueOf(textChars);

In total we have 2 * n iterations, also yielding O(n) .

So it might indeed be slightly faster, provided you know the size . However the difference will not be that big, its O(n) too.

---

Size unknown

If you don't know the size you could exchange char[] with ArrayList<Character> ( LinkedList would also work, but could be slower):

ArrayList<Character> textChars = new ArrayList<>();

// Yields n iterations
for (char c : charStack) {
    // Set the ArrayList
    // Setting is done in constant time
    textChars.add(charStack.pop());
}

// Unfortunately there is no nice method
// to directly convert ArrayList to String
StringBuilder sb = new StringBuilder();

// Reversely iterate the ArrayList, the reverse
// direction comes at no additional cost
// Yields n iterations
for (int i = textChars.size() - 1; i >= 0; i--) {
    sb.append(textChars.get(i));
}

// Yields n iterations
String text = sb.toString();

Now we have about 3 * n iterations but with a bigger overhead due to ArrayList and Character . Without having made experiments I would say that your approach is better than any kind of this, if the size is unknown.

Answer 3

Note that charStack.pop() actually removes the elements from the stack - are you sure that it is intended?

You could do it like that without removing elements:

private static String getString(Stack<Character> charStack) {
    StringBuilder output = new StringBuilder();

    for (Character c : charStack) {
        output.append(c);    
    }

    return output.reverse().toString();
}