JAVA的随机的字符串的封装(基本上够用了)

我是能说我是一个码农,是个菜逼,是个代码的搬运工,现在站在各个巨人的肩膀上看着java的世界:

  1 import java.util.Random;
  2
  3 public class UranDom {
  4     /**
  5      * 以下均为random函数
  6      * **/
  7     private static Random random;
  8      private static long seed;
  9       static {
 10           seed=System.currentTimeMillis();
 11           random=new Random(seed);
 12       }
 13
 14     private UranDom(){}
 15
 16     /**
 17      * 获取种子值
 18      * @return long 随机种子生成器种子值
 19      *
 20      * */
 21     public static long getSeed(){
 22         return seed;
 23     }
 24
 25     /**
 26      * 随机返回0到1之间的实数[0,1)
 27      * @return double 随机数
 28      *
 29      * **/
 30     public static double uniform(){
 31         return random.nextDouble();
 32     }
 33
 34     /**
 35      * 随机0到N-1的整数[0,N)
 36      * @param N 上限
 37      * @retrun int 随机数
 38      * **/
 39     public static int uniform(int N){
 40         return random.nextInt(N);
 41     }
 42     /**
 43      * 随机返回a到b-1之间的整数
 44      * @param a 下限
 45      * @param b 上限
 46      * @return int  随机数
 47      *
 48      * **/
 49     public static int uniform(int a,int b){
 50         return a+uniform(b-1);
 51     }
 52
 53     /**
 54      * 随机返回a到b之间的实数
 55      * @param a 下限
 56      * @param b 上限
 57      * @return int  随机数
 58      *
 59      * **/
 60
 61     public static double uniform(double a,double b){
 62         return a+uniform()*(b-a);
 63     }
 64
 65     /**     *
 66      * @param type ==1 数字
 67      * @param type ==2 纯小写字母
 68      * @param type ==3 纯大写字母
 69      * @param type ==4 数字和小写字母混排
 70      * @param type ==5 数字和大写字母混排
 71      * @param type ==6大写和小写字母混排
 72      * @param type ==7 大小写和数字混排
 73      * @param length  长度
 74      * @param both  只有length>2且type>4时生效,意思是,两者或以上都必须有一个以上的类型
 75      * **/
 76     public static String RandString(int type,int length,boolean both){
 77         StringBuffer buffer=new StringBuffer();
 78         StringBuffer sb=null;
 79         String number="0123456789";
 80         String sletter="abcdefghijklmnopqrstuvwxyz";
 81         String bletter="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 82
 83         //处理type
 84         switch(type){
 85         case 1://纯数字
 86             buffer.append(number);
 87             sb=new StringBuffer();
 88             while(length>0){
 89                 sb.append(buffer.charAt(UranDom.uniform(10)));
 90                 length--;
 91             }
 92             break;
 93         case 2://纯小写
 94             buffer.append(sletter);
 95             sb=new StringBuffer();
 96             while(length>0){
 97                 sb.append(buffer.charAt(UranDom.uniform(26)));
 98                 length--;
 99             }
100             break;
101         case 3://纯大写
102             buffer.append(bletter);
103             sb=new StringBuffer();
104             while(length>0){
105                 sb.append(buffer.charAt(UranDom.uniform(26)));
106                 length--;
107             }
108             break;
109         case 4://数字+小写
110             buffer.append(number+sletter);
111             if(!both){
112                 sb=new StringBuffer();
113                 while(length>0){
114                     sb.append(buffer.charAt(UranDom.uniform(36)));
115                     length--;
116                 }
117             }else {//两者必有其一
118                 sb=new StringBuffer();
119                 int ra1=UranDom.uniform(length);
120                 int ra2=UranDom.uniform(length);
121                 //如果重复则重新随机
122                 while(ra2==ra1){
123                     ra2=UranDom.uniform(length);
124                 }
125                 //随机第一个和第二个的数值
126                 char c1=(char)(‘0‘+UranDom.uniform(10));
127                 char c2=(char)(‘a‘+UranDom.uniform(26));
128
129                 while(length>0){
130                     if(length==ra1){
131                         sb.append(c1);
132                     }
133                     else if(length==ra2)
134                     {
135                         sb.append(c2);
136                     }
137                     else sb.append(buffer.charAt(UranDom.uniform(36)));
138                     length--;
139                 }
140             }
141             break;
142         case 5://数字+大写
143             buffer.append(number+bletter);
144             if(!both){
145                 sb=new StringBuffer();
146                 while(length>0){
147                     sb.append(buffer.charAt(UranDom.uniform(36)));
148                     length--;
149                 }
150             }else {//两者必有其一
151                 sb=new StringBuffer();
152                 int ra1=UranDom.uniform(length);
153                 int ra2=UranDom.uniform(length);
154                 //如果重复则重新随机
155                 while(ra2==ra1){
156                     ra2=UranDom.uniform(length);
157                 }
158                 //随机第一个和第二个的数值
159                 char c1=(char)(‘0‘+UranDom.uniform(10));
160                 char c2=(char)(‘A‘+UranDom.uniform(26));
161
162                 while(length>0){
163                     if(length==ra1){
164                         sb.append(c1);
165                     }
166                     else if(length==ra2)
167                     {
168                         sb.append(c2);
169                     }
170                     else sb.append(buffer.charAt(UranDom.uniform(36)));
171                     length--;
172                 }
173
174             }
175             break;
176         case 6://大写+小写
177             buffer.append(sletter+bletter);
178             if(!both){
179                 sb=new StringBuffer();
180                 while(length>0){
181                     sb.append(buffer.charAt(UranDom.uniform(52)));
182                     length--;
183                 }
184             }else {//两者必有其一
185                 sb=new StringBuffer();
186                 int ra1=UranDom.uniform(length);
187                 int ra2=UranDom.uniform(length);
188                 //如果重复则重新随机
189                 while(ra2==ra1){
190                     ra2=UranDom.uniform(length);
191                 }
192                 //随机第一个和第二个的数值
193                 char c1=(char)(‘a‘+UranDom.uniform(26));
194                 char c2=(char)(‘A‘+UranDom.uniform(26));
195
196                 while(length>0){
197                     if(length==ra1){
198                         sb.append(c1);
199                     }
200                     else if(length==ra2)
201                     {
202                         sb.append(c2);
203                     }
204                     else sb.append(buffer.charAt(UranDom.uniform(52)));
205                     length--;
206                 }
207             }
208             break;
209         case 7:
210             buffer.append(number+sletter+bletter);
211             if(!both){
212                 sb=new StringBuffer();
213                 while(length>0){
214                     sb.append(buffer.charAt(UranDom.uniform(62)));
215                     length--;
216                 }
217             }else {//三者必有其一
218                 sb=new StringBuffer();
219                 int ra1=UranDom.uniform(length);
220                 int ra2=UranDom.uniform(length);
221                 int ra3=UranDom.uniform(length);
222                 //如果重复则重新随机
223                 while(ra2==ra1){
224                     ra2=UranDom.uniform(length);
225                 }
226                 while(ra3==ra2||ra3==ra1){
227                     ra3=UranDom.uniform(length);
228                 }
229                 //随机第一个和第二个的数值
230                 char c1=(char)(‘0‘+UranDom.uniform(10));
231                 char c2=(char)(‘A‘+UranDom.uniform(26));
232                 char c3=(char)(‘a‘+UranDom.uniform(26));
233                 System.out.println(c1+c2+c3);
234                 while(length>0){
235                     if(length==ra1){
236                         sb.append(c1);
237                     }
238                     else if(length==ra2)
239                     {
240                         sb.append(c2);
241                     }
242                     else if(length==ra3){
243                         sb.append(c3);
244                     }
245                     else sb.append(buffer.charAt(UranDom.uniform(62)));
246                     length--;
247             }
248             break;
249         }
250
251     }
时间: 2024-08-07 21:23:43

JAVA的随机的字符串的封装(基本上够用了)的相关文章

Horspool算法(java)随机生成字符串

java代码 import java.util.Scanner; public class Horspool { public static void ShiftTable(char[] p, int[] table){ for (int i = 0; i < 26; i++) { table[i] = p.length; } for (int i = 0; i < p.length - 1; i++) { table[p[i] -'A'] = p.length - 1 - i; } } pu

java中随机生成字符串的方法(三种)

1.生成的字符串每个位置都有可能是str中的一个字母或数字,需要导入的包是import java.util.Random; //length用户要求产生字符串的长度 public static String getRandomString(int length){ String str="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; Random random=new Random(); StringB

Java随机字符串:随机数字字符串,工具类

Java中生成随机数,字符串的工具类 1. 调用方法需要传入生成字符串的长度和需要的类型 生成随机数字 生成随机字母字符串 生成随机字符串+数字等 ......... 2. 总共8种类型,具体看工具类中的注释. 1 import java.util.Date; 2 import java.util.Random; 3 import java.util.UUID; 4 5 /** 6 * @Name RandomStringUtil 7 * @Descr 生成随机字符串 8 * @author d

Java随机取字符串的工具类

原文:Java随机取字符串的工具类 源代码下载地址:http://www.zuidaima.com/share/1550463479532544.htm Java 随机取字符串的工具类 可以全部是数字,字符,也可以字符和数字组合的工具类,希望能给大家带来帮助 package com.zuidaima.test; import java.util.Random; public class RandomUtils { public static final String ALLCHAR = "012

JAVA中用于处理字符串的“三兄弟”

JAVA中用于处理字符串常用的有三个类:java.lang.String.java.lang.StringBuffer.java.lang.StringBuilder,这三者的共同之处都是final类,不允许被继承,这主要是从性能和安全性上考虑的,因为这几个类都是经常被使用着的,且考虑到防止其中的参数被修改影响到其它的应用.StringBuffer与StringBuilder两个基本上差不多,只是StringBuffer是线程安全,可以不需要额外的同步用于多线程中:StringBuilder是非

Java中常用的字符串API

Java中常用的字符串API 这些API都封装在了 import java.lang; (默认导入无需手工导入) 字符串.length() 返回字符串的长度 字符串1.equals(字符串2) 判断两个字符串内容是否一致(不能用==) 字符串1.equalsIgnoreCase(字符串2) 判断两个字符串内容是否一致(不区分大小写) 字符串.toLowerCase() 返回小写字符串 字符串.toUpperCase() 返回大写字符串 字符串1.concat(字符串2) 返回字符串1接上字符串2

使用JAXB实现JAVA对象和XML字符串的互相转换实例

测试类: package com.yanek.test; import java.util.ArrayList; import java.util.List; import com.yanek.test.JaxbUtil.CollectionWrapper; public class Test { /** * @param args */ public static void main(String[] args) { //创建java对象 Hotel hotel=new Hotel(); ho

学习java随笔第八篇:封装、继承、多态

java和c#一样都是面向对象的语言. 面向对象的语言有三大特征:封装.继承.多态 封装 封装:隐藏对象的属性和实现细节,仅对外公开接口,控制在程序中属性的读和修改的访问级别. class Person2 { private String name; public void setName(String name) { this.name=name; } public String getName() { return name; } private String sex; public voi

java python oracle判断字符串是否为数字的函数

java public boolean isNumeric(String str){ Pattern pattern = Pattern.compile("^-?[0-9]+\\.?[0-9]+"); Matcher isNum = pattern.matcher(str); if( !isNum.matches() ){ return false; } return true; } python def isNum(value): try: int(value) + 1 except