Basic project calculations

You can, of course, do this in one way of describing it. Major trade-offs:

• If you load everything from the database and filter the table in Java, you are using more memory (although not as much as you might think, as described below).
• If you are filtering from the database and reloading every time the user changes the filter, there will be a large delay (latency) in displaying the data as the new query will be executed on the database with (usually) a network connection between the database and the application being the most a big bottleneck (although there are others).

Database access and concurrency

In general, you should run database queries on a background thread (see Using Threads to Create Database Queries ); if you make frequent queries to the database (i.e. filtering through the database) this gets tricky and includes frequent disabling of UI controls when a background task is running.

TableView

design and memory management

JavaFX TableView

is a virtualized control. This means that visual components (cells) are only created for visible elements (plus maybe a small amount of caching). These cells are then reused as the user scrolls to display various "items" as needed. Visual components tend to be quite memory-heavy (they have hundreds of properties - colors, font properties, sizes, layout properties, etc.), most of which have CSS views), so limiting the number generated saves a lot of memory and the memory of the visible portion of the table view is essentially constant, no matter how many items are in the table's backing list.

General memory consumption calculations

The observable list items

that forms the table backing list contains only data: it is not hard to estimate the approximate amount of memory consumed by a list of a given size. String

use 2 bytes per character, and also a little fixed overhead, double

use 8 bytes, int

use 4 bytes, etc. If you put fields in JavaFX properties (which is recommended), there will be multiple bytes for each one; each object has ~ 16 bytes overhead, and the links themselves usually use up to 8 bytes. Thus, a typical objectStudent

which stores multiple string fields typically consumes on the order of several hundred bytes in memory (Of course, if everyone has an image associated with it, for example, it could be much larger.) So if you load, say, 100,000 students from a database, you would be using on the order of 10-100 MB of RAM, which is pretty manageable. on most personal computer systems.

Rough general guidelines

Generally, for the type of application being described, I would recommend loading what's in your database and filtering it in memory. In my usual field of work (genomics), where we sometimes need 10 or 100 million people, this is not possible. (If your database contains, say, all enrolled students in US public schools , you might run into similar problems.)

However, as a rule of thumb, for a "normal" object (that is, one that does not have large data objects, such as images associated with it), the size of your table will be too large for the user to be able to comfortably manipulate (even with filtering) before you will seriously expand the memory capacity of the user's machine.

Filtering a table in Java (all objects in memory)

Filtering in your code is pretty straightforward. In short, you load everything in ObservableList

and wrap ObservableList

in FilteredList

. A FilteredList

wraps the original list and Predicate

, which returns true

, the element must pass the filter (to be included) or false if excluded.

Thus, the code snippets you would use might look like this:

ObservableList<Student> allStudents = loadStudentsFromDatabase();
FilteredList<Student> filteredStudents = new FilteredList<>(allStudents);
studentTable.setItems(filteredStudents);

      

        
        
        
      

    

And then you can change the predicate based on the textbox with code like:

filterTextField.textProperty().addListener((obs, oldText, newText) -> {
    if (newText.isEmpty()) {
        // no filtering:
        filteredStudents.setPredicate(student -> true);
    } else {
        filteredStudents.setPredicate(student -> 
            // whatever logic you need:
            student.getFirstName().contains(newText) || student.getLastName().contains(newText));
    }
});

      

        
        
        
      

    

This tutorial takes a closer look at filtering (and sorting) tables.

Comments on the implementation of "query filtering"

If you don't want to load everything from the database, you are skipping the filtered list entirely. The database query will almost certainly not run fast enough to filter (using a new database query) as the user enters types, so you need an Update button (or an action listener on a text box) that recalculates the new filtered data ... You will probably need to do this on a background thread as well. You didn't need to set new cellValueFactory

(or cellFactory

s) on table columns or reload columns; you just call studentTable.setItems(newListOfStudents);

when the database query is complete.