Cannot resolve symbol string java ошибка

When a user refers to a variable that hasn’t been declared in the application, the “can’t find symbol” error occurs. To put it another way, the compiler isn’t aware of the variable’s declaration. For example:

class HelloCodeunderscored {
    public static void main( String args[] ) {
      int x = 15;
      int y =1 4;
      // result is not declared. It will show an error.
      result = x * y;
    }
}

What are possible solutions to this problem?

If you ever encounter this issue, you should review the code for the following scenarios:

• Make sure you’ve declared the variable, for example, int i = 15;. If int has not been written, the error may show.
• Also, see if the defined variable is outside the code, for example, if it is not a member of the HelloCodeunderscored class.
• Make sure you’re using the right case. If you declare a variable as var but access it as Var, it is an example of such a scenario.
• Numbers, dollar signs, and hyphens are not allowed in identifier values; check for them.

Errors in Compilation Time

The compiler examines and checks the code for various things during compilation, including reference types, type casts, and method declarations, to mention a few. This stage of the compilation process is crucial since it is here that we will encounter a compilation mistake.

Compile-time mistakes can be divided into three categories:

Syntax errors

One of the most common programming errors is failing to use a semicolon at the end of a statement; other typical errors include forgetting imports, mismatching parentheses, and omitting the return statement.

Type-checking errors

This is a method of ensuring that our code is type-safe. With this check, we provide that the kinds of expressions are consistent. If we define a variable of type int, we should never assign a value of type double or String to it.

Compiler will crash

Meanwhile, there’s a chance the compiler will crash. It is exceptionally uncommon, but it does happen. In this scenario, it’s good to know that the issue isn’t with our code but with something else.

Compilers follow a set of rules that are specific to each language. If a code doesn’t follow these requirements, the compiler won’t be able to convert it, resulting in a compilation error. The key to resolving the “Cannot find symbol” compilation problem is to figure out what’s causing it.

We may deduce the line of code where the problem occurred and which element is incorrect from the error message. Knowing the most common causes of this mistake will make it easier and faster to resolve.

Symbol Tables: An Overview

Compilers construct and maintain symbol tables, which are significant data structures for storing information related to identifiers in source code. This information is placed into symbol tables during lexical and syntactic analysis and subsequently used in the compilation process.

The identifiers of classes, interfaces, variables, and methods are bound to correspond entries in the symbol tables when the declarations are processed. When these identifiers appear in source code, the compiler looks them up in the symbol tables. It uses that information to confirm that a variable has been declared, establish the variable’s scope, and do type checking to ensure that an expression is semantically correct.

Symbol tables are also employed in the creation and optimization of code. The following is a simplified representation of a symbol table entry (or simply a symbol) in Java:

<symbol name (identifier), type, scope, [attributes]>

The comparable notation for a global variable declaration, such as final double ratio, would be <ratio, double, global, [final]>.

Error: Cannot Find Symbol

As the name implies, the cannot locate symbol error refers to a symbol that you cannot find. While there are a variety of causes for this, they all boil down to the Java compiler being unable to locate the symbol associated with a given identifier.

Two more fields are included in the compiler’s message for the cannot locate symbol error:

“symbol” refers to the name and type of the referenced identifier. On the other hand, “location” refers to the class where the identifier is used.

What causes the symbol cannot be found error?

The following are the most typical causes of the cannot locate symbol compile-time error:

• Variable and method declarations missing,
• References to variables and methods being out of scope
• misspelled identifiers, and
• omitted import statements.

Symbol Not Found vs. Cannot Find Symbol vs. Cannot Resolve Symbol

The cannot find symbol issue can also be encountered under the words symbol not found and cannot resolve symbol, as different Java compilers use somewhat different wording. Apart from the names, there is no difference between the meanings of these phrases.

Examples of “Cannot Find Symbol Error.”

Some of these “Cannot find symbol error” are as follows:

Handling an undeclared variable

The cannot find symbol error is raised when the Java compiler encounters an identifier it can’t find in the symbol table. As a result, the most common cause of this error is when a reference to an undeclared variable is made. Unlike some other languages, which don’t require explicit variable declarations or may enable declaring a variable after it’s been referenced (through hoisting ), Java requires that a variable be declared before being used or referenced in any form.

