使用push和pop的堆棧

Question

目前我正在編寫一個接收堆棧的方法，並且必須通過該堆棧並將所有偶數添加到新堆棧，然後返回新堆棧。例如，如果堆棧包含1,3,4,5,7,8,10 ...，則新堆棧在添加後只包含4,8,10。到目前爲止，這是我的代碼，但似乎無法讓他們通過。提前致謝！

public class StackExample { 
public static Stack<Integer> getEvenNumbers(Stack<Integer> stack) { 
Stack<Integer> a = stack; 
Stack<Integer> c = new Stack<Integer>(); 
System.out.println(length(stack)); 
if(length(stack)==1) 
{ 
    return stack; 
} 
while (!(a.isEmpty())) { 
    int num = a.pop(); 
    if (num % 2 == 0) { 
     c.push(num); 
    } else { 

    } 
} 
System.out.println(c.isEmpty()); 
return c; 
} 

下面是測試：

if(length(stack)==1) 
{ 
    return stack; 
} 

要麼放棄這種優化或檢查它是否包含連元：

import static org.junit.Assert.*; 

import java.lang.reflect.Field; 

import org.junit.Test; 

public class StackExampleTest { 
private class StackTest extends Stack<Integer> { 
    public StackTest(int[] values) { 
     for (int i = values.length-1; i > -1; i--) { 
      push(values[ i ]); 
     } 
    } 
} 
@Test 
public void testReflection() { 
    Class<?> iClass = StackExample.class; 
    Field[] iFields = iClass.getDeclaredFields(); 

    for (Field f : iFields) { 
     if (!f.isSynthetic()) { 
      fail("Class shouldn't have any fields [found: \""+f.getName()+"\"]"); 
     } 
    } 
} 
@Test 
public void testEmpty() { 
    int[]   input = new int[]{ }; 
    Stack<Integer> stack = new StackTest(input); 
    Stack<Integer> result = StackExample.getEvenNumbers(stack); 

    assertTrue("result should be empty", result.isEmpty()); 
    assertTrue("stack should be empty", stack .isEmpty()); 
    assertTrue("stack and result cannot be the same object", stack != result); 
} 
@Test 
public void test1Odd() { 
    int[]   input = new int[]{ 5 }; 
    Stack<Integer> stack = new StackTest(input); 
    Stack<Integer> result = StackExample.getEvenNumbers(stack); 

    assertTrue("result should be empty", result.isEmpty()); 

    for (int expected : input) { 
     if (stack.isEmpty()) 
      fail("\"stack\" empty: '"+ expected +"' expected"); 
     else { 
      int actual = stack.pop(); 
      assertEquals("incorrect result", expected, actual); 
     } 
    } 
    assertTrue("stack and result cannot be the same object", stack != result); 
} 
@Test 
public void test1Even() { 
    int[]   input = new int[]{ 4 }; 
    Stack<Integer> stack = new StackTest(input); 
    Stack<Integer> result = StackExample.getEvenNumbers(stack); 

    for (int expected : new int[]{ 4 }) { 
     if (result.isEmpty()) 
      fail("\"result\" empty: '"+ expected +"' expected"); 
     else { 
      int actual = result.pop(); 
      assertEquals("incorrect result", expected, actual); 
     } 
    } 
    for (int expected : input) { 
     if (stack.isEmpty()) 
      fail("\"stack\" empty: '"+ expected +"' expected"); 
     else { 
      int actual = stack.pop(); 
      assertEquals("incorrect result", expected, actual); 
     } 
    } 
    assertTrue("stack and result cannot be the same object", stack != result); 
} 
@Test 
public void testNoneEven() { 
    int[]   input = new int[]{ 9, 77, 3, 5, 11 }; 
    Stack<Integer> stack = new StackTest(input); 
    Stack<Integer> result = StackExample.getEvenNumbers(stack); 

    assertTrue("result should be empty", result.isEmpty()); 

    for (int expected : input) { 
     if (stack.isEmpty()) 
      fail("\"stack\" empty: '"+ expected +"' expected"); 
     else { 
      int actual = stack.pop(); 
      assertEquals("incorrect result", expected, actual); 
     } 
    } 
    assertTrue("stack and result cannot be the same object", stack != result); 
} 
@Test 
public void testSomeEven() { 
    int[]   input = new int[]{ 44, 77, 8, 3, 5, 12 }; 
    Stack<Integer> stack = new StackTest(input); 
    Stack<Integer> result = StackExample.getEvenNumbers(stack); 

    for (int expected : new int[]{ 44, 8, 12 }) { 
     if (result.isEmpty()) 
      fail("\"result\" empty: '"+ expected +"' expected"); 
     else { 
      int actual = result.pop(); 
      assertEquals("incorrect result", expected, actual); 
     } 
    } 
    for (int expected : input) { 
     if (stack.isEmpty()) 
      fail("\"stack\" empty: '"+ expected +"' expected"); 
     else { 
      int actual = stack.pop(); 
      assertEquals("incorrect result", expected, actual); 
     } 
    } 
    assertTrue("stack and result cannot be the same object", stack != result); 
} 
@Test 
public void testAllEven() { 
    int[]   input = new int[]{ 12, 22, 6, 14, 12 }; 
    Stack<Integer> stack = new StackTest(input); 
    Stack<Integer> result = StackExample.getEvenNumbers(stack); 

    for (int expected : input) { 
     if (result.isEmpty()) 
      fail("\"result\" empty: '"+ expected +"' expected"); 
     else { 
      int actual = result.pop(); 
      assertEquals("incorrect result", expected, actual); 
     } 
    } 
    for (int expected : input) { 
     if (stack.isEmpty()) 
      fail("\"stack\" empty: '"+ expected +"' expected"); 
     else { 
      int actual = stack.pop(); 
      assertEquals("incorrect result", expected, actual); 
     } 
    } 
    assertTrue("stack and result cannot be the same object", stack != result); 
} 
} 

Answer 1

如果堆棧包含奇數這將失敗test1Odd 。