Java:NullPointerException是否在空检查上？

我已经通读了这里的一些NullPointerException线程，并将我的代码格式化为使用我找到的一个简单检查，但我仍然得到一个NullPointerException

完整代码：请注意错误所在的**

public class Assignment11 {

public static void main(String[] args) {
    ArrayList<Employee> employeeArray = new ArrayList<Employee>();
    ArrayList<Book> booksToCirculate = new ArrayList<Book>();
    ArrayList<Book> archivedbooks = new ArrayList<Book>();
    int passAndCirc = 0;
    int totalEmployees = 0;

    addBook("Software Engineering", booksToCirculate);
    addBook("Chemistry", booksToCirculate);


    addEmployee("Adam", booksToCirculate, employeeArray);
    addEmployee("Sam", booksToCirculate, employeeArray);
    addEmployee("Ann",booksToCirculate, employeeArray);



    circulateBook("Chemistry","1999 03 20",booksToCirculate,employeeArray);
    //circulateBook("Software Engineering","1998 02 20",booksToCirculate,employeeArray);



    passOn("Chemistry", "1999 03 25",employeeArray,archivedbooks,booksToCirculate);

    passOn("Chemistry", "1999 03 29",employeeArray,archivedbooks,booksToCirculate);

    passOn("Chemistry", "1999 03 30",employeeArray,archivedbooks,booksToCirculate);

    passOn("Software Engineering","1998 02 21",employeeArray,archivedbooks,booksToCirculate);

//  passOn("Software Engineering","1998 02 29",employeeArray,archivedbooks,booksToCirculate);




}

public static void addEmployee(String aName, ArrayList<Book> booksToCirculate, ArrayList<Employee> employeeArray)
{
    Employee anEmployee = new Employee();
    anEmployee.setName(aName);
    employeeArray.add(anEmployee);
    for (Book b : booksToCirculate)
    {
        b.getQueue().add(anEmployee); //adds employee to each queue
    }
    System.out.println(anEmployee.getName() + " has been added to each queue, and list of employees.");


}

public static void addBook(String aName, ArrayList<Book> booksToCirculate)
{
    Book aBook = new Book();
    aBook.setBookName(aName);
    aBook.setArchived(false);
    //aBook.setStartDate(LocalDate.now()); //lookin good
    booksToCirculate.add(aBook);
    System.out.println(aBook.getBookName() + " has been added to the library.");

}

public static void circulateBook(String aName, String aDate, ArrayList<Book> booksToCirculate, ArrayList<Employee> employeeArray)
{
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern ( "yyyy MM dd" );
    LocalDate dateStarted = formatter.parse ( aDate , LocalDate :: from ); //have the date in 2015 11 05 format
    Employee anEmployee = null;
    Book aBook = null;
    Queue<Employee> Employees = new LinkedList<>();


    for (Book b : booksToCirculate)
    {
        if (b.getBookName().equals(aName))
        {
            b.setStartDate(dateStarted);
            anEmployee = b.getQueue().poll();
            aBook = b;

            Employees = b.getQueue();
            b.setQueue(Employees);              
        }


    }
    for (Book b: booksToCirculate)
    {
        if (!b.getBookName().equals(aName))
        {
            b.setQueue(Employees);
            b.getQueue().add(anEmployee);
        }
    }

    for (Employee e : employeeArray)
    {
        if (e.getName().equals(anEmployee.getName()))
        {
            //System.out.println(e.getName());
            e.setaBook(aBook);
            e.setRetainingTime(0);
            System.out.println(e.getName()+" Has the book " + e.getaBook().getBookName()+" Given to him on: "+e.getaBook().getStartDate() + " setting his/her waiting time to " + e.getRetainingTime()+ ".");
        }
    }


}

public static void passOn(String aName, String aDate, ArrayList<Employee> employeeArray, ArrayList<Book> archivedBooks, ArrayList<Book> booksToCirculate)
{
    Employee anEmployee = null;
    Book aBook = null;
    Queue<Employee> Employees = new LinkedList<>();
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern ( "yyyy MM dd" );
    LocalDate datePassed = formatter.parse ( aDate , LocalDate :: from );
    LocalDate dateReceived;
    LocalDate startDate;
    int daysElapsed = 0;
    int daysElapsed2 = 0;

    for (Employee e : employeeArray)
    {
***************************************************************************     
        if (e.getaBook().getBookName() != null)  //Where the error is
            if (e.getaBook().getBookName().equals(aName)){ 
            {
                startDate = e.getaBook().getStartDate();
                Period period = Period.between ( startDate, datePassed );
                daysElapsed2 = period.getDays();
                e.setRetainingTime(daysElapsed2);
                System.out.println(e.getName() + " has passed on "+ e.getaBook().getBookName()+" changing his/her's retaining time to " + daysElapsed2+ ".");

            }
        }

    }
//**************************************************************************
    for (Book b : booksToCirculate)
    {
        outerloop:
        if (b.getBookName().equals(aName))
        {
            if (b.getQueue().isEmpty())
            {
                b.setEndDate(datePassed);
                archivedBooks.add(b);
                b.setEndDate(datePassed);
                b.setArchived(true);
                System.out.println("The book " + b.getBookName() + " has been archived.");
                break outerloop;
            }
            dateReceived = b.getStartDate();
            Period period = Period.between ( dateReceived, datePassed );
            daysElapsed = period.getDays();
            anEmployee = b.getQueue().poll();
            anEmployee.setWaitingTime(daysElapsed);
            anEmployee.setaBook(b);
            aBook = b;

            Employees = b.getQueue();
            b.setQueue(Employees);              
        }
    }

    for (Book b: booksToCirculate)
    {
        if (!b.getBookName().equals(aName))
        {
            b.setQueue(Employees);

            b.getQueue().add(anEmployee);
        }
    }

    for (Employee e : employeeArray)
    {
        if (e.getName().equals(anEmployee.getName()))
        {
            e.setaBook(aBook);
            e.setRetainingTime(daysElapsed);
            System.out.println(e.getName()+" Has the book " + e.getaBook().getBookName()+" passed to him on: "+datePassed + " setting his/her waiting time to " + e.getRetainingTime()+ ".");
        }
    }

    //break maybe

}
}

