I know that both of these have been posted about and I apologize if I shouldn't post this but I'm just a bit confused. Recently I posted on a Java Forums topic about things you disliked about Java, I mentioned the Java2D bug that causes stuttering and someone said there was no Java2D bug. I am pretty positive I read about a Java2D bug here. I posted how I drew and they said drawing with a Canvas is bad (I believe ra4king suggested this to me?). So I guess my question is who should I believe >_< I'm all confused now. Is there a Java2D bug that causes slight stuttering? Is drawing on a Canvas better or worse then extending paintComponent() in a JComponent?

I don't know how you define stuttering, or what you are trying to do exactly. Java 2D has worked fine for me and works well for basic click and drag animation and simple sprite animation (smoke, twinkling stars) that I am doing in Hexara. And it manages this despite a high use of cpu for the sound effects.

The Full-Screen Exclusive Mode API is designed for more demanding graphics. A lot of the folks here use it and champion it and I have no reason to doubt either them or the documentation. If I felt I needed it for the immediate project, I wouldn't hesitate to dive in. You can read about it here:
http://download.oracle.com/javase/tutorial/extra/fullscreen/index.html

But with either path, there are lots of ways to go wrong and write less than optimal code. Maybe that's why some of the frameworks are so popular, as they both simplify away a many low-level complexities as well as greatly speed up development.

If you still have the stuttering problem, I suspect there are issues with the coding, not the API. At least for me, 98% of the time I start to suspect there's a bug in the system it turns out to be a mistake or misunderstanding on my part. But maybe you are programming at a superior level than I am. This would not be too difficult.

Whoever said drawing on Canvas is bad is either a troll or thinks he knows something that everyone else doesn't.
And the only major Java2D bug I'm aware of is the V-Sync not available in windowed mode problem.

How did you make your game loop?

Slick2D uses OpenGL, while Canvas uses Java2D, two completely different things.

Swing uses AWT. AWT is a windowing system, Swing is a GUI library that uses AWT, aka Graphics2D, to draw the widgets.
However, since passive rendering (aka calling redraw() and waiting for another thread to call paint()) is not recommended for games, Swing is not suitable for games.

And there is no point for JCanvas since JComponent is already there.

Try this game http://ra4king.is-a-geek.net/games/JDoodleJump
Do you see any screen tearing? Does it slow down/lag/stutter at any time?

@ra4king Nope I'm not noticing any tearing/stuttering or lag. It runs at a constant 59fps and looks good.

@Riven Oh. Thanks that seems to help.

I have it running at 60-61fps now and the cube moves 5px every update. At first it starts out fine no tearing/stuttering then after a little while it starts to tear/stutter. Could this be because my game loop has no way of catching up? Like skipping frames or something? My game loop is exactly the same as above, except for the change Riven pointed out on line 15.

@Mickelukas Yup, exactly 5px every update. Sure I can post the code, right now it's just moving a box.
[CODE]
public class MyCanvas extends Canvas implements Runnable
{
   private int cWidth, cHeight; // Canvas width and height
   private Thread animator = null; // Animation thread
   private BufferStrategy strategy = null;
   private volatile boolean running;
   private int reqFPS; // Requested FPS
   private long period; // Period between updates
   private long fpsTime; // Used to calculate current FPS
   private int fps; // Current fps
   private int frames; // Number of frames drawn

   private int x, y; // X, and Y cord. of th cube
   private final int cubeWidth = 25, cubeHeight = 25;
   private final int SPEED = 5; // Speed of the cube in pixels

   public MyCanvas(int width, int height, int fps)
   {
      cWidth = width;
      cHeight = height;
      x = (cWidth - cubeWidth) / 2;
      y = (cHeight - cubeHeight) / 2;
      reqFPS = fps;
      period = Math.round(1000000000.0 / (double) reqFPS);
      fps = frames = 0;
      fpsTime = 0l;
      setBackground(Color.black);
      setPreferredSize(new Dimension(cWidth, cHeight));
      setIgnoreRepaint(true);
      running = true;
   }

   public void start()
   {
      createBufferStrategy(2);
      strategy = getBufferStrategy();
      requestFocusInWindow();
      if(animator == null)
      {
         animator = new Thread(this);
         animator.start();
      }
   }

   public void updateGame()
   {
      // Check time
      long curr = System.nanoTime();
      if(curr - fpsTime >= 1000000000)
      {
         // Update FPS
         fps = frames;
         frames = 0;
         fpsTime = curr;
      }

      // Update cube location
      x += SPEED;
      if(x > cWidth)
         x = 0 - cubeWidth;
   }

   public void paintGame()
   {
      do
      {
         do
         {
            Graphics2D g = (Graphics2D) strategy.getDrawGraphics();
            // Clear the screen
            g.setColor(getBackground());
            g.fillRect(0, 0, cWidth, cHeight);

            // Draw the cube
            g.setColor(Color.white);
            g.fillRect(x, y, cubeWidth, cubeHeight);

            // Draw the FPS
            g.drawString("FPS: " + fps, 5, cHeight - 5);

            g.dispose();
         }while(strategy.contentsRestored());

         strategy.show();
      }while(strategy.contentsLost());
      frames++;
   }

   @Override
   public void run()
   {
      long start = fpsTime = System.nanoTime();

      while(running)
      {
         updateGame();
         paintGame();

         while((System.nanoTime() - start) < period)
            try
            {
               Thread.sleep(1);
            }catch(Exception e)
            {}
         start += period;
      }
      System.exit(0);
   }
}

/**
 * Creates a JFrame and adds an instance of MyCanvas to it.
 */
class MyCanvasTester
{
   public static void main(String args[])
   {
      SwingUtilities.invokeLater(new Runnable()
      {
         public void run()
         {
            createAndShowGUI();
         }
      });
   }

   public static void createAndShowGUI()
   {
      JFrame frame = new JFrame("Canvas Test");
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      MyCanvas canvas = (MyCanvas) frame.add(new MyCanvas(600, 600, 60));
      frame.setFocusable(false);
      frame.setIgnoreRepaint(true);
      frame.pack();
      frame.setVisible(true);
      canvas.start();
   }
}
[/CODE]

What's this line doing? ONE_SECOND is a second in nanoseconds right? Is FPS the FPS you want or the FPS you're getting?

EDIT: Out of curiosity, would it be any more efficient to declare the variables used in the while loop outside of it so that they aren't being created for every iteration of the loop, or does it not make a difference.

EDIT 2: Here is what I have so far. I was using Thread.sleep(1) but it was causing stuttering and I'm not getting that with Thread.yield(). I was also getting 59 fps with Thread.sleep(1) and I'm getting 60 fps (which is what I request) with Thread.yield(). I think my loop now does what you are talking about. Any improvements to make?

Variables are not 'created', they simply use space on the stack-frame. It's much faster than accessing instance fields, as they add a level of indirection.

You're leaking time again. Just keep in mind that the only way you're ever allowed to 'bump time' is not by assigning 'now' but by adding a constant to the previous timestamp.

ONE_SECOND = 1e9
And FPS is the number of frames I want per second.

How is he leaking time?