Figure (a) shows how an undeclared variable, in this case, the identifier average on line 9, causes two instances of the cannot find symbol error at the code’s locations. Figure (b) resolves the issue by declaring this variable with its data type (or inferring its kind with the var keyword in Java 10+).

Figure (a)

package codeunderscored;

public class CodeUndeclaredVariable {
    public static void main(String... args) {
        int x = 16;
        int y = 20;
        int z = 42;

        averageResults = (x + y + z) / 3.0; // averageResults is not declared
        System.out.println(averageResults);
    }
}

Figure (b)

package codeunderscored;

public class UndeclaredVariable {
    public static void main(String... args) {
        int x = 16;
        int y = 20;
        int z = 42;

        double averageResults = (x + y + z) / 3.0;
        System.out.println(averageResults);
    }
}

Dealing with an Out of scope variable

The compiler throws the cannot find symbol error when a Java application tries to access a variable declared in a separate (non-inherited or non-overlapping) scope. The effort to try and have access to the variable counter on lines 17 and 18 in Figure (a), which is only available within the statement declared on line 11, demonstrates this. Figure (b) indicates that moving the counter variable outside the for loop resolves the problem.

Figure (a)

package codeunderscored;

import java.util.Arrays;
import java.util.List;

public class CodeOutOfScopeVariable {
    public static void main(String... args) {
        final List<String> strings = Arrays.asList("Hello", "Codeunderscored");
        final String searchFor = "Codeunderscored";

        for (int counter = 0; counter < strings.size(); counter++) {
            if (strings.get(counter).equals(searchFor)) {
                break;
            }
        }

        if (counter < strings.size()) {
            System.out.println("The word " + searchFor + " was found at index " +    counter);
        } else {
            System.out.println("The word " + searchFor + " wasn't found");
        }
    }
}

Figure (b)

package codeunderscored;

import java.util.Arrays;
import java.util.List;

public class CodeOutOfScopeVariable {
    public static void main(String... args) {
        final List<String> strings = Arrays.asList("Hello", "Codeunderscored");
        final String searchFor = "Codeunderscored";
        int counter;

        for (counter = 0; counter < strings.size(); counter++) {
            if (strings.get(counter).equals(searchFor)) {
                break;
            }
        }

        if (counter < strings.size()) {
            System.out.println("The word " + searchFor + " was found at index " + counter);
        } else {
            System.out.println("The word " + searchFor + " wasn't found");
        }
    }
}

Figures (a) & (b): Error and resolution for not being able to discover a symbol for an out-of-scope variable.

Method name misspelled

A cannot locate symbol error is caused by misspelling an existing method or any valid identifier. Because Java identifiers are case-sensitive, any change of an existing variable, method, class, interface, or package name, as shown in Figure (b), will result in this error.

Figure (a)

package codeunderscored;

public class CodeMisspelledMethodName {

    static int fibonacci(int n) {
        if (n == 0) return 0;
        if (n == 1) return 1;
        return fibonacci(n - 1) + fibonacci(n - 2);
    }

    public static void main(String... args) {
        int fibResult = Fibonacci(20); // Fibonacci ≠ fibonacci
        System.out.println(fibResult);
    }
}

Figure (b)

package codeunderscored;

public class CodeMisspelledMethodName {
    static int fibonacci(int n) {
        if (n == 0) return 0;
        if (n == 1) return 1;
        return fibonacci(n - 1) + fibonacci(n - 2);
    }

    public static void main(String... args) {
        int fibResult = fibonacci(20);
        System.out.println(fibResult);
    }
}

Error Figure (a) and resolution Figure (b): Cannot find the symbol for a misspelled method name

An import statement is missing

Using classes, whether from the Java platform or a library, necessitates appropriately importing them using the import statement. If you don’t, the Java compiler will complain about a symbol that can’t be found. The java.util package is used in the code sample in Figure (a). The cannot locate symbol issue arises because the list class was created without specifying the necessary import. The problem is solved by adding the missing import statement line 4 in Figure (b).

Figure (a)

package codeunderscored;

