另一种选择是构建一个在相似值之间具有公共标识符的Map。可能有点复杂，但应该比循环 replaceAll 多次将两个值标准化。

import java.util.HashMap;
import java.util.Map;

public class VisuallySimilar
{
  public static int id = 0;
  public static Map<Character, Integer> map = new HashMap<>();

  public static void similarChars(Character... chars) {
    for(Character c : chars) {
      map.put(c, id);
    }
    id++;
  }

  public static boolean areSimilar(String val1, String val2) {
    if(val1.length() != val2.length())
      return false;

    char[] char1 = val1.toCharArray();
    char[] char2 = val2.toCharArray();

    for(int i = 0; i < char1.length; i++) {
      if(char1[i] == char2[i] || map.get(char1[i]) == map.get(char2[i]))
        continue;
      return false;
    }
    return true;
  }

  public static void main(String[] args) {
    similarChars('0', 'o', 'O', 'Q');
    similarChars('T', 'I', '1');

    String val1 = "b0x";
    String val2 = "box";

    System.out.println("Are Similar: " + areSimilar(val1, val2));
  }
}

首先，在声明字符串变量时，不必每次都进行构造函数调用。

String string1 = "0" // that is fine. No need to call constructor.

然后，我建议您创建一个集合，其中包含所有应该看起来相同的角色。
迭代第一个输入的所有字符，并检查是否：
第一个输入的每个字符等于第二个输入的每个字符
如果是“视觉上看同一个字符”，请检查第二个输入是否包含关联的字符。
根据您提供的数据，我建议您使用此解决方案，尽管它不是完美的：

import javafx.util.Pair;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {

private static List<List<Character>> charactersVisuallyLookingTheSame = new ArrayList<>();

public static void main(String[] args) {
    initCharactersThatLookTheSame();

    Scanner sc = new Scanner(System.in);
    System.out.println("Enter First String:");
    String str1 = sc.nextLine();
    System.out.println("Enter Second String:");
    String str2 = sc.nextLine();
    sc.close();
    boolean equal = equalsVisually(str1, str2);
    System.out.println(equal);
}

private static boolean equalsVisually(String first, String second)
{
    // some checks just in case...
    if(first == null || second == null)
    {
        return false;
    }
    // to be equal visually, they must have the same length.
    if(first.length() != second.length())
    {
        return false;
    }

    char[] firstAsArray = first.toCharArray();
    char[] secondAsArray = second.toCharArray();

    for(int i = 0; i < firstAsArray.length; i++)
    {
        // if it is different
        if(firstAsArray[i] != secondAsArray[i])
        {
            if(!isCharVisuallyLookingTheSame(firstAsArray[i], secondAsArray[i]))
            {
                return false;
            }
        }
    }
    return true;
}

private static boolean isCharVisuallyLookingTheSame(char first, char second)
{
    // we check if it looks visually the same
    for(List<Character> visuallyTheSameList : charactersVisuallyLookingTheSame)
    {
        boolean doesFirstStringContainVisualChar = false;
        for(Character c1 : visuallyTheSameList)
        {
            if(first == c1)
            {
                boolean doesSecondStringCharVisuallyEquals = false;
                for(Character c2 : visuallyTheSameList)
                {
                    if((second == c2))
                    {
                        return true;
                    }
                }
            }
        }
    }
    return false;
}

private static void initCharactersThatLookTheSame()
{
    // these lists contain all the characters that look visually the same.
    // add in here any list of characters that visually look the same.

    List<Character> o = new ArrayList<>();
    charactersVisuallyLookingTheSame.add(o);
    o.add('0');
    o.add('o');
    o.add('Q');

    List<Character> i = new ArrayList<>();
    charactersVisuallyLookingTheSame.add(i);
    i.add('1');
    i.add('I');
    i.add('T');

    List<Character>  z = new ArrayList<>();
    charactersVisuallyLookingTheSame.add(z);
    z.add('2');
    z.add('Z');

    List<Character> S = new ArrayList<>();
    charactersVisuallyLookingTheSame.add(S);
    S.add('5');
    S.add('S');

    List<Character> B = new ArrayList<>();
    charactersVisuallyLookingTheSame.add(B);
    B.add('8');
    B.add('B');
}

}
一些输出：


我想那就行了。如果有任何问题，请毫不犹豫地在调试模式下执行它。我快速编码了这个，可能会出错。
但总的来说，我建议你：使用正则表达式。这是由另一个答案提出的，我认为这只能比这个更好。然而，正则表达式可能很难理解。。。

这个问题（以及大多数关于字符串模式匹配的问题）的答案是正则表达式。您只需对所有字符转换使用replaceall来规范化字符串。
比如：

str1 = str1.replaceAll("[oQ]", 0);
str1 = str1.replaceAll("[IT]", 1);