First non repeated character
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.