I need help figuring out how to stop my program from throwing a NullPointerException

Question

I'm having this annoying issue of a null pointer exception being thrown when trying to run my program.

This program I'm working on right now is another extension of a program I'm still working on.

In this part, I just added a FileFilter, so for the most part the implementation should be the same.

Here is my code:

    import java.io.*;
    import java.util.*;

    public class DirectorySize extends DirectoryProcessor
    {


        /*
            Dan Czarnecki
            October 29, 2013

            Class variables:
                private HashMap<File, DirectoryStatistics> directory
                    A HashMap object that will contain the files and folders
                    within a directory

            Constructors:
                public DirectorySize(File startingDirectory) throws FileNotFoundException
                    Creates a DirectorySize object, takes in a pathname (inherited from DirectoryProcessor class,
                    and has a single hashmap of a DirectoryStatistics object to hold the files and folders
                    within a directory

            Methods:
                public void processFile(File file)
                    A method that searches for all the files and folders
                    within a directory and calculated the total size
                    for each of them
                public void run()
                    Calls the processFile() method and prints out
                    the files and folders (along with their sizes)
                    in the directory
                public String toString()
                    Returns each element in the directory Vector


            Modification History
                October 29, 2013
                    Original version of class
                    Implemented run() and processFile() methods
                October 30, 2013
                    Added implementation of FileFilter to processFile() method
            */
            private HashMap<File, DirectoryStatistics> directory;

            public DirectorySize(File startingDirectory, FileFilter fileFilter) throws FileNotFoundException
            {
                super(startingDirectory, fileFilter);
                directory = new HashMap <File, DirectoryStatistics>();
            }


            public void processFile(File file, FileFilter fileFilter) throws FileNotFoundException
            {
                DirectoryStatistics parent;
                int index;
                File parentFile;
                boolean find;
                boolean filter;

                if(fileFilter == null)
                {
                    System.out.println("null" + fileFilter);
                }

                if(file == null)
                {
                    System.out.println("null");
                }

                parentFile = file.getParentFile();
                parent = new DirectoryStatistics(parentFile, fileFilter);
                find = directory.containsValue(parent);
                filter = fileFilter.accept(file);

                if(find)
                {
                    directory.put(parentFile, parent);
                    if(filter)
                    {
                        directory.get(parentFile).setSizeInBytes(file.length());
                        directory.get(parentFile).incrementFileCount();
                    }

                }


                if(find)
                {
                    if(filter)
                    {
                        directory.get(find).addToSizeInBytes(file.length()); //increments the total size of the directory
                        directory.get(find).incrementFileCount(); //increments the number of files in the directory
                    }

                }


            }

            public void run() throws FileNotFoundException
            {
                File file;
                file = directoryLister.next();


                while(file != null) //the following will be called when the File object is not null
                {
                    processFile(file, fileFilter);
                    file = directoryLister.next();
                }

            }

            public String toString()
            {
                Set<File> parentFile = directory.keySet();
                File[] parentFileArray = parentFile.toArray(new File[0]);

                String str; //creates a new string that will hold the file or directory name
                str = "";

                for(int i = 0; i < parentFileArray.length; i++)
                {
                    str = str + directory.get(parentFileArray[i]).toString();
                }

                return str;
            }    
        }
import java.io.*;
import java.util.*;

public class FileNamesEndingWithFileFilter implements FileFilter
{
    /*
    Dan Czarnecki
    October 30, 2013

    Class variables:
        private String ending
            Tells the program to search for programs with
            certain extensions
        private boolean isCaseSensitive
            Tells the program if the file extension is
            case sensitive or not

    Methods
        public void FileNamesEndingWithFileFilter(String ending, boolean isCaseSensitive)

        public boolean accept(File file)

    */
    private String ending;
    private boolean isCaseSensitive;

    public FileNamesEndingWithFileFilter(String ending, boolean isCaseSensitive)
    {
        if(ending == null)
        {
            throw new IllegalArgumentException("null input");
        }

        ending = ending;
        isCaseSensitive = isCaseSensitive;
    }

    public boolean accept(File file)
    {
        String name;
        name = file.getName();

        if(isCaseSensitive)
        {
            return name.endsWith(ending);
        }

        else
        {
            name = name.toLowerCase();
            ending.toLowerCase();
            return name.endsWith(ending);
        }
    }
}

import java.io.*;

public class TestDirectoryListerPart7
{
    /*
    Dan Czarnecki
    October 29, 2013

    Class variables:
    N/A

    Constructors:
    N/A

    Methods:
        public static void main(String[] args) throws FileNotFoundException
            Performs the functions of the Directory Processing program,
            implementing the functions of the DirectoryProcessor,
            DirectorySize, and DirectoryStatistics classes

    Modification history:
        October 29, 2013
            Created class in which program will run in

    */
    public static void main(String[] args) throws FileNotFoundException
    {
        DirectoryProcessor directoryProcessor;
        File startingDirectory;
        FileFilter fileFilter;

        startingDirectory = new File("U:/MyWeb/Coursework/");
        fileFilter = new FileNamesEndingWithFileFilter("class", true);
        directoryProcessor = new DirectorySize(startingDirectory, fileFilter);

        System.out.println("Determining total number of bytes in each directory: " + startingDirectory);
        directoryProcessor.run();
        System.out.println(directoryProcessor);
    }
}

When running this program, the value for both the FileFilter and File inside my processFile() method are returning null pointer exceptions.
Here is the detailed error message I am getting:

Exception in thread "main" java.lang.NullPointerException
    at DirectorySize.processFile(DirectorySize.java:71) (the call to my accept() method in my FileNamesEndingWithFileFilterClass)
    at DirectorySize.run(DirectorySize.java:106) (the call to my processFile() method)
    at TestDirectoryListerPart7.main(TestDirectoryListerPart7.java:37) (the call to my run() method in DirectorySize)

Answer 1

You are checking if fileFilter is null, if it is null you just print it to console and continue, trying to use that object later on. Naturally, it will throw a NullPointerException . You may want to return in that if (or make sure you are not passing a null fileFilter to your processFile method). Like this:

if(fileFilter == null)
{
    System.out.println("I want a file filter!");
    return;
}

Answer 2

I think it is here. Where do you create directoryLister? It may be null

while(file != null) //the following will be called when the File object is not null
{
      processFile(file, fileFilter);
      file = directoryLister.next();
}