How to populate JTable with an existing ArrayList of objects?

The "primary" issues comes about from, I suspect, a data sharing issue.

Basically, F1ChampionshipGUI extending from Formula1ChampionshipManager, but you create a separate Formula1ChampionshipManager instance

Formula1ChampionshipManager formula1ChampionshipManager =new Formula1ChampionshipManager();
F1ChampionshipGUI guiCode = new F1ChampionshipGUI();

These two "data sources" have nothing in common, so adding data to formula1ChampionshipManager will not expose that data to guiCode.

I'd remove the extends Formula1ChampionshipManager from F1ChampionshipGUI and simply pass it an instance of Formula1ChampionshipManager directly. This is basic programming concept, see Passing Information to a Method or a Constructor for more details.

Having said that, you have a litany of other issues. Unless you have a very specific requirement, don't mix console and GUI workflows together. They have very different requirements.

I would strongly recommend having a look at:

• Creating a GUI With Swing
• How to Use Buttons, Check Boxes, and Radio Buttons
• How to Write an Action Listener
• Laying Out Components Within a Container

You should then take a look at:

• How to Use Tables
• How to use Tables: Sorting and Filtering

You'll also want to be familiar with:

• The Delegation Pattern
• Dependency Injection
• The Observer Pattern

because without those concepts, nothing I'm about to do will make any sense.

Because they weren't provided, I created my own Formula1ChampionshipManager and Formula1Driver classes...

public class Formula1Driver {

    private String driverName;
    private String driverTeam;
    private String driverLocation;
    private int firstPositions;
    private int secondPositions;
    private int thirdPositions;
    private int racesParticipated;
    private int points;

    public Formula1Driver(String driverName, String driverTeam, String driverLocations, int firstPositions, int secondPositions, int thirdPositions, int racesParticipated, int points) {
        this.driverName = driverName;
        this.driverTeam = driverTeam;
        this.driverLocation = driverLocations;
        this.firstPositions = firstPositions;
        this.secondPositions = secondPositions;
        this.thirdPositions = thirdPositions;
        this.racesParticipated = racesParticipated;
        this.points = points;
    }

    public String getDriverName() {
        return driverName;
    }

    public String getDriverTeam() {
        return driverTeam;
    }

    public String getDriverLocation() {
        return driverLocation;
    }

    public int getFirstPositions() {
        return firstPositions;
    }

    public int getSecondPositions() {
        return secondPositions;
    }

    public int getThirdPositions() {
        return thirdPositions;
    }

    public int getRacesParticipated() {
        return racesParticipated;
    }

    public int getPoints() {
        return points;
    }

}

public class Formula1ChampionshipManager {

    private List<Formula1Driver> drivers;

    public Formula1ChampionshipManager() {
        drivers = new ArrayList<>();
    }

    public int size() {
        return drivers.size();
    }

    public Formula1Driver getDriverAt(int index) {
        return drivers.get(index);
    }

    public void add(Formula1Driver driver) {
        drivers.add(driver);
        // This is where I'd employee an observer pattern to notify
        // interested parties that a driver was added
    }

    public void remove(Formula1Driver driver) {
        drivers.remove(driver);
        // This is where I'd employee an observer pattern to notify
        // interested parties that a driver was removed
    }
}

This formed the bases of the rest of the solution.

Because it's easier to do, I created my own custom TableModel, which uses the Formula1ChampionshipManager as its source of data.

public class Formula1DriverTableModel extends AbstractTableModel {

    private Formula1ChampionshipManager manager;
    private String[] columnNames = new String[]{"Name", "Team", "Location", "First positions", "Second positions", "Third positions", "Races participated", "Points"};

    public Formula1DriverTableModel(Formula1ChampionshipManager manager) {
        this.manager = manager;
    }

    public Formula1ChampionshipManager getManager() {
        return manager;
    }

    @Override
    public int getRowCount() {
        return getManager().size();
    }

    @Override
    public int getColumnCount() {
        return columnNames.length;
    }

