Java 查找是否存在'；是两个整数中类似的十进制数字

我目前在高中上了一堂Java课，我需要找到一段代码来帮助我找到两个整数中是否有相似的数字

例如，在整数49和93中，两个整数中都有一个相似的数字（即9） 我需要写一个代码，看看是否有一个共同的数字

更新：你们问我试过什么，我已经在下面评论过了，就在这里

//Declaring
int a= 12;
int b= 23;
char a1= a.charAt(0); //An obvious coding error

更新：多亏了穆罕默德·阿迪尔的建议，这就是我所尝试的

    int a= 12;
    int b= 23;
    String firstInt = "";
    String secondInt = "";
    firstInt= Integer.toString(a);
    secondInt= Integer.toString(b);
    int firstCharA= firstInt.charAt(0);
    int secondCharA= firstInt.charAt(1);
    int firstCharB= secondInt.charAt(0);
    int secondCharB= secondInt.charAt(1);

更新：这里是比较

if(firstCharA == firstCharB || firstCharA == secondCharB || secondCharA == firstCharB || secondCharA == secondCharB)
        {
            output = true;
        }
        else
        {
            output = false;
        }

        System.out.println(output);

简单地说：

int a is 12
int b is 23
bool contains is false
for each char in b
    verify if a contains current b char
        then
            contains become true
            break the loop
        otherwise
            go to next b char
print contains

简单地说：

int a is 12
int b is 23
bool contains is false
for each char in b
    verify if a contains current b char
        then
            contains become true
            break the loop
        otherwise
            go to next b char
print contains

简单地说：

int a is 12
int b is 23
bool contains is false
for each char in b
    verify if a contains current b char
        then
            contains become true
            break the loop
        otherwise
            go to next b char
print contains

简单地说：

int a is 12
int b is 23
bool contains is false
for each char in b
    verify if a contains current b char
        then
            contains become true
            break the loop
        otherwise
            go to next b char
print contains

---

您编写的代码只适用于两位整数。 更一般的情况是

public class DuplicateDigits {
    public static void main(final String[] args) {
        DuplicateDigits d = new DuplicateDigits();
        Random random = new Random();
        int maxRandom = 10000;
        for (int iTest = 0; iTest < 100; iTest++) {
            int a = random.nextInt(maxRandom) + 1;
            int b = random.nextInt(maxRandom) + 1;
            boolean output = d.hasSameDigits(a, b);
            if (output) {
                System.out.println(a + " and " + b + " have duplicate digits");
            } else {
                System.out.println(a + " and " + b + " do not have duplicate digits");
            }
        }

    }

    public boolean hasSameDigits(final int a, final int b) {
        int digitsA[] = extractDigits(a);
        int digitsB[] = extractDigits(b);
        for (int digitA : digitsA) {
            for (int digitB : digitsB) {
                if (digitA == digitB) {
                    return true;
                }
            }
        }
        return false;
    }

    private int[] extractDigits(int number) {

        LinkedList<Integer> stack = new LinkedList<Integer>();
        while (number > 0) {
            stack.push(number % 10);
            number = number / 10;
        }
        int digits[] = new int[stack.size()];
        for (int index = 0; index < stack.size(); index++) {
            digits[index] = stack.get(index);
        }
        return digits;
    }

}

