Day: September 9, 2021

How to create java sms

import requests

endPoint = 'https://api.mnotify.com/api/template'
apiKey = 'YOUR_API_KEY'
url = endPoint + '?key=' + apiKey
response = requests.get(url)
data = response.json();

Before Java 8, methods had to throw an exception or return null, with neither of which approaches were perfect. Optional, OptionalInt, OptionalLong, and OptionalDouble were introduced in Java 8 to represent values that might possibly be null.

Optionals have two internal states, empty or present. An Optional is empty if the underlying reference is null. An Optional is present when the underlying reference is not null.

Although there are many ways to use Optionals, chaining optionals usually provides for writing clear and concise code, especially when complex filtering is required.

At the end of this tutorial, you would have learned:

1. How to use Optional methods map() and filter().

1. Java 8.
2. Java functional concepts: Optional, method reference.

1. A Java IDE with at least JDK 8 support.

To follow along with this tutorial, perform the steps below:

1. Create a new empty Java 8+ project.

2. Create a new package com.example.

3. Create a new Java class called Entry.

4. Create the main() method inside the Entry class.

5. Create two LocalDate constants inside the Entry class like below:

    private static final LocalDate GEN_ALPHA = LocalDate.ofYearDay(2010,1); //1
    private static final LocalDate GEN_Z = LocalDate.ofYearDay(1997, 1); //2

6. Add a convenient method for checking if a LocalDate instance is considered a Gen Z.

    private static boolean isGenZ(LocalDate d){ //7
       return (d.isEqual(GEN_Z) || d.isAfter(GEN_Z)) && d.isBefore(GEN_ALPHA);
    }

Our project is very simple to understand. The two LocalDate constants declared on lines 1 and 2 represent the beginning date for 2 demographics cohorts: Alpha and Gen Z. The convenient method declared on line 7 contains logic to check whether a date(birthday) can be classified as Gen Z.

The method Optional#get should never be used directly without checking whether the Optional is present(or NOT empty). If Optional#get is called directly, the program will throw NoSuchElementException at runtime.

Add this method inside the Entry class.

private static void noCheckOpt(){ //8
   Optional<LocalDate> opt = Optional.empty();

   LocalDate ogDate = opt.get(); //9

   if(isGenZ(ogDate)){
       LocalDate modifiedDate = ogDate
               .plusYears(1)
               .plusMonths(5)
               .plusDays(10);
       System.out.println(modifiedDate);
   }
}

The method above tries to get the underlying LocalDate object from an Optional, and then tries to create a new date in the if block only if the ogDate is a Gen Z date.

The code snippet deliberately instantiated an empty Optional to simulate a situation where an Optional object received from an API can be empty. Professional code should never be written like this.

After calling the method above from main(), we can see that the code throws NoSuchElementException as expected.

To avoid the program throwing NoSuchElementException, the most basic thing that a developer can do is to at least check the Optional object whether it contains a value with Optional#isEmpty or Optional#isPresent.

The method below adds the presence check.

private static void checkOpt(){ //10
   Optional<LocalDate> opt = Optional.empty(); //11

   if(opt.isPresent()){ //12
       LocalDate ogDate = opt.get(); //13
       if(isGenZ(ogDate)){ //14
           LocalDate modifiedDate = ogDate //15
                   .plusYears(1)
                   .plusMonths(5)
                   .plusDays(10);
           System.out.println(modifiedDate);
       }
   }
}

If we comment out the call to the previous method, and then call this method, our code should not be throwing any exception anymore. It finds that the Optional opt is empty at line 12, so it stops executing the rest of the method.

But this method has a problem. It is very verbose. By having to check whether the Optional is empty AND whether the underlying LocalDate is Gen Z, we now have nested if blocks. We also added two variable declarations.

To improve readability, we can use builtin Optional methods Optional#filter and Optional#map like the code snippet below.

