尝试从文件读取时 JavaFX 构建崩溃

您的问题没有重点且不清楚。但是，为了好玩，我将尝试修改您的代码。

在关注点分离中编程中，这是一个非常有用的概念。这意味着将代码组织在单独的块中，每个块都专注于特定的作业。

一项工作是将您的购物清单项目写入存储，然后将它们读回来。这应该在一个特定的类中。我们将这个类称为 。Repository

我们需要定义要进入存储库的对象。你的班级构思不周，因为列表只是项目的集合。这是我们需要定义的项目。我们可以通过记录来做到这一点。此类的唯一工作是表示表示来自现实世界的杂货项目所需的已验证状态。GroceryList

public record GroceryItem( String name )
{
    public GroceryItem ( final String name )
    {
        Objects.requireNonNull ( name );
        if ( name.isBlank ( ) ) throw new IllegalArgumentException ( "Grocery item name cannot be blank." );
        this.name = name;
    }
}

存储库需要保存杂货项目并再次检索。这个类的唯一工作是持久存储和检索对象的状态。在这里，我们编写了一个简单的虚假实现，足以开始。

public class Repository
{
    private List < GroceryItem > storedGroceryItems =
            new ArrayList <> (
                    List.of (
                            new GroceryItem ( "Bananas" ) ,
                            new GroceryItem ( "Eggs" ) ,
                            new GroceryItem ( "Olive oil" )
                    )
            );

    public List < GroceryItem > fetchGroceryItems ( )
    {
        return List.copyOf ( this.storedGroceryItems );
    }

    public boolean saveGroceryItem ( final GroceryItem groceryItem )
    {
        if ( this.storedGroceryItems.contains ( groceryItem ) ) return false;
        return this.storedGroceryItems.add ( groceryItem );
    }

    public boolean deleteGroceryItem ( final GroceryItem groceryItem )
    {
        return this.storedGroceryItems.remove ( groceryItem );
    }

    public boolean removeAllGroceryItems ( )
    {
        List < GroceryItem > emptyList = List.of ( );
        return this.storedGroceryItems.retainAll ( emptyList );
    }

}

编写一些测试进行验证。我们期待所有“真实”的结果。

public class TestRepository
{
    public static void main ( String[] args )
    {
        TestRepository.testPreloadedRepository ( );
    }

    public static void testPreloadedRepository ( )
    {
        Repository repository = new Repository ( );
        boolean success;

        List < GroceryItem > list = repository.fetchGroceryItems ( );
        System.out.println ( "list has 3 elements: " + ( list.size ( ) == 3 ) );

        List < GroceryItem > expectedList =
                List.of (
                        new GroceryItem ( "Bananas" ) ,
                        new GroceryItem ( "Eggs" ) ,
                        new GroceryItem ( "Olive oil" )
                );
        System.out.println ( "list has expected items: " + ( list.equals ( expectedList ) ) );

        GroceryItem broccoli = new GroceryItem ( "Broccoli" );
        success = repository.saveGroceryItem ( broccoli );
        System.out.println ( "success = " + success );
        list = repository.fetchGroceryItems ( );
        System.out.println ( "list has 4 elements: " + ( list.size ( ) == 4 ) );
        expectedList =
                List.of (
                        new GroceryItem ( "Bananas" ) ,
                        new GroceryItem ( "Eggs" ) ,
                        new GroceryItem ( "Olive oil" ) ,
                        broccoli
                );
        System.out.println ( "list has expected items: " + ( list.equals ( expectedList ) ) );

        GroceryItem eggs = new GroceryItem ( "Eggs" );
        success = repository.deleteGroceryItem ( eggs );
        System.out.println ( "success = " + success );
        list = repository.fetchGroceryItems ( );
        System.out.println ( "list has 3 elements: " + ( list.size ( ) == 3 ) );
        expectedList =
                List.of (
                        new GroceryItem ( "Bananas" ) ,
                        new GroceryItem ( "Olive oil" ) ,
                        broccoli
                );
        System.out.println ( "list has expected items: " + ( list.equals ( expectedList ) ) );
    }
}

我们所有的测试都通过了。

list has 3 elements: true
list has expected items: true
success = true
list has 4 elements: true
list has expected items: true
success = true
list has 3 elements: true
list has expected items: true

给高级学生的提示：在实际工作中，我们会使用像 Jupiter 这样的框架来编写测试。然后，我们在 JUnit 5 等测试工具中运行测试。

现在在 JavaFX 中构建 GUI 实现为 OpenJFX。

public class HelloApplication extends Application
{
    private Repository repository = new Repository ( );

    @Override
    public void start ( Stage stage ) throws IOException
    {
        Pane pane = this.buildPane ();
        Scene scene = new Scene ( pane , 500 , 350 );
        stage.setTitle ( "Grocery List" );
        stage.setScene ( scene );
        stage.show ( );
    }