公共类重复数字{
公共静态void main（最终字符串[]args）{
重复数字d=新的重复数字（）；
随机=新随机（）；
int maxRandom=10000；
对于（int-iTest=0；iTest<100；iTest++）{
int a=random.nextInt（maxRandom）+1；
intb=random.nextInt（maxRandom）+1；
布尔输出=d.hasSameDigits（a，b）；
如果（输出）{
System.out.println（a+“和“+b+”有重复的数字）；
}否则{
System.out.println（a+”和“+b+”没有重复的数字）；
}
}
}
公共布尔数字（最终整数a、最终整数b）{
int digitsA[]=提取数字（a）；
int digitsB[]=提取的数字（b）；
for（int-digitA:digitsA）{
对于（int digitB:digitsB）{
if（digitA==digib）{
返回true；
}
}
}
返回false；
}
私有整数[]位（整数编号）{
LinkedList堆栈=新建LinkedList（）；
而（数量>0）{
堆栈推送（编号%10）；
数字=数字/10；
}
整数位数[]=新整数[stack.size（）]；
对于（int index=0；index

您编写的代码仅适用于两位整数。 更一般的情况是

public class DuplicateDigits {
    public static void main(final String[] args) {
        DuplicateDigits d = new DuplicateDigits();
        Random random = new Random();
        int maxRandom = 10000;
        for (int iTest = 0; iTest < 100; iTest++) {
            int a = random.nextInt(maxRandom) + 1;
            int b = random.nextInt(maxRandom) + 1;
            boolean output = d.hasSameDigits(a, b);
            if (output) {
                System.out.println(a + " and " + b + " have duplicate digits");
            } else {
                System.out.println(a + " and " + b + " do not have duplicate digits");
            }
        }

    }

    public boolean hasSameDigits(final int a, final int b) {
        int digitsA[] = extractDigits(a);
        int digitsB[] = extractDigits(b);
        for (int digitA : digitsA) {
            for (int digitB : digitsB) {
                if (digitA == digitB) {
                    return true;
                }
            }
        }
        return false;
    }

    private int[] extractDigits(int number) {

        LinkedList<Integer> stack = new LinkedList<Integer>();
        while (number > 0) {
            stack.push(number % 10);
            number = number / 10;
        }
        int digits[] = new int[stack.size()];
        for (int index = 0; index < stack.size(); index++) {
            digits[index] = stack.get(index);
        }
        return digits;
    }

}

公共类重复数字{
公共静态void main（最终字符串[]args）{
重复数字d=新的重复数字（）；
随机=新随机（）；
int maxRandom=10000；
对于（int-iTest=0；iTest<100；iTest++）{
int a=random.nextInt（maxRandom）+1；
intb=random.nextInt（maxRandom）+1；
布尔输出=d.hasSameDigits（a，b）；
如果（输出）{
System.out.println（a+“和“+b+”有重复的数字）；
}否则{
System.out.println（a+”和“+b+”没有重复的数字）；
}
}
}
公共布尔数字（最终整数a、最终整数b）{
int digitsA[]=提取数字（a）；
int digitsB[]=提取的数字（b）；
for（int-digitA:digitsA）{
对于（int digitB:digitsB）{
if（digitA==digib）{
返回true；
}
}
}
返回false；
}
私有整数[]位（整数编号）{
LinkedList堆栈=新建LinkedList（）；
而（数量>0）{
堆栈推送（编号%10）；
数字=数字/10；
}
整数位数[]=新整数[stack.size（）]；
对于（int index=0；index

您编写的代码仅适用于两位整数。 更一般的情况是

public class DuplicateDigits {
    public static void main(final String[] args) {
        DuplicateDigits d = new DuplicateDigits();
        Random random = new Random();
        int maxRandom = 10000;
        for (int iTest = 0; iTest < 100; iTest++) {
            int a = random.nextInt(maxRandom) + 1;
            int b = random.nextInt(maxRandom) + 1;
            boolean output = d.hasSameDigits(a, b);
            if (output) {
                System.out.println(a + " and " + b + " have duplicate digits");
            } else {
                System.out.println(a + " and " + b + " do not have duplicate digits");
            }
        }

    }

    public boolean hasSameDigits(final int a, final int b) {
        int digitsA[] = extractDigits(a);
        int digitsB[] = extractDigits(b);
        for (int digitA : digitsA) {
            for (int digitB : digitsB) {
                if (digitA == digitB) {
                    return true;
                }
            }
        }
        return false;
    }

    private int[] extractDigits(int number) {

        LinkedList<Integer> stack = new LinkedList<Integer>();
        while (number > 0) {
            stack.push(number % 10);
            number = number / 10;
        }
        int digits[] = new int[stack.size()];
        for (int index = 0; index < stack.size(); index++) {
            digits[index] = stack.get(index);
        }
        return digits;
    }

}

公共类重复数字{
公共静态void main（最终字符串[]args）{
重复数字d=新的重复数字（）；
随机=新随机（）；
int maxRandom=10000；
对于（int-iTest=0；iTest<100；iTest++）{
int a=random.nextInt（maxRandom）+1；
intb=random.nextInt（maxRandom）+1；
布尔输出=d.hasSameDigits（a，b）；
如果（输出）{
System.out.println（a+“和“+b+”有重复的数字）；
}否则{
System.out.println（a+”和“+b+”没有重复的数字）；
}
}
}
公共布尔数字（最终整数a、最终整数b）{
int digitsA[]=提取数字（a）；
int digitsB[]=提取的数字（b）；
for（int-digitA:digitsA）{
对于（int digitB:digitsB）{
if（digitA==digib）{
返回true；
}
}
}
返回false；
}
私有整数[]位（整数编号）{
LinkedList堆栈=新建LinkedList（）；
而（数量>0）{
堆栈推送（编号%10）；
数字=数字/10；
}
整数位数[]=新整数[stack.size（）]；
对于（int index=0；index

您编写的代码仅适用于两位整数。 更一般的情况是

public class DuplicateDigits {
    public static void main(final String[] args) {
        DuplicateDigits d = new DuplicateDigits();
        Random random = new Random();
        int maxRandom = 10000;
        for (int iTest = 0; iTest < 100; iTest++) {
            int a = random.nextInt(maxRandom) + 1;
            int b = random.nextInt(maxRandom) + 1;
            boolean output = d.hasSameDigits(a, b);
            if (output) {
                System.out.println(a + " and " + b + " have duplicate digits");
            } else {
                System.out.println(a + " and " + b + " do not have duplicate digits");
            }
        }

    }

    public boolean hasSameDigits(final int a, final int b) {
        int digitsA[] = extractDigits(a);
        int digitsB[] = extractDigits(b);
        for (int digitA : digitsA) {
            for (int digitB : digitsB) {
                if (digitA == digitB) {
                    return true;
                }
            }
        }
        return false;
    }

    private int[] extractDigits(int number) {

        LinkedList<Integer> stack = new LinkedList<Integer>();
        while (number > 0) {
            stack.push(number % 10);
            number = number / 10;
        }
        int digits[] = new int[stack.size()];
        for (int index = 0; index < stack.size(); index++) {
            digits[index] = stack.get(index);
        }
        return digits;
    }

}

公共类重复数字{
公共静态void main（最终字符串[]args）{
重复数字d=新的重复数字（）；
随机=新随机（）；
int maxRandom=10000；
对于（int-iTest=0；iTest<100；iTest++）{
int a=random.nextInt（maxRandom）+1；
intb=random.nextInt（maxRandom）+1；
布尔输出=d.hasSameDigits（a，b）；
如果（输出）{
System.out.println（a+“和“+b+”有重复的数字）；
}否则{
System.out.println（a+”和“+b+”没有重复的数字）；
}
}