Change
acronymAlphabets += Character.toUpperCase(separatedWords [i].charAt(0));
to
acronymAlphabets += Character.toUpperCase(separatedWords [i].charAt(0))+".";

Here is one way using streams.

String[] titles = {"Institute of Electrical and Electronics Engineers",     
    "Association for Computing MACHINERY",
    "Association of  Lions, and Tigers, and Bears, oh my!!"};

for (String title : titles) {
    System.out.println(createAcronym(title));
}

prints

I.E.E.E
A.C.M
A.L.T.B

• Split on anything that isn't a word and stream the array
• filter any words not starting with an upper case character.
• Map the first letter of each word to a String.
• and join together with a period between each word.

public static String createAcronym(String title) {
    return Arrays.stream(title.split("\\W+"))
            .filter(str -> Character.isUpperCase(str.charAt(0)))
            .map(str -> str.substring(0, 1))
            .collect(Collectors.joining("."));
}

Here's a solution that will include a starting letter if it is capitalized, and tack on a period (".") after any included letters.

A few comments:

• Line 3: a StringBuilder is an efficient, powerful way to make small additions to a String
• Line 5: use a "for" loop over the words (from line 2)
• Line 6: isolate the starting character of "word"
• Line 8: if firstChar is upper case, go ahead and append it to the StringBuilder result (no need to uppercase it again – it is already upper case or we wouldn't have made to line 8); and any time we append a letter, always go ahead and append a ".", too
• Line 12: once we're done with all of the words, conver the StringBuilder to a String, and return the result

1.  public static String createAcronym(String input) {
2.     String[] words = input.split(" ");
3.     StringBuilder result = new StringBuilder();
4.
5.     for (String word : words) {
6.         char firstChar = word.charAt(0);
7.         if (Character.isUpperCase(firstChar)) {
8.              result.append(firstChar).append(".");
9.         }
10.    }
11.
12.    return result.toString();
13. }

You could further improve this by editing Line 2: instead of calling split() with a single space (" "), you could instead use a regular expressions to split on any number of whitespaces, tabs, etc.

Don't you just need to append a period (.) after each letter.

Add the following line at the end of the loop.

acronymAlphabets += ".";

Footnote: I would say the Answer offered by Kaan above using StringBuilder is better. I have offered an Answer making minimal chances to the code in the question. Given the OP is a novice I believe it's unhelpful to introduce too many new ideas in a reply. In programming and Java there's usually a dozen ways to do anything. Bombarding novices with new concepts only confuses them. One step at a time if you ask me.

Other Answers, such as the one by WJS, give a direct, correct solution to the specifics of the Question: appending . to each capital letter. My Answer here is more for fun.

tl;dr

Using code points rather than char.

System.out.println(
        String.join(   // Join a bunch of strings into a single `String` object.
                "" ,   // Join the strings without any delimiter between them.
                Arrays.stream(  // Turn an array into a stream of elements for processing.
                                "Association of  Lions, and Tigers, and Bears, oh my!!"
                                        .split( " " )  // Returns an array of string objects, `String[]`. 
                        )
                        .filter( ( String part ) -> ! part.isBlank() )  // Skip any string elements without significant text.
                        .map( ( String part ) -> part.codePoints().boxed().toList() )  // Generate a stream of `int` integer numbers representing the code point numbers of each character in the string element. Via boxing, convert those `int` primitives into `Integer` objects. Collect the `Integer` objects into a `List`. 
                        .filter( ( List < Integer > codePoints ) -> Character.isUpperCase( codePoints.get( 0 ) ) )  // Skip any list of code points if the first code point represents a character other than an uppercase letter. 
                        .map( ( List < Integer > codePoints ) -> Character.toString( codePoints.get( 0 ) ) + "." )  // Extract the first code point `Integer` number, turn into a `String` containing the single character represented by that code point, and append a FULL STOP. 
                        .toList()  // Collect all those generated strings (single character plus FULL STOP) to a list.
        )
);

A.L.T.B.

Code points

I recommend making a habit of using code point integer numbers rather than the legacy char type. As a 16-bit value, char is physically incapable of representing most characters.

This code makes heavy use of streams. If not yet comfortable with streams, you could replace with conventional loops.

Pull apart the phrase.

    System.out.println( "input = " + input );
    String[] parts = input.split( " " );
    if ( parts.length == 0 ) { throw new IllegalArgumentException( "Input must consist of multiple words separated by spaces." ); }
    System.out.println( "parts = " + Arrays.toString( parts ) );

Convert each part of the phrase into code point integer numbers.

    List < List < Integer > > codePointsOfEachPart =
            Arrays
                    .stream( parts )
                    .filter( part -> ! part.isBlank() )
                    .map( part -> part.codePoints().boxed().toList() )
                    .toList();

Filter for those parts of the phrase that begin with an uppercase letter. From each of the qualifying parts, extract the first letter, append a FULL STOP, and collect to a list.

    List < String > abbreviations =
            codePointsOfEachPart
                    .stream()
                    .filter( ( List < Integer > codePoints ) -> Character.isUpperCase( codePoints.get( 0 ) ) )
                    .map( codePoints -> Character.toString( codePoints.get( 0 ) ) + "." )
                    .toList();

    // Join the collection of UppercaseLetter + FULL STOP combos into a single piece of text.
    String result = String.join( "" , abbreviations );

    return result;
}

When run:

input = Association of  Lions, and Tigers, and Bears, oh my!!
parts = [Association, of, , Lions,, and, Tigers,, and, Bears,, oh, my!!]
output = A.L.T.B.

Pull that all together for your copy-paste convenience.

private String acronym ( final String input )
{
    // Pull apart the phrase.
    System.out.println( "input = " + input );
    String[] parts = input.split( " " );
    if ( parts.length == 0 ) { throw new IllegalArgumentException( "Input must consist of multiple words separated by spaces." ); }
    System.out.println( "parts = " + Arrays.toString( parts ) );

    // Convert each part of the phrase into code point integer numbers.
    List < List < Integer > > codePointsOfEachPart =
            Arrays
                    .stream( parts )
                    .filter( part -> ! part.isBlank() )
                    .map( part -> part.codePoints().boxed().toList() )
                    .toList();

    // Filter for those parts of the phrase that begin with an uppercase letter.
    // From each of the qualifying parts, extract the first letter, append a FULL STOP, and collect to a list.
    List < String > abbreviations =
            codePointsOfEachPart
                    .stream()
                    .filter( ( List < Integer > codePoints ) -> Character.isUpperCase( codePoints.get( 0 ) ) )
                    .map( codePoints -> Character.toString( codePoints.get( 0 ) ) + "." )
                    .toList();

    // Join the collection of UppercaseLetter + FULL STOP combos into a single piece of text.
    String result = String.join( "" , abbreviations );

    return result;
}

That code could be shortened, into a single line of code! Not that I necessarily recommend doing so.

System.out.println(
        String.join(
                "" ,
                Arrays.stream(
                                "Association of  Lions, and Tigers, and Bears, oh my!!"
                                        .split( " " )
                        )
                        .filter( part -> ! part.isBlank() )
                        .map( part -> part.codePoints().boxed().toList() )
                        .filter( ( List < Integer > codePoints ) -> Character.isUpperCase( codePoints.get( 0 ) ) )
                        .map( codePoints -> Character.toString( codePoints.get( 0 ) ) + "." )
                        .toList()
        )
);

A.L.T.B.