import java.util.Arrays;

public class CodeMissingImportList {
    private static final List<String> CONSTANTS = Arrays.asList("A", "B", "C");

    public static void main(String... args) {
        System.out.println(CONSTANTS);
    }
}

Figure (b)

package codeunderscored;

import java.util.Arrays;
import java.util.List;

public class CodeMissingImportList {
    private static final List<String> CONSTANTS = Arrays.asList("A", "B", "C");

    public static void main(String... args) {
        System.out.println(CONSTANTS);
    }
}

Figure (a) Error and resolution (b): Cannot find the symbol for missing import

Examples that aren’t as common

The fundamental cause of the Java error cannot locate the symbol is sometimes found in unexpected or hidden areas. It is the case when a sentence is prematurely terminated by an unintentional semicolon Figure (a) or when object creation is attempted without a correct constructor invocation, which must include the new keyword Figure 6.

Figure (a)

package codeunderscored;

public class CodeLoopScope {

public static void main(String... args) {
        int start = 1, end = 10;
        for (int i = start; i <= end; i++); {
            System.out.print(i == end ? i : i + ", ");
        }
    }
}

Figure (b)

package codeunderscored;

public class CodeLoopScope {
    public static void main(String... args) {
        int start = 1, end = 10;
        for (int i = start; i <= end; i++) {
            System.out.print(i == end ? i : i + ", ");
        }
    }
}

Unable to locate a symbol for a prematurely stopped loop Figure (a) error and Figure (b) resolution

Figure (a)

package codeunderscored;

public class CodeObjectCreation {
    public static void main(String... args) {
        String s = String("Hello Codeunderscored!");
        System.out.println(s);
    }
}

Figure (b)

package codeunderscored;

public class CodeObjectCreation {
    public static void main(String... args) {
        String s = new String("Hello Codeunderscored!");
        System.out.println(s);
    }
}

Figure (a) Error and Figure (b) Resolution for Cannot Find Symbol Constructor Call

Other reasons for the problem “can’t find symbol” include:

Here are a few instances where the “Cannot detect symbol” appears unexplainable until you investigate further.

Inability to find symbol ‘var’:

You’re presumably trying to compile source code with an older compiler or an older—source level that employs local variable type inference (i.e., a var declaration). In Java 10, the var was introduced. Check your JDK version, build files, and IDE settings (if this happens in an IDE).

You’re not compiling or recompiling anything

New Java programmers occasionally don’t grasp how the Java toolchain works or haven’t set up a repeatable “build process,” such as utilizing an IDE, Ant, Maven, Gradle, etc. In this case, the programmer may end up chasing his tail, looking for an imaginary fault that is caused by improper recompilation of the code, and so on.

Another example is when you compile and run a class with (Java 9+) java SomeClass.java. You’re likely to get “Cannot resolve symbol” errors referring to the 2nd class if the class depends on another class that you haven’t compiled (or recompiled). The other source file(s) are not compiled automatically. In addition, the new “compile and execute” mode of the java command isn’t suited for launching programs with multiple source code files.

Incorrect dependencies

If you use an IDE or a build tool that manages the build path and project dependencies, you may have made a mistake with the dependencies; for example, you may have left out a dependency or chosen the incorrect version. Check the project’s build file if you’re using a build tool (Ant, Maven, Gradle, etc.). Further, examine the project’s build path setup if you’re using an IDE.

An issue with a previous build

It’s possible that a previous build failed, so a JAR file was created with missing classes. You would usually note such failure if you were using a build tool. If you acquire JAR files from someone else, you’ll have to rely on them constructing correctly and catching mistakes.

Use tar -tvf when you need to list the suspected JAR files contents if you suspect this.

Problems with Android

When programming for Android and seeing “Cannot discover symbol” issues linked to R, keep in mind that the context.xml file defines the R symbols. Check that your context.xml file is valid and in the right location and that the R class file for it has been generated and compiled. Because Java symbols are case sensitive, the corresponding XML ids are as well.

Other symbol problems on Android are most frequently caused by the factors mentioned above, such as missing or inaccurate dependencies, wrong package names, methods or fields that don’t exist in a specific API version, spelling/typing issues, and so on.

