First non repeated character Problem Statement :
Print the first non repeating character in a string.
Example :
In the string somecharsjustdon'tliketorepeat, m is the first non-repeating charecter.

My attempt :
New Code : Old one was not working as expected so I have updated the post. Old code can be found below new code
public class FirstNonRepeatedChar{
    static boolean isRepeated(String str, char c){
        int count = 0;
        for(char ch: str.toCharArray()){
            if(c == ch){
                count++;
            } 
        }
        
        return count &gt; 1;
    }
    
    static void printFirstNonRepeatedChar(String str){
        boolean found = false;
        
        for(char c : str.toCharArray()){
            
            if(! isRepeated(str, c)){
                found = true;
                System.out.println(str + &quot; : &quot; +c);
                break;
            }
        }
        
        if(!found){
            System.out.println(str + &quot; : No non-repeated char&quot;);
        }
    }
    
    public static void main(String [] args){
        String []testCases = {&quot;aaabbcc&quot;, &quot;sss&quot;, &quot;121&quot;, &quot;test&quot;, &quot;aabc&quot;};
        
        for(String str: testCases){
            printFirstNonRepeatedChar(str);
        }
    }
}

Old code
public class FirstNonRepeatedChar{

    public static void main(String [] args){
        String str = &quot;somecharsjustdon'tliketorepeat&quot;;
        
        loopI:
        for(int i = 0;i&lt;str.length();i++){
            for(int j = i+1; j&lt;str.length();j++){
                if(str.charAt(i)==str.charAt(j))
                    continue loopI;
            }
            System.out.println(str.charAt(i));
            break;
        }
    }
}

I want to ask :

Is there better way to solve this problem? Especially, is there efficient way to do this using built-in classes?
Can I reduce complexity?
Is there any case where my code may fail to generate appropriate result? and how can I avoid these failures?

Thanks in advance!
Welcome to Code Review. There are already excellent answers, I am adding an alternative solution running in \$O(n)\$ and relatively simple to understand.
private static void printFirstNonRepeatedChar(String str) {
    // LinkedHashMap maintains the insertion order
    Map&lt;Character, Integer&gt; freq = new LinkedHashMap&lt;&gt;();
    
    // Create map of frequencies   
    for (Character c : str.toCharArray()) {
        if (freq.containsKey(c)) {
            freq.put(c, freq.get(c) + 1);
        } else {
            freq.put(c, 1);
        }
    }
    
    // Find first character with frequency 1
    for (Entry&lt;Character, Integer&gt; entry : freq.entrySet()) {
        if (entry.getValue() == 1) {
            System.out.println(entry.getKey());
            break;
        }
    }
}

The map freq contains the frequencies of the characters. For example, given the string aabbc, the map will be:

a -&gt; 2
b -&gt; 2
c -&gt; 1

LinkedHashMap maintains the insertion order so after building the map it's enough to find the first entry with frequency 1.
This is the same but using Streams:
private static Character findFirstNonRepeatedChar(String str) {
    Map&lt;Character, Long&gt; freq = str.codePoints()
            .mapToObj(c -&gt; (char) c)
            .collect(Collectors.groupingBy(Function.identity(),
                                           LinkedHashMap::new, 
                                           Collectors.counting()));
    return freq.entrySet().stream()
            .filter(e -&gt; e.getValue()==1)
            .map(Map.Entry::getKey)
            .findFirst().orElse(null);
}

Time complexity
Your solution runs in \$O(n^2)\$, where \$n\$ is the length of the input string. I highlighted in your code the relevant parts:
static void printFirstNonRepeatedChar(String str){
    // O(n)
    for(char c : str.toCharArray()){
        // isRepeated runs in O(n)
        if(! isRepeated(str, c)){
           // O(1)
        }
    }
    //..
}

As @Joop Eggen said, for small input strings you need to benchmark the solutions to really see the difference, but for large inputs the Big O notation must be considered.
Testing and reusability
Generally, it's better to return a result instead of printing in the method. It's easier to test and reuse. In your case the method could return the character or null. For example:
static Character printFirstNonRepeatedChar(String str){
    //...
        if(! isRepeated(str, c)){
            return c;
        }
        return null;
}

Now the method is easy to test:
@Test
public void findFirstNonRepeatedCharTest() {
    assertEquals(Character.valueOf('c'),findFirstNonRepeatedChar(&quot;aabbc&quot;));
    assertNull(findFirstNonRepeatedChar(&quot;aa&quot;));
}

Minor changes

In the method printFirstNonRepeatedChar you can just return; instead of using the flag found and break.