class Employee{
String name;
int waiting_time;
int retaining_time;
int priority;
Book aBook;
ArrayList <Book> booksRead = new ArrayList<Book>();

public Employee()
{
    this.waiting_time=0;
    this.retaining_time=0;
}

public void setName(String aName)
{
    name = aName;
}

public String getName()
{
    return name;
}

public void setWaitingTime(int waitingtime)
{
    waiting_time = waitingtime;
}

public int getWaitingTime()
{
    return waiting_time;
}

public void setRetainingTime(int retainingtime)
{
    retaining_time = retainingtime;
}

public int getRetainingTime()
{
    return retaining_time;
}

public void setPriority()
{
    priority = waiting_time - retaining_time;
}

public int getPriority()
{
    return priority;
}

public void setaBook(Book book)
{
    aBook = book;
}
public Book getaBook()
{
    return aBook;
}

public void setbooksRead(ArrayList<Book> j)
{
    booksRead = j;
}

public ArrayList<Book> getbooksRead()
{
    return booksRead;
}
}

class Book{
String name;
LocalDate start_date;
LocalDate end_date;
boolean archived;
Queue<Employee> Employees = new LinkedList<>();

public Book()
{

}

public void setBookName(String aBook)
{
    name = aBook;
}

public String getBookName()
{
    return name;
}

public void setStartDate(LocalDate starting)
{
    start_date = starting;
}

public LocalDate getStartDate()
{
    return start_date;
}

public void setEndDate(LocalDate ending)
{
    end_date = ending;
}

public LocalDate getEndDate()
{
    return end_date;
}

public void setArchived(boolean ba)
{
    archived = ba;
}

public boolean isArchived()
{
    return archived;
}

public void setQueue(Queue<Employee> qa)
{
    Employees = qa;
}

public Queue<Employee> getQueue()
{
    return Employees;
}
}

