Fatal编程技术网
  • java/
  • Java 拖放中的NPE

Java 拖放中的NPE

java javafx-2 javafx

Java 拖放中的NPE,java,javafx-2,javafx,parseint,javafx-8,Java,Javafx 2,Javafx,Parseint,Javafx 8,我在WindowsJVM7_25中测试了这段代码，它运行得很好 import java.util.Random; import javafx.application.Application; import javafx.collections.ObservableList; import javafx.event.EventHandler; import javafx.scene.Node; import javafx.scene.Scene; import javafx

我在WindowsJVM7_25中测试了这段代码，它运行得很好

import java.util.Random;  
import javafx.application.Application;  
import javafx.collections.ObservableList;  
import javafx.event.EventHandler;  
import javafx.scene.Node;  
import javafx.scene.Scene;  
import javafx.scene.input.ClipboardContent;  
import javafx.scene.input.DragEvent;  
import javafx.scene.input.Dragboard;  
import javafx.scene.input.MouseEvent;  
import javafx.scene.input.TransferMode;  
import javafx.scene.layout.BorderPane;  
import javafx.scene.layout.FlowPane;  
import javafx.scene.layout.Pane;  
import javafx.stage.Stage;  
public class DraggableFlowPane extends Application {  
    @Override  
    public void start(Stage primaryStage) {  
        final FlowPane root = new FlowPane();  
        final Random rng = new Random();  
        final int NUM_NODES = 120;  
        for (int i = 0; i < NUM_NODES; i++) {  
            int red = rng.nextInt(256);  
            int green = rng.nextInt(256);  
            int blue = rng.nextInt(256);  
            Node node = createNode();  
            node.setStyle(String.format("-fx-background-color: rgb(%d, %d, %d);", red, green, blue));  
            root.getChildren().add(node);  
        }  
        primaryStage.setScene(new Scene(root, 600, 500));  
        primaryStage.show();  
    }  
    private Node createNode() {  
        final BorderPane bp = new BorderPane();  
        bp.setOnDragDetected(new EventHandler<MouseEvent>() {  
            @Override  
            public void handle(MouseEvent event) {  
                Dragboard db = bp.startDragAndDrop(TransferMode.MOVE);  
                ClipboardContent clipboard = new ClipboardContent();  
                final int nodeIndex = bp.getParent().getChildrenUnmodifiable()  
                        .indexOf(bp);  
                clipboard.putString(Integer.toString(nodeIndex));  
                db.setContent(clipboard);  
                event.consume();  
            }  
        });  
        bp.setOnDragOver(new EventHandler<DragEvent>() {  
            @Override  
            public void handle(DragEvent event) {  
                boolean accept = true;  
                final Dragboard dragboard = event.getDragboard();  
                if (dragboard.hasString()) {  
                    int incomingIndex = Integer.parseInt(dragboard.getString());  
                    int myIndex = bp.getParent().getChildrenUnmodifiable()  
                            .indexOf(bp);  
                    if (incomingIndex == myIndex) {  
                        accept = false;  
                    }  
                } else {  
                    accept = false;  
                }  
                if (accept) {  
                    event.acceptTransferModes(TransferMode.MOVE);  
                }  
            }  
        });  
        bp.setOnDragDropped(new EventHandler<DragEvent>() {  
            @Override  
            public void handle(DragEvent event) {  
                boolean success = false;  
                final Dragboard dragboard = event.getDragboard();  
                if (dragboard.hasString()) {  
                    int incomingIndex = Integer.parseInt(dragboard.getString());  
                    final Pane parent = (Pane) bp.getParent();  
                    final ObservableList<Node> children = parent.getChildren();  
                    int myIndex = children.indexOf(bp);  
                    final int laterIndex = Math.max(incomingIndex, myIndex);  
                    Node removedLater = children.remove(laterIndex);  
                    final int earlierIndex = Math.min(incomingIndex, myIndex);  
                    Node removedEarlier = children.remove(earlierIndex);  
                    children.add(earlierIndex, removedLater);  
                    children.add(laterIndex, removedEarlier);  
                    success = true;  
                }  
                event.setDropCompleted(success);  
            }  
        });  
        bp.setMinSize(50, 50);  
        return bp;  
    }  
    public static void main(String[] args) {  
        launch(args);  
    }  
}
（及更多）

int incomingIndex=Integer.parseInt（dragboard.getString（））的内容为空


您能告诉我如何解决此问题或重写代码吗？
您似乎将
null
作为int传递，并且
null
无法转换为
整数（或int）


检查
dragboard.getString（）
的输出，检查
dragboard.hastring（）
。如果
dragboard.getString（）
为空，它肯定应该返回
FALSE
。因此，您永远不会到达
intincomingindex=Integer.parseInt（dragboard.getString（）），因为如果（dragboard.hastring（））

