How to draw png images to the screen efficiently?

Hello everyone, sorry if this question sounds too nooby, but how would you draw png images in the game without it lagging. I tried to use drawImage, but it caused HUGE lag when number of pctures increased.

This is my code skeleton here

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236

package attempt1;

import java.awt.Canvas;
import java.awt.Dimension;
import java.awt.DisplayMode;
import java.awt.Graphics2D;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Rectangle;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.image.BufferStrategy;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class Main implements Runnable
{
   private int WIDTH = 1000;
   private int HEIGHT = 500;
   private long desiredFPS = 60;
   
   private String title = "Maple Story";
   
   private long desiredDeltaLoop = (1000*1000*1000)/desiredFPS;
   private boolean running = true;
   
   private JFrame frame;
   private Canvas canvas;
   private BufferStrategy bufferStrategy;
   
   private GraphicsDevice graphicsDevice;
   private DisplayMode originalDisplayMode;
   
   public Main()
   {
      GraphicsEnvironment graphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
      graphicsDevice = graphicsEnvironment.getDefaultScreenDevice();
      originalDisplayMode = graphicsDevice.getDisplayMode();
      
      // create new Frame
      frame = new JFrame(title);
      frame.setUndecorated(true);

      graphicsDevice.setFullScreenWindow(frame);
      if (graphicsDevice.isDisplayChangeSupported())
      {
         graphicsDevice.setDisplayMode(getBestDisplayMode(graphicsDevice));
      }
      
      Rectangle bounds = frame.getBounds();
      WIDTH = (int)bounds.getWidth();
      HEIGHT = (int)bounds.getHeight();      
      
      // create new JPanel with specified width and height
      JPanel panel = (JPanel) frame.getContentPane();
      panel.setPreferredSize(new Dimension(WIDTH, HEIGHT));
      panel.setLayout(null);
      // create a canvas inside the JPanel with specified width and height
      canvas = new Canvas();
      //canvas.setBounds(0, 0, WIDTH, HEIGHT);
      canvas.setBounds(bounds);
      canvas.setIgnoreRepaint(true);
      
      panel.add(canvas);
      // Add Mouse and Key Listeners
      canvas.addMouseListener(new MouseControl());
      canvas.addKeyListener(new KeyInputHandler());
      // initialize the window
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.pack();
      frame.setResizable(false);
      frame.setVisible(true);
      
      setup();
      // set graphics device
      canvas.createBufferStrategy(2);
      bufferStrategy = canvas.getBufferStrategy();
      // focus on the window
      canvas.requestFocus();
   }
   /*
    * Main game loop
    */
   public void run()
   {
      long beginLoopTime;
      long endLoopTime;
      long currentUpdateTime = System.nanoTime();
      long lastUpdateTime;
      long deltaLoop;
      
      while(running)
      {
         beginLoopTime = System.nanoTime();
         
         render();
         
         lastUpdateTime = currentUpdateTime;
         currentUpdateTime = System.nanoTime();
         update((int) ((currentUpdateTime - lastUpdateTime)/(1000*1000)));
         
         endLoopTime = System.nanoTime();
         deltaLoop = endLoopTime - beginLoopTime;
           
           if(deltaLoop > desiredDeltaLoop)
           {
               //Do nothing. We are already late.
           }
           else
           {
               try
               {
                   Thread.sleep((desiredDeltaLoop - deltaLoop)/(1000*1000));
               }
               catch(InterruptedException e)
               {
                   //Do nothing
               }
           }
      }
   }
   /*
    * Method to initialise graphics that are going to be painted to the screen
    */
   private void render()
   {
      Graphics2D g = (Graphics2D) bufferStrategy.getDrawGraphics();
      g.clearRect(0, 0, WIDTH, HEIGHT);
      render(g);
      g.dispose();
      bufferStrategy.show();
   }
   /*
    * Initialise all of your Objects in here
    */
   public void setup()
   {
      
   }
   /*
    * Method that handles all the movements that are supposed to happen
    * So initialise all the x and y changes here
    * deltaTime tells you how many nanoseconds have passed by since this function
    * was last called
    */
   protected void update(int deltaTime)
   {
      
   }
   /*
    * Method where you paint to the screen
    */
   protected void render(Graphics2D g)
   {
      /*
       * START PAINTING
       * START PAINTING
       * START PAINTING
       * START PAINTING
       * START PAINTING
       * START PAINTING
       */

      
      
      /*
         * STOP PAINTING
         * STOP PAINTING
         * STOP PAINTING
         * STOP PAINTING
         * STOP PAINTING
         * STOP PAINTING
         */
   }
   /*
    * Keyboard Action listeners
    * Key esc closes the program by default
    */
   private class KeyInputHandler extends KeyAdapter
   {
      public void keyPressed(KeyEvent e)
      {
         if(e.getKeyCode()==27)
           {
            graphicsDevice.setDisplayMode(originalDisplayMode);
            graphicsDevice.setFullScreenWindow(null);
              System.exit(0);
           }
      }
      
      public void keyReleased(KeyEvent e)
      {
         
      }
   }
   /*
    * Mouse Action Listeners
    */
   private class MouseControl extends MouseAdapter
   {
      
   }
   /*
    * public static void main
    * I do not even have to explain this
    */
   public static void main(String [] args)
   {
      Main ex = new Main();
      new Thread(ex).start();
   }
   
   private static DisplayMode MODES[] = new DisplayMode[]
   {
      new DisplayMode(640, 480, 32, 0), new DisplayMode(640, 480, 16, 0),
       new DisplayMode(640, 480, 8, 0)
   };

   private static DisplayMode getBestDisplayMode(GraphicsDevice device)
   {
      for (int x = 0, xn = MODES.length; x < xn; x++)
      {
         DisplayMode[] modes = device.getDisplayModes();
         for (int i = 0, in = modes.length; i < in; i++)
         {
            if (modes[i].getWidth() == MODES[x].getWidth() && modes[i].getHeight() == MODES[x].getHeight() && modes[i].getBitDepth() == MODES[x].getBitDepth())
            {
               return MODES[x];
            }
         }
      }
      return null;
   }
}

So what would you suggest I use to draw png images?
I heard that BufferedImage is good, but I have failed miserably at using it, because it does not seem to have same properties as Image, especially when it comes to getWidht and getHeight commands.
Thanks to everyone for help in advance ^^