JAVA随机数生成Int、Long、Float、Double

随机数Int的生成 生成无边界的Int

1
2
3
4
5
6
7
8
@Test
public void testRandom_generatingIntegerUnbounded() throws Exception {
 
   int intUnbounded = new Random().nextInt();
   System.out.println(intUnbounded);
}
 
 

生成有边界的Int

1
2
3
4
5
6
7
8
9
10
@Test
public void testRandom_generatingIntegerBounded_withRange() throws Exception {
 
   int min = 1;
   int max = 10;
   int intBounded = min + ((int) (new Random().nextFloat() * (max - min)));
   System.out.println(intBounded);
}
 
 

包含1而不包含10 使用Apache Common Math来生成有边界的Int

1
2
3
4
5
6
7
8
9
@Test
public void testRandom_generatingIntegerBounded_withApacheMath() throws Exception {
 
   int min = 1;
   int max = 10;
   int intBounded = new RandomDataGenerator().nextInt(min, max);
   System.out.println(intBounded);
}
 

包含1且包含10 使用Apache Common Lang的工具类来生成有边界的Int

1
2
3
4
5
6
7
8
9
10
@Test
public void testRandom_generatingIntegerBounded_withApacheLangInclusive() throws Exception {
 
   int min = 1;
   int max = 10;
   int intBounded = RandomUtils.nextInt(min, max);
   System.out.println(intBounded);
}
 
 

包含1而不包含10 使用TreadLocalRandom来生成有边界的Int

1
2
3
4
5
6
7
8
9
10
@Test
public void testRandom_generatingIntegerBounded_withThreadLocalRandom() throws Exception {
 
   int min = 1;
   int max = 10;
   int threadIntBound = ThreadLocalRandom.current().nextInt(min, max);
   System.out.println(threadIntBound);
}
 
 

包含1而不包含10 随机数Long的生成 生成无边界的Long

1
2
3
4
5
6
7
8
@Test
public void testRandom_generatingLongUnbounded() throws Exception {
 
   long unboundedLong = new Random().nextLong();
   System.out.println(unboundedLong);
}
 
 

因为Random类使用的种子是48bits，所以nextLong不能返回所有可能的long值，long是64bits。 生成有边界的Long

1
2
3
4
5
6
7
8
9
10
@Test
public void testRandom_generatingLongBounded_withRange() throws Exception {
 
   long min = 1;
   long max = 10;
   long rangeLong = min + (((long) (new Random().nextDouble() * (max - min))));
   System.out.println(rangeLong);
}
 
 

以上只会生成1到10的long类型的随机数 使用Apache Commons Math来生成有边界的Long

1
2
3
4
5
6
7
8
9
10
@Test
public void testRandom_generatingLongBounded_withApacheMath() throws Exception {
 
   long min = 1;
   long max = 10;
   long rangeLong = new RandomDataGenerator().nextLong(min, max);
   System.out.println(rangeLong);
}
 
 

此方式主要使用的RandomDataGenerator类提供的生成随机数的方法 使用Apache Commons Lang的工具类来生成有边界的Long

1
2
3
4
5
6
7
8
9
10
@Test
public void testRandom_generatingLongBounded_withApacheLangInclusive() throws Exception {
 
   long min = 1;
   long max = 10;
   long longBounded = RandomUtils.nextLong(min, max);
   System.out.println(longBounded);
}
 
 

RandomUtils提供了对java.util.Random的补充 使用ThreadLocalRandom生成有边界的Long

1
2
3
4
5
6
7
8
9
10
@Test
public void testRandom_generatingLongBounded_withThreadLocalRandom() throws Exception {
 
   long min = 1;
   long max = 10;
   long threadLongBound = ThreadLocalRandom.current().nextLong(min, max);
   System.out.println(threadLongBound);
}
 
 

随机数Float的生成 生成0.0-1.0之间的Float随机数

1
2
3
4
5
6
7
8
@Test
public void testRandom_generatingFloat0To1() throws Exception {
 
   float floatUnbounded = new Random().nextFloat();
   System.out.println(floatUnbounded);
}
 
 

以上只会生成包含0.0而不包括1.0的float类型随机数 生成有边界的Float随机数

1
2
3
4
5
6
7
8
9
10
@Test
public void testRandom_generatingFloatBounded_withRange() throws Exception {
 
   float min = 1f;
   float max = 10f;
   float floatBounded = min + new Random().nextFloat() * (max - min);
   System.out.println(floatBounded);
}
 
 

