Value of Boolean changes when assign to variable - java

I'm doing tokenize the line(String).

I have to tokenize literally this line.

class Main { into [ "class" , "Main", "{" ]

The progress is like there are conditions I variablized like boolean conditionA = (isSpace && isSymbol) .

and In the for loop I inspect a character of the line. In example above, like inspect c and l and a .. so on.

And Here is problem.

I made a boolean variable

private static boolean isTailWhiteSpace = 
Character.isWhitespace(currentChar) && !tempWord.isEmpty();

Character.isWhitespace(currentChar) in currentChar is a space right next to class in class Main {

Because currentChar is now holding a space value, so isWhiteSpace is true.

!tempWord.isEmpty() in tempWord is a class so tempWord holds "class" .

Also, tempWord is now holding "class" so the value is !false . So true .

I expected their value to be true && true . So the variable holds these result also true.

But It didn't work like I expected.

Because I didn't believe my self over computer, So I checked debugger.

And declaration of isTailwhiteSpace .

How can isTailWhiteSpace be false?

I also checked the possible side effects, But the isTailWhiteSpace is only used once and never redeclared.

And for more information, This is usage of above code if statement,

else if(isTailWhiteSpace){
tokenizedLine.add(tempWord);
tempWord = "";
}

Here is reproducible code.

import java.util.ArrayList;
import java.util.Arrays;
class BooleanDemo {
private static String tempWord = "";
private static char currentChar;
private static boolean isTailWhiteSpace = Character.isWhitespace(currentChar) && !tempWord.isEmpty();
//Just for symbol checking
private static final Character[] symbols = {
'(', ')', '{', '}', '[', ']', '.', ',', ';', '+', '-', '*', '/', '|', '&', '<', '>', '=', '~'
};
private static final ArrayList<Character> symbolList = new ArrayList<>(Arrays.asList(symbols));
private static boolean isSymbol = symbolList.contains(currentChar);
public static ArrayList<String> tokenize(String line){
ArrayList<String> tokenizedLine = new ArrayList<>();
for(char c : line.toCharArray()){
currentChar = c;
if(isTailWhiteSpace){
tokenizedLine.add(tempWord);
tempWord = "";
}else if(!isSymbol){
tempWord += currentChar;
}else{
System.out.println("else");
}
}
return tokenizedLine;
}
public static void main(String[] args){
String sampleLine = "class Main {";
System.out.println(BooleanDemo.tokenize(sampleLine));
//Expected Result = ["class", "Main", "{"]
}
}

After the initial initialization, you did not dynamically refresh the value of isTailWhiteSpace in the code

private static boolean isTailWhiteSpace = Character.isWhitespace(currentChar) && !tempWord.isEmpty();
isTailWhiteSpace = true && false;

Can you understand this code：

String a = "";
boolean b = true && a.isEmpty();
a = "abc";
System.out.println(b); // I think, although the value of a has changed, but b is still true

You need to recalculate the value of isTailWhiteSpace whenever tempWord changes. If I give a and b as an example, it should be like this:

String a = "";
boolean b = true && a.isEmpty();
System.out.println(b); // b is true
a = "abc";
System.out.println(b); // I think, although the value of a has changed, but b is still true
b = true && a.isEmpty();
System.out.println(b); // now, b is false

In you code:

if(isTailWhiteSpace){
tokenizedLine.add(tempWord);
tempWord = "";
// here, tempWord changed, you need to recalculate
}else if(!isSymbol){
tempWord += currentChar;
// here, tempWord changed, you need to recalculate
}else{
System.out.println("else");
}

Working, don't have much time, you can handle the details yourself, or you can extract a method to calculate isTailWhiteSpace

The concept you are looking for is a procedure, and not an assignment.

For example, you're assigning the variable as follows.

private static boolean isTailWhiteSpace = 
    Character.isWhitespace(currentChar) && !tempWord.isEmpty();

I imagine, you are presuming that whenever you call isTailWhiteSpace, that it will run the assignment statement.
In other words, currentChar would be a different value.

What you're looking for here is a procedure, which Java refers to as methods.

private static boolean isTailWhiteSpace() {
    return Character.isWhitespace(currentChar) && !tempWord.isEmpty();
}

Furthermore, the conditional statement can be reduced.
If the Character.isWhitespace(currentChar) expression returns true, then !tempWord.isEmpty() will, hence, be true.

The String#isEmpty method is just a quicker way of typing string.length == 0.
In fact, if you review the source-code for isEmpty you'll find that, that is the exact statement it executes.

@Override
public boolean isEmpty() {
    return value.length == 0;
}

Similarly, your isSymbol statement will not execute its assignment when it is resolved within the code.
You'll have to change this to a method, as well.

private static boolean isSymbol() {
    return symbolList.contains(currentChar);
}

Since there are now methods, make sure to append the opening and closing parentheses on their usages.

Finally, to derive a list that also contains a symbols character, you'll need a new else-if conditional within your for-loop.

I am not sure where you require the println for "else", so I added it to the appending block.

for(char c : line.toCharArray()){
    currentChar = c;
    if(isTailWhiteSpace()) {
        tokenizedLine.add(tempWord);
        tempWord = "";
    } else if (isSymbol()) {
        tokenizedLine.add(String.valueOf(currentChar));
    }else {
        System.out.println("else");
        tempWord += currentChar;
    }
}

So, altogether, your code would be as follows.

private static String tempWord = "";
private static char currentChar;

private static boolean isTailWhiteSpace() {
    return Character.isWhitespace(currentChar);
}

//Just for symbol checking
private static final Character[] symbols = {
    '(', ')', '{', '}', '[', ']', '.', ',', ';', '+', '-', '*', '/', '|', '&', '<', '>', '=', '~'
};
private static final ArrayList<Character> symbolList = new ArrayList<>(Arrays.asList(symbols));

private static boolean isSymbol() {
    return symbolList.contains(currentChar);
}

public static ArrayList<String> tokenize(String line){
    ArrayList<String> tokenizedLine = new ArrayList<>();

    for(char c : line.toCharArray()){
        currentChar = c;
        if(isTailWhiteSpace()) {
            tokenizedLine.add(tempWord);
            tempWord = "";
        } else if (isSymbol()) {
            tokenizedLine.add(String.valueOf(currentChar));
        }else {
            System.out.println("else");
            tempWord += currentChar;
        }
    }

    return tokenizedLine;
}

public static void main(String[] args){
    String sampleLine = "class Main {";

    System.out.println(BooleanDemo.tokenize(sampleLine));
    //Expected Result = ["class", "Main", "{"]
}

This will yield the following output.

else
else
else
else
else
else
else
else
else
[class, Main, {]