Comment puis-je obtenir une résolution d'écran en java?


136

Comment obtenir la résolution de l'écran (largeur x hauteur) en pixels?

J'utilise un JFrame et les méthodes java swing.


2
pouvez-vous fournir plus de détails sur ce que vous remettez en question. Une doublure peut conduire à des centaines de façons différentes.
Anil Vishnoi

7
Je suppose que vous ne vous souciez pas des configurations de plusieurs moniteurs. Il semble que de nombreux développeurs d'applications les ignorent. Tout le monde utilise plusieurs moniteurs là où je travaille, nous devons donc toujours y penser. Nous sondons tous les moniteurs et les configurons comme des objets d'écran afin de pouvoir les cibler lorsque nous ouvrons de nouvelles images. Si vous n'avez vraiment pas besoin de cette fonctionnalité, alors je suppose que vous avez posé une question aussi ouverte et accepté une réponse si rapidement.
Erick Robertson le

Réponses:


267

Vous pouvez obtenir la taille de l'écran avec la Toolkit.getScreenSize()méthode.

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

Sur une configuration multi-moniteurs, vous devez utiliser ceci:

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

Si vous souhaitez obtenir la résolution d'écran en DPI, vous devrez utiliser la getScreenResolution()méthode Toolkit.


Ressources :


4
Cela ne fonctionne pas pour moi. J'ai un moniteur 3840x2160, mais getScreenSizerenvoie 1920x1080.
ZhekaKozlov

15

Ce code énumère les périphériques graphiques sur le système (si plusieurs moniteurs sont installés), et vous pouvez utiliser ces informations pour déterminer l'affinité du moniteur ou le placement automatique (certains systèmes utilisent un petit moniteur latéral pour les affichages en temps réel pendant qu'une application est en cours d'exécution dans l'arrière-plan, et un tel moniteur peut être identifié par la taille, les couleurs de l'écran, etc.):

// 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
}


3

Il s'agit de la résolution de l'écran auquel le composant donné est actuellement attribué (quelque chose comme la plupart des parties de la fenêtre racine est visible sur cet écran).

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

Usage:

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

Si vous voulez respecter les barres d'outils, etc., vous devrez également calculer avec ceci:

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

3

Voici un code fonctionnel (Java 8) qui renvoie la position x du bord le plus à droite de l'écran le plus à droite. Si aucun écran n'est trouvé, il renvoie 0.

  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);

Voici des liens vers le JavaDoc.

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


2

Ces trois fonctions renvoient la taille de l'écran en Java. Ce code tient compte des configurations multi-moniteurs et des barres de tâches. Les fonctions incluses sont: getScreenInsets () , getScreenWorkingArea () et 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;
}

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

System.out.println(resolution);

1
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);

1

Voici un extrait de code que j'utilise souvent. Il renvoie toute la zone d'écran disponible (même sur les configurations multi-moniteurs) tout en conservant les positions natives du moniteur.

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);
}

Sur un ordinateur avec deux moniteurs Full HD, où celui de gauche est défini comme moniteur principal (dans les paramètres Windows), la fonction retourne

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

Sur la même configuration, mais avec le bon moniteur défini comme moniteur principal, la fonction renvoie

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

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

Bienvenue dans Stack Overflow! Bien que cet extrait de code puisse résoudre la question, inclure une explication aide vraiment à améliorer la qualité de votre message. N'oubliez pas que vous répondez à la question aux lecteurs à l'avenir, et que ces personnes pourraient ne pas connaître les raisons de votre suggestion de code. Essayez également de ne pas surcharger votre code avec des commentaires explicatifs, cela réduit la lisibilité du code et des explications!
kayess
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.