private static void optChain(){ //16
   Optional.<LocalDate>empty() //17
           .filter(Entry::isGenZ) //18
           .map(d -> d.plusYears(1).plusMonths(5).plusDays(10)) //19
           .ifPresent(System.out::println); //20
}

To understand how this method works, let us review what the previous method was doing, from start to finish:

1. Check whether the Optional is empty.
2. Check whether the underlying LocalDate object is a Gen Z.
3. If it is Gen Z, transform it.
4. Prints out the LocalDate.

The filter() and map() methods automatically perform the Optional emptiness check for us, and return an empty Optional object downstream, so we do not have to write the checks ourselves. It is only at the last step that we have to call ifPresent(), and ifPresent() is certainly more readable than a manual if block, therefore it increases readability.

Another added benefit of using filter(), map(), and ifPresent() is that we can pass a lambda or a method reference into them, increasing readability even more.

    package com.example;

    import java.time.LocalDate;
    import java.util.Optional;

    public class Entry {
       private static final LocalDate GEN_ALPHA = LocalDate.ofYearDay(2010,1); //1
       private static final LocalDate GEN_Z = LocalDate.ofYearDay(1997, 1); //2

       public static void main(String... args){ //3
           //noCheckOpt(); //4
           //checkOpt(); //5
           //optChain(); //6
       }

       private static boolean isGenZ(LocalDate d){ //7
           return (d.isEqual(GEN_Z) || d.isAfter(GEN_Z)) && d.isBefore(GEN_ALPHA);
       }

       private static void noCheckOpt(){ //8
           Optional<LocalDate> opt = Optional.empty();

           LocalDate ogDate = opt.get(); //9

           if(isGenZ(ogDate)){
               LocalDate modifiedDate = ogDate
                       .plusYears(1)
                       .plusMonths(5)
                       .plusDays(10);
               System.out.println(modifiedDate);
           }
       }

       private static void checkOpt(){ //10
           Optional<LocalDate> opt = Optional.empty(); //11

           if(opt.isPresent()){ //12
               LocalDate ogDate = opt.get(); //13
               if(isGenZ(ogDate)){ //14
                   LocalDate modifiedDate = ogDate //15
                           .plusYears(1)
                           .plusMonths(5)
                           .plusDays(10);
                   System.out.println(modifiedDate);
               }
           }
       }

       private static void optChain(){ //16
           Optional.<LocalDate>empty() //17
                   .filter(Entry::isGenZ) //18
                   .map(d -> d.plusYears(1).plusMonths(5).plusDays(10)) //19
                   .ifPresent(System.out::println); //20
       }

    }

Manually checking for Optional presence works, but there are a lot of convenient methods that we can use together with lambdas and method reference sugar syntax. Surely it does cost some extra time to look them up, but the benefits to readability would be worth it.

The full project code can be found here https://github.com/dmitrilc/DaniWebJavaOptionalChaining/tree/master

Java 15 introduced Text Blocks. The main reason behind Text Blocks is that programmers can write multiline strings without having to specify escapes for the most common scenarios.

At the end of this tutorial, you would have learned:

1. How to store multiline String using Text Block.
2. Some edge cases to watch out for when using Text Blocks.

1. Basic Java

1. A Java IDE with support for JDK 15+.

A Text Block can be used anywhere a String literal can be used. Instead of one pair of double quotes used in String literals, a Text Block uses 3 pairs of double quotes.

Here is a traditional multiline String of an HTML document:

    var html = "<!DOCTYPE html>\n" +
           "<html>\n" +
           "    <head>\n" +
           "    </head>\n" +
           "    <body>\n" +
           "        <p>Hello World</p>\n" +
           "    </body>\n" +
           "</html>";

And here is a Text Block:

    var html = """
           <!DOCTYPE html>
           <html>
               <head>
               </head>
               <body>
                   <p>Hello World</p>
               </body>
           </html>
           """;

As you can see, the version using the Text Block no longer has to add the new line character (\n) and concatenate every new line. Removing the need for String concatenation also removes all of the extra double quotes () and plus signs (+), improving readability.