使用Apache Common Math来生成有边界的Float随机数

1
2
3
4
5
6
7
8
9
10
@Test
public void testRandom_generatingFloatBounded_withApacheMath() throws Exception {
 
   float min = 1f;
   float max = 10f;
   float randomFloat = new RandomDataGenerator().getRandomGenerator().nextFloat();
   float generatedFloat = min + randomFloat * (max - min);
   System.out.println(generatedFloat);
}
 

使用Apache Common Lang来生成有边界的Float随机数

1
2
3
4
5
6
7
8
9
10
@Test
public void testRandom_generatingFloatBounded_withApacheLang() throws Exception {
 
   float min = 1f;
   float max = 10f;
   float generatedFloat = RandomUtils.nextFloat(min, max);
   System.out.println(generatedFloat);
}
 
 

使用ThreadLocalRandom生成有边界的Float随机数 ThreadLocalRandom类没有提供 随机数Double的生成 生成0.0d-1.0d之间的Double随机数

1
2
3
4
5
6
7
8
@Test
public void testRandom_generatingDouble0To1() throws Exception {
 
   double generatorDouble = new Random().nextDouble();
   System.out.println(generatorDouble);
}
 
 

与Float相同，以上方法只会生成包含0.0d而不包含1.0d的随机数 生成带有边界的Double随机数

1
2
3
4
5
6
7
8
9
10
11
12
@Test
public void testRandom_generatingDoubleBounded_withRange() throws Exception {
 
   double min = 1.0;
   double max = 10.0;
   double boundedDouble = min + new Random().nextDouble() * (max - min);
   System.out.println(boundedDouble);
   assertThat(boundedDouble, greaterThan(min));
   assertThat(boundedDouble, lessThan(max));
}
 
 

使用Apache Common Math来生成有边界的Double随机数

1
2
3
4
5
6
7
8
9
10
11
12
13
@Test
public void testRandom_generatingDoubleBounded_withApacheMath() throws Exception {
 
   double min = 1.0;
   double max = 10.0;
   double boundedDouble = new RandomDataGenerator().getRandomGenerator().nextDouble();
   double generatorDouble = min + boundedDouble * (max - min);
   System.out.println(generatorDouble);
   assertThat(generatorDouble, greaterThan(min));
   assertThat(generatorDouble, lessThan(max));
}
 
 

使用Apache Common Lang生成有边界的Double随机数

1
2
3
4
5
6
7
8
9
10
@Test
public void testRandom_generatingDoubleBounded_withApacheLang() throws Exception {
 
   double min = 1.0;
   double max = 10.0;
   double generatedDouble = RandomUtils.nextDouble(min, max);
   System.out.println(generatedDouble);
}
 
 

使用ThreadLocalRandom生成有边界的Double随机数

1
2
3
4
5
6
7
8
9
10
@Test
public void testRandom_generatingDoubleBounded_withThreadLocalRandom() throws Exception {
 
   double min = 1.0;
   double max = 10.0;
   double generatedDouble = ThreadLocalRandom.current().nextDouble(min, max);
   System.out.println(generatedDouble);
}
 
 

JAVA中有多少可以实现随机数的类或方法? java.util.Random 这个类提供了生成Bytes、Int、Long、Float、Double、Boolean的随机数的方法 java.util.Math.random 方法提供了生成Double随机数的方法，这个方法的内部实现也是调用了java.util.Random的nextDouble方法，只不过它对多线程进行了更好的支持，在多个线程并发时会减少每个随机数生成器的竞争 第三方工具类，如Apache Common Lang库与Apache Common Math库中提供的随机数生成类，真正使用一行代码来实现复杂的随机数生成 java.util.concurrent.ThreadLocalRandom 专为多线程并发使用的随机数生成器，使用的方法为ThreadLocalRandom.current.nextInt()，此类是在JDK1.7中提供的，并且特别适合ForkJoinTask框架，而且在这个类中直接提供了生成有边界的随机数的操作，如public int nextInt(int origin, int bound)，这样也可以一行代码来实现复杂的随机数生成了。 最后的总结为单线程中使用java.util.Random类，在多线程中使用java.util.concurrent.ThreadLocalRandom类。 […]

龙生   07 Dec 2018
View Details

