问题户又来求助了。
{:3_65:}

1. /*
   
2. 一个四位数1587，取出其千位、百位、十位、个位四个数字
   
3. 
   
4. 输出这四个数所能组合出的所有的两位数
   
5. 思路：
   
6. 1.定义四个int，分别存放千位、百位、十位、个位
   
7. 2.组合四个数字。。。。（不会）
   
8.   
   
9.   */
   
10. public class PrintDemo {
    
11. 
    
12. public static void main(String[] args) {
    
13.         
    
14.         int i=1587;
    
15.         int a=i/1000;
    
16.         int b=i/100-10*a;
    
17.         int c=i/10-100*a-b*10;
    
18.         int d=i%10;
    
19.                                                         //水平有限，没想出思路
    
20. }
    
21. }

复制代码

public static void main(String[] args){
                        int i=1587;
                        int [] a = new int[4];
                        String [] s = new String[12];//用来储存两个数字的组合
                        int n = 0;//记录
                        //遍历这个四位数各个位数的值
                        for(int j = 0;j < a.length; j++){
                                a[j] = i % 10;
                                i = i / 10;
                        }
                        //输出这四个数字
                        for(int j = 0; j < 4; j++){
                                System.out.println(a[j]);
                        }
                        //这四个数字任意两个的组合
                        for (int j = 0;j < 4 ;j++ ){
                                for(int k = j + 1; k < 4;k++){
                                        s[n] = "" + a[j] + a[k];
                                        n ++;//有几个这样的数字
                                }
                        }
                        //输出任意两个数字的组合
                        for(int j = 0; j < n; j++){
                                System.out.println(s[j]);
                        }
        }
我是这个样子想的,希望对你有帮助

import java.util.*;
class Demo
{
        public static void main(String[] args)
        {
                method(1587);
        }
        public static void method(int x)
        {
               
                int m=0;        //用于存放two数组角标
                int[] arr = new int[4];                //定义一个新数组arr，用于存放1587这个数值的单个数字；
                int[] two = new int[arr.length*arr.length];        //定义一个新数组two，用于存放最后生成的两位数
                for(int y=0;y<arr.length;y++)
                {
                        arr[y]=x%10;                        //把单个数，存放到arr中
                        x=x/10;                                       
                }

                for(int z=0;z<arr.length;z++)        //两个循环嵌套。。用于两位数的组合；注意：若三位数，就是三层循环嵌套了……
                {
                        for(int y=0;y<arr.length;y++)
                        {
                                two[m]=arr[z]*10+arr[y];
                                        m++;
                        }
                }
                 System.out.println(Arrays.toString(two));;
        }
}

        我对题目的理解是这样的，组成四位数的数组组成的不重复两位数个数。
        数字的开头不能为0.
        因为要求不重复，使用HashSet

1. public static void main(String[] args) {
   
2.                 // TODO Auto-generated method stub
   
3.                 int n = 1123;
   
4.                
   
5.                 HashSet<Integer> hashSet = new HashSet<Integer>();
   
6.                 char[] ch = Integer.toString(n).toCharArray();
   
7.                 for(int i = 0; i < ch.length; i++){
   
8.                         for(int j = 0; j < ch.length; j++){
   
9.                                 if(ch[i] != '0'){
   
10.                                         hashSet.add((ch[i]-'0')*10+(ch[j]-'0'));
    
11.                                 }
    
12.                                 if(ch[j] != '0'){
    
13.                                         hashSet.add((ch[j]-'0')*10+(ch[i]-'0'));
    
14.                                 }
    
15.                         }
    
16.                 }
    
17.                
    
18.                 System.out.println(hashSet);
    
19.                
    
20.         }

复制代码

1. import java.util.Scanner;
   
2. class PrintData
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 Scanner in = new Scanner(System.in);
   
7.                 System.out.println("请输入一个四位的正整数：");
   
8.                 int n = in.nextInt();
   
9.                 int a=n/1000;
   
