Robot robot = new Robot();
BufferedImage image = robot.createScreenCapture(new Rectangle( 15, 15, 150, 150));

Robot robot = new Robot();
BufferedImage image = robot.createScreenCapture(
         new Rectangle(java.awt.Toolkit.getDefaultToolkit().getScreenSize()) );

Robot robot = new Robot();
BufferedImage image = robot.createScreenCapture(
        new Rectangle( frame.getX(), frame.getY(), frame.getWidth(), frame.getHeight() )
        );

Image java.applet.Applet.getImage(URL url);
Image java.applet.Applet.getImage(URL url, String name);

/** Accès au toolkit : */
java.awt.Toolkit toolkit = java.awt.Toolkit.getDefaultToolkit();
/** lecture de l'image : */
Image image = toolkit.getImage("fichier");
Image image = toolkit.getImage(url);

java.net.URL url = getClass().getResource("chemin/nom.gif");

import javax.imageio.*; 
public class FormatsImages{
public static boolean canRead(String format){
   boolean type = ImageIO.getImageReadersByFormatName(format).hasNext();
   boolean mime = ImageIO.getImageReadersByMIMEType(format).hasNext();
   boolean suffixe = ImageIO.getImageReadersBySuffix(format).hasNext();
   String infos = "Informations lecture "+format+" : ";
   infos+="Format image = "+type+", ";
   infos+="MIME = "+mime+", ";
   infos+="Suffixe fichier = "+suffixe;
   System.out.println(infos);
   return type||mime||suffixe;
}
public static boolean canWrite(String format){
   boolean type = ImageIO.getImageWritersByFormatName(format).hasNext();
   boolean mime = ImageIO.getImageWritersByMIMEType(format).hasNext();
   boolean suffixe = ImageIO.getImageWritersBySuffix(format).hasNext();
   String infos = "Informations écriture "+format+" : ";
   infos+="Format image = "+type+", ";
   infos+="MIME = "+mime+", ";
   infos+="Suffixe fichier = "+suffixe;
   System.out.println(infos);
   return type||mime||suffixe;
}
}

canRead("gif");
canRead("jpg");
canRead("bmp");
canRead("image/jpeg");
//quelques vérifications sur les possibilités de lecture
canWrite("gif");
canWrite("jpg");
canWrite("bmp");
canWrite("image/jpeg");
//quelques vérifications sur les possibilités d'écriture

String[] formatsLecture = ImageIO.getReaderFormatNames();  
String[] formatsEcriture = ImageIO.getWriterFormatNames();
//affichage des formats d'images lisibles
System.out.println("Formats d'images disponibles en lecture");
for(int i=0;i<formatsLecture.length;i++){
   System.out.println(formatsLecture[i]);
}  
System.out.println("Formats d'images disponibles en écriture");
for(int i=0;i<formatsEcriture.length;i++){
   System.out.println(formatsEcriture[i]);
}

public class MonPanel extends JComponent {
        
        /** variable de classe contenant l'image à afficher en fond */
        private Image bg;
        
        /** Surcharge de la fonction paintComponent() pour afficher notre image */
         public void paintComponent(Graphics g) {
                g.drawImage(bg,0,0,null);
        } 
}

public class MonPanel {
        
        /** variable de classe contenant l'image à afficher en fond */
        private Image bg;
        
        /** Surcharge de la fonction paint() pour afficher notre image */
         public void paint(Graphics g) {
                g.drawImage(bg,0,0,null);
        } 
}

BufferedImage toBufferedImage(Image image) {
        /** On test si l'image n'est pas déja une instance de BufferedImage */
        if( image instanceof BufferedImage ) {
                /** cool, rien à faire */
                return( (BufferedImage)image );
        } else {
                /** On s'assure que l'image est complètement chargée */
                image = new ImageIcon(image).getImage();
                
                /** On crée la nouvelle image */
                BufferedImage bufferedImage = new BufferedImage(
                                                      image.getWidth(null),
                                                      image.getHeight(null),
                                                      BufferedImage.TYPE_INT_RGB );
                Graphics g = bufferedImage.createGraphics();
                g.drawImage(image,0,0,null);
                g.dispose();
                
                return( bufferedImage );
        } 
}

//on crée auparavant une BufferedImage
Image monImage = Toolkit.getDefaultToolkit().createImage(maBufferedImage.getSource());

ColorConvertOp op = new ColorConvertOp(
                                             ColorSpace.getInstance(ColorSpace.CS_GRAY),
                                             null);
