Please enable JavaScript.

Coggle requires JavaScript to display documents.

Level 4 - Coggle Diagram

- - - - Threads can be used to perform complicated tasks in the background without interrupting the main program.
    - - There are two ways to create a thread.
        
        It can be created by extending the Thread class and overriding its run() method:
        
        public class Main extends Thread {
        public void run() {
        System.out.println("This code is running in a thread");
        }
        }
        
        Running Threads
        
        If the class extends the Thread class, the thread can be run by creating an instance of the class and call its start() method:
        
        public class Main extends Thread {
        public static void main(String[] args) {
        Main thread = new Main();
        thread.start();
        System.out.println("This code is outside of the thread");
        }
        public void run() {
        System.out.println("This code is running in a thread");
        }
        }
        
        If the class implements the Runnable interface, the thread can be run by passing an instance of the class to a Thread object's constructor and then calling the thread's start() method:
        
        public class Main implements Runnable {
        public static void main(String[] args) {
        Main obj = new Main();
        Thread thread = new Thread(obj);
        thread.start();
        System.out.println("This code is outside of the thread");
        }
        public void run() {
        System.out.println("This code is running in a thread");
        }
        }
        
        Another way to create a thread is to implement the Runnable interface:
        
        public class Main implements Runnable {
        public void run() {
        System.out.println("This code is running in a thread");
        }
        }
        
        Differences between "extending" and "implementing" Threads
        
        The major difference is that when a class extends the Thread class, you cannot extend any other class, but by implementing the Runnable interface, it is possible to extend from another class as well, like: class MyClass extends OtherClass implements Runnable.
    - - Because threads run at the same time as other parts of the program, there is no way to know in which order the code will run. When the threads and main program are reading and writing the same variables, the values are unpredictable. The problems that result from this are called concurrency problems.
        
        A code example where the value of the variable amount is unpredictable:
        
        public class Main extends Thread {
        public static int amount = 0;
        public static void main(String[] args) {
        Main thread = new Main();
        thread.start();
        System.out.println(amount);
        amount++;
        System.out.println(amount);
        }
        public void run() {
        amount++;
        }
        }
        
        To avoid concurrency problems, it is best to share as few attributes between threads as possible. If attributes need to be shared, one possible solution is to use the isAlive() method of the thread to check whether the thread has finished running before using any attributes that the thread can change.
        
        Use isAlive() to prevent concurrency problems:
        
        public class Main extends Thread {
        public static int amount = 0;
        public static void main(String[] args) {
        Main thread = new Main();
        thread.start();
        // Wait for the thread to finish
        while(thread.isAlive()) {
        System.out.println("Waiting...");
        }
        // Update amount and print its value
        System.out.println("Main: " + amount);
        amount++;
        System.out.println("Main: " + amount);
        }
        public void run() {
        amount++;
        }
        }
  - - - The simplest lambda expression contains a single parameter and an expression:
        
        parameter -> expression
        
        To use more than one parameter, wrap them in parentheses:
        
        (parameter1, parameter2) -> expression
        
        Expressions are limited. They have to immediately return a value, and they cannot contain variables, assignments or statements such as if or for. In order to do more complex operations, a code block can be used with curly braces. If the lambda expression needs to return a value, then the code block should have a return statement.
        
        (parameter1, parameter2) -> { code block }
    - - Lambda expressions are usually passed as parameters to a function:
        
        Use a lamba expression in the ArrayList's forEach() method to print every item in the list:
        
        import java.util.ArrayList;
        public class Main {
        public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<Integer>();
        numbers.add(5);
        numbers.add(9);
        numbers.add(8);
        numbers.add(1);
        numbers.forEach( (n) -> { System.out.println(n); } );
        }
        }
        
        Lambda expressions can be stored in variables if the variable's type is an interface which has only one method. The lambda expression should have the same number of parameters and the same return type as that method. Java has many of these kinds of interfaces built in, such as the Consumer interface (found in the java.util package) used by lists.
        
        Use Java's Consumer interface to store a lambda expression in a variable:
        
        import java.util.ArrayList;
        import java.util.function.Consumer;
        public class Main {
        public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<Integer>();
        numbers.add(5);
        numbers.add(9);
        numbers.add(8);
        numbers.add(1);
        Consumer<Integer> method = (n) -> { System.out.println(n); };
        numbers.forEach( method );
        }
        }
        
        1 more item...
