Come posso ottenere la risoluzione dello schermo in Java?


136

Come si ottiene la risoluzione dello schermo (larghezza x altezza) in pixel?

Sto usando un JFrame e i metodi swing java.


2
puoi fornire qualche dettaglio in più su ciò che ti interessa. Una fodera può portare a centinaia di modi diversi.
Anil Vishnoi,

7
Immagino che non ti interessi alle configurazioni di più monitor. Sembra che molti sviluppatori di applicazioni li ignorino. Tutti usano più monitor dove lavoro, quindi dobbiamo sempre pensarci. Esaminiamo tutti i monitor e li impostiamo come oggetti dello schermo in modo da poterli indirizzare quando apriamo nuovi frame. Se davvero non hai bisogno di questa funzionalità, allora penso che sia giusto che tu abbia fatto una domanda così aperta e abbia accettato una risposta così rapidamente.
Erick Robertson,

Risposte:


267

È possibile ottenere le dimensioni dello schermo con il Toolkit.getScreenSize()metodo.

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

Su una configurazione multi-monitor dovresti usare questo:

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

Se vuoi ottenere la risoluzione dello schermo in DPI dovrai usare il getScreenResolution()metodo su Toolkit.


Risorse:


4
Questo non funziona per me. Ho un monitor 3840x2160, ma getScreenSizerestituisce 1920x1080.
Zheka Kozlov

15

Questo codice enumera i dispositivi grafici sul sistema (se sono installati più monitor) e puoi utilizzare tali informazioni per determinare l'affinità del monitor o il posizionamento automatico (alcuni sistemi utilizzano un piccolo monitor laterale per i display in tempo reale mentre un'app è in esecuzione in lo sfondo e un monitor di questo tipo può essere identificato per dimensioni, colori dello schermo, ecc.):

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

Questa è la risoluzione dello schermo a cui è assegnato il componente dato (qualcosa come la maggior parte della finestra principale è visibile su quello schermo).

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

Uso:

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

Se vuoi rispettare le barre degli strumenti, ecc. Dovrai calcolare anche con questo:

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

3

Ecco del codice funzionale (Java 8) che restituisce la posizione x del bordo più a destra dello schermo più a destra. Se non viene trovata alcuna schermata, restituisce 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);

Ecco i collegamenti a JavaDoc.

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


2

Queste tre funzioni restituiscono le dimensioni dello schermo in Java. Questo codice rappresenta le configurazioni multi-monitor e le barre delle attività. Le funzioni incluse sono: getScreenInsets () , getScreenWorkingArea () e getScreenTotalArea () .

Codice:

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

Ecco uno snippet di codice che uso spesso. Restituisce l'intera area dello schermo disponibile (anche su configurazioni multi-monitor) mantenendo le posizioni native del monitor.

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

Su un computer con due monitor Full HD, dove quello sinistro è impostato come monitor principale (nelle impostazioni di Windows), la funzione ritorna

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

Nella stessa configurazione, ma con il monitor giusto impostato come monitor principale, la funzione ritorna

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

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

Benvenuto in Stack Overflow! Sebbene questo frammento di codice possa risolvere la domanda, inclusa una spiegazione aiuta davvero a migliorare la qualità del tuo post. Ricorda che stai rispondendo alla domanda per i lettori in futuro e quelle persone potrebbero non conoscere i motivi del tuo suggerimento sul codice. Si prega inoltre di cercare di non riempire il codice con commenti esplicativi, questo riduce la leggibilità sia del codice che delle spiegazioni!
kayess,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.