java保留两位小数4种方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.math.BigDecimal;
    import java.text.DecimalFormat;
    import java.text.NumberFormat;
    public class format {
        double f = 111231.5585;
        public void m1() {
            BigDecimal bg = new BigDecimal(f);
            double f1 = bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            System.out.println(f1);
        }
        /**
         * DecimalFormat转换最简便
         */
        public void m2() {
            DecimalFormat df = new DecimalFormat("#.00");
            System.out.println(df.format(f));
        }
        /**
         * String.format打印最简便
         */
        public void m3() {
            System.out.println(String.format("%.2f", f));
        }
        public void m4() {
            NumberFormat nf = NumberFormat.getNumberInstance();
            nf.setMaximumFractionDigits(2);
            System.out.println(nf.format(f));
        }
        public static void main(String[] args) {
            format f = new format();
            f.m1();
            f.m2();
            f.m3();
            f.m4();
        }
    }

from:https://www.cnblogs.com/chenrenshui/p/6128444.html

龙生   07 Dec 2018
View Details

java正则匹配返回所有匹配项

1
2
3
4
5
6
7
8
9
    List<String> getMatchers(String regex, String source){
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(source);
        List<String> list = new ArrayList<>();
        while (matcher.find()) {
            list.add(matcher.group());
        }
        return list;
    }

from:https://blog.csdn.net/w305172521/article/details/75330661

龙生   05 Dec 2018
View Details

java中字符串String 转 int

String -> int s="12345"; int i; 第一种方法：i=Integer.parseInt(s); 第二种方法：i=Integer.valueOf(s).intValue(); 这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？ int -> String int i=12345; String s=""; 第一种方法：s=i+""; 第二种方法：s=String.valueOf(i); 这两种方法有什么区别呢？作用是不是一样的呢？是不是在任何下都能互换呢？ 以下是答案： 第一种方法：s=i+""; //会产生两个String对象 第二种方法：s=String.valueOf(i); //直接使用String类的静态方法，只产生一个对象 第一种方法：i=Integer.parseInt(s);//直接使用静态方法，不会产生多余的对象，但会抛出异常 第二种方法：i=Integer.valueOf(s).intValue();//Integer.valueOf(s) 相当于 new Integer(Integer.parseInt(s))，也会抛异常，但会多产生一个对象 ——————————————————————-- 1如何将字串 String 转换成整数 int? A. 有两个方法: 1). int i = Integer.parseInt([String]); 或 i = Integer.parseInt([String],[int radix]); 2). int i = Integer.valueOf(my_str).intValue(); 注: 字串转成 Double, Float, Long 的方法大同小异. 2 如何将整数 int 转换成字串 String ? A. 有叁种方法: 1.) String s = String.valueOf(i); 2.) String s = Integer.toString(i); 3.) String s = "" + i; 注: Double, Float, Long 转成字串的方法大同小异. JAVA数据类型转换 […]

龙生   05 Dec 2018
View Details

java 生成[min,max]之间的随机整数

这里使用Random类的nextInt()方法来生成，生成[min,max]区间的随机整数公式： Random rand=new Random(); rand.nextInt(max- min+ 1) + min； 这里封装成方法了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
* 求[Min,Max]区间之间的随机整数。
* @param Min 最小值
* @param Max 最大值
* @return 一个Min和Max之间的随机整数
*/
public static int randomIntMinToMax(int Min, int Max)
{
//如果相等，直接返回，还生成个屁
if(Min==Max)
{
return Max;
}
//如果Min比Max大，交换两个的值，如果不交换下面nextInt()会出错
if(Min>Max)
{
Min^=Max;
Max^=Min;
Min^=Max;
}
Random rand=new Random();//nextInt()不是静态方法，不能直接用类名调用
return rand.nextInt(Max - Min + 1) + Min;
}

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package random;
import java.util.Random;
public class GetRandom
{
    public static void main(String[] args)
    {
        Random rand = new Random();
        int Min = 0;
        int Max = 9;
        int[] count = new int[Max - Min + 1];
        for (int i = 0; i < 10000; i++)
        {
            count[randomIntMinToMax(Min, Max)]++;
        }
        System.out.println();
        char percentCh = '%';
        for (int i = 0; i < count.length; i++)
        {
            double percent = 100 * (double) count[i] / 10000;
            System.out.printf("%d生成次数:%-4d,占百分比:%.2f%c\n", i, count[i], percent,
                    percentCh);
        }
    }
    /**
     * 求[Min,Max]区间之间的随机整数。
     *
     * @param Min
     *            最小值
     * @param Max
     *            最大值
     * @return 一个Min和Max之间的随机整数
     */
    public static int randomIntMinToMax(int Min, int Max)
    {
        // 如果相等，直接返回，还生成个屁
        if (Min == Max)
        {
            return Max;
        }
        // 如果Min比Max大，交换两个的值，如果不交换下面nextInt()会出错
        if (Min > Max)
        {
            Min ^= Max;
            Max ^= Min;
            Min ^= Max;
        }
        Random rand = new Random();// nextInt()不是静态方法，不能直接用类名调用
        return rand.nextInt(Max - Min + 1) + Min;
    }
}