BufferedImage imageGrise = op.filter(bufferedImage,null);

float[ ] matrice = {
        0.1, 0.1, 0.1,
        0.1, 0.2, 0.1,
        0.1, 0.1, 0.1
        };
BufferedImageOp op = new ConvolveOp(new Kernel(3,3,matrice));
BufferedImage nouvelleImage = op.filter(bufferedImage, null);

/** Création d'une nouvelle image */
BufferedImage nouvelleImage = new BufferedImage(
                                          imageSource.getWidth(),
                                          imageSource.getHeight(),
                                          imageSource.getType());
Graphics2D g2d = nouvelleImage.createGraphics();
/** préparation de la transformation */
AffineTransform at = new AffineTransform();
at.rotate(angle,x,y);

g2d.drawImage(imageSource,at,null);
g2d.dispose();

/** Lecture d'un seul pixel : */
int rgb = bufferedImage.getRGB(x,y);

/** Lecture de tous les pixels : */
int w = bufferedImage.getWidth();
int h = bufferedImage.getHeight();
int[] rgbs = new int[w*h]; /** on crée l'espace neccessaire */
bufferedImage.getRGB(0,0,w,h,rgbs,0,w);

/** Ecriture d'un seul pixel : */
bufferedImage.setRGB(x,y,rgb);

/** Ecriture de tous les pixels : */
int w = bufferedImage.getWidth();
int h = bufferedImage.getHeight();
int[] rgbs = new int[w*h];
bufferedImage.setRGB(0,0,w,h,rgbs,0,w);

/** Lecture manuelle des composantes : */
int rgb = bufferedImage.getRGB(x,y);
int alpha = (rgb >>24 ) & 0xFF;
int rouge = (rgb >>16 ) & 0xFF;
int vert = (rgb >> 8 ) & 0xFF;
int bleu = rgb & 0xFF;

/** Construction d'un pixel : */
int rgb = (alpha<<24)+(rouge<<16)+(vert<<8)+bleu;
/** Les composantes doivent obligatoirement être comprises dans l'intervalle 0-255 */

/** Effectue une homothétie de l'image.
 * 
 * @param bi l'image.
 * @param scaleValue la valeur de l'homothétie.
 * @return une image réduite ou agrandie.
 * 
 */public static BufferedImage scale(BufferedImage bi, double scaleValue) {
        AffineTransform tx = new AffineTransform();
        tx.scale(scaleValue, scaleValue);
        AffineTransformOp op = new AffineTransformOp(tx,
                AffineTransformOp.TYPE_BILINEAR);
        BufferedImage biNew = new BufferedImage( (int) (bi.getWidth() * scaleValue),
                (int) (bi.getHeight() * scaleValue),
                bi.getType());
        return op.filter(bi, biNew);
                
}

Image icone = Toolkit.getDefaultToolkit().getImage("./monImage.jpg");
maFenetre.setIconImage(icone);

public Image getImage(Component component){
   if(component==null){return null;}
   int width = component.getWidth();
   int height = component.getHeight();
   BufferedImage image = new BufferedImage(width, height, 
                                             BufferedImage.TYPE_INT_RGB);
   Graphics2D g = image.createGraphics();
   component.paintAll(g);
   g.dispose();
   return image;
}

public boolean alphaLayer(Image image){
   ColorModel modele = null; 
   if(image instanceof BufferedImage){
      // si on a affaire à une BufferedImage on regarde son ColorModel
      BufferedImage bi = (BufferedImage)image;
      modele = bi.getColorModel(); 
   }else {
     // on traite l'image pixel par pixel afin de récuperer un ColorModel
      PixelGrabber pg = new PixelGrabber(image, 0, 0, 1, 1, false); 
      try{
       // on découpe donc l'image pixel par pixel
         pg.grabPixels(); 
      }catch (InterruptedException e) {
         e.printStackTrace();
      } 
      modele = pg.getColorModel();
   }
   return modele.hasAlpha(); 
}

// on crée auparavant la BufferedImage avec le nom bi

Graphics2D g2d = bi.createGraphics(); // on récupère le contexte graphique de la BufferedImage   
g2d.setColor( Color.red ); // on met l'état de couleur rouge à la BufferedImage
g2d.fillOval( 30, 30, 100, 100 ); // on dessine un cercle de centre x=30 y=30 et de rayon=100
g2d.dispose(); //on libère la mémoire utilisée pour le contexte graphique