Text Block has compiler support, so syntax errors are mostly obvious. But there are quite a few edge cases that programmers should watch out for when working with Text Blocks.

If the closing triple quotes are on a new line of their own, Java will insert an extra new line character (\n) at the end.

This method will return a String with an extra new line at the end.

private static String withNewline(){
   return  """
           Hello
           World
           """;
}

While this method will return a String without an extra new line.

private static String noNewline(){
   return """
           Hello
           World""";
}

Both are valid code that will compile, but the behavior will not be flagged by IDEs and can certainly catch programmers off guard.

IDEs tend to insert extra spaces and tabs when formatting our code, but how does javac (the compiler) determine whether some white space is part of the String?

Take a look at the withNewline() method below. There are at least 16 spaces from the beginning of the line to the word Hello.

To simplify the concept, we only need to remember that the starting position of the closing triple quotes is the cutoff point. Everything before that will be discarded by the compiler.

   private static String zeroSpaces(){
       return  """
               Hello
               World
               """;
   }

   private static String eightSpaces(){
       return  """
               Hello
               World
       """;
   }

   private static String sixteenSpaces(){
       return  """
               Hello
               World
""";
   }

The 3 methods above exemplify the different positions of the closing triple quotes. They print:

Hello
World
        Hello
        World
                Hello
                World

When a final new line is purposely skipped by the programmer, you must use the String#indent method to set the indentation of the Text Block.

private static String fourSpaces(){
   return """
           Hello
           World""".indent(4);
}

Output:

    Hello
    World

Just like leading white space, trailing white space is also stripped out by the compiler. There are 3 official strategies that you can adapt to preserve trailing white spaces: character substitution, character fence, and octal escape sequence for space. You can find the code for these methods below.

private static String charSub() {
   return """
           Hello$$$$
           World
           """.replace('$', ' ');
}

private static String charFence() {
   return """
           Hello   |
           World|
           """.replace("|\n", "\n");
}

private static String octalEscape() {
   return """
           Hello\040\040\040
           World
           """;
}

It is hard to tell if the output actually preserved the trailing white spaces, but it is possible if you place your cursor at the end of the output in your IDE terminal. In IntelliJ, I can highlight the extra white spaces on the lines that were preserved like the screenshot below.

package com.example;

public class Entry {

   public static void main(String[] args){

   }

   private static String noBlock(){
       var html = "<!DOCTYPE html>\n" +
               "<html>\n" +
               "    <head>\n" +
               "    </head>\n" +
               "    <body>\n" +
               "        <p>Hello World</p>\n" +
               "    </body>\n" +
               "</html>";

       return html;
   }

   private static String textBlock(){
       var html = """
               <!DOCTYPE html>
               <html>
                   <head>
                   </head>
                   <body>
                       <p>Hello World</p>
                   </body>
               </html>
               """;

       return html;
   }

   private static String withNewline(){
       return  """
               Hello
               World
               """;
   }

   private static String noNewline(){
       return """
               Hello
               World""";
   }

   private static String zeroSpaces(){
       return  """
               Hello
               World
               """;
   }

   private static String eightSpaces(){
       return  """
               Hello
               World
       """;
   }

   private static String sixteenSpaces(){
       return  """
               Hello
               World
""";
   }

   private static String fourSpaces(){
       return """
               Hello
               World""".indent(4);
   }

   private static String charSub() {
       return """
               Hello$$$$
               World
               """.replace('$', ' ');
   }

   private static String charFence() {
       return """
               Hello   |
               World|
               """.replace("|\n", "\n");
   }

   private static String octalEscape() {
       return """
               Hello\040\040\040
               World
               """;
   }

}

Because we have given up precision for convenience, it is important to keep these edge cases in mind when working with Text Blocks, especially when storing white space-sensitive documents. For example, XML-based documents are more forgiving than something like Python, Yaml, when white spaces are used incorrectly.

You can find all of the code used in this article here https://github.com/dmitrilc/DaniWebJavaTextBlock/tree/master