Wie kann ich die Bildschirmauflösung in Java erhalten?

Wie kann man die Bildschirmauflösung (Breite x Höhe) in Pixel erhalten?

Ich benutze einen JFrame und die Java-Swing-Methoden.

Sie können die Bildschirmgröße mit der Toolkit.getScreenSize()Methode erhalten.

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
double width = screenSize.getWidth();
double height = screenSize.getHeight();

Bei einer Konfiguration mit mehreren Monitoren sollten Sie Folgendes verwenden:

GraphicsDevice gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
int width = gd.getDisplayMode().getWidth();
int height = gd.getDisplayMode().getHeight();

Wenn Sie die Bildschirmauflösung in DPI erhalten möchten, müssen Sie die getScreenResolution()Methode aktivieren Toolkit.

Ressourcen:

• javadoc - Toolkit.getScreenSize ()
• Java-Fehler 5100801- Toolkit.getScreenSize () gibt unter Multimon Linux nicht die richtige Dimension zurück

Dieser Code listet die Grafikgeräte auf dem System auf (wenn mehrere Monitore installiert sind), und Sie können diese Informationen verwenden, um die Monitoraffinität oder die automatische Platzierung zu bestimmen (einige Systeme verwenden einen kleinen Seitenmonitor für Echtzeitanzeigen, während eine App ausgeführt wird Der Hintergrund und ein solcher Monitor können anhand der Größe, der Bildschirmfarben usw. identifiziert werden.

// Test if each monitor will support my app's window
// Iterate through each monitor and see what size each is
GraphicsEnvironment ge      = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice[]    gs      = ge.getScreenDevices();
Dimension           mySize  = new Dimension(myWidth, myHeight);
Dimension           maxSize = new Dimension(minRequiredWidth, minRequiredHeight);
for (int i = 0; i < gs.length; i++)
{
    DisplayMode dm = gs[i].getDisplayMode();
    if (dm.getWidth() > maxSize.getWidth() && dm.getHeight() > maxSize.getHeight())
    {   // Update the max size found on this monitor
        maxSize.setSize(dm.getWidth(), dm.getHeight());
    }

    // Do test if it will work here
}

Dieser Anruf gibt Ihnen die gewünschten Informationen.

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

Dies ist die Auflösung des Bildschirms, dem die angegebene Komponente derzeit zugewiesen ist (so etwas wie der größte Teil des Stammfensters ist auf diesem Bildschirm sichtbar).

public Rectangle getCurrentScreenBounds(Component component) {
    return component.getGraphicsConfiguration().getBounds();
}

Verwendung:

Rectangle currentScreen = getCurrentScreenBounds(frameOrWhateverComponent);
int currentScreenWidth = currentScreen.width // current screen width
int currentScreenHeight = currentScreen.height // current screen height
// absolute coordinate of current screen > 0 if left of this screen are further screens
int xOfCurrentScreen = currentScreen.x

Wenn Sie Symbolleisten usw. respektieren möchten, müssen Sie auch damit rechnen:

GraphicsConfiguration gc = component.getGraphicsConfiguration();
Insets screenInsets = Toolkit.getDefaultToolkit().getScreenInsets(gc);

Hier ist ein Funktionscode (Java 8), der die x-Position am rechten Rand des Bildschirms ganz rechts zurückgibt. Wenn keine Bildschirme gefunden werden, wird 0 zurückgegeben.

  GraphicsDevice devices[];

  devices = GraphicsEnvironment.
     getLocalGraphicsEnvironment().
     getScreenDevices();

  return Stream.
     of(devices).
     map(GraphicsDevice::getDefaultConfiguration).
     map(GraphicsConfiguration::getBounds).
     mapToInt(bounds -> bounds.x + bounds.width).
     max().
     orElse(0);

Hier finden Sie Links zum JavaDoc.

GraphicsEnvironment.getLocalGraphicsEnvironment ()
GraphicsEnvironment.getScreenDevices ()
GraphicsDevice.getDefaultConfiguration ()
GraphicsConfiguration.getBounds ()

Diese drei Funktionen geben die Bildschirmgröße in Java zurück. Dieser Code berücksichtigt Multi-Monitor-Setups und Taskleisten. Die enthaltenen Funktionen sind: getScreenInsets () , getScreenWorkingArea () und getScreenTotalArea () .

Code:

/**
 * getScreenInsets, This returns the insets of the screen, which are defined by any task bars
 * that have been set up by the user. This function accounts for multi-monitor setups. If a
 * window is supplied, then the the monitor that contains the window will be used. If a window
 * is not supplied, then the primary monitor will be used.
 */
static public Insets getScreenInsets(Window windowOrNull) {
    Insets insets;
    if (windowOrNull == null) {
        insets = Toolkit.getDefaultToolkit().getScreenInsets(GraphicsEnvironment
                .getLocalGraphicsEnvironment().getDefaultScreenDevice()
                .getDefaultConfiguration());
    } else {
        insets = windowOrNull.getToolkit().getScreenInsets(
                windowOrNull.getGraphicsConfiguration());
    }
    return insets;
}

/**
 * getScreenWorkingArea, This returns the working area of the screen. (The working area excludes
 * any task bars.) This function accounts for multi-monitor setups. If a window is supplied,
 * then the the monitor that contains the window will be used. If a window is not supplied, then
 * the primary monitor will be used.
 */
static public Rectangle getScreenWorkingArea(Window windowOrNull) {
    Insets insets;
    Rectangle bounds;
    if (windowOrNull == null) {
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        insets = Toolkit.getDefaultToolkit().getScreenInsets(ge.getDefaultScreenDevice()
                .getDefaultConfiguration());
        bounds = ge.getDefaultScreenDevice().getDefaultConfiguration().getBounds();
    } else {
        GraphicsConfiguration gc = windowOrNull.getGraphicsConfiguration();
        insets = windowOrNull.getToolkit().getScreenInsets(gc);
        bounds = gc.getBounds();
    }
    bounds.x += insets.left;
    bounds.y += insets.top;
    bounds.width -= (insets.left + insets.right);
    bounds.height -= (insets.top + insets.bottom);
    return bounds;
}

/**
 * getScreenTotalArea, This returns the total area of the screen. (The total area includes any
 * task bars.) This function accounts for multi-monitor setups. If a window is supplied, then
 * the the monitor that contains the window will be used. If a window is not supplied, then the
 * primary monitor will be used.
 */
static public Rectangle getScreenTotalArea(Window windowOrNull) {
    Rectangle bounds;
    if (windowOrNull == null) {
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        bounds = ge.getDefaultScreenDevice().getDefaultConfiguration().getBounds();
    } else {
        GraphicsConfiguration gc = windowOrNull.getGraphicsConfiguration();
        bounds = gc.getBounds();
    }
    return bounds;
}

int resolution =Toolkit.getDefaultToolkit().getScreenResolution();

System.out.println(resolution);

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
double width = screenSize.getWidth();
double height = screenSize.getHeight();
framemain.setSize((int)width,(int)height);
framemain.setResizable(true);
framemain.setExtendedState(JFrame.MAXIMIZED_BOTH);

Hier ist ein Codeausschnitt, den ich oft benutze. Es gibt den gesamten verfügbaren Bildschirmbereich zurück (auch bei Setups mit mehreren Monitoren), wobei die nativen Monitorpositionen beibehalten werden.

public static Rectangle getMaximumScreenBounds() {
    int minx=0, miny=0, maxx=0, maxy=0;
    GraphicsEnvironment environment = GraphicsEnvironment.getLocalGraphicsEnvironment();
    for(GraphicsDevice device : environment.getScreenDevices()){
        Rectangle bounds = device.getDefaultConfiguration().getBounds();
        minx = Math.min(minx, bounds.x);
        miny = Math.min(miny, bounds.y);
        maxx = Math.max(maxx,  bounds.x+bounds.width);
        maxy = Math.max(maxy, bounds.y+bounds.height);
    }
    return new Rectangle(minx, miny, maxx-minx, maxy-miny);
}

Auf einem Computer mit zwei Full-HD-Monitoren, wobei der linke als Hauptmonitor festgelegt ist (in den Windows-Einstellungen), kehrt die Funktion zurück

java.awt.Rectangle[x=0,y=0,width=3840,height=1080]

Beim gleichen Setup, jedoch mit dem richtigen Monitor als Hauptmonitor, kehrt die Funktion zurück

java.awt.Rectangle[x=-1920,y=0,width=3840,height=1080]

int screenResolution = Toolkit.getDefaultToolkit().getScreenResolution();
System.out.println(""+screenResolution);