如果找不到问题，请粘贴
Dragboard
类实现

编辑：

那么这将更加健壮：


private Node createNode() {  
        final BorderPane bp = new BorderPane();  
        bp.setOnDragDetected(new EventHandler<MouseEvent>() {  
            @Override  
            public void handle(MouseEvent event) {  
                Dragboard db = bp.startDragAndDrop(TransferMode.MOVE);  
                ClipboardContent clipboard = new ClipboardContent();  
                final int nodeIndex = bp.getParent().getChildrenUnmodifiable()  
                        .indexOf(bp);  
                clipboard.putString(Integer.toString(nodeIndex));  
                db.setContent(clipboard);  
                event.consume();  
            }  
        });  
        bp.setOnDragOver(new EventHandler<DragEvent>() {  
            @Override  
            public void handle(DragEvent event) {  
                boolean accept = true;  
                final Dragboard dragboard = event.getDragboard();  
                if (dragboard.hasString()) {  
                  try {
                    int incomingIndex = Integer.parseInt(dragboard.getString());  
                    int myIndex = bp.getParent().getChildrenUnmodifiable()  
                            .indexOf(bp);  
                    if (incomingIndex == myIndex) {  
                        accept = false;  
                    }  
                  } catch(java.lang.NumberFormatException e) {
                    //handle null or not number string in clipboard
                    accept = false;
                  }
                } else {  
                    accept = false;  
                }  
                if (accept) {  
                    event.acceptTransferModes(TransferMode.MOVE);  
                }  
            }  
        });  
        bp.setOnDragDropped(new EventHandler<DragEvent>() {  
            @Override  
            public void handle(DragEvent event) {  
                boolean success = false;  
                final Dragboard dragboard = event.getDragboard();  
                if (dragboard.hasString()) {  
                  try {
                    int incomingIndex = Integer.parseInt(dragboard.getString());  
                    final Pane parent = (Pane) bp.getParent();  
                    final ObservableList<Node> children = parent.getChildren();  
                    int myIndex = children.indexOf(bp);  
                    final int laterIndex = Math.max(incomingIndex, myIndex);  
                    Node removedLater = children.remove(laterIndex);  
                    final int earlierIndex = Math.min(incomingIndex, myIndex);  
                    Node removedEarlier = children.remove(earlierIndex);  
                    children.add(earlierIndex, removedLater);  
                    children.add(laterIndex, removedEarlier);  
                    success = true;  
                  } catch(java.lang.NumberFormatException e) {
                    //handle null or not number string in clipboard
                  }
                }  
                event.setDropCompleted(success);  
            }  
        });  
        bp.setMinSize(50, 50);  
        return bp;  
    } 



专用节点createNode（）{
最终边界窗格bp=新边界窗格（）；
检测到bp.setOnDragDetected（新的EventHandler（）{
@凌驾
公共无效句柄（MouseEvent事件）{
Dragboard db=bp.startDragAndDrop（TransferMode.MOVE）；
剪贴板内容剪贴板=新的剪贴板内容（）；
final int nodeIndex=bp.getParent（）.getChildrenUnmodifiable（）
.indexOf（bp）；
clipboard.putString（Integer.toString（nodeIndex））；
db.setContent（剪贴板）；
event.consume（）；
}  
});  
setOnDragOver（新的EventHandler（）{
@凌驾
公共无效句柄（DrageEvent事件）{
布尔接受=真；
最终Dragboard Dragboard=event.getDragboard（）；
if（dragboard.hastring（））{
试一试{
int incomingIndex=Integer.parseInt（dragboard.getString（））；
int myIndex=bp.getParent（）.getChildrenUnmodifiable（）
.indexOf（bp）；
如果（incomingIndex==myIndex）{
接受=错误；
}  
}catch（java.lang.numberformatexe）{
//处理剪贴板中的空或非数字字符串
接受=错误；
}
}否则{
接受=错误；
}  
如果（接受）{
event.acceptTransferModes（TransferMode.MOVE）；
}  
}  
});  
setOnDragDrop（新的EventHandler（）{
@凌驾
公共无效句柄（DrageEvent事件）{
布尔成功=假；
最终Dragboard Dragboard=event.getDragboard（）；
if（dragboard.hastring（））{
试一试{
int incomingIndex=Integer.parseInt（dragboard.getString（））；
最终窗格父项=（窗格）bp.getParent（）；
最终ObservableList children=parent.getChildren（）；
int-myIndex=children.indexOf（bp）；
最终int laterIndex=Math.max（收入指数，我的指数）；
Node removedLater=子级。移除（laterIndex）；
最终int-earlierIndex=Math.min（incomingIndex，myIndex）；
Node RemovedPrevior=子级。移除（earlierIndex）；
添加（早期索引，稍后删除）；
添加（laterIndex，RemovedPrevious）；
成功=真实；
}catch（java.lang.numberformatexe）{
//处理剪贴板中的空或非数字字符串
}
}  
事件。setDropCompleted（成功）；
}  
});  
bp.setMinSize（50,50）；
返回bp；
} 

