How to Create a File Manager Project In Java Netbeans
In this Java Tutorial we will see how How To Create a File Manager System Project in java swing using netbeans.
This java project allows users to navigate through their file system, copy, paste, and delete files and folders.
What We Are Gonna Use In This Project:
- Java Programming Language.- NetBeans Editor.
- Flatleaf library.
What We Will Do In This Project:
- Create a method to update the displayed files and folders when the user navigates to a new directory.
- Create a method to delete entire directories and their contents.
- Create a method to copy files and folders from a source directory to a destination directory.
- Create a method to generate unique names for copied files to avoid overwriting existing files.
- Sets up buttons and event listeners to enable or disable various operations (copy, paste, delete) based on user selections.
- Use a JFileChooser to allow users to select a folder for initial navigation.
Project Source Code:
/**
*
* @author 1BestCsharp
*/
// downoload flatlaf library to make the app look better
// https://search.maven.org/artifact/com.formdev/flatlaf/3.1.1/jar?eh=
// When you click on something in the table
fileTable.addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e)
{
// If you quickly click twice
if(e.getClickCount() == 2)
{
// Find the row you clicked on
int selectedRow = fileTable.getSelectedRow();
// If you clicked on a row
if(selectedRow >= 0)
{
// get the file name
String selectedFileName = (String) tableModel.getValueAt(selectedRow, 0);
// Make a new path to that file / directory
File selectedFile = new File(currentDirectory, selectedFileName);
// If it's a folder
if(selectedFile.isDirectory())
{
// Change to that folder
currentDirectory = selectedFile;
// Show the files / folders inside the folder
refreshList(currentDirectory);
}
}
}
}
});
// When you press the button to go to the parent directory
parentButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// Find the Parent folder of the currentDirectory.
File parentDirectory = currentDirectory.getParentFile();
// If we found a folder.
if(parentDirectory != null && parentDirectory.isDirectory())
{
// Display the Parent Directory content
currentDirectory = parentDirectory;
refreshList(parentDirectory);
}
}
});
// When the "Copy" button is clicked
copyButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// Get the rows that are selected in the table
int[] selectedRows = fileTable.getSelectedRows();
// Prepare a place to store the files/folders we want to copy
cliboardFiles = new ArrayList<>();
// Go through each selected row
for(int row : selectedRows)
{
// Get the name of the file from the table
String fileName = (String) tableModel.getValueAt(row, 0);
// Create a "path" to the file we want to copy
File fileToCopy = new File(currentDirectory, fileName);
// Put the file in our clipboard (like when you copy text)
cliboardFiles.add(fileToCopy);
}
// Enable the "Paste" button so we can use it now
pasteButton.setEnabled(true);
}
});
// When "Paste" button is clicked
pasteButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// If something is in the clipboard
if(cliboardFiles != null)
{
// Go through each thing in the clipboard
for(File file : cliboardFiles)
{
// If it's a folder
if(file.isDirectory())
{
// Get the folder's name
String folderName = file.getName();
// Generate a unique name for the copied folder
File destFolder = generateUniqueFileName(currentDirectory, folderName);
// Try to copy the folder to the new place
try
{
copyDirectory(file.toPath().toString(), destFolder.toPath().toString());
}
catch(IOException ex)
{
ex.printStackTrace();
}
}
else if(file.isFile())
{
String fileName = file.getName();
File destFolder = generateUniqueFileName(currentDirectory, fileName);
try
{
Files.copy(file.toPath(), destFolder.toPath(), StandardCopyOption.REPLACE_EXISTING);
}
catch(IOException ex)
{
ex.printStackTrace();
}
}
}
refreshList(currentDirectory);
}
pasteButton.setEnabled(false);
}
});
// When the "Delete" button is clicked
deleteButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// Get the row of the selected file or folder in the table
int selectedRow = fileTable.getSelectedRow();
// If a file or folder is selected
if(selectedRow >= 0)
{
// Get the name of the selected file or folder
String selectedFileName = (String) tableModel.getValueAt(selectedRow, 0);
// Create a path to the selected file or folder
File fileToDelete = new File(currentDirectory, selectedFileName);
// If the selected file or folder actually exists
if(fileToDelete.exists())
{
try
{
// If it's a folder
if(fileToDelete.isDirectory())
{
// Call a special function to delete the whole
deleteDirectory(fileToDelete);
}
else
{
// If it's just a file, delete it using a different method
Files.delete(fileToDelete.toPath());
}
}
catch(IOException ex)
{
ex.printStackTrace();
}
// Refresh the list of files and folders in the current directory
refreshList(currentDirectory);
}
}
}
});
// Implement file navigation logic using JFileChooser
// Step 1: Create a JFileChooser
JFileChooser fileChooser = new JFileChooser();
// Step 2: Set the tool to only choose folders, not other things
fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
// Step 3: Start the tool in a familiar place called "home"
fileChooser.setCurrentDirectory(new File(System.getProperty("user.home")));
// Step 4: When someone does something with the tool (like clicking or choosing),
// we want to know and do something too
fileChooser.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// Step 5: Find out which folder was chosen
File selectedFile = fileChooser.getSelectedFile();
// Step 6: If a folder was really chosen (not nothing), let's do some things
if(selectedFile != null)
{
// Step 7: Remember the chosen folder as the current place
currentDirectory = selectedFile;
// Step 8: Show all the files and folders inside the chosen folder
refreshList(currentDirectory);
// Step 9: Make buttons active so we can copy and delete
copyButton.setEnabled(true);
deleteButton.setEnabled(true);
}
}
});
// Step 10: Open the file chooser so we can start choosing a folder
fileChooser.showOpenDialog(this);
// This method helps to show the list of files and folders in a special place.
private void refreshList(File directory)
{
// First, we check if the location we are looking at is a folder.
if(directory.isDirectory())
{
// We start by making the list empty, like cleaning up a table.
tableModel.setRowCount(0);
// Now we get a list of all the files and folders inside the location.
File[] files = directory.listFiles();
// If we found some files, let's go through each one.
if(files != null)
{
for(File file : files)
{
// We find out the name of each file or folder.
String name = file.getName();
// We check if it's a folder or a file.
// If it's a folder, we call it a "Directory". If it's a file, we call it a "File".
String type = file.isDirectory() ? "Folder" : "File";
// If it's a folder, we don't know its size, so we write a "-" instead.
// If it's a file, we tell its size in numbers.
String size = file.isDirectory() ? "-" : String.valueOf(file.length());
// We put all this information into the table model.
tableModel.addRow(new Object[]{name, type, size});
}
}
}
}
// This method helps delete a whole folder and everything inside it.
// It needs a 'directory' to start deleting from.
private void deleteDirectory(File directory) throws IOException
{
// First, we check if there are any files inside this folder.
// If there are, we need to go through each one of them.
File[] files = directory.listFiles();
// If there are files in the folder...
if(files != null)
{
// For each file in the folder...
for(File file : files)
{
// If a file is actually a folder, we need to delete it too.
if(file.isDirectory())
{
// We use the same method to delete this folder and its contents.
deleteDirectory(file);
}
// If it's not a folder, it's a regular file.
else
{
// We simply delete the regular file.
Files.delete(file.toPath());
}
}
// After we've deleted all the files inside the folder,
// we can now delete the empty folder itself.
Files.delete(directory.toPath());
}
}
/**
* Copies all the files and folders from the source directory to the destination directory.
*
* @param sourceDirectoryLocation The place where the things to copy are.
* @param destinationDirectoryLocation The place where the things will be copied to.
* @throws IOException If something goes wrong while copying.
*/
public void copyDirectory(String sourceDirectoryLocation, String distinationDirectoryLocation) throws IOException
{
// Start looking at each file or folder inside the source directory.
Files.walk(Paths.get(sourceDirectoryLocation))
.forEach(source->{
// Calculate where the file or folder should go in the destination directory.
Path destination = Paths.get(distinationDirectoryLocation,
source.toString().substring(
sourceDirectoryLocation.length()
));
try
{
// Copy the file or folder to its new place in the destination directory.
Files.copy(source, destination);
}
catch(IOException ex)
{
ex.printStackTrace();
}
});
}
// This method helps make sure our copied files have unique names
private File generateUniqueFileName(File directory, String fileName)
{
// Get the main part of the file name and its extension
String baseName = fileName; // Let's call the main part of the name "baseName"
String extension = ""; // Let's call the part after the dot "extension"
// If there's a dot in the name (like "picture.jpg"), split it into base name and extension
int extensionIndex = fileName.lastIndexOf('.'); // Find where the dot is
if(extensionIndex != -1)
{
baseName = fileName.substring(0, extensionIndex); // The part before the dot
extension = fileName.substring(extensionIndex); // The part after the dot
}
// We'll start counting from 1 to make sure our new name is unique
int count = 1;
// Combine the base name, count, and extension to make a new name
File destFile = new File(directory, fileName);
// As long as a file with this name already exists, let's make a new one
while(destFile.exists())
{
destFile = new File(directory, baseName + "(" + count + ")" + extension);
count++; // Increase the count for the next try
}
// Finally, return the unique name we found
return destFile;
}
The Final Result:
if you want the source code click on the download button below
More Java Projects:
Download Projects Source Code
