如何在java中直观地比较两个字符串？

到目前为止，我正在制作一个小程序，比较两个字符串的结果是真是假。然而，如果程序在视觉上看起来是一样的，那么它需要说true。例如，如果它说box和b0x，那么它就是真的。到目前为止，结果看起来是错误的，如下所示

  Enter First String:
  box
  Enter Second String:
  b0x
  false

下面的字符串需要视为相同

0, o and Q
1, I and T 
2 and Z
5 and S 
8 and B

以下是我目前的工作

   import java.util.Scanner;

   public class Program {

public static void main(String[] args) {
    {
        
        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();
        
        
            String string1 = new String("0"); 
            String string2 = new String("o"); 
            String string3 = new String("q"); 
            String string4 = new String("1");
            String string5 = new String("l"); 
            String string6 = new String("T"); 
            String string7 = new String("2"); 
            String string8 = new String("z"); 
            String string9 = new String("5"); 
            String string10 = new String("s"); 
            String string11 = new String("8"); 
            String string12 = new String("b"); 
      
       
            
      
            // Comparing for String 3 = String 4 
            if (str1.equals(str2))
            {
                System.out.print(true);
            }
         
            else if(string1.equals(str1))
            {
                System.out.print(true);
            }
            
            else if(string2.equals(str2))
            {
                System.out.print(true);
            }
            
            else 
            {
                System.out.print(false);
            }
    
    }
}

}

---

是否有任何算法，我可以使用或任何方式，程序可以检测为真，即使他们在视觉上是相同的。非常感谢您的帮助，谢谢

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

比如：

---

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

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));
  }
}

import java.util.HashMap；
导入java.util.Map；
公共类可视相似
{
公共静态int id=0；
publicstaticmap=newhashmap（）；
公共静态无效相似字符（字符…字符）{
for（字符c:字符）{
地图放置（c，id）；
}
id++；
}
公共静态布尔值是相似的（字符串val1，字符串val2）{
如果（val1.length（）！=val2.length（））
返回false；
char[]char1=val1.toCharArray（）；
char[]char2=val2.toCharArray（）；
for（int i=0；i

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

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');
}

导入javafx.util.Pair；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.Scanner；
公共班机{
私有静态列表字符visuallylookingthesame=newarraylist（）；
公共静态void main（字符串[]args）{
initCharactersThatLookTheSame（）；
扫描仪sc=新的扫描仪（System.in）；
System.out.println（“输入第一个字符串：”）；
字符串str1=sc.nextLine（）；
System.out.println（“输入第二个字符串：”）；
字符串str2=sc.nextLine（）；
sc.close（）；
布尔相等=相等（str1，str2）；
System.out.println（相等）；
}
私有静态布尔等式（字符串第一，字符串第二）
{
//一些支票以防万一。。。
if（first==null | | second==null）
{
返回false；
}
//为了在视觉上相等，它们必须具有相同的长度。
if（first.length（）！=second.length（））
{
返回false；
}
char[]firstAsArray=first.toCharArray（）；
char[]secondAsArray=second.toCharArray（）；
for（int i=0；i

}

---

一些产出：

---

---

我想那就行了。如果有任何问题，请毫不犹豫地在调试模式下执行它。我快速编码了这个，可能会出错

---

但总的来说，我建议您：使用正则表达式。这是由另一个答案提出的，我认为这只能比这个更好。然而，正则表达式可能很难理解…

看起来这可能是一个映射的工作，其中每个字符都映射到它映射到的每个字符。@Pshemo感谢您的更正

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');
}