    private Pane buildPane () {
        // Data
        List < GroceryItem > groceryItems = this.repository.fetchGroceryItems ( );
        ObservableList < GroceryItem > observableList = FXCollections.observableArrayList ( groceryItems );

        // Widgets
        ListView < GroceryItem > listView = new ListView <> ( observableList );
        TextField newGroceryItemField = new TextField ( );
        newGroceryItemField.setPromptText ( "new grocery item" );
        Button addButton = new Button ( "Add…" );
        Button removeButton = new Button ( "Delete" );

        // Behavior
        addButton.setOnMouseClicked ( ( MouseEvent mouseEvent ) ->
        {
            String input = newGroceryItemField.getText ( );
            if ( input.isBlank ( ) ) return;
            GroceryItem groceryItem = new GroceryItem ( input );
            if ( observableList.contains ( groceryItem ) ) return;
            if ( this.repository.saveGroceryItem ( groceryItem ) )
            {
                observableList.add ( groceryItem );
            }
        } );

        removeButton.setOnMouseClicked ( ( MouseEvent mouseEvent ) ->
        {
            GroceryItem groceryItem = listView.getSelectionModel ( ).getSelectedItem ( );
            if ( Objects.nonNull ( groceryItem ) )
            {
                if ( this.repository.deleteGroceryItem ( groceryItem ) )
                {
                    observableList.remove ( groceryItem );
                }
            }
        } );

        // Arrange
        BorderPane borderPane = new BorderPane ( );
        borderPane.setCenter ( listView );
        borderPane.setBottom ( new HBox ( newGroceryItemField , addButton , removeButton ) );
        return borderPane;
    }

    public static void main ( String[] args ) { launch ( ); }
}

一切正常后，我们可以回到我们的.我们可以重写以实际保存到文件中，而不是使用内存中的虚拟列表。Repository

查看 Java NIO 类（如 Path、Paths 和 Files）以简化文件处理。

package work.basil.example.exgrocerylist;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.ArrayList;
import java.util.List;

public class Repository
{
    private Path dataFilePath = Paths.get ( "/Users/basil_dot_work/GroceryItems.txt" );

    public List < GroceryItem > fetchGroceryItems ( )
    {
        boolean go = this.createAndPopulateFileIfNotExists ( );
        try
        {
            List < String > lines = Files.readAllLines ( this.dataFilePath , StandardCharsets.UTF_8 );
            List < GroceryItem > groceryItems = new ArrayList <> ( );
            for ( String line : lines )
            {
                if ( line.isBlank ( ) )
                {
                    continue;
                }
                GroceryItem groceryItem = new GroceryItem ( line );
                groceryItems.add ( groceryItem );
            }
            return List.copyOf ( groceryItems );
        }
        catch ( IOException e )
        {
            throw new RuntimeException ( e );
        }
    }

    private boolean createAndPopulateFileIfNotExists ( )
    {
        if ( Files.exists ( this.dataFilePath ) ) return true;
        List < GroceryItem > defaultGroceryItems =
                List.of (
                        new GroceryItem ( "Bananas" ) ,
                        new GroceryItem ( "Eggs" ) ,
                        new GroceryItem ( "Olive oil" )
                );
        List < String > lines =
                defaultGroceryItems.stream ( ).map ( GroceryItem :: name ).toList ( );
        try
        {
            Files.write ( this.dataFilePath , lines , StandardCharsets.UTF_8 );
            return ( this.fetchGroceryItems ( ).equals ( defaultGroceryItems ) );
        }
        catch ( IOException e )
        {
            throw new RuntimeException ( e );
        }
    }

    public boolean saveGroceryItem ( final GroceryItem groceryItem )
    {
        List < GroceryItem > groceryItems = this.fetchGroceryItems ( );
        if ( groceryItems.contains ( groceryItem ) ) return false;
        try
        {
            Files.write ( this.dataFilePath , groceryItem.name ( ).getBytes ( ) , StandardOpenOption.APPEND );
        }
        catch ( IOException e )
        {
            throw new RuntimeException ( e );
        }
        return this.fetchGroceryItems ( ).contains ( groceryItem );
    }

    public boolean deleteGroceryItem ( final GroceryItem groceryItem )
    {
        List < GroceryItem > groceryItems = this.fetchGroceryItems ( );
        if ( ! groceryItems.contains ( groceryItem ) ) return false;
        List < GroceryItem > groceryItemsModifiable = new ArrayList <> ( groceryItems );
        boolean go = groceryItemsModifiable.remove ( groceryItem );
        if ( ! go )
        {
            return false;
        }
        List < String > lines = groceryItemsModifiable.stream ( ).map ( GroceryItem :: name ).toList ( );
        try
        {
            Files.write ( this.dataFilePath , lines , StandardCharsets.UTF_8 );
            return true;
        }
        catch ( IOException e )
        {
            throw new RuntimeException ( e );
        }
    }

    public boolean removeAllGroceryItems ( )
    {
        List < String > lines = List.of ( );
        try
        {
            Files.write ( this.dataFilePath , lines , StandardCharsets.UTF_8 );
            return ( this.fetchGroceryItems ( ).isEmpty ( ) );
        }
        catch ( IOException e )
        {
            throw new RuntimeException ( e );
        }
    }
}

给高级学生的提示：应该是一个接口，有两个具体的实现：一个用于我们的内存列表，另一个用于我们的文件存储。Repository

小心。。。此基于文件有一个错误：用户无法添加多个杂货项目。我们可以确定 bug 存在于这个基于文件的实现中，因为我们可以切换回基于内存列表的实现来查看 bug 消失。这种错误验证对于编写更简单的虚假实现来说是一个很大的好处。我会把未发现的错误留在原地，因为我已经为学校作业做了太多。RepositoryRepository

另一个问题：尽管这个基于文件的实现中存在错误，但我们所有的测试都通过了。这意味着我们的测试是不够的，需要修改。我也会把它留给读者做一个练习。