Java工具类——数字计算工具 NumberUtil

[java] view plaincopy
  1. package com.luang.util.common;  
  2.     
  3. import java.util.HashSet;    
  4. import java.util.Random;    
  5. import java.util.Set;    
  6.   
  7.   
  8. /** 
  9.  *  
  10.  * NumberUtil.java 
  11.  * 
  12.  * @desc 数字计算工具  
  13.  * @author Guoxp 
  14.  * @datatime Apr 7, 2013 3:52:29 PM 
  15.  * 
  16.  */  
  17. public class NumberUtil {    
  18.     
  19.     /**  生成不重复随机数 
  20.      * 根据给定的最小数字和最大数字,以及随机数的个数,产生指定的不重复的数组   
  21.      * @param begin 最小数字(包含该数)   
  22.      * @param end 最大数字(不包含该数)   
  23.      * @param size 指定产生随机数的个数   
  24.      */      
  25.     public int[] generateRandomNumber(int begin, int end, int size) {      
  26.         // 加入逻辑判断,确保begin<end并且size不能大于该表示范围      
  27.         if (begin >= end || (end - begin) < size) {      
  28.             return null;      
  29.         }             
  30.         // 种子你可以随意生成,但不能重复      
  31.         int[] seed = new int[end - begin];       
  32.           
  33.         for (int i = begin; i < end; i ++) {      
  34.             seed[i - begin] = i;      
  35.         }      
  36.         int[] ranArr = new int[size];      
  37.         Random ran = new Random();      
  38.         // 数量你可以自己定义。      
  39.         for (int i = 0; i < size; i++) {      
  40.             // 得到一个位置      
  41.             int j = ran.nextInt(seed.length - i);                 
  42.             // 得到那个位置的数值      
  43.             ranArr[i] = seed[j];      
  44.             // 将最后一个未用的数字放到这里      
  45.             seed[j] = seed[seed.length - 1 - i];      
  46.         }      
  47.         return ranArr;      
  48.     }    
  49.   
  50.   
  51.     /**  生成不重复随机数 
  52.      * 根据给定的最小数字和最大数字,以及随机数的个数,产生指定的不重复的数组   
  53.      * @param begin 最小数字(包含该数)   
  54.      * @param end 最大数字(不包含该数)   
  55.      * @param size 指定产生随机数的个数   
  56.      */      
  57.      public Integer[] generateBySet(int begin, int end, int size) {      
  58.         // 加入逻辑判断,确保begin<end并且size不能大于该表示范围      
  59.         if (begin >= end || (end - begin) < size) {      
  60.             return null;      
  61.         }      
  62.               
  63.         Random ran = new Random();      
  64.         Set<Integer> set = new HashSet<Integer>();      
  65.         while (set.size() < size) {      
  66.             set.add(begin + ran.nextInt(end - begin));      
  67.         }      
  68.               
  69.         Integer[] ranArr = new Integer[size];      
  70.         ranArr = set.toArray(new Integer[size]);      
  71.         //ranArr = (Integer[]) set.toArray();      
  72.               
  73.         return ranArr;      
  74.     }    
  75.     /**  
  76.     * 判断String是否是整数  
  77.     */    
  78.     public boolean isInteger(String s){    
  79.         if((s != null)&&(s!=""))    
  80.          return s.matches("^[0-9]*$");    
  81.         else    
  82.          return false;    
  83.     }    
  84.     /**  
  85.     * 判断字符串是否是浮点数  
  86.     */    
  87.     public boolean isDouble(String value) {    
  88.         try {    
  89.            Double.parseDouble(value);    
  90.            if (value.contains("."))    
  91.                return true;    
  92.            return false;    
  93.         } catch (NumberFormatException e) {    
  94.            return false;    
  95.         }    
  96.     }    
  97.     /**  
  98.     * 判断字符串是否是数字  
  99.     */    
  100.     public boolean isNumber(String value) {    
  101.         return isInteger(value) || isDouble(value);    
  102.     }    
  103.     
  104.         //排序方法    
  105.     public static void sort(int[] array) {// 小到大的排序    
  106.         int temp = 0;    
  107.         for (int i = 0; i < array.length; i++) {    
  108.             for (int j = i; j < array.length; j++) {    
  109.                 if (array[i] > array[j]) {    
  110.                     temp = array[i];    
  111.                     array[i] = array[j];    
  112.                     array[j] = temp;    
  113.                 }    
  114.             }    
  115.         }    
  116.     }    
  117.     
  118.     /**  
  119.      * 是否是质数  
  120.      */    
  121.     public static boolean isPrimes(int n) {    
  122.         for (int i = 2; i <= Math.sqrt(n); i++) {    
  123.             if (n % i == 0) {    
  124.                 return false;    
  125.             }    
  126.         }    
  127.         return true;    
  128.     }    
  129.     
  130.     /**  
  131.      * 阶乘  
  132.      * @param n  
  133.      * @return  
  134.      */    
  135.     public static int factorial(int n) {    
  136.         if (n == 1) {    
  137.             return 1;    
  138.         }    
  139.         return n * factorial(n - 1);    
  140.     }    
  141.     /**  
  142.      * 平方根算法  
  143.      * @param x  
  144.      * @return  
  145.      */    
  146.     public static long sqrt(long x) {    
  147.         long y = 0;    
  148.         long b = (~Long.MAX_VALUE) >>> 1;    
  149.         while (b > 0) {    
  150.             if (x >= y + b) {    
  151.                  x -= y + b;    
  152.                  y >>= 1;    
  153.                  y += b;    
  154.             } else {    
  155.                  y >>= 1;    
  156.             }     
  157.             b >>= 2;    
  158.        }     
  159.         return y;    
  160.     }    
  161.         
  162.     private int math_subnode(int selectNum, int minNum) {    
  163.         if (selectNum == minNum) {    
  164.             return 1;    
  165.         } else {    
  166.             return selectNum * math_subnode(selectNum - 1, minNum);    
  167.         }    
  168.     }    
  169.     
  170.     private int math_node(int selectNum) {    
  171.         if (selectNum == 0) {    
  172.             return 1;    
  173.         } else {    
  174.             return selectNum * math_node(selectNum - 1);    
  175.         }    
  176.     }    
  177.     /**  
  178.      * 可以用于计算双色球、大乐透注数的方法  
  179.      * selectNum:选中了的小球个数  
  180.      * minNum:至少要选中多少个小球  
  181.      * 比如大乐透35选5可以这样调用processMultiple(7,5);  
  182.      * 就是数学中的:C75=7*6/2*1  
  183.      */    
  184.     public int processMultiple(int selectNum, int minNum) {    
  185.         int result;    
  186.         result = math_subnode(selectNum, minNum)    
  187.                 / math_node(selectNum - minNum);    
  188.         return result;    
  189.     }    
  190.     
  191. /** 
  192. * 求m和n的最大公约数 
  193. */       
  194.     public static int gongyue(int m, int n) {       
  195.         while (m % n != 0) {       
  196.             int temp = m % n;       
  197.             m = n;       
  198.             n = temp;       
  199.         }       
  200.         return n;       
  201.     }       
  202.       
  203.     /**    
  204.      * 求两数的最小公倍数    
  205.      */         
  206.     public static int gongbei(int m, int n) {       
  207.         return m * n / gongyue(m, n);       
  208.     }    
  209.         
  210.     /**    
  211.      * 递归求两数的最大公约数    
  212.      */       
  213.     public static int divisor(int m,int n){        
  214.         if(m%n==0){       
  215.            return n;       
  216.        }else{       
  217.            return divisor(n,m%n);       
  218.        }       
  219.     }    
  220.     public static void main(String[] args){    
  221.       NumberUtil util=new NumberUtil();    
  222.       System.out.println(util.sqrt(100));  
  223.     }    
  224. }    
发布了141 篇原创文章 · 获赞 7 · 访问量 45万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览