Problems with the IDE

People have reported occasions when their IDE becomes confused, and the compiler in the IDE cannot detect a class that already exists… or vice versa. If the IDE is set up with the incorrect JDK version, it can happen.

If the IDE’s caches become out of sync with the file system, it can happen.

There are IDE-specific solutions to this. The latter could be a problem in the IDE. For example, there is a typical case of how Eclipse incorrectly handled a Maven “test” tree. That particular bug, it appears, was fixed a long time ago.

Homoglyphs

It’s possible to have identifiers that appear the same but aren’t because they contain homoglyphs if you use UTF-8 encoding for your source files. You can circumvent this by limiting the source file encoding to ASCII or Latin-1 and utilizing Java uxxxx escapes for additional characters.

Hidden System classes

We’ve seen situations when the compiler complains that substring is an unknown symbol, such as this.

String s = ...
String s1 = s.substring(1);

It turns out that the programmer had written their version of String, which lacked substring operations. It has been done with System, Scanner, and other classes in the past.

Overall, don’t use the same names as common library classes when defining your classes! You can also use fully qualified names to remedy the situation. In the preceding example, the programmer may have written:

java.lang.String s = ...

java.lang.String s1 = s.substring(1);

What should I do about these errors?

• In general, you should start by determining what triggered the compilation mistake.
• Examine the line in the file that the compilation error notice refers to.
• Determine which symbol the error message is referring to.
• Figure out why the compiler says it can’t find the symbol; check the section above!
• Then you consider what your code is trying to communicate.
• Subsequently, try to figure out what changes you need to make to your source code to get it to do what you want.

It’s worth noting that not every “correction” is accurate. Consider the following:

for (int i = 1; i < 10; i++) {
    for (j = 1; j < 10; j++) {
        ...
    }
}

Assume the compiler says for j, “Cannot find symbol.” There are several ways we could “correct” this:

• We suppose we could edit the inner for to for (int j = 1; j< 10; j++) – which would be correct.
• Alternatively, we could put a declaration for j before the inner or outer for loops, which would probably be correct.
• In the inner for loop, we could also change j to i, and that would be incorrect! and so forth. To discover the proper remedy, you must first understand what your code is attempting to accomplish.

Example: how erroneous variable scoping can result in a “Cannot find symbol” error

List<String> stringsVar = ...

for (int i = 0; i < stringsVar.size(); i++) {
    if (stringsVar.get(i).equalsIgnoreCase("fnord")) {
        break;
    }
}
if (i < strings.size()) {
    ...
}

For i in the if statement, this will result in a “Cannot find symbol” problem. Even though we earlier declared i, it only applies to the for statement and its body. The if statement’s reference to i cannot see that declaration of I because it is not within the project’s scope. A suitable correction would be to place the if statement within the loop or declare I before the loop begins.)

Example: an apparently strange “Cannot find symbol” issue caused by a typo

for (int i = 0; i < 100; i++); {
    System.out.println("i is " + i);
}

It will result in a compilation error in the println call, indicating that i is missing. But (as you point out), we did declare it!

