java 一个随机数，然后倒序显示输出

Posted 2023-04-25

比如
随机数：462
倒序数：264

方法如下：

public class Test 

    // 随机数倒序的方法,参数是随机数
    public void sorts(int i) 

        char[] charArray = (i + "").toCharArray();
        String string = "";

        // 倒序显示
        for (int j = charArray.length - 1; j > -1; j--) 
            string += charArray[j];
        
        int int1 = Integer.parseInt(string);
        System.out.println(i +"倒序以后变成：" + int1);

    

    public static void main(String[] args) 

        Test test = new Test();
        test.sorts(35461);
    

运行效果：

参考技术A

运行结果：

具体代码如下：

import java.util.Random;

public class App11 

public static void main(String[] args) 

Random random = new Random(System.currentTimeMillis());

int num = random.nextInt(1000);

System.out.println("随机数：" + num);

String result = "";

do 

result += num % 10;

num /= 10;

 while(num != 0);

System.out.println("倒序数：" + result);

本回答被提问者采纳 参考技术B import java.util.Random;

public class Demo
public static void main (String args[])
//定义一个数组存放随机数：
int[] randoms = new int[3];

//产生3个随机数：
Random rnd = new Random();
for (int i=0; i<randoms.length; i++)
randoms[i] = rnd.nextInt();

//正序输出：
System.out.println("正序输出：");
for (int i=0; i<randoms.length; i++)
System.out.println(randoms[i]);

//逆序输出：
System.out.println("逆序输出：");
for (int i=randoms.length-1; i>=0; i--)
System.out.println(randoms[i]);

参考技术C public class BubbleSort

public static void BubbleSort(int[] arr)
if(arr == null && arr.length ==0)
return;
for(int i=0;i<arr.length-1;i++)
for(int j=arr.length-1;j>i;j--)
if(arr[j]<arr[j-1])
swap(arr,j,j-1);



public static void swap(int[] arr,int i,int j)
int temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;

public static void main(String[] args)
// int[] a =100,900,8,75,63,58,88,99,303,2;
int[] a = new int[3];
for(int i=0;i<a.length;i++)
int tem = (int)(Math.random()*10);
a[i] = tem;

BubbleSort(a);
for(int i=0;i<10;i++)
System.out.println("a = "+a[i]);



参考技术D public static String strReverseWithArray2(String string)
if(string==null||string.length()==0)return string;
int length = string.length();
char [] array = string.toCharArray();
for(int i = 0;i<length/2;i++)
array[i] = string.charAt(length-1-i);
array[length-1-i] = string.charAt(i);

return new String(array);

Java单词倒序输出

　　如何将一段单词倒序输出？把“Hello Java Hello China”变成“China Hello Java Hello”？

　　看起来好像很简单，只需要把字符串先分割成单词，然后加入一个StringBuilder或者StringBuffer中，最后再使用toString方法即可，现在来实现一下：

/**
 * @author Frank
 * @create 2017/11/24
 * @description
 */
public class Test {
    public static void main(String[] args) {
        String src = "Hello Java Hello China";//需要处理的字符串
        String[] arr = src.split(" ");//按空格分割
        int length = arr.length;//计算数组长度
        StringBuilder sb = new StringBuilder(src.length());//新建一个StringBuilder对象
        for (int i=length-1;i>=1;i--){
                sb.append(arr[i]+" ");//将字符串依次加入StringBuilder中
        }
        sb.append(arr[0]);//最后一个单词不加空格
        System.out.println(sb.toString());//输出
    }
}

　　因为是使用单线程，所以用StringBuilder的效率会高于StringBuffer，输出如下：

China Hello Java Hello

　　好的，现在就完美的解决了问题。

　　但事实上，通常并不是全用空格分隔开来的，而是有逗号，句号，引号等，那么这该如何处理呢？