运行结果：

1
2
3
4
5
6
7
8
9
10
0生成次数:998 ,占百分比:9.98%
1生成次数:962 ,占百分比:9.62%
2生成次数:1005,占百分比:10.05%
3生成次数:1020,占百分比:10.20%
4生成次数:1020,占百分比:10.20%
5生成次数:997 ,占百分比:9.97%
6生成次数:966 ,占百分比:9.66%
7生成次数:1002,占百分比:10.02%
8生成次数:1006,占百分比:10.06%
9生成次数:1024,占百分比:10.24%

from:https://blog.csdn.net/qq_21808961/article/details/80526231

龙生   05 Dec 2018
View Details

为什么说Java中的随机数都是伪随机数？

什么是伪随机数？ 1.伪随机数是看似随机实质是固定的周期性序列,也就是有规则的随机。 2.只要这个随机数是由确定算法生成的,那就是伪随机,只能通过不断算法优化,使你的随机数更接近随机。 (随机这个属性和算法本身就是矛盾的) 3.通过真实随机事件取得的随机数才是真随机数。 Java随机数产生原理： Java的随机数产生是通过线性同余公式产生的,也就是说通过一个复杂的算法生成的。 伪随机数的不安全性： Java自带的随机数函数是很容易被黑客破解的,因为黑客可以通过获取一定长度的随机数序列来推出你的seed,然后就可以预测下一个随机数。 不用种子的不随机性会增大的原因：           java.Math.Random()实际是在内部调用java.util.Random()的,使用一个和当前系统时间有关的数字作为种子数。两个随机数就很可能相同。              double a = Math.random()；              double b = Math.random();               Random r1 = new Random(); 　　　　   r1.nextInt(10);               Random r2 = new Random(); 　　　　　r2.nextInt(10); Java中产生随机数的方法有两种：  　　第一种：Math.random() 　　第二种：new Random() 一、java.lang.Math.Random： 调用这个Math.Random()函数能够返回带正号的double值,取值范围是[0.0,1.0),在该范围内（近似）均匀分布。因为返回值是double类型的,小数点后面可以保留15位小数，所以产生相同的可能性非常小,在这一定程度上是随机数。 二、java.util.Random： Random r1 = new Random(); Random r2 = new Random(); Random r3 = new Random(10); Random r4 = […]

龙生   05 Dec 2018
View Details

java学习-获取当前毫秒数,毫秒转时间,时间计算,时间转毫秒,时间相关

时间有关 +1s 1、获取当前毫秒数

1
long t1=System.currentTimeMillis();

2、毫秒数转换为时间

1
2
3
Date date2=new Date();
date2.setTime(t1);
System.err.println(date2);

3、时间格式化

1
2
3
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
String fmDate=simpleDateFormat.format(date2);
System.err.println(fmDate);

4、字符串格式时间获取毫秒数

1
2
3
4
String sdate = "2018-06-01 06-06-06";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
long time = simpleDateFormat.parse(sdate).getTime();
System.err.println(time);

5、毫秒数的计算 把两个毫秒数差值传进来就可以看见相差多久 原贴：https://blog.csdn.net/sunshinestation/article/details/4568946

1
2
3
4
5
6
7
8
public static String formatDuring(long mss) {  
    long days = mss / (1000 * 60 * 60 * 24);  
    long hours = (mss % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60);  
    long minutes = (mss % (1000 * 60 * 60)) / (1000 * 60);  
    long seconds = (mss % (1000 * 60)) / 1000;  
    return days + " days " + hours + " hours " + minutes + " minutes "  
            + seconds + " seconds ";  
}

6、java api提供的方法： 待续 7、时间插入数据库 先转换成yyyy-MM-dd HH:mm:ss这个格式，然后可以以字符串格式插入

1
2
3
Date date=new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String fmDate=simpleDateFormat.format(date);

——————— 作者：云驿 来源：CSDN 原文：https://blog.csdn.net/sinat_32238399/article/details/80512452 版权声明：本文为博主原创文章，转载请附上博文链接！

龙生   05 Dec 2018
View Details

java生成6位随机数的5种方法