    @Override
    public String getColumnName(int column) {
        return columnNames[column];
    }

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        Formula1Driver driver = getManager().getDriverAt(rowIndex);
        switch (columnIndex) {
            case 0:
                return driver.getDriverName();
            case 1:
                return driver.getDriverTeam();
            case 2:
                return driver.getDriverLocation();
            case 3:
                return driver.getFirstPositions();
            case 4:
                return driver.getSecondPositions();
            case 5:
                return driver.getThirdPositions();
            case 6:
                return driver.getRacesParticipated();
            case 7:
                return driver.getPoints();
        }
        return null;
    }

}

This is an example of delegation and dependency injection (it also forms part of a different pattern, but you're probably somewhat overloaded by now)

nb: With an addition of an observer pattern directly to Formula1ChampionshipManager, Formula1DriverTableModel could register itself to be notified when drivers are added or removed and trigger appropriate change events via it's own observer pattern, but I took this as been out of context to the question

Then I created a "master" component to act as the "main" UI...

public class MasterPane extends JPanel {

    private JTable table;
    private Formula1DriverTableModel model;
    private Formula1ChampionshipManager manager;

    public MasterPane(Formula1ChampionshipManager manager) {
        this.manager = manager;
        setLayout(new BorderLayout());
        model = new Formula1DriverTableModel(manager);
        table = new JTable();
        table.setAutoCreateRowSorter(true);
        table.setModel(model);
        List<RowSorter.SortKey> sortKeys = new ArrayList<RowSorter.SortKey>();
        sortKeys.add(new RowSorter.SortKey(7, SortOrder.ASCENDING));
        sortKeys.add(new RowSorter.SortKey(0, SortOrder.ASCENDING));
        sortKeys.add(new RowSorter.SortKey(1, SortOrder.ASCENDING));
        table.getRowSorter().setSortKeys(sortKeys);
        
        add(new JScrollPane(table));

        JPanel actions = new JPanel(new GridBagLayout());
        JButton add = new JButton("Add");
        JButton delete = new JButton("Delete");
        JButton save = new JButton("Save");
        JButton load = new JButton("Load");

        actions.add(add);
        actions.add(delete);
        actions.add(save);
        actions.add(load);

        add(actions, BorderLayout.SOUTH);

        add.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // This is likely going to be a dialog of some kind
                // which presents the form to the user ... possibly
                // passing the manager, maybe not.  I might wait till
                // the form is completed and ascertain the appropriate
                // course of action based on the state of the dialog
            }
        });
        delete.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // Get the selected index of the table and remove 
                // the driver at that location
            }
        });
        save.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // Call the management functionality
                JOptionPane.showMessageDialog(MasterPane.this, "All you data belong to us", "Saved", JOptionPane.INFORMATION_MESSAGE);
            }
        });
        load.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // Call the management functionality
                JOptionPane.showMessageDialog(MasterPane.this, "All you data now loaded", "Loaded", JOptionPane.INFORMATION_MESSAGE);
            }
        });
    }

    public Formula1ChampionshipManager getManager() {
        return manager;
    }

}

This presents a list of the drivers and some actions the user can take. You will note that the table will automatically sort the drivers. Since I didn't have the requirements for this, I sorted them by points, name and team. This demonstrates the power using something like JTables inbuilt sorting capabilities.

And finally, I built the Formula1ChampionshipManager, populated it and build the UI...

EventQueue.invokeLater(new Runnable() {
    @Override
    public void run() {
        Formula1ChampionshipManager manager = new Formula1ChampionshipManager();
        manager.add(new Formula1Driver("Hare", "H1", "", 0, 1, 0, 1, 50));
        manager.add(new Formula1Driver("Tortus", "T1", "", 1, 0, 0, 1, 100));

        JFrame frame = new JFrame();
        frame.add(new MasterPane(manager));
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
});

What's important to note here is, "Hare" is added first, so it's the first entry in our list, but in the UI, "Torus" is listed first 😱

But wait, where's edit?!

You can make the table editable and allow the user to modify the row data directly! See if you can figure out how to do that, hint, it's part of the TableModel ;)