- - - - To use the File class, create an object of the class, and specify the filename or directory name:
        
        import java.io.File; // Import the File class
        File myObj = new File("filename.txt"); // Specify the filename
    - - To create a file in Java, you can use the createNewFile() method. This method returns a boolean value: true if the file was successfully created, and false if the file already exists. Note that the method is enclosed in a try...catch block. This is necessary because it throws an IOException if an error occurs (if the file cannot be created for some reason):
        
        import java.io.File; // Import the File class
        import java.io.IOException; // Import the IOException class to handle errors
        public class CreateFile {
        public static void main(String[] args) {
        try {
        File myObj = new File("filename.txt");
        if (myObj.createNewFile()) {
        System.out.println("File created: " + myObj.getName());
        } else {
        System.out.println("File already exists.");
        }
        } catch (IOException e) {
        System.out.println("An error occurred.");
        e.printStackTrace();
        }
        }
        }
        
        To create a file in a specific directory (requires permission), specify the path of the file and use double backslashes to escape the "\" character (for Windows). On Mac and Linux you can just write the path, like: /Users/name/filename.txt
        
        File myObj = new File("C:\Users\MyName\filename.txt");
      - Write To a File
        
        In the following example, we use the FileWriter class together with its write() method to write some text to the file we created in the example above. Note that when you are done writing to the file, you should close it with the close() method:
        
        import java.io.FileWriter; // Import the FileWriter class
        import java.io.IOException; // Import the IOException class to handle errors
        public class WriteToFile {
        public static void main(String[] args) {
        try {
        FileWriter myWriter = new FileWriter("filename.txt");
        myWriter.write("Files in Java might be tricky, but it is fun enough!");
        myWriter.close();
        System.out.println("Successfully wrote to the file.");
        } catch (IOException e) {
        System.out.println("An error occurred.");
        e.printStackTrace();
        }
        }
        }
      - Java Read Files
        
        Read a File
        
        In the following example, we use the Scanner class to read the contents of the text file we created in the previous chapter:
        
        import java.io.File; // Import the File class
        import java.io.FileNotFoundException; // Import this class to handle errors
        import java.util.Scanner; // Import the Scanner class to read text files
        public class ReadFile {
        public static void main(String[] args) {
        try {
        File myObj = new File("filename.txt");
        Scanner myReader = new Scanner(myObj);
        while (myReader.hasNextLine()) {
        String data = myReader.nextLine();
        System.out.println(data);
        }
        myReader.close();
        } catch (FileNotFoundException e) {
        System.out.println("An error occurred.");
        e.printStackTrace();
        }
        }
        }
      - Java Delete Files
        
        To delete a file in Java, use the delete() method:
        
        import java.io.File; // Import the File class
        public class DeleteFile {
        public static void main(String[] args) {
        File myObj = new File("filename.txt");
        if (myObj.delete()) {
        System.out.println("Deleted the file: " + myObj.getName());
        } else {
        System.out.println("Failed to delete the file.");
        }
        }
        }
        
        Delete a Folder
        
        You can also delete a folder. However, it must be empty:
        
        import java.io.File;
        public class DeleteFolder {
        public static void main(String[] args) {
        File myObj = new File("C:\Users\MyName\Test");
        if (myObj.delete()) {
        System.out.println("Deleted the folder: " + myObj.getName());
        } else {
        System.out.println("Failed to delete the folder.");
        }
        }
        }