Please enable JavaScript.

Coggle requires JavaScript to display documents.

Level 3 - Coggle Diagram

- - - - HashMap<String, String> capitalCities = new HashMap<String, String>();
  - - - capitalCities.put("England", "London");
  - - - capitalCities.get("England");
  - - - capitalCities.remove("England");
  - - - Note: Use the keySet() method if you only want the keys, and use the values() method if you only want the values:
        
        for (String i : capitalCities.keySet()) {
        
        for (String i : capitalCities.values()) {
- - - - cars.add("Volvo"); cars.add("BMW"); cars.add("Ford"); cars.add("BMW"); cars.add("Mazda");
        
        Note: In the example above, even though BMW is added twice it only appears once in the set because every item in a set has to be unique.
  - - - cars.contains("Mazda");
  - - - cars.remove("Volvo");
    - - cars.clear();
  - - - cars.size();
  - - - for (String i : cars) {
- - - - Represents a date (year, month, day (yyyy-MM-dd))
    - - Represents a time (hour, minute, second and nanoseconds (HH-mm-ss-ns))
    - - Represents both a date and a time (yyyy-MM-dd-HH-mm-ss-ns)
    - - Formatter for displaying and parsing date-time objects
  - - - import java.time.LocalDate; // import the LocalDate class
        public class Main {
        public static void main(String[] args) {
        LocalDate myObj = LocalDate.now(); // Create a date object
        System.out.println(myObj); // Display the current date
        }
        }
  - - - import java.time.LocalTime; // import the LocalTime class
        public class Main {
        public static void main(String[] args) {
        LocalTime myObj = LocalTime.now();
        System.out.println(myObj);
        }
        }
        
        Display Current Date and Time
        
        To display the current date and time, import the java.time.LocalDateTime class, and use its now() method:
  - - - import java.time.LocalDateTime; // Import the LocalDateTime class
        import java.time.format.DateTimeFormatter; // Import the DateTimeFormatter class
        public class Main {
        public static void main(String[] args) {
        LocalDateTime myDateObj = LocalDateTime.now();
        System.out.println("Before formatting: " + myDateObj);
        DateTimeFormatter myFormatObj = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss");
        String formattedDate = myDateObj.format(myFormatObj); System.out.println("After formatting: " + formattedDate);
        }
        }
        
        Before Formatting: 2022-03-18T15:28:37.388049
        After Formatting: 18-03-2022 15:28:37
      - The ofPattern() method accepts all sorts of values, if you want to display the date and time in a different format. For example:
        
        yyyy-MM-dd "1988-09-29"
        
        dd/MM/yyyy "29/09/1988"
        
        dd-MMM-yyyy "29-Sep-1988"
        
        E, MMM dd yyyy "Thu, Sep 29 1988"
- - - - Getting an Iterator
        
        The iterator() method can be used to get an Iterator for any collection:
        
        // Import the ArrayList class and the Iterator class
        import java.util.ArrayList;
        import java.util.Iterator;
        public class Main {
        public static void main(String[] args) {
        // Make a collection ArrayList<String> cars = new ArrayList<String>(); cars.add("Volvo"); cars.add("BMW"); cars.add("Ford"); cars.add("Mazda"); // Get the iterator Iterator<String> it = cars.iterator(); // Print the first item System.out.println(it.next());
        }
        }
        
        Looping Through a Collection
        
        To loop through a collection, use the hasNext() and next() methods of the Iterator:
        
        while(it.hasNext()) {
        System.out.println(it.next());
        }
        
        Removing Items from a Collection
        
        Iterators are designed to easily change the collections that they loop through. The remove() method can remove items from a collection while looping.
        
        1 more item...
        
        Note: Trying to remove items using a for loop or a for-each loop would not work correctly because the collection is changing size at the same time that the code is trying to loop.
  - - - When an error occurs, Java will normally stop and generate an error message. The technical term for this is: Java will throw an exception (throw an error).
    - - The try statement allows you to define a block of code to be tested for errors while it is being executed.
        
        The catch statement allows you to define a block of code to be executed, if an error occurs in the try block.
        
        The try and catch keywords come in pairs:
        
        try {
        // Block of code to try
        }
        catch(Exception e) {
        // Block of code to handle errors
        }
    - - The finally statement lets you execute code, after try...catch, regardless of the result:
    - - The throw statement allows you to create a custom error.
        
        The throw statement is used together with an exception type. There are many exception types available in Java: ArithmeticException, FileNotFoundException, ArrayIndexOutOfBoundsException, SecurityException, etc:
        
        public class Main {
        static void checkAge(int age) {
        if (age < 18) {
        throw new ArithmeticException("Access denied - You must be at least 18 years old.");
        }
        else {
        System.out.println("Access granted - You are old enough!");
        }
        }
        public static void main(String[] args) {
        checkAge(15); // Set age to 15 (which is below 18...)
        }
        }
        
        The output will be:
        
        Exception in thread "main" java.lang.ArithmeticException: Access denied - You must be at least 18 years old.
        at Main.checkAge(Main.java:4)
        at Main.main(Main.java:12)
  - - - A regular expression can be a single character, or a more complicated pattern.
        
        Regular expressions can be used to perform all types of text search and text replace operations.
        
        Java does not have a built-in Regular Expression class, but we can import the java.util.regex package to work with regular expressions. The package includes the following classes:
        
        Pattern Class - Defines a pattern (to be used in a search)
        
        Matcher Class - Used to search for the pattern
        
        PatternSyntaxException Class - Indicates syntax error in a regular expression pattern
        
        Find out if there are any occurrences of the word "w3schools" in a sentence:
        
        import java.util.regex.Matcher;
        import java.util.regex.Pattern;
        public class Main {
        public static void main(String[] args) {
        Pattern pattern = Pattern.compile("w3schools", Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher("Visit W3Schools!");
        boolean matchFound = matcher.find();
        if(matchFound) {
        System.out.println("Match found");
        } else {
        System.out.println("Match not found");
        }
        }
        }
        
        Example Explained
        
        1 more item...
        
        Flags
        
        Flags in the compile() method change how the search is performed. Here are a few of them:
        
        Pattern.CASE_INSENSITIVE - The case of letters will be ignored when performing a search.
        
        Pattern.LITERAL - Special characters in the pattern will not have any special meaning and will be treated as ordinary characters when performing a search.
        
        Pattern.UNICODE_CASE - Use it together with the CASE_INSENSITIVE flag to also ignore the case of letters outside of the English alphabet
- - - - Data abstraction is the process of hiding certain details and showing only essential information to the user.
        Abstraction can be achieved with either abstract classes or interfaces (which you will learn more about in the next chapter).
        
        The abstract keyword is a non-access modifier, used for classes and methods:
        
        Abstract class: is a restricted class that cannot be used to create objects (to access it, it must be inherited from another class).
        
        An abstract class can have both abstract and regular methods:
        
        it is not possible to create an object of the Animal class:
        
        To access the abstract class, it must be inherited from another class. Let's convert the Animal class we used in the Polymorphism chapter to an abstract class:
        
        1 more item...
        
        Abstract method: can only be used in an abstract class, and it does not have a body. The body is provided by the subclass (inherited from).
      - Why And When To Use Abstract Classes and Methods?
        
        To achieve security - hide certain details and only show the important details of an object.
  - - - An interface is a completely "abstract class" that is used to group related methods with empty bodies:
        
        // interface
        interface Animal {
        public void animalSound(); // interface method (does not have a body)
        public void run(); // interface method (does not have a body)
        }
        
        To access the interface methods, the interface must be "implemented" (kinda like inherited) by another class with the implements keyword (instead of extends). The body of the interface method is provided by the "implement" class:
        
        // Interface
        interface Animal {
        public void animalSound(); // interface method (does not have a body)
        public void sleep(); // interface method (does not have a body)
        }
        // Pig "implements" the Animal interface
        class Pig implements Animal {
        public void animalSound() {
        // The body of animalSound() is provided here
        System.out.println("The pig says: wee wee");
        }
        public void sleep() {
        // The body of sleep() is provided here
        System.out.println("Zzz");
        }
        }
        class Main {
        public static void main(String[] args) {
        Pig myPig = new Pig(); // Create a Pig object
        myPig.animalSound();
        myPig.sleep();
        }
        }
    - - Interface methods do not have a body - the body is provided by the "implement" class
        
        On implementation of an interface, you must override all of its methods
        
        Interface methods are by default abstract and public
        
        Interface attributes are by default public, static and final
        
        An interface cannot contain a constructor (as it cannot be used to create objects)
    - - 1) To achieve security - hide certain details and only show the important details of an object (interface).
      - 2) Java does not support "multiple inheritance" (a class can only inherit from one superclass). However, it can be achieved with interfaces, because the class can implement multiple interfaces. Note: To implement multiple interfaces, separate them with a comma (see example below).
        
        Multiple Interfaces
        
        class DemoClass implements FirstInterface, SecondInterface
- - - - To create an enum, use the enum keyword (instead of class or interface), and separate the constants with a comma. Note that they should be in uppercase letters:
        
        enum Level {
        LOW,
        MEDIUM,
        HIGH
        }
        
        You can access enum constants with the dot syntax:
        
        Level myVar = Level.MEDIUM;
    - - The enum type has a values() method, which returns an array of all enum constants. This method is useful when you want to loop through the constants of an enum:
        
        for (Level myVar : Level.values()) {
        System.out.println(myVar);
        }
    - - Use enums when you have values that you know aren't going to change, like month days, days, colors, deck of cards, etc.
  - - - To use the Scanner class, create an object of the class and use any of the available methods found in the Scanner class documentation. In our example, we will use the nextLine() method, which is used to read Strings:
        
        import java.util.Scanner; // Import the Scanner class
        class Main {
        public static void main(String[] args) {
        Scanner myObj = new Scanner(System.in); // Create a Scanner object
        System.out.println("Enter username");
        String userName = myObj.nextLine(); // Read user input System.out.println("Username is: " + userName); // Output user input
        }
        }
        
        Note: If you enter wrong input (e.g. text in a numerical input), you will get an exception/error message (like "InputMismatchException").
- - - - import java.util.ArrayList; // import the ArrayList class
        ArrayList<String> cars = new ArrayList<String>(); // Create an ArrayList object
        
        The ArrayList class has many useful methods.
        
        For example, to add elements to the ArrayList, use the add() method
        
        cars.add("Volvo");
        
        To access an element in the ArrayList, use the get() method and refer to the index number:
        
        cars.get(0);
        
        To modify an element, use the set() method and refer to the index number:
        
        cars.set(0, "Opel");
        
        To remove an element, use the remove() method and refer to the index number:
        
        cars.remove(0);
        
        To remove all the elements in the ArrayList, use the clear() method:
        
        cars.clear();
        
        To find out how many elements an ArrayList have, use the size method:
        
        cars.size();
    - - You can also loop through an ArrayList with the for-each loop:
        
        for (String i : cars) {
    - - Another useful class in the java.util package is the Collections class, which include the sort() method for sorting lists alphabetically or numerically:
        
        Collections.sort(cars); // Sort cars
- - - - The ArrayList class has a regular array inside it. When an element is added, it is placed into the array. If the array is not big enough, a new, larger array is created to replace the old one and the old one is removed.
    - - The LinkedList stores its items in "containers." The list has a link to the first container and each container has a link to the next container in the list. To add an element to the list, the element is placed into a new container and that container is linked to one of the other containers in the list.
    - - Use an ArrayList for storing and accessing data, and LinkedList to manipulate data.