公共类分配11{
公共静态void main（字符串[]args）{
ArrayList employeeArray=新的ArrayList（）；
ArrayList bookstocyclate=新的ArrayList（）；
ArrayList archivedbooks=新的ArrayList（）；
int passAndCirc=0；
int totalEmployees=0；
addBook（“软件工程”，booksToCirculate）；
addBook（“化学”，booksToCirculate）；
addEmployee（“Adam”，图书流通，employeeArray）；
addEmployee（“Sam”，booksToCirculate，employeeArray）；
addEmployee（“Ann”，booksToCirculate，employeeArray）；
流通书籍（“化学”，“1999 03 20”，书籍流通，员工数组）；
//流通图书（“软件工程”，“1998 02 20”，图书流通，员工数组）；
passOn（“化学”、“1999 03 25”、员工阵列、档案册、图书流通）；
passOn（“化学”，“1999 03 29”，员工阵列，档案册，图书流通）；
passOn（“化学”，“1999 03 30”，员工阵列，档案册，图书流通）；
passOn（“软件工程”，“1998 02 21”，员工阵列，档案册，图书流通）；
//passOn（“软件工程”，“1998 02 29”，员工阵列，档案册，图书流通）；
}
publicstaticvoidaddemployee（字符串aName、arraylistbookstocirculate、arraylistemployeearray）
{
员工anEmployee=新员工（）；
anEmployee.setName（aName）；
employeeArray.add（一个雇员）；
用于（b册：图书流通）
{
b、 getQueue（）.add（anEmployee）；//将员工添加到每个队列中
}
System.out.println（anEmployee.getName（）+“已添加到每个队列和员工列表中。”）；
}
公共静态void addBook（字符串aName、数组列表booksToCirculate）
{
Book aBook=新书（）；
aBook.setBookName（aName）；
aBook.setArchived（false）；
//aBook.setStartDate（LocalDate.now（））；//看起来不错
图书流通。添加（aBook）；
System.out.println（aBook.getBookName（）+“已添加到库中。”）；
}
公共静态void循环书（字符串aName、字符串aDate、ArrayList booksToCirculate、ArrayList employeeArray）
{
DateTimeFormatter formatter=DateTimeFormatter.of模式（“yyyy-MM-dd”）；
LocalDate DateStart=formatter.parse（aDate，LocalDate:：from）；//日期采用2015 11 05格式
Employee-anEmployee=null；
Book aBook=null；
队列员工=新建LinkedList（）；
用于（b册：图书流通）
{
如果（b.getBookName（）.equals（aName））
{
b、 设置开始日期（日期开始）；
anEmployee=b.getQueue（）.poll（）；
aBook=b；
Employees=b.getQueue（）；
b、 设置队列（员工）；
}
}
用于（b册：图书流通）
{
如果（！b.getBookName（）.equals（aName））
{
b、 设置队列（员工）；
b、 getQueue（）.add（一个雇员）；
}
}
for（员工e:employeeArray）
{
如果（e.getName（）.equals（anEmployee.getName（）））
{
//System.out.println（e.getName（））；
e、 setaBook（aBook）；
e、 设置保留时间（0）；
System.out.println（e.getName（）+“将书”+e.getaBook（）.getBookName（）+“交给他：”+e.getaBook（）.getStartDate（）+“将他/她的等待时间设置为”+e.getRetainingTime（）+”）；
}
}
}
公共静态void passOn（字符串aName、字符串aDate、ArrayList employeeArray、ArrayList archivedBooks、ArrayList booksToCirculate）
{
Employee-anEmployee=null；
Book aBook=null；
队列员工=新建LinkedList（）；
DateTimeFormatter formatter=DateTimeFormatter.of模式（“yyyy-MM-dd”）；
LocalDate datePassed=formatter.parse（aDate，LocalDate:：from）；
LocalDate-dateReceived；
本地日期开始日期；
int daysElapsed=0；
int daysElapsed2=0；
for（员工e:employeeArray）
{
***************************************************************************     
if（e.getaBook（）.getBookName（）！=null）//错误在哪里
如果（e.getaBook（）.getBookName（）.equals（aName））{
{
startDate=e.getaBook（）.getStartDate（）；
Period Period=Period.between（开始日期，已通过日期）；
daysElapsed2=period.getDays（）；
e、 设置保留时间（daysElapsed2）；
System.out.println（e.getName（）+“已传递”+e.getaBook（）.getBookName（）+“将其保留时间更改为”+daysElapsed2+”）；
}
}
}
//**************************************************************************
用于（b册：图书流通）
{
外部环路：
如果（b.getBookName（）.equals（aName））
{
if（b.getQueue（）.isEmpty（））
{
b、 setEndDate（日期已过）；
增加（b）；
b、 setEndDate（日期已过）；
b、 设置存档（真）；
System.out.println（“书籍”+b.getBookName（）+“已存档”）；
断开外环；
}
dateReceived=b.getStartDate（）；
Period Period=Period.between（dateReceived，datePassed）；
daysElapsed=period.getDays（）；
anEmployee=b.getQueue（）.poll（）；
a员工。设置等待时间（daysElapsed）；
一名雇员。setaBook（b）；
aBook=b；
Employees=b.getQueue（）；
b、 设置队列（员工）；
}
}
用于（b册：图书流通）
{
如果（！b.getBookName（）.equals（aName））
{
b、 设置队列（员工）；
b、 getQueue（）.add（一个雇员）；
}
}
for（员工e:employeeArray）
{
如果（e.getName（）.equals（anEmployee.getName（）））
{
 for (Employee e : employeeArray)
{

    if (e!=null && e.getaBook()!=null &&e.getaBook().getBookName() != null && e.getaBook().getBookName().equals(aName))  //modified code

           startDate = e.getaBook().getStartDate();
            Period period = Period.between ( startDate, datePassed );
            daysElapsed2 = period.getDays();
            e.setRetainingTime(daysElapsed2);
            System.out.println(e.getName() + " has passed on "+ e.getaBook().getBookName()+" changing his/her's retaining time to " + daysElapsed2+ ".");
   }

}