10.                 int b=n/100-10*a;
    
11.                 int c=n/10-100*a-b*10;
    
12.                 int d=n%10;
    
13.                 int[] arr = new int[4];
    
14.                 arr[0] = a;
    
15.                 arr[1] = b;
    
16.                 arr[2] = c;
    
17.                 arr[3] = d;
    
18. 
    
19.                 for(int i=0;i<3;i++)
    
20.                 {
    
21.                         for(int j=i+1;j<4;j++)
    
22.                         {
    
23.                                 System.out.println(arr[i]*10+arr[j]);
    
24.                                 System.out.println(arr[i]+arr[j]*10);
    
25.                         }
    
26.                 }
    
27.         }
    
28. }
    
29. 
    
30. 不好意思啦，能力实在是有限，只能排出各位都不相同的组合来啊！

复制代码

1. public class T8 {
   
2. /**
   
3. * 思想：将1587看成字符串，将字符串转化成字符，然后遍历所有元素并按要求输出
   
4. * @param args
   
5. */
   
6. public static void main(String[] args) {
   
7. 
   
8.         String ss = "1587";
   
9.         char[] cc=ss.toCharArray();
   
10.         System.out.println("随机组合后的两位数分别为：");
    
11.        for (char c : cc) {//遍历，因为要求两位，故遍历两遍
    
12.                 for (char c1 : cc) {
    
13.                         if (c != c1) {//组合时，数字在两位中任意一位上出现，则在另一位上不再出现
    
14.                                 System.out.print(""+c+c1+"\t");//先转换成字符串，后运算
    
15.                         }
    
16.                 }
    
17.         }
    
18. }
    
19. }
    
20. 
    

复制代码

1. public static void main(String[] args) {
   
2.                 permute("abc");
   
3.         }
   
4.         public static void permute(String str){
   
5.                 int x=0;//要细化这里,这里必须对应几个变量进行位移,暂时不优化.
   
6.                 int y=0;
   
7.                 int z=0;//三个转换值
   
8.                 int n=0;//控制换行,
   
9.                 int index=1;//控制转换
   
10.                 char[] chs=str.toCharArray();
    
11.                 //具体跑多少次,这个计算不出来.所以用while循环,用break跳出.
    
12.                 while(true){
    
13.                         if(y==0&&z==0){
    
14.                                 System.out.print(""+chs[x]+chs[y]+chs[z]+" ");
    
15.                                 n++;
    
16.                         }
    
17.                         if(y<str.length()&&z<str.length()){
    
18.                                 if(y==z)
    
19.                                         z++;
    
20.                                 else if(y<z)
    
21.                                                 y=z+(z=y)*0;//俩数交换;
    
22.                                 else if(y>z)
    
23.                                         z++;
    
24.                         }
    
25.                         if(index<=str.length()){//1,2,3
    
26.                                 System.out.print(""+chs[x]+chs[y]+chs[z]+" ");
    
27.                                 if(y==(str.length()-1)&&z==(str.length()-1)){//循环完毕要交换需要组合的单词
    
28.                                         if(index<str.length()){
    
29.                                                 char temp = chs[0];
    
30.                                                 chs[0] = chs[index];
    
31.                                                 chs[index] = temp;
    
32.                                                 index++;
    
33.                                         } else {
    
34.                                                 index=0;
    
35.                                         }
    
36.                                         x=y=z=0;
    
37.                                 }
    
38.                         }
    
39.                         if(index==0)
    
40.                                 break;
    
41.                         n++;
    
42.                         if(n%10==0)
    
43.                                 System.out.println();
    
44.                 }
    
45.         }

复制代码

这个可以实现你要的,但是我是根据我的需求做的,你需要修改.
用穷举实现的各种组合,代码写得比较乱,涉及很多条件控制.
打印结果:
aaa aab aba abb abc acb acc bbb bba bab
baa bac bca bcc ccc cca cac caa cab cba
cbb