public void keyPresssd(KeyEvent e)
{
         switch (e.getKeyCode())
         {
               case KeyEvent.VK_ESCAPE:
                      keyboard[KEY_ESC] = true;
               case KeyEvent.VK_ENTER:
                      keyboard[KEY_ENTER] = true;
               ...
          }
}

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.HashSet;


public class PixelPerfect extends JFrame implements KeyListener, Runnable {

   int x = 0, y = 0, xVel = 0, yVel = 0;
   HashSet<String> maskPlayer1, maskPlayer2;
   JPanel panel = new JPanel();
   BufferedImage b1, b2;
   
   @Override
   public void keyPressed(KeyEvent arg0) {
      
      if(arg0.getKeyCode() == KeyEvent.VK_RIGHT) {
         xVel = 3;
      }
      if(arg0.getKeyCode() == KeyEvent.VK_LEFT) {
         xVel = -3;
      }
      if(arg0.getKeyCode() == KeyEvent.VK_DOWN) {
         yVel = 3;
      }
      if(arg0.getKeyCode() == KeyEvent.VK_UP) {
         yVel = -3;
      }
   }

   @Override
   public void keyReleased(KeyEvent arg0) {
      
      xVel = 0;
      yVel = 0;
   }

   @Override
   public void keyTyped(KeyEvent arg0) {
      
      
   }
   
   public void paint(Graphics g) {
      
      Graphics2D g2d = (Graphics2D)g;
      g2d.setColor(Color.white);
      g2d.fillRect(0,0,300,300);
      
      g2d.drawImage(b1.getSubimage(0, 0, 79, 77), x, y, 79, 77, null);
      g2d.drawImage(b2.getSubimage(0, 0, 67, 60), 200, 200, 67, 60, null);
   }


   public static void main(String[] args) {
      
      new Thread(new PixelPerfect()).start();
   }
   
   public PixelPerfect() {
      
            b1 = new BufferedImage(79, 77, BufferedImage.TYPE_INT_ARGB);
      b2 = new BufferedImage(67, 60, BufferedImage.TYPE_INT_ARGB);
         try {
            b1.createGraphics().drawImage(ImageIO.read(this.getClass().getResource("groudon.gif")),
                  0,0,79,77,null);
            b2.createGraphics().drawImage(ImageIO.read(this.getClass().getResource("squirrel.png")),
               0,0,67,60,null);
         } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
         }
         
         
         setSize(300, 300);
      add(panel);
      setVisible(true);
      
      addKeyListener(this);
      setFocusable(true);
   }

   @Override
   public void run() {
      
      try {
         while(true) {
            
            update();
            repaint();
            
            Thread.sleep(17);
            
         }
      } catch(Exception ex) {
         
      }
   }

   private void update() {
      
      x += xVel;
      y += yVel;
      
      if(checkCollision()) {

         x -= xVel;
         y -= yVel;
      }
   }

   private boolean checkCollision() {
      
      // This method detects to see if the images overlap at all. If they do, collision is possible
            int ax1 = x;
            int ay1 = y;
            int ax2 = x + 79;
            int ay2 = y + 77;
            int bx1 = 200;
            int by1 = 200;
            int bx2 = 267;
            int by2 = 260;
            
            /*if(by2 < ay1 || ay2 < by1 || bx2 < ax1 || ax2 < bx1)
            {
               return false; // Collision is impossible.
            }
            else // Collision is possible.
            {*/
               // get the masks for both images
               maskPlayer1 = getMask(b1);
               maskPlayer2 = getMask(b2);
            
               maskPlayer1.retainAll(maskPlayer2);  // Check to see if any pixels in maskPlayer2 are the same as those in maskPlayer1
               
               if(maskPlayer1.size() > 0){  // if so, than there exists at least one pixel that is the same in both images, thus
                  return true;
               }
               return false;   
            //}
   }

//returns a HashSet of strings that list all the pixels in an image that aren't transparent
   // the pixels contained in the HashSet follow the guideline of:
   // x,y where x is the absolute x position of the pixel and y is the absolute y position of the pixel
   public HashSet<String> getMask(BufferedImage img){
      
      String s = "";
      HashSet<String> mask = new HashSet<String>();
      BufferedImage image = img;

      int pixel, a;
      for(int i = 0; i < image.getWidth(); i++){ // for every (x,y) component in the given box, 
         for( int j = 0; j < image.getHeight(); j++){
      
            pixel = image.getRGB(i, j); // get the RGB value of the pixel
            a = (pixel >> 24) & 0xff;
      
            if(a != 0){  // if the alpha is not 0, it must be something other than transparent
               if(img == b1) {
                  s = (x + i) + "," + (y + j);
                  mask.add(s); // add the absolute x and absolute y coordinates
               }
               else {
                  s = (200 + i) + "," + (200 + j);
                  mask.add(s);
               }
            }
         }
      }
      
      return mask;  //return our set
   }

}

// returns a HashSet of strings that list all the pixels in an image that aren't transparent
   // the pixels contained in the HashSet follow the guideline of:
   // x,y where x is the absolute x position of the pixel and y is the absolute y position of the pixel
   public HashSet<String> getMask(GameObject go){
      
      HashSet<String> mask = new HashSet<String>();
      BufferedImage image = null;
      try {
         image = ImageIO.read(new File (go.getDefaultImageLocation()));
      } catch (IOException e) {
         System.out.println("error");
      }
      int pixel, a;
      for(int i = 0; i < image.getWidth(); i++){ // for every (x,y) component in the given box, 
         for( int j = 0; j < image.getHeight(); j++){
      
      pixel = image.getRGB(i, j); // get the RGB value of the pixel
      a= (pixel >> 24) & 0xff;
      
      if(a != 0){  // if the alpha is not 0, it must be something other than transparent
         mask.add((go.xPos+i)+","+(go.yPos- j)); // add the absolute x and absolute y coordinates to our set
      }
         }
      }
      
      return mask;  //return our set
      
   }

// Returns true if there is a collision between object a and object b   
   public boolean checkCollision(GameObject a, GameObject b){
      
      // This method detects to see if the images overlap at all. If they do, collision is possible
      int ax1 = a.getxPos();
      int ay1 = a.getyPos();
      int ax2 = ax1 + a.getWidth();
      int ay2 = ay1 + a.getHeight();
      int bx1 = b.getxPos();
      int by1 = b.getyPos();
      int bx2 = bx1 + b.getWidth();
      int by2 = by1 + b.getHeight();
      
      if(by2 < ay1 || ay2 < by1 || bx2 < ax1 || ax2 < bx1)
      {
         return false; // Collision is impossible.
      }
      else // Collision is possible.
      {
         // get the masks for both images
         HashSet<String> maskPlayer1 = getMask(player1);
         HashSet<String> maskPlayer2 = getMask(player2);
      
         maskPlayer1.retainAll(maskPlayer2);  // Check to see if any pixels in maskPlayer2 are the same as those in maskPlayer1
         
         if(maskPlayer1.size() > 0){  // if so, than there exists at least one pixel that is the same in both images, thus
            System.out.println("Collision" + count);//  collision has occurred.
            count++;
            return true;
            
            }
         }
         return false;   
      }

a= (pixel >> 24) & 0xff;