1. 用math.random()实现，比较麻烦的一种方式，思路是：math.random()生成的是[0.0, 1.0)的伪随机数，如果 当前值是0.9…，则直接*1000000返回，其他情况可能生成0.8…，0.03…，0.0003…，这些情况都*1000000，但是结果可能是6位，5位，4位都有可能，那么再加上100000，肯定就保证是6位了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
for (int i = 0; i <= 200; i++)
{
    int intFlag = (int)(Math.random() * 1000000);
    String flag = String.valueOf(intFlag);
    if (flag.length() == 6 && flag.substring(0, 1).equals("9"))
    {
     System.out.println(intFlag);
    }
    else
    {
        intFlag = intFlag + 100000;
        System.out.println(intFlag);
    }        
}

2. 面试可以用到的一种方式，一行代码实现，思路是：math.random()范围是[0.0, 1.0)，那么math.random()*9+1一定是小于10的，(Math.random()*9+1)*100000一定是<10*100000=1000000的一个数

1
2
3
for(int j = 0; j< 100; j++){
    System.out.println((int)((Math.random()*9+1)*100000));
}

  3. random.nextInt(10)意思是返回大于等于0，小于10的一个正整数， 既然是生成6位随机数，每个数一定是0-9之内的，我循环6次，每次从0-9随机选取一个数字拼接字符串返回，不就行了。

1
2
3
4
5
6
7
Random random = new Random();
String result="";
for (int i=0;i<6;i++)
{
result+=random.nextInt(10);
}
System.out.println(result);

4. random.nextInt(10)知道是什么意思了，最大的6位数是999999，最小的六位数是100000，我想到了下面的方法：

1
2
3
4
5
6
7
8
9
for (int i = 0; i <= 100; i++)
{
    int flag = new Random().nextInt(999999);
    if (flag < 100000)
    {
        flag += 100000;
    }
    System.out.println(flag);
}

5. 最后的一种方法，是引入了一个source字符串，从这个字符串里可以随机生成一个子串返回，很多pc网站用这个方法生成带字母数字的验证码，原理类似3

1
2
3
4
5
6
7
8
9
10
11
for (int i = 0; i <= 100; i++)
{
String sources = "0123456789"; // 加上一些字母，就可以生成pc站的验证码了
Random rand = new Random();
StringBuffer flag = new StringBuffer();
for (int j = 0; j < 6; j++)
{
flag.append(sources.charAt(rand.nextInt(9)) + "");
}
System.out.println(flag.toString());
}

ps: math.random()生成的是个伪随机数，何为伪随机数，这里java是以当前系统时间的相关数字作为种子数，按照特定复杂算法生成的，其实它生成的大量随机数是线性均匀分布的，黑客是完全可能通过返回的大量随机数结果破解种子数的，所以它并不是真正的随机，叫伪随机数。由此我们可以知道通过计算机生成一个真随机数几乎是不可能的，因为最终的输出结果都是依赖算法程序的，这些算法程序本身就是固定的，我们只能通过更复杂的算法不断优化，让它无限趋近于真随机数，但不绝对。 参考：http://www.cnblogs.com/greatfish/p/5845924.html ——————— 作者：流浪猫走失了 来源：CSDN 原文：https://blog.csdn.net/u012491783/article/details/76862526 版权声明：本文为博主原创文章，转载请附上博文链接！

龙生   05 Dec 2018
View Details

fastJson顺序遍历JSON字段(转)

fastJson在把json格式的字符串转换成JSONObject的时候，使用的是HashMap，所以排序规则是根据HASH值排序的，如果想要按照字符串顺序遍历JSON属性,需要在转换的时候指定使用LinkedHashMap代替HashMap。 以下为实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void main(String[] args) {
        String jsonStr = "{\"size\":\"7.5\",\"width\":\"M (B)\"}";
 
        System.out.println("无序遍历结果：");
        JSONObject jsonObj = JSON.parseObject(jsonStr);
        for (Map.Entry<String, Object> entry : jsonObj.entrySet()) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
 
        System.out.println("-------------------");
        System.out.println("有序遍历结果：");
        LinkedHashMap<String, String> jsonMap = JSON.parseObject(jsonStr, new TypeReference<LinkedHashMap<String, String>>() {
        });
        for (Map.Entry<String, String> entry : jsonMap.entrySet()) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }

from:https://www.cnblogs.com/seely/p/5715512.html

龙生   05 Dec 2018
View Details
1 … 164 165 166 … 432

Copyright © 2024 Longsheng All rights reserved.