Final Exam: Lead Developer

  • 1 video | 32s
  • Includes Assessment
  • Earns a Badge
Rating 2.6 of 5 users Rating 2.6 of 5 users (5)
Final Exam: Lead Developer will test your knowledge and application of the topics presented throughout the Lead Developer track of the Skillsoft Aspire Apprentice Developer to Journeyman Developer Journey.


  • Recognize how type parameters can be applied not only to classes, but also to specific methods inside classes
    describe important methods of the list interface and how the .addall, .removeall, and .retainall methods work
    traverse a doubly linked list from the last element to the first
    describe how the overridden version of .equals can be used to control list equality operations
    describe the two limitations of an array
    recognize how the @deprecated annotation can be used to flag the instantiation of objects of deprecated classes at compile-time
    demonstrate that the @safevarargs annotation is purely indicative and does not perform any run time or compile checks
    demonstrate various relationships between base and derived classes in the presence of type parameters
    describe when you can use the .sublist method to get a part of a list
    describe how different implementations of the set interface differ in their notions of set order
    analyze algorithms with logarithmic time complexity
    recognize exactly what counts as a functional interface and what does not
    analyze compiled bytecode to see how java uses type erasure to ensure type safety and prevent code bloat
    describe how the .get, .set, .add, .indexof, and .lastindexof methods work
    pop elements from and peek into a stack implemented using linked lists
    create a treeset and sort it using various custom comparators
    differentiate between arraylists and linkedlists and the use cases where they are suitable
    describe how you can create a custom comparator
    use upper bounded wildcards to specify that a type parameter must be a sub-class of a certain type
    analyze algorithms with cubic time complexity
    pop elements from a stack implemented using arrays
    define a method, override it, and then mark that overridden version with the @override annotation
    dequeue elements in a queue implemented using arrays
    use the built-in classes in java for queues and stacks
    recognize how using type parameters can ensure both type safety and code reuse
    recognize what streams are and some of the methods you can invoke on them
    describe how you can iterate over lists using listiterator
    create a hashset object and invoke multiple methods on it, and also correctly override the .hashcode and .equals method of the contained class
    recognize the different types of sets and how they all extend the set, collection, and iterable interfaces
    apply default values to an element in annotation and also experiment with unnamed elements
  • demonstrate that predicates can be used to transform one stream object into another
    change the target policy to control exactly what code elements an annotation can be applied to
    demonstrate that custom objects can be keys or values in maps, but that in order to ensure that there are no duplicates you have to override the .hashcode and .equals methods of those contained objects correctly
    apply terminal operations on predicates
    differentiate between methods used to compute set union, difference, intersection, and equality operations
    recognize how the iterable and iterator interfaces can be accessed using loops to avoid run-time errors from going over the limits of a list
    dequeue elements in a queue implemented as a circular queue
    recognize how maps work and that they are very similar to their set counterparts
    differentiate between bounded and unbounded type parameters
    analyze algorithms with constant time complexity
    insert a new node at the head, count the number of nodes in a linked list
    recognize how type parameters may exist only in the base class, or only in the derived class, or in both
    describes the is-a relationship of an arraylist with collection, iterable, and list
    recognize use-cases where a base class specifies one type parameter and the derived class specifies multiple type parameters
    delete a node from a linked list and rewire the list
    describe how you can use the .copy function to take values from one list and put them in another
    count nodes and delete nodes in a circular linked list
    push new elements on to the stack implemented using arrays
    analyze algorithms with quadratic time complexity
    incorporate constraints, known as bounds, on type parameters
    analyze algorithms with linear time complexity
    insert a new node at the tail of the linked list
    apply the @override annotation to detect typographical errors in method names at compile-time rather than at run-time
    search for a node with specific data in a linked list
    enumerate different scenarios in which the @suppresswarnings annotation can be applied
    push new elements on to a stack implemented using linked list
    enqueue elements in a queue implemented using arrays
    recognize different aspects of specifying and using type parameters
    enqueue elements in a queue implemented as a circular queue
    describe how varargs are defined and used


Skillsoft is providing you the opportunity to earn a digital badge upon successful completion on some of our courses, which can be shared on any social network or business platform.

Digital badges are yours to keep, forever.


Rating 4.5 of 25 users Rating 4.5 of 25 users (25)
Rating 4.6 of 28 users Rating 4.6 of 28 users (28)