The issue is the semicolon (;) that appears before the {. In that instance, a semicolon is an empty statement according to the Java language syntax. The for loop’s body is therefore made up of the empty statement. So here’s what that code actually means:

for (int i = 0; i < 100; i++);

// The previous and following are separate statements!!

{
    System.out.println("i is " + i);
}

The preceding declaration of i in the for statement is out of scope in the block. That is because the {…} block is not the body of the for loop.

Example: A “Cannot find symbol” error produced by a typo

int tmp = ...
  
int res = tmp(a + b);

The tmp in the tmp(…) phrase is incorrect, despite the earlier declaration. The compiler will look for a tmp method, but it will not locate one. The previously specified tmp is in the variables namespace, not the methods namespace. In one of the examples we saw, the programmer had forgotten to include an operator. This is what he wanted to write:

If you’re compiling from the command line, there’s another reason why the compiler might not discover a symbol. It’s possible that you just neglected to build or recompile another class.

For instance, suppose you have two classes, Secondary and Primary, and Secondary utilizes Primary. If you’ve never compiled Primary before and run javac Secondary.java, the compiler will likely fail because it can’t find the symbol Primary.

Compile Secondary and Primary together, for example, with javac Secondary.java Primary.java or javac *.java. Better still, utilize a Java build tool such as Ant, Maven, Gradle, etc.

Conclusion

The cannot find symbol error, also known as a symbol not found and cannot resolve symbol, is a Java compile-time error that occurs when the compiler cannot figure out what an identifier in the source code refers to. As with every other compilation fault, it’s critical to figure out what’s causing it, isolate the problem, and fix it effectively.

This error is mainly caused by referring to undeclared variables and methods, such as by misspelling them or failing to import their associated package. As seen in this article, once a problem has been identified, resolving it is relatively simple.

Query:

Please explain the following about “Cannot find symbol”, “Cannot resolve symbol” or “Symbol not found” errors (in Java).

“Cannot find symbol”, “Cannot resolve symbol” and “Symbol not found” all mean the same thing. Different Java compilers use different phraseology.

Firstly, it is a compilation error¹. It means that either there is a problem in your Java source code, or there is a problem in the way that you are compiling it.

Your Java source code consists of the following things:

• Keywords: like class, while, and so on.
• Literals: like true, false, 42, 'X' and "Hi mum!".
• Operators and other non-alphanumeric tokens: like +, =, {, and so on.
• Identifiers: like Reader, i, toString, processEquibalancedElephants, and so on.
• Comments and whitespace.

A “Cannot find symbol” error is about the identifiers. When your code is compiled, the compiler needs to work out what each and every identifier in your code means.

A “Cannot find symbol” error means that the compiler cannot do this. Your code appears to be referring to something that the compiler doesn’t understand.

What can cause a “Cannot find symbol” error?

As a first order, there is only one cause. The compiler looked in all of the places where the identifier should be defined, and it couldn’t find the definition. This could be caused by a number of things. The common ones are as follows:

• For identifiers in general:
  • Perhaps you spelled the name incorrectly; i.e. StringBiulder instead of StringBuilder. Java cannot and will not attempt to compensate for bad spelling or typing errors.
  • Perhaps you got the case wrong; i.e. stringBuilder instead of StringBuilder. All Java identifiers are case sensitive.
  • Perhaps you used underscores inappropriately; i.e. mystring and my_string are different. (If you stick to the Java style rules, you will be largely protected from this mistake …)
  • Perhaps you are trying to use something that was declared “somewhere else”; i.e. in a different context to where you have implicitly told the compiler to look. (A different class? A different scope? A different package? A different code-base?)
• For identifiers that should refer to variables:
  • Perhaps you forgot to declare the variable.
  • Perhaps the variable declaration is out of scope at the point you tried to use it. (See example below)
• For identifiers that should be method or field names:
  • Perhaps you are trying to refer to an inherited method or field that wasn’t declared in the parent / ancestor classes or interfaces.
  • Perhaps you are trying to refer to a method or field that does not exist (i.e. has not been declared) in the type you are using; e.g. "rope".push()².
  • Perhaps you are trying to use a method as a field, or vice versa; e.g. "rope".length or someArray.length().
  • Perhaps you are mistakenly operating on an array rather than array element; e.g. String strings[] = ... if (strings.charAt(3)) { ... } // maybe that should be 'strings[0].charAt(3)'
• For identifiers that should be class names:
  • Perhaps you forgot to import the class.
  • Perhaps you used “star” imports, but the class isn’t defined in any of the packages that you imported.
  • Perhaps you forgot a new as in: String s = String(); // should be 'new String()'
• For cases where type or instance doesn’t appear to have the member (e.g. method or field) you were expecting it to have:
  • Perhaps you have declared a nested class or a generic parameter that shadows the type you were meaning to use.
  • Perhaps you are shadowing a static or instance variable.
  • Perhaps you imported the wrong type; e.g. due to IDE completion or auto-correction may have suggested java.awt.List rather than java.util.List.
  • Perhaps you are using (compiling against) the wrong version of an API.
  • Perhaps you forgot to cast your object to an appropriate subclass.
  • Perhaps you have declared your variable’s type to be a supertype of the one with the member you are looking for.

The problem is often a combination of the above. For example, maybe you “star” imported java.io.* and then tried to use the Files class … which is in java.nio not java.io. Or maybe you meant to write File … which is a class in java.io.

Here is an example of how incorrect variable scoping can lead to a “Cannot find symbol” error:

List<String> strings = ...

for (int i = 0; i < strings.size(); i++) {
    if (strings.get(i).equalsIgnoreCase("fnord")) {
        break;
    }
}
if (i < strings.size()) {
    ...
}

This will give a “Cannot find symbol” error for i in the if statement. Though we previously declared i, that declaration is only in scope for the for statement and its body. The reference to i in the if statement cannot see that declaration of i. It is out of scope.

(An appropriate correction here might be to move the if statement inside the loop, or to declare i before the start of the loop.)

Here is an example that causes puzzlement where a typo leads to a seemingly inexplicable “Cannot find symbol” error:

for (int i = 0; i < 100; i++); {
    System.out.println("i is " + i);
}

This will give you a compilation error in the println call saying that i cannot be found. But (I hear you say) I did declare it!

The problem is the sneaky semicolon ( ; ) before the {. The Java language syntax defines a semicolon in that context to be an empty statement. The empty statement then becomes the body of the for loop. So that code actually means this:

for (int i = 0; i < 100; i++); 

// The previous and following are separate statements!!

{
    System.out.println("i is " + i);
}

The { ... } block is NOT the body of the for loop, and therefore the previous declaration of i in the for statement is out of scope in the block.

Here is another example of “Cannot find symbol” error that is caused by a typo.

int tmp = ...
int res = tmp(a + b);

Despite the previous declaration, the tmp in the tmp(...) expression is erroneous. The compiler will look for a method called tmp, and won’t find one. The previously declared tmp is in the namespace for variables, not the namespace for methods.

In the example I came across, the programmer had actually left out an operator. What he meant to write was this:

int res = tmp * (a + b);

There is another reason why the compiler might not find a symbol if you are compiling from the command line. You might simply have forgotten to compile or recompile some other class. For example, if you have classes Foo and Bar where Foo uses Bar. If you have never compiled Bar and you run javac Foo.java, you are liable to find that the compiler can’t find the symbol Bar. The simple answer is to compile Foo and Bar together; e.g. javac Foo.java Bar.java or javac *.java. Or better still use a Java build tool; e.g. Ant, Maven, Gradle and so on.

There are some other more obscure causes too … which I will deal with below.

How do I fix these errors ?

Generally speaking, you start out by figuring out what caused the compilation error.

• Look at the line in the file indicated by the compilation error message.
• Identify which symbol that the error message is talking about.
• Figure out why the compiler is saying that it cannot find the symbol; see above!

Then you think about what your code is supposed to be saying. Then finally you work out what correction you need to make to your source code to do what you want.

Note that not every “correction” is correct. Consider this:

for (int i = 1; i < 10; i++) {
    for (j = 1; j < 10; j++) {
        ...
    }
}

Suppose that the compiler says “Cannot find symbol” for j. There are many ways I could “fix” that:

• I could change the inner for to for (int j = 1; j < 10; j++) – probably correct.
• I could add a declaration for j before the inner for loop, or the outer for loop – possibly correct.
• I could change j to i in the inner for loop – probably wrong!
• and so on.

The point is that you need to understand what your code is trying to do in order to find the right fix.

Obscure causes

Here are a couple of cases where the “Cannot find symbol” is seemingly inexplicable … until you look closer.

1. Incorrect dependencies: If you are using an IDE or a build tool that manages the build path and project dependencies, you may have made a mistake with the dependencies; e.g. left out a dependency, or selected the wrong version. If you are using a build tool (Ant, Maven, Gradle, etc), check the project’s build file. If you are using an IDE, check the project’s build path configuration.
2. Cannot find symbol ‘var’: You are probably trying to compile source code that uses local variable type inference (i.e. a var declaration) with an older compiler or older --source level. The var was introduced in Java 10. Check your JDK version and your build files, and (if this occurs in an IDE), the IDE settings.
3. You are not recompiling: It sometimes happens that new Java programmers don’t understand how the Java tool chain works, or haven’t implemented a repeatable “build process”; e.g. using an IDE, Ant, Maven, Gradle and so on. In such a situation, the programmer can end up chasing his tail looking for an illusory error that is actually caused by not recompiling the code properly, and the like …
4. An earlier build problem: It is possible that an earlier build failed in a way that gave a JAR file with missing classes. Such a failure would typically be noticed if you were using a build tool. However if you are getting JAR files from someone else, you are dependent on them building properly, and noticing errors. If you suspect this, use tar -tvf to list the contents of the suspect JAR file.
5. IDE issues: People have reported cases where their IDE gets confused and the compiler in the IDE cannot find a class that exists … or the reverse situation.
   • This could happen if the IDE has been configured with the wrong JDK version.
   • This could happen if the IDE’s caches get out of sync with the file system. There are IDE specific ways to fix that.
   • This could be an IDE bug. For instance @Joel Costigliola described a scenario where Eclipse did not handle a Maven “test” tree correctly: see this answer. (Apparently that particular bug was been fixed a long time ago.)
6. Android issues: When you are programming for Android, and you have “Cannot find symbol” errors related to R, be aware that the R symbols are defined by the context.xml file. Check that your context.xml file is correct and in the correct place, and that the corresponding R class file has been generated / compiled. Note that the Java symbols are case sensitive, so the corresponding XML ids are be case sensitive too.Other symbol errors on Android are likely to be due to previously mention reasons; e.g. missing or incorrect dependencies, incorrect package names, method or fields that don’t exist in a particular API version, spelling / typing errors, and so on.
7. Hiding system classes: I’ve seen cases where the compiler complains that substring is an unknown symbol in something like the followingString s = ... String s1 = s.substring(1); It turned out that the programmer had created their own version of String and that his version of the class didn’t define a substring methods. I’ve seen people do this with System, Scanner and other classes.Lesson: Don’t define your own classes with the same names as common library classes!The problem can also be solved by using the fully qualified names. For example, in the example above, the programmer could have written:java.lang.String s = ... java.lang.String s1 = s.substring(1);
8. Homoglyphs: If you use UTF-8 encoding for your source files, it is possible to have identifiers that look the same, but are in fact different because they contain homoglyphs. See this page for more information.You can avoid this by restricting yourself to ASCII or Latin-1 as the source file encoding, and using Java uxxxx escapes for other characters.

What does a “Cannot find symbol” error mean? Answer #2:

One more example of ‘Variable is out of scope’

As I’ve seen that kind of questions a few times already, maybe one more example to what’s illegal even if it might feel okay.

Consider this code:

if(somethingIsTrue()) {
  String message = "Everything is fine";
} else {
  String message = "We have an error";
}
System.out.println(message);

That’s invalid code. Because neither of the variables named message is visible outside of their respective scope – which would be the surrounding brackets {} in this case.

You might say: “But a variable named message is defined either way – so message is defined after the if“.

But you’d be wrong.

Java has no free() or delete operators, so it has to rely on tracking variable scope to find out when variables are no longer used (together with references to these variables of cause).

It’s especially bad if you thought you did something good. I’ve seen this kind of error after “optimizing” code like this:

if(somethingIsTrue()) {
  String message = "Everything is fine";
  System.out.println(message);
} else {
  String message = "We have an error";
  System.out.println(message);
}

“Oh, there’s duplicated code, let’s pull that common line out” -> and there it it.

The most common way to deal with this kind of scope-trouble would be to pre-assign the else-values to the variable names in the outside scope and then reassign in if:

String message = "We have an error";
if(somethingIsTrue()) {
  message = "Everything is fine";
} 
System.out.println(message);

What does a “Cannot find symbol” error mean? Answer #3:

You’ll also get this error if you forget a new:

String s = String();

versus

String s = new String();

because the call without the new keyword will try and look for a (local) method called String without arguments – and that method signature is likely not defined.

And one of the simplest solution that might work for you in 99% of the cases is:

Using IntelliJ

Select Build->Rebuild Project will solve it.

Hope this post helped you in understanding what does a “Cannot find symbol” error means.

Follow Programming Articles for more!