　　那就只能一个字符一个字符判断了，用charAt()来判断字符是否为逗号句号或者引号，空格，如果是的话就知道到了分隔点了，如果不是的话就加入一个临时的StringBuilder对象，代码如下：

/**
 * @author Frank
 * @create 2017/11/24
 * @description
 */
public class Test2 {
    public static void main(String[] args) {
        String src = "Hello Java,Hello China.";//需要处理的字符串
        StringBuilder tmp = new StringBuilder(20);//定义一个StringBuilder对象
        StringBuilder goal = new StringBuilder(src.length());//定义一个StringBuilder对象来存放最终要输出的信息
        char c;//定义一个字符变量
        for (int i=src.length()-1;i>=0;i--){
            c = src.charAt(i);//从后往前取字符
            if(c ==‘ ‘ || c == ‘,‘ || c == ‘.‘){//判断是否为分隔字符
                goal.append(tmp);//如果是的话就把tmp加入到goal中来
                goal.append(c);//在把分隔字符也一起加入
                tmp.delete(0,tmp.length());//清空tmp
            }else {
                tmp.insert(0,c);//如果不是分隔字符，说明单词未完整，继续加入tmp中
            }
        }
        if (!tmp.equals("")){
            goal.append(tmp);//如果tmp中还有内容，在添加到goal中
        }
        System.out.println(goal.toString());//输出
    }
}

　　输出如下：

.China Hello,Java Hello

　　好像没什么问题了。　　

　　现在难度进一步升级，如果有一个20M的字符串，“Hello_,_China_..._Bye.”（...代表中间省略的部分），单词之间用空格隔开，现在需要把所有单词全部颠倒顺序，要求效率不能太低。不看这个20M的话，好像没什么难度，关键就在于这个20M，肯定不能像第一种方式用split分割，那样的话会创建一个很大的字符串数组，浪费很多空间。

　　所以这里采用第二种方式。

　　我们先随机生成一个字符串，然后再使用第二种方式进行处理：

/**
 * @author Frank
 * @create 2017/11/24
 * @description
 */
public class Test3 {
    public static void main(String[] args) {
        long time = 0;
        StringBuilder sb = new StringBuilder();
        //先生成一个比较大的字符串
        for (int i=0;i<10000000;i++){
            sb.append(i+" ");
        }
        System.out.println("字符串长度："+sb.length());

        //开始计算时间
        time = System.currentTimeMillis();
        StringBuilder tmp = new StringBuilder(20);//定义一个StringBuilder对象存放临时数据
        StringBuilder goal = new StringBuilder(sb.length());//定义一个StringBuilder对象来存放最终要输出的信息
        char c;//定义一个字符变量
        for (int i=sb.length()-1;i>=0;i--){
            c = sb.charAt(i);//从后往前取字符
            if(c ==‘ ‘){//判断是否为分隔字符
                goal.append(tmp);//如果是的话就把tmp加入到goal中来
                goal.append(c);//在把分隔字符也一起加入
                tmp.delete(0,tmp.length());//清空tmp
            }else {
                tmp.insert(0,c);//如果不是分隔字符，说明单词未完整，继续加入tmp中
            }
        }
        if (!tmp.equals("")){
            goal.append(tmp);//如果tmp中还有内容，在添加到goal中
        }
        System.out.println(System.currentTimeMillis()-time);//输出运行时间
    }
}

　　输出如下：

字符串长度：78888890
608

　　608毫秒，速度还ok，生成字符串还是要花挺多时间的，因为一直要进行内存复制，如果在循环次数后再加一个0，就会内存不足了。。。。

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at java.util.Arrays.copyOf(Arrays.java:3332)
    at java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:124)
    at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:448)
    at java.lang.StringBuilder.append(StringBuilder.java:136)
    at com.frank.string.test1.Test3.main(Test3.java:14)

　　至此，本篇问题讨论完毕，如果有更好更快的方法，欢迎留言交流讨论。