JFrame Ingrandisci finestra

Sto mettendo insieme un'animazione veloce e sporca usando lo swing. Vorrei che la finestra fosse ingrandita. Come posso fare ciò?

A condizione che tu stia estendendo JFrame:

public void run() {
    MyFrame myFrame = new MyFrame();
    myFrame.setVisible(true);
    myFrame.setExtendedState(myFrame.getExtendedState() | JFrame.MAXIMIZED_BOTH);
}

Qualcosa di simile a this.setExtendedState(this.getExtendedState() | this.MAXIMIZED_BOTH);

import java.awt.*;
import javax.swing.*;

public class Test extends JFrame
{
    public Test()
    {
        GraphicsEnvironment env =
GraphicsEnvironment.getLocalGraphicsEnvironment();
        this.setMaximizedBounds(env.getMaximumWindowBounds());
        this.setExtendedState(this.getExtendedState() | this.MAXIMIZED_BOTH);
    }

    public static void main(String[] args)
    {
        JFrame.setDefaultLookAndFeelDecorated(true);

        Test t = new Test();
        t.setVisible(true);
    }
}

Se stai usando un JFrame, prova questo

JFrame frame = new JFrame();
//...
frame.setExtendedState(JFrame.MAXIMIZED_BOTH);

Che ne dici JFrame.setExtendedState(JFrame.MAXIMIZED_BOTH)?

mi piace questa versione:

import java.awt.Dimension;
import java.awt.GraphicsConfiguration;
import java.awt.Toolkit;
import javax.swing.JFrame;

public class Test
{
    public static void main(String [] args)
    {
        final JFrame frame = new JFrame();
        final GraphicsConfiguration config = frame.getGraphicsConfiguration();

        final int left = Toolkit.getDefaultToolkit().getScreenInsets(config).left;
        final int right = Toolkit.getDefaultToolkit().getScreenInsets(config).right;
        final int top = Toolkit.getDefaultToolkit().getScreenInsets(config).top;
        final int bottom = Toolkit.getDefaultToolkit().getScreenInsets(config).bottom;

        final Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        final int width = screenSize.width - left - right;
        final int height = screenSize.height - top - bottom;

        frame.setResizable(false);
        frame.setSize(width,height);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);       
        frame.setVisible(true);
    }
}

Il modo per impostare JFrame a schermo intero è impostare l' MAXIMIZED_BOTHopzione che sta per MAXIMIZED_VERT | MAXIMIZED_HORIZ, che rispettivamente imposta il frame per massimizzare verticalmente e orizzontalmente

package Example;
import java.awt.GraphicsConfiguration;
import javax.swing.JFrame;
import javax.swing.JButton;

public class JFrameExample
{
    static JFrame frame;
    static GraphicsConfiguration gc;
    public static void main(String[] args)
    {
        frame = new JFrame(gc);
        frame.setTitle("Full Screen Example");
        frame.setExtendedState(MAXIMIZED_BOTH);

        JButton button = new JButton("exit");
        b.addActionListener(new ActionListener(){@Override
        public void actionPerformed(ActionEvent arg0){
            JFrameExample.frame.dispose();
            System.exit(0);
        }});

        frame.add(button);
        frame.setVisible(true);
    }
}

Ho provato le soluzioni in questo thread e quelle qui , ma semplicemente chiamare setExtendedState(getExtendedState()|Frame.MAXIMIZED_BOTH);subito dopo aver chiamato setVisible(true);apparentemente non funziona per il mio ambiente (Windows 10, JDK 1.8, la mia barra delle applicazioni si trova sul lato destro dello schermo). Farlo in questo modo lascia ancora un piccolo spazio a sinistra, a destra e in basso.

Quello che ha funzionato per me, tuttavia, è chiamare setExtendedState(...quando la finestra è attivata, in questo modo:

public class SomeFrame extends JFrame {

    public SomeFrame() {
        // ...
        setVisible(true);
        setResizable(true);
        // if you are calling setSize() for fallback size, do that here
        addWindowListener (
            new WindowAdapter() {
                private boolean shown = false;
                @Override
                public void windowActivated(WindowEvent we) {
                    if(shown) return;
                    shown = true;
                    setExtendedState(getExtendedState()|JFrame.MAXIMIZED_BOTH);
                }
            }
        );
    }
}

Ho finito per usare questo codice:

public void setMaximized(boolean maximized){
    if(maximized){
        DisplayMode mode = this.getGraphicsConfiguration().getDevice().getDisplayMode();
        Insets insets = Toolkit.getDefaultToolkit().getScreenInsets(this.getGraphicsConfiguration());
        this.setMaximizedBounds(new Rectangle(
                mode.getWidth() - insets.right - insets.left, 
                mode.getHeight() - insets.top - insets.bottom
        ));
        this.setExtendedState(this.getExtendedState() | JFrame.MAXIMIZED_BOTH);
    }else{
        this.setExtendedState(JFrame.NORMAL);
    }
}

Questa opzione ha funzionato meglio di tutte le opzioni, incluso il supporto di più monitor. L'unico difetto che ha è che l'offset della barra delle applicazioni viene utilizzato su tutti i monitor in alcune configurazioni.

La risposta di @kgiannakakis è completamente corretta, ma se qualcuno si è bloccato in questo problema e utilizza Java 6 su Linux (ad esempio, Mint 19 Cinnamon), lo stato MAXIMIZED_BOTH a volte non viene applicato.

Potresti provare a chiamare il metodo pack () dopo aver impostato questo stato.

Esempio di codice:

public MainFrame() {
    setContentPane(contentPanel); //some JPanel is here
    setPreferredSize(new Dimension(1200, 800));
    setMinimumSize(new Dimension(1200, 800));
    setSize(new Dimension(1200, 800));
    setExtendedState(JFrame.MAXIMIZED_BOTH);
    pack();
}

Questo non è necessario se utilizzi Java 7+ o Java 6 su Windows.