彼得

我通过这个链接来了解更多关于拖放功能的信息。
从他们给出的例子来看，你似乎做了预期的事情

进入您的实际代码：
我将尝试理解我是否将null放入setOnDragDetected（{}）中的ClipboardContent对象中；
ClipboardContent类扩展了HashMap-

如果您试图获取的nodeIndex不是DataFormat.PLAIN_文本，则剪贴板.putString（）可能不会实际将索引放入hashmap中。请参阅javadoc中的语句-“将此值设置为null将有效地将其从剪贴板中清除”，并确认是否没有发生这种情况

如果“put”操作成功，putString方法将布尔值返回为True

我将打印这两个内容（“putString（）”的输出和“nodeIndex”的值），以调查出了什么问题

-问候,，

Ravi.
NPE是一种不相信你的程序的笑话。我会首先制作一个简化的示例，并突出显示令人不快的行。我得到“java.lang.NumberFormatException:null”它看起来像是一个bug或剪贴板实现中的行为差异，这在不同的平台上是不同的=>提交关于Jira的错误报告。
dragboard.getString（）的内容在
null
中，这就是异常发生的原因。您需要找出它为什么为
null
。但这是另一个问题，至少你可以确认NPE。不，我不明白为什么它可以在windows上工作，但不能在linux上工作。也许您可以将代码“开销”减少到一个小样本来重现错误。示例越小，我们越容易找到问题/原因。然后用较小的示例打开另一个问题，再试试运气；）Dragboard是JavaFX包的一部分，我无法编辑此代码。还有其他解决方案吗？例如，我可以实现t吗

int incomingIndex = Integer.parseInt(dragboard.getString());  



private Node createNode() {  
        final BorderPane bp = new BorderPane();  
        bp.setOnDragDetected(new EventHandler<MouseEvent>() {  
            @Override  
            public void handle(MouseEvent event) {  
                Dragboard db = bp.startDragAndDrop(TransferMode.MOVE);  
                ClipboardContent clipboard = new ClipboardContent();  
                final int nodeIndex = bp.getParent().getChildrenUnmodifiable()  
                        .indexOf(bp);  
                clipboard.putString(Integer.toString(nodeIndex));  
                db.setContent(clipboard);  
                event.consume();  
            }  
        });  
        bp.setOnDragOver(new EventHandler<DragEvent>() {  
            @Override  
            public void handle(DragEvent event) {  
                boolean accept = true;  
                final Dragboard dragboard = event.getDragboard();  
                if (dragboard.hasString()) {  
                  try {
                    int incomingIndex = Integer.parseInt(dragboard.getString());  
                    int myIndex = bp.getParent().getChildrenUnmodifiable()  
                            .indexOf(bp);  
                    if (incomingIndex == myIndex) {  
                        accept = false;  
                    }  
                  } catch(java.lang.NumberFormatException e) {
                    //handle null or not number string in clipboard
                    accept = false;
                  }
                } else {  
                    accept = false;  
                }  
                if (accept) {  
                    event.acceptTransferModes(TransferMode.MOVE);  
                }  
            }  
        });  
        bp.setOnDragDropped(new EventHandler<DragEvent>() {  
            @Override  
            public void handle(DragEvent event) {  
                boolean success = false;  
                final Dragboard dragboard = event.getDragboard();  
                if (dragboard.hasString()) {  
                  try {
                    int incomingIndex = Integer.parseInt(dragboard.getString());  
                    final Pane parent = (Pane) bp.getParent();  
                    final ObservableList<Node> children = parent.getChildren();  
                    int myIndex = children.indexOf(bp);  
                    final int laterIndex = Math.max(incomingIndex, myIndex);  
                    Node removedLater = children.remove(laterIndex);  
                    final int earlierIndex = Math.min(incomingIndex, myIndex);  
                    Node removedEarlier = children.remove(earlierIndex);  
                    children.add(earlierIndex, removedLater);  
                    children.add(laterIndex, removedEarlier);  
                    success = true;  
                  } catch(java.lang.NumberFormatException e) {
                    //handle null or not number string in clipboard
                  }
                }  
                event.setDropCompleted(success);  
            }  
        });  
        bp.setMinSize(50, 50);  
        return bp;  
    }