diff --git a/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/Person.java b/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/Person.java
deleted file mode 100644
index 7c7088a0c7..0000000000
--- a/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/Person.java
+++ /dev/null
@@ -1,217 +0,0 @@
-package com.baeldung.comparing;
-
-import java.time.LocalDate;
-import java.util.Comparator;
-import java.util.Objects;
-
-public class Person {
-    public static class PersonWithoutEquals {
-        private String firstName;
-        private String lastName;
-
-        public PersonWithoutEquals(String firstName, String lastName) {
-            this.firstName = firstName;
-            this.lastName = lastName;
-        }
-    }
-
-    public static class PersonWithEquals {
-        private String firstName;
-        private String lastName;
-        private LocalDate birthDate;
-
-        public PersonWithEquals(String firstName, String lastName) {
-            if (firstName == null || lastName == null) {
-                throw new NullPointerException("Names can't be null");
-            }
-            this.firstName = firstName;
-            this.lastName = lastName;
-        }
-
-        public PersonWithEquals(String firstName, String lastName, LocalDate birthDate) {
-            this(firstName, lastName);
-
-            this.birthDate = birthDate;
-        }
-
-        public String firstName() {
-            return firstName;
-        }
-
-        public String lastName() {
-            return lastName;
-        }
-
-        public LocalDate birthDate() {
-            return birthDate;
-        }
-
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
-            PersonWithEquals that = (PersonWithEquals) o;
-            return firstName.equals(that.firstName) &&
-              lastName.equals(that.lastName) &&
-              Objects.equals(birthDate, that.birthDate);
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(firstName, lastName);
-        }
-    }
-
-    public static class PersonWithEqualsAndWrongComparable implements Comparable<PersonWithEqualsAndWrongComparable> {
-        private String firstName;
-        private String lastName;
-        private LocalDate birthDate;
-
-        public PersonWithEqualsAndWrongComparable(String firstName, String lastName) {
-            if (firstName == null || lastName == null) {
-                throw new NullPointerException("Names can't be null");
-            }
-            this.firstName = firstName;
-            this.lastName = lastName;
-        }
-
-        public PersonWithEqualsAndWrongComparable(String firstName, String lastName, LocalDate birthDate) {
-            this(firstName, lastName);
-
-            this.birthDate = birthDate;
-        }
-
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
-            PersonWithEqualsAndWrongComparable that = (PersonWithEqualsAndWrongComparable) o;
-            return firstName.equals(that.firstName) &&
-              lastName.equals(that.lastName) &&
-              Objects.equals(birthDate, that.birthDate);
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(firstName, lastName);
-        }
-
-        @Override
-        public int compareTo(PersonWithEqualsAndWrongComparable o) {
-            return this.lastName.compareTo(o.lastName);
-        }
-    }
-
-    public static class PersonWithEqualsAndComparable implements Comparable<PersonWithEqualsAndComparable> {
-        private String firstName;
-        private String lastName;
-        private LocalDate birthDate;
-
-        public PersonWithEqualsAndComparable(String firstName, String lastName) {
-            if (firstName == null || lastName == null) {
-                throw new NullPointerException("Names can't be null");
-            }
-            this.firstName = firstName;
-            this.lastName = lastName;
-        }
-
-        public PersonWithEqualsAndComparable(String firstName, String lastName, LocalDate birthDate) {
-            this(firstName, lastName);
-
-            this.birthDate = birthDate;
-        }
-
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
-            PersonWithEqualsAndComparable that = (PersonWithEqualsAndComparable) o;
-            return firstName.equals(that.firstName) &&
-              lastName.equals(that.lastName) &&
-              Objects.equals(birthDate, that.birthDate);
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(firstName, lastName);
-        }
-
-        @Override
-        public int compareTo(PersonWithEqualsAndComparable o) {
-            int lastNamesComparison = this.lastName.compareTo(o.lastName);
-            if (lastNamesComparison == 0) {
-                int firstNamesComparison = this.firstName.compareTo(o.firstName);
-                if (firstNamesComparison == 0) {
-                    if (this.birthDate != null && o.birthDate != null) {
-                        return this.birthDate.compareTo(o.birthDate);
-                    } else if (this.birthDate != null) {
-                      return 1;
-                    } else if (o.birthDate != null) {
-                        return -1;
-                    } else {
-                        return 0;
-                    }
-                } else {
-                    return firstNamesComparison;
-                }
-            } else {
-                return lastNamesComparison;
-            }
-        }
-    }
-
-    public static class PersonWithEqualsAndComparableUsingComparator implements Comparable<PersonWithEqualsAndComparableUsingComparator> {
-        private String firstName;
-        private String lastName;
-        private LocalDate birthDate;
-
-        public PersonWithEqualsAndComparableUsingComparator(String firstName, String lastName) {
-            if (firstName == null || lastName == null) {
-                throw new NullPointerException("Names can't be null");
-            }
-            this.firstName = firstName;
-            this.lastName = lastName;
-        }
-
-        public PersonWithEqualsAndComparableUsingComparator(String firstName, String lastName, LocalDate birthDate) {
-            this(firstName, lastName);
-
-            this.birthDate = birthDate;
-        }
-
-        public String firstName() {
-            return firstName;
-        }
-
-        public String lastName() {
-            return lastName;
-        }
-
-        public LocalDate birthDate() {
-            return birthDate;
-        }
-
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
-            PersonWithEqualsAndComparableUsingComparator that = (PersonWithEqualsAndComparableUsingComparator) o;
-            return firstName.equals(that.firstName) &&
-              lastName.equals(that.lastName) &&
-              Objects.equals(birthDate, that.birthDate);
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(firstName, lastName);
-        }
-
-        @Override
-        public int compareTo(PersonWithEqualsAndComparableUsingComparator o) {
-            return Comparator.comparing(PersonWithEqualsAndComparableUsingComparator::lastName)
-              .thenComparing(PersonWithEqualsAndComparableUsingComparator::firstName)
-              .thenComparing(PersonWithEqualsAndComparableUsingComparator::birthDate, Comparator.nullsLast(Comparator.naturalOrder()))
-              .compare(this, o);
-        }
-    }
-}
diff --git a/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithEquals.java b/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithEquals.java
new file mode 100644
index 0000000000..e3a61fc05a
--- /dev/null
+++ b/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithEquals.java
@@ -0,0 +1,51 @@
+package com.baeldung.comparing;
+
+import java.time.LocalDate;
+import java.util.Objects;
+
+public class PersonWithEquals {
+    private String firstName;
+    private String lastName;
+    private LocalDate birthDate;
+
+    public PersonWithEquals(String firstName, String lastName) {
+        if (firstName == null || lastName == null) {
+            throw new NullPointerException("Names can't be null");
+        }
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public PersonWithEquals(String firstName, String lastName, LocalDate birthDate) {
+        this(firstName, lastName);
+
+        this.birthDate = birthDate;
+    }
+
+    public String firstName() {
+        return firstName;
+    }
+
+    public String lastName() {
+        return lastName;
+    }
+
+    public LocalDate birthDate() {
+        return birthDate;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        PersonWithEquals that = (PersonWithEquals) o;
+        return firstName.equals(that.firstName) &&
+          lastName.equals(that.lastName) &&
+          Objects.equals(birthDate, that.birthDate);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(firstName, lastName);
+    }
+}
diff --git a/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithEqualsAndComparable.java b/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithEqualsAndComparable.java
new file mode 100644
index 0000000000..5611ce8a09
--- /dev/null
+++ b/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithEqualsAndComparable.java
@@ -0,0 +1,62 @@
+package com.baeldung.comparing;
+
+import java.time.LocalDate;
+import java.util.Objects;
+
+public class PersonWithEqualsAndComparable implements Comparable<PersonWithEqualsAndComparable> {
+    private String firstName;
+    private String lastName;
+    private LocalDate birthDate;
+
+    public PersonWithEqualsAndComparable(String firstName, String lastName) {
+        if (firstName == null || lastName == null) {
+            throw new NullPointerException("Names can't be null");
+        }
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public PersonWithEqualsAndComparable(String firstName, String lastName, LocalDate birthDate) {
+        this(firstName, lastName);
+
+        this.birthDate = birthDate;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        PersonWithEqualsAndComparable that = (PersonWithEqualsAndComparable) o;
+        return firstName.equals(that.firstName) &&
+          lastName.equals(that.lastName) &&
+          Objects.equals(birthDate, that.birthDate);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(firstName, lastName);
+    }
+
+    @Override
+    public int compareTo(PersonWithEqualsAndComparable o) {
+        int lastNamesComparison = this.lastName.compareTo(o.lastName);
+        if (lastNamesComparison == 0) {
+            int firstNamesComparison = this.firstName.compareTo(o.firstName);
+            if (firstNamesComparison == 0) {
+                if (this.birthDate != null && o.birthDate != null) {
+                    return this.birthDate.compareTo(o.birthDate);
+                } else if (this.birthDate != null) {
+                  return 1;
+                } else if (o.birthDate != null) {
+                    return -1;
+                } else {
+                    return 0;
+                }
+            } else {
+                return firstNamesComparison;
+            }
+        } else {
+            return lastNamesComparison;
+        }
+    }
+}
diff --git a/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithEqualsAndComparableUsingComparator.java b/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithEqualsAndComparableUsingComparator.java
new file mode 100644
index 0000000000..ed322cb353
--- /dev/null
+++ b/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithEqualsAndComparableUsingComparator.java
@@ -0,0 +1,60 @@
+package com.baeldung.comparing;
+
+import java.time.LocalDate;
+import java.util.Comparator;
+import java.util.Objects;
+
+public class PersonWithEqualsAndComparableUsingComparator implements Comparable<PersonWithEqualsAndComparableUsingComparator> {
+    private String firstName;
+    private String lastName;
+    private LocalDate birthDate;
+
+    public PersonWithEqualsAndComparableUsingComparator(String firstName, String lastName) {
+        if (firstName == null || lastName == null) {
+            throw new NullPointerException("Names can't be null");
+        }
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public PersonWithEqualsAndComparableUsingComparator(String firstName, String lastName, LocalDate birthDate) {
+        this(firstName, lastName);
+
+        this.birthDate = birthDate;
+    }
+
+    public String firstName() {
+        return firstName;
+    }
+
+    public String lastName() {
+        return lastName;
+    }
+
+    public LocalDate birthDate() {
+        return birthDate;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        PersonWithEqualsAndComparableUsingComparator that = (PersonWithEqualsAndComparableUsingComparator) o;
+        return firstName.equals(that.firstName) &&
+          lastName.equals(that.lastName) &&
+          Objects.equals(birthDate, that.birthDate);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(firstName, lastName);
+    }
+
+    @Override
+    public int compareTo(PersonWithEqualsAndComparableUsingComparator o) {
+        return Comparator.comparing(PersonWithEqualsAndComparableUsingComparator::lastName)
+          .thenComparing(PersonWithEqualsAndComparableUsingComparator::firstName)
+          .thenComparing(PersonWithEqualsAndComparableUsingComparator::birthDate, Comparator.nullsLast(Comparator.naturalOrder()))
+          .compare(this, o);
+    }
+}
diff --git a/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithEqualsAndWrongComparable.java b/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithEqualsAndWrongComparable.java
new file mode 100644
index 0000000000..e0bdaa413a
--- /dev/null
+++ b/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithEqualsAndWrongComparable.java
@@ -0,0 +1,44 @@
+package com.baeldung.comparing;
+
+import java.time.LocalDate;
+import java.util.Objects;
+
+public class PersonWithEqualsAndWrongComparable implements Comparable<PersonWithEqualsAndWrongComparable> {
+    private String firstName;
+    private String lastName;
+    private LocalDate birthDate;
+
+    public PersonWithEqualsAndWrongComparable(String firstName, String lastName) {
+        if (firstName == null || lastName == null) {
+            throw new NullPointerException("Names can't be null");
+        }
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public PersonWithEqualsAndWrongComparable(String firstName, String lastName, LocalDate birthDate) {
+        this(firstName, lastName);
+
+        this.birthDate = birthDate;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        PersonWithEqualsAndWrongComparable that = (PersonWithEqualsAndWrongComparable) o;
+        return firstName.equals(that.firstName) &&
+          lastName.equals(that.lastName) &&
+          Objects.equals(birthDate, that.birthDate);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(firstName, lastName);
+    }
+
+    @Override
+    public int compareTo(PersonWithEqualsAndWrongComparable o) {
+        return this.lastName.compareTo(o.lastName);
+    }
+}
diff --git a/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithoutEquals.java b/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithoutEquals.java
new file mode 100644
index 0000000000..bb4c6b958b
--- /dev/null
+++ b/core-java-modules/core-java-lang-2/src/main/java/com/baeldung/comparing/PersonWithoutEquals.java
@@ -0,0 +1,11 @@
+package com.baeldung.comparing;
+
+public class PersonWithoutEquals {
+    private String firstName;
+    private String lastName;
+
+    public PersonWithoutEquals(String firstName, String lastName) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+}
diff --git a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ComparableInterfaceUnitTest.java b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ComparableInterfaceUnitTest.java
index 6e10188852..281c4a0201 100644
--- a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ComparableInterfaceUnitTest.java
+++ b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ComparableInterfaceUnitTest.java
@@ -35,34 +35,34 @@ class ComparableInterfaceUnitTest {
 
     @Test
     void givenTwoPersonWithEqualsAndWrongComparableAndConsecutiveLastNames_whenCompareTo_thenNegative() {
-        Person.PersonWithEqualsAndWrongComparable richard = new Person.PersonWithEqualsAndWrongComparable("Richard", "Jefferson");
-        Person.PersonWithEqualsAndWrongComparable joe = new Person.PersonWithEqualsAndWrongComparable("Joe", "Portman");
+        PersonWithEqualsAndWrongComparable richard = new PersonWithEqualsAndWrongComparable("Richard", "Jefferson");
+        PersonWithEqualsAndWrongComparable joe = new PersonWithEqualsAndWrongComparable("Joe", "Portman");
 
         assertThat(richard.compareTo(joe)).isNegative();
     }
 
     @Test
     void givenTwoPersonWithEqualsAndWrongComparableAndSameLastNames_whenReversedCompareTo_thenZero() {
-        Person.PersonWithEqualsAndWrongComparable richard = new Person.PersonWithEqualsAndWrongComparable("Richard", "Jefferson");
-        Person.PersonWithEqualsAndWrongComparable mike = new Person.PersonWithEqualsAndWrongComparable("Mike", "Jefferson");
+        PersonWithEqualsAndWrongComparable richard = new PersonWithEqualsAndWrongComparable("Richard", "Jefferson");
+        PersonWithEqualsAndWrongComparable mike = new PersonWithEqualsAndWrongComparable("Mike", "Jefferson");
 
         assertThat(richard.compareTo(mike)).isZero();
     }
 
     @Test
     void givenTwoPersonWithEqualsAndWrongComparableAndConsecutiveLastNames_whenReversedCompareTo_thenPositive() {
-        Person.PersonWithEqualsAndWrongComparable richard = new Person.PersonWithEqualsAndWrongComparable("Richard", "Jefferson");
-        Person.PersonWithEqualsAndWrongComparable joe = new Person.PersonWithEqualsAndWrongComparable("Joe", "Portman");
+        PersonWithEqualsAndWrongComparable richard = new PersonWithEqualsAndWrongComparable("Richard", "Jefferson");
+        PersonWithEqualsAndWrongComparable joe = new PersonWithEqualsAndWrongComparable("Joe", "Portman");
 
         assertThat(joe.compareTo(richard)).isPositive();
     }
 
     @Test
     void givenTwoPersonWithEqualsAndWrongComparableAndSameLastNames_whenSortedSet_thenProblem() {
-        Person.PersonWithEqualsAndWrongComparable richard = new Person.PersonWithEqualsAndWrongComparable("Richard", "Jefferson");
-        Person.PersonWithEqualsAndWrongComparable mike = new Person.PersonWithEqualsAndWrongComparable("Mike", "Jefferson");
+        PersonWithEqualsAndWrongComparable richard = new PersonWithEqualsAndWrongComparable("Richard", "Jefferson");
+        PersonWithEqualsAndWrongComparable mike = new PersonWithEqualsAndWrongComparable("Mike", "Jefferson");
 
-        SortedSet<Person.PersonWithEqualsAndWrongComparable> people = new TreeSet<>();
+        SortedSet<PersonWithEqualsAndWrongComparable> people = new TreeSet<>();
         people.add(richard);
         people.add(mike);
 
@@ -71,34 +71,34 @@ class ComparableInterfaceUnitTest {
 
     @Test
     void givenTwoPersonWithEqualsAndComparableAndConsecutiveLastNames_whenCompareTo_thenNegative() {
-        Person.PersonWithEqualsAndComparable richard = new Person.PersonWithEqualsAndComparable("Richard", "Jefferson");
-        Person.PersonWithEqualsAndComparable joe = new Person.PersonWithEqualsAndComparable("Joe", "Portman");
+        PersonWithEqualsAndComparable richard = new PersonWithEqualsAndComparable("Richard", "Jefferson");
+        PersonWithEqualsAndComparable joe = new PersonWithEqualsAndComparable("Joe", "Portman");
 
         assertThat(richard.compareTo(joe)).isNegative();
     }
 
     @Test
     void givenTwoPersonWithEqualsAndComparableAndSameLastNames_whenReversedCompareTo_thenZero() {
-        Person.PersonWithEqualsAndComparable richard = new Person.PersonWithEqualsAndComparable("Richard", "Jefferson");
-        Person.PersonWithEqualsAndComparable mike = new Person.PersonWithEqualsAndComparable("Mike", "Jefferson");
+        PersonWithEqualsAndComparable richard = new PersonWithEqualsAndComparable("Richard", "Jefferson");
+        PersonWithEqualsAndComparable mike = new PersonWithEqualsAndComparable("Mike", "Jefferson");
 
         assertThat(richard.compareTo(mike)).isPositive();
     }
 
     @Test
     void givenTwoPersonWithEqualsAndComparableAndConsecutiveLastNames_whenReversedCompareTo_thenPositive() {
-        Person.PersonWithEqualsAndComparable richard = new Person.PersonWithEqualsAndComparable("Richard", "Jefferson");
-        Person.PersonWithEqualsAndComparable joe = new Person.PersonWithEqualsAndComparable("Joe", "Portman");
+        PersonWithEqualsAndComparable richard = new PersonWithEqualsAndComparable("Richard", "Jefferson");
+        PersonWithEqualsAndComparable joe = new PersonWithEqualsAndComparable("Joe", "Portman");
 
         assertThat(joe.compareTo(richard)).isPositive();
     }
 
     @Test
     void givenTwoPersonWithEqualsAndComparableAndSameLastNames_whenSortedSet_thenProblem() {
-        Person.PersonWithEqualsAndComparable richard = new Person.PersonWithEqualsAndComparable("Richard", "Jefferson");
-        Person.PersonWithEqualsAndComparable mike = new Person.PersonWithEqualsAndComparable("Mike", "Jefferson");
+        PersonWithEqualsAndComparable richard = new PersonWithEqualsAndComparable("Richard", "Jefferson");
+        PersonWithEqualsAndComparable mike = new PersonWithEqualsAndComparable("Mike", "Jefferson");
 
-        SortedSet<Person.PersonWithEqualsAndComparable> people = new TreeSet<>();
+        SortedSet<PersonWithEqualsAndComparable> people = new TreeSet<>();
         people.add(richard);
         people.add(mike);
 
diff --git a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ComparatorInterfaceUnitTest.java b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ComparatorInterfaceUnitTest.java
index a406b12752..769ae60bed 100644
--- a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ComparatorInterfaceUnitTest.java
+++ b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ComparatorInterfaceUnitTest.java
@@ -10,16 +10,16 @@ class ComparatorInterfaceUnitTest {
 
     @Test
     void givenListOfTwoPersonWithEqualsAndComparatorByFirstName_whenSort_thenSortedByFirstNames() {
-        Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman");
-        Person.PersonWithEquals allan = new Person.PersonWithEquals("Allan", "Dale");
+        PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
+        PersonWithEquals allan = new PersonWithEquals("Allan", "Dale");
 
-        List<Person.PersonWithEquals> people = new ArrayList<>();
+        List<PersonWithEquals> people = new ArrayList<>();
         people.add(joe);
         people.add(allan);
 
-        Comparator<Person.PersonWithEquals> compareByFirstNames = new Comparator<Person.PersonWithEquals>() {
+        Comparator<PersonWithEquals> compareByFirstNames = new Comparator<PersonWithEquals>() {
             @Override
-            public int compare(Person.PersonWithEquals o1, Person.PersonWithEquals o2) {
+            public int compare(PersonWithEquals o1, PersonWithEquals o2) {
                 return o1.firstName().compareTo(o2.firstName());
             }
         };
@@ -30,14 +30,14 @@ class ComparatorInterfaceUnitTest {
 
     @Test
     void givenListOfTwoPersonWithEqualsAndComparatorByFirstNameFunctionalStyle_whenSort_thenSortedByFirstNames() {
-        Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman");
-        Person.PersonWithEquals allan = new Person.PersonWithEquals("Allan", "Dale");
+        PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
+        PersonWithEquals allan = new PersonWithEquals("Allan", "Dale");
 
-        List<Person.PersonWithEquals> people = new ArrayList<>();
+        List<PersonWithEquals> people = new ArrayList<>();
         people.add(joe);
         people.add(allan);
 
-        Comparator<Person.PersonWithEquals> compareByFirstNames = Comparator.comparing(Person.PersonWithEquals::firstName);
+        Comparator<PersonWithEquals> compareByFirstNames = Comparator.comparing(PersonWithEquals::firstName);
         people.sort(compareByFirstNames);
 
         assertThat(people).containsExactly(allan, joe);
@@ -45,34 +45,34 @@ class ComparatorInterfaceUnitTest {
 
     @Test
     void givenTwoPersonWithEqualsAndComparableUsingComparatorAndConsecutiveLastNames_whenCompareTo_thenNegative() {
-        Person.PersonWithEqualsAndComparableUsingComparator richard = new Person.PersonWithEqualsAndComparableUsingComparator("Richard", "Jefferson");
-        Person.PersonWithEqualsAndComparableUsingComparator joe = new Person.PersonWithEqualsAndComparableUsingComparator("Joe", "Portman");
+        PersonWithEqualsAndComparableUsingComparator richard = new PersonWithEqualsAndComparableUsingComparator("Richard", "Jefferson");
+        PersonWithEqualsAndComparableUsingComparator joe = new PersonWithEqualsAndComparableUsingComparator("Joe", "Portman");
 
         assertThat(richard.compareTo(joe)).isNegative();
     }
 
     @Test
     void givenTwoPersonWithEqualsAndComparableUsingComparatorAndSameLastNames_whenReversedCompareTo_thenZero() {
-        Person.PersonWithEqualsAndComparableUsingComparator richard = new Person.PersonWithEqualsAndComparableUsingComparator("Richard", "Jefferson");
-        Person.PersonWithEqualsAndComparableUsingComparator mike = new Person.PersonWithEqualsAndComparableUsingComparator("Mike", "Jefferson");
+        PersonWithEqualsAndComparableUsingComparator richard = new PersonWithEqualsAndComparableUsingComparator("Richard", "Jefferson");
+        PersonWithEqualsAndComparableUsingComparator mike = new PersonWithEqualsAndComparableUsingComparator("Mike", "Jefferson");
 
         assertThat(richard.compareTo(mike)).isPositive();
     }
 
     @Test
     void givenTwoPersonWithEqualsAndComparableUsingComparatorAndConsecutiveLastNames_whenReversedCompareTo_thenPositive() {
-        Person.PersonWithEqualsAndComparableUsingComparator richard = new Person.PersonWithEqualsAndComparableUsingComparator("Richard", "Jefferson");
-        Person.PersonWithEqualsAndComparableUsingComparator joe = new Person.PersonWithEqualsAndComparableUsingComparator("Joe", "Portman");
+        PersonWithEqualsAndComparableUsingComparator richard = new PersonWithEqualsAndComparableUsingComparator("Richard", "Jefferson");
+        PersonWithEqualsAndComparableUsingComparator joe = new PersonWithEqualsAndComparableUsingComparator("Joe", "Portman");
 
         assertThat(joe.compareTo(richard)).isPositive();
     }
 
     @Test
     void givenTwoPersonWithEqualsAndComparableUsingComparatorAndSameLastNames_whenSortedSet_thenProblem() {
-        Person.PersonWithEqualsAndComparableUsingComparator richard = new Person.PersonWithEqualsAndComparableUsingComparator("Richard", "Jefferson");
-        Person.PersonWithEqualsAndComparableUsingComparator mike = new Person.PersonWithEqualsAndComparableUsingComparator("Mike", "Jefferson");
+        PersonWithEqualsAndComparableUsingComparator richard = new PersonWithEqualsAndComparableUsingComparator("Richard", "Jefferson");
+        PersonWithEqualsAndComparableUsingComparator mike = new PersonWithEqualsAndComparableUsingComparator("Mike", "Jefferson");
 
-        SortedSet<Person.PersonWithEqualsAndComparableUsingComparator> people = new TreeSet<>();
+        SortedSet<PersonWithEqualsAndComparableUsingComparator> people = new TreeSet<>();
         people.add(richard);
         people.add(mike);
 
diff --git a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/EqualsMethodUnitTest.java b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/EqualsMethodUnitTest.java
index 4775bc3de1..6ae243c0ff 100644
--- a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/EqualsMethodUnitTest.java
+++ b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/EqualsMethodUnitTest.java
@@ -49,24 +49,24 @@ class EqualsMethodUnitTest {
 
     @Test
     void givenTwoPersonWithoutEqualsWithSameNames_whenEquals_thenFalse() {
-        Person.PersonWithoutEquals joe = new Person.PersonWithoutEquals("Joe", "Portman");
-        Person.PersonWithoutEquals joeAgain = new Person.PersonWithoutEquals("Joe", "Portman");
+        PersonWithoutEquals joe = new PersonWithoutEquals("Joe", "Portman");
+        PersonWithoutEquals joeAgain = new PersonWithoutEquals("Joe", "Portman");
 
         assertThat(joe.equals(joeAgain)).isFalse();
     }
 
     @Test
     void givenTwoPersonWithEqualsWithSameNames_whenEquals_thenTrue() {
-        Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman");
-        Person.PersonWithEquals joeAgain = new Person.PersonWithEquals("Joe", "Portman");
+        PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
+        PersonWithEquals joeAgain = new PersonWithEquals("Joe", "Portman");
 
         assertThat(joe.equals(joeAgain)).isTrue();
     }
 
     @Test
     void givenTwoPersonWittEqualsWithDifferentNames_whenEquals_thenFalse() {
-        Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman");
-        Person.PersonWithEquals nathalie = new Person.PersonWithEquals("Nathalie", "Portman");
+        PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
+        PersonWithEquals nathalie = new PersonWithEquals("Nathalie", "Portman");
 
         assertThat(joe.equals(nathalie)).isFalse();
     }
diff --git a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/GuavaUnitTest.java b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/GuavaUnitTest.java
index 0a4d0dd8d3..42d3a606a0 100644
--- a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/GuavaUnitTest.java
+++ b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/GuavaUnitTest.java
@@ -1,18 +1,11 @@
 package com.baeldung.comparing;
 
 import com.google.common.base.Objects;
-import com.google.common.base.Strings;
 import com.google.common.collect.ComparisonChain;
-import com.google.common.primitives.Booleans;
-import com.google.common.primitives.Bytes;
 import com.google.common.primitives.Ints;
-import com.google.common.primitives.Shorts;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
-import java.util.ArrayList;
-import java.util.List;
-
 import static org.assertj.core.api.Assertions.assertThat;
 
 class GuavaUnitTest {
@@ -66,8 +59,8 @@ class GuavaUnitTest {
     class ComparisonChainClass {
         @Test
         void givenTwoPersonWithEquals_whenComparisonChainByLastNameThenFirstName_thenSortedJoeFirstAndNathalieSecond() {
-            Person.PersonWithEquals nathalie = new Person.PersonWithEquals("Nathalie", "Portman");
-            Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman");
+            PersonWithEquals nathalie = new PersonWithEquals("Nathalie", "Portman");
+            PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
 
             int comparisonResult = ComparisonChain.start()
               .compare(nathalie.lastName(), joe.lastName())
diff --git a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ObjectsEqualsStaticMethodUnitTest.java b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ObjectsEqualsStaticMethodUnitTest.java
index c26cb4e08c..0e24305d87 100644
--- a/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ObjectsEqualsStaticMethodUnitTest.java
+++ b/core-java-modules/core-java-lang-2/src/test/java/com/baeldung/comparing/ObjectsEqualsStaticMethodUnitTest.java
@@ -10,40 +10,40 @@ class ObjectsEqualsStaticMethodUnitTest {
 
     @Test
     void givenTwoPersonWithEqualsWithSameNames_whenObjectsEquals_thenTrue() {
-        Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman");
-        Person.PersonWithEquals joeAgain = new Person.PersonWithEquals("Joe", "Portman");
+        PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
+        PersonWithEquals joeAgain = new PersonWithEquals("Joe", "Portman");
 
         assertThat(Objects.equals(joe, joeAgain)).isTrue();
     }
 
     @Test
     void givenTwoPersonWithEqualsWithDifferentNames_whenObjectsEquals_thenFalse() {
-        Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman");
-        Person.PersonWithEquals nathalie = new Person.PersonWithEquals("Nathalie", "Portman");
+        PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
+        PersonWithEquals nathalie = new PersonWithEquals("Nathalie", "Portman");
 
         assertThat(Objects.equals(joe, nathalie)).isFalse();
     }
 
     @Test
     void givenTwoPersonWithEqualsFirstNull_whenObjectsEquals_thenFalse() {
-        Person.PersonWithEquals nobody = null;
-        Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman");
+        PersonWithEquals nobody = null;
+        PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
 
         assertThat(Objects.equals(nobody, joe)).isFalse();
     }
 
     @Test
     void givenTwoObjectsSecondtNull_whenObjectsEquals_thenFalse() {
-        Person.PersonWithEquals joe = new Person.PersonWithEquals("Joe", "Portman");
-        Person.PersonWithEquals nobody = null;
+        PersonWithEquals joe = new PersonWithEquals("Joe", "Portman");
+        PersonWithEquals nobody = null;
 
         assertThat(Objects.equals(joe, nobody)).isFalse();
     }
 
     @Test
     void givenTwoObjectsNull_whenObjectsEquals_thenTrue() {
-        Person.PersonWithEquals nobody = null;
-        Person.PersonWithEquals nobodyAgain = null;
+        PersonWithEquals nobody = null;
+        PersonWithEquals nobodyAgain = null;
 
         assertThat(Objects.equals(nobody, nobodyAgain)).isTrue();
     }