字符串常用工具集合类.docx

字符串常用工具集合类.docx

《字符串常用工具集合类.docx》由会员分享，可在线阅读，更多相关《字符串常用工具集合类.docx（28页珍藏版）》请在冰豆网上搜索。

字符串常用工具集合类

packagecn.edu.fudan.ora.utils;

002

003

importjava.security.MessageDigest;

004

importjava.security.SecureRandom;

005

importjava.util.regex.Matcher;

006

importjava.util.regex.Pattern;

007

008

importjavax.crypto.Cipher;

009

importjavax.crypto.SecretKey;

010

importjavax.crypto.SecretKeyFactory;

011

importjavax.crypto.spec.DESKeySpec;

012

013

//************************************************************************

014

//【类　名】　　　　字符串工具集合类

015

/**

016

*字符串操作方法实现.

017

*

018

*@author　　　yuegy

019

*@version　　2011-02-10

020

*/

021

//************************************************************************

022

//【作　成】　　　　www.sh-　　　　2011-02-10（R1.00）

023

//************************************************************************

024

publicclassStrUtil{

025

026

privatestaticfinalStringPASSWORD_CRYPT_KEY="__fudan_";

027

privatefinalstaticStringDES="DES";

028

privatefinalstaticStringMD5="MD5";

029

publicfinalstaticStringEMPTY="";

030

publicfinalstaticStringPADLEFT="LEFT";

031

publicfinalstaticStringPADRIGHT="RIGHT";

032

033

/**

034

*MD5加密.

035

*

036

*@paramstr

037

*@return

038

*/

039

publicstaticStringencryptByMD5（Stringstr）{

040

MessageDigestmessageDigest=null;

041

try{

042

messageDigest=MessageDigest.getInstance（MD5）;

043

messageDigest.reset（）;

044

messageDigest.update（str.getBytes（"UTF-8"））;

045

}catch（Exceptione）{

046

return"";

047

}

048

049

byte[]byteArray=messageDigest.digest（）;

050

StringBuffermd5StrBuff=newStringBuffer（）;

051

for（inti=0;i

052

if（Integer.toHexString（0xFF&byteArray[i]）.length（）==1）

053

md5StrBuff.append（"0"）.append（

054

Integer.toHexString（0xFF&byteArray[i]））;

055

else

056

md5StrBuff.append（Integer.toHexString（0xFF&byteArray[i]））;

057

}

058

returnmd5StrBuff.toString（）;

059

}

060

061

/**

062

*

063

*加密.

064

*

065

*@paramsrc

066

*数据源

067

*

068

*@paramkey

069

*密钥，长度必须是8的倍数

070

*

071

*@return返回加密后的数据

072

*

073

*@throwsException

074

*

075

*/

076

privatestaticbyte[]encrypt（byte[]src,byte[]key）throwsException{

077

078

//DES算法要求有一个可信任的随机数源

079

SecureRandomsr=newSecureRandom（）;

080

081

//从原始密匙数据创建DESKeySpec对象

082

DESKeySpecdks=newDESKeySpec（key）;

083

084

//创建一个密匙工厂，然后用它把DESKeySpec转换成

085

//一个SecretKey对象

086

SecretKeyFactorykeyFactory=SecretKeyFactory.getInstance（DES）;

087

088

SecretKeysecurekey=keyFactory.generateSecret（dks）;

089

090

//Cipher对象实际完成加密操作

091

Ciphercipher=Cipher.getInstance（DES）;

092

093

//用密匙初始化Cipher对象

094

cipher.init（Cipher.ENCRYPT_MODE,securekey,sr）;

095

096

//现在，获取数据并加密

097

098

//正式执行加密操作

099

returncipher.doFinal（src）;

100

}

101

102

/**

103

*

104

*解密.

105

*

106

*@paramsrc

107

*数据源

108

*

109

*@paramkey

110

*密钥，长度必须是8的倍数

111

*

112

*@return返回解密后的原始数据

113

*

114

*@throwsException

115

*

116

*/

117

privatestaticbyte[]decrypt（byte[]src,byte[]key）throwsException{

118

119

//DES算法要求有一个可信任的随机数源

120

SecureRandomsr=newSecureRandom（）;

121

122

//从原始密匙数据创建一个DESKeySpec对象

123

DESKeySpecdks=newDESKeySpec（key）;

124

125

//创建一个密匙工厂，然后用它把DESKeySpec对象转换成

126

//一个SecretKey对象

127

SecretKeyFactorykeyFactory=SecretKeyFactory.getInstance（DES）;

128

SecretKeysecurekey=keyFactory.generateSecret（dks）;

129

130

//Cipher对象实际完成解密操作

131

Ciphercipher=Cipher.getInstance（DES）;

132

133

//用密匙初始化Cipher对象

134

cipher.init（Cipher.DECRYPT_MODE,securekey,sr）;

135

136

//现在，获取数据并解密

137

//正式执行解密操作

138

returncipher.doFinal（src）;

139

140

}

141

142

/**

143

*

144

*密码解密.

145

*

146

*@paramdata

147

*

148

*@return

149

*

150

*@throwsException

151

*

152

*/

153

publicfinalstaticStringdecryptByDES（Stringdata）{

154

try{

155

returnnewString（decrypt（hex2byte（data.getBytes（））,

156

PASSWORD_CRYPT_KEY.getBytes（）））;

157

}catch（Exceptione）{

158

159

}

160

returnnull;

161

}

162

163

/**

164

*

165

*密码加密.

166

*

167

*@parampassword

168

*

169

*@return

170

*

171

*@throwsException

172

*

173

*/

174

publicfinalstaticStringencryptByDES（Stringpassword）{

175

try{

176

returnbyte2hex（encrypt（password.getBytes（）,PASSWORD_CRYPT_KEY

177

.getBytes（）））;

178

}catch（Exceptione）{

179

180

}

181

returnnull;

182

}

183

184

/**

185

*

186

*二行制转字符串.

187

*

188

*@paramb

189

*

190

*@return

191

*

192

*/

193

publicstaticStringbyte2hex（byte[]b）{

194

Stringhs=EMPTY;

195

Stringstmp=EMPTY;

196

for（intn=0;n

197

stmp=（java.lang.Integer.toHexString（b[n]&0XFF））;

198

if（stmp.length（）==1）

199

hs=hs+"0"+stmp;

200

else

201

hs=hs+stmp;

202

}

203

returnhs.toUpperCase（）;

204

}

205

206

publicstaticbyte[]hex2byte（byte[]b）{

207

if（（b.length%2）!

=0）

208

thrownewIllegalArgumentException（"长度不是偶数"）;

209

byte[]b2=newbyte[b.length/2];

210

for（intn=0;n

211

Stringitem=newString（b,n,2）;

212

b2[n/2]=（byte）Integer.parseInt（item,16）;

213

}

214

returnb2;

215

}

216

217

/**

218

*去掉字符串中的指定字符.

219

*

220

*@paramsrc

221

*输入字符串

222

*@paramchars

223

*要去除的字符

224

*

225

*例：

trim（"abcdxxxx",'','x'）==>"abcd"

226

*

227

*@return输出字符串

228

*

229

*/

230

publicstaticStringtrim（Stringsrc,char...chars）{

231

if（src==null）{

232

returnEMPTY;

233

}

234

intcount=src.length（）;

235

intlen=src.length（）;

236

intst=0;

237

238

while（st

239

if（src.charAt（st）<''）{//非打印字符

240

st++;

241

}else{

242

booleanfound=false;

243

for（charc:

chars）{

244

if（src.charAt（st）==c）{

245

found=true;

246

break;

247

}

248

}

249

if（found）{

250

st++;

251

}else{

252

break;

253

}

254

}

255

}

256

while（st

257

if（src.charAt（len-1）<''）{

258

len--;

259

}else{

260

booleanfound=false;

261

for（charc:

chars）{

262

if（src.charAt（len-1）==c）{

263

found=true;

264

break;

265

}

266

}

267

if（found）{

268

len--;

269

}else{

270

break;

271

}

272

}

273

}

274

return（（st>0）||（len

src.substring（st,len）:

src;

275

}

276

277

/**

278

*去掉字符串左边的指定字符.

279

*

280

*@paramsrc

281

*输入字符串

282

*@paramchars

283

*要去除的字符

284

*

285

*例：

trimLeft（"abcdxxxx",'','x'）==>"abcdxxxx"

286

*

287

*@return输出字符串

288

*

289

*/

290

publicstaticStringtrimLeft（Stringsrc,char...chars）{

291

if（src==null）{

292

returnEMPTY;

293

}

294

intcount=src.length（）;

295

intlen=src.length（）;

296

intst=0;

297

298

while（st

299

if（src.charAt（st）<''）{//非打印字符

300

st++;

301

}else{

302

booleanfound=false;

303

for（charc:

chars）{

304

if（src.charAt（st）==c）{

305

found=true;

306

break;

307

}

308

}

309

if（found）{

310

st++;

311

}else{

312

break;

313

}

314

}

315

}

316

return（（st>0）||（len

src.substring（st,len）:

src;

317

}

318

319

/**

320

*去掉字符串右边的指定字符.

321

*

322

*@paramsrc

323

*输入字符串

324

*@paramchars

325

*要去除的字符

326

*

327

*例：

trimRight（"abcdxxxx",'','x'）==>"abcd"

328

*

329

*@return输出字符串

330

*

331

*/

332

publicstaticStringtrimRight（Stringsrc,char...chars）{

333

if（src==null）{

334

returnEMPTY;

335

}

336

intcount=src.length（）;

337

intlen=src.length（）;

338

intst=0;

339

340

while（st

341

if（src.charAt（len-1）<''）{

342

len--;

343

}else{

344

booleanfound=false;

345

for（charc:

chars）{

346

if（src.charAt（len-1）==c）{

347

found=true;

348

break;

349

}

350

}

351

if（found）{

352

len--;

353

}else{

354

break;

355

}

356

}

357

}

358

return（（st>0）||（len

src.substring（st,len）:

src;

359

}

360

361

/**

362

*判断字符串是空.

363

*

364

*@paraminputStr

365

*输入字符串

366

*

367

*@returnboolean

368

*

369

*/

370

publicstaticbooleanisEmpty（StringinputStr）{

371

returnnull==inputStr||EMPTY.equals（inputStr）;

372

}

373

374

/**

375

*判断字符串是空.

376

*

377

*@paraminputStr

378

*输入字符串

379

*

380

*@returnboolean

381

*

382

*/

383

publicstaticbooleanisNotEmpty（StringinputStr）{

384

return!

isEmpty（inputStr）;

385

}

386

387

/**

388

*字符串左填充.

389

*

390

*@paramsrc

391

*@parampadchar

392

*@paramlen

393

*@return

394

*/

395

publicstaticStringpadLeft（Stringsrc,Stringpadchar,intlen）{

396

if（isEmpty（padchar））{

397

returnsrc;

398

}

399

Stringout=src;

400

if（isEmpty（out））{

401

out=EMPTY;

402

}

403

if（len<=0||out.length（）>=len）{

404

returnout;

405

}

406

StringBuffersb=newStringBuffer（）;

407

for（inti=0;i

408

sb.append（padchar）;

409

}

410

sb.append（out）;

411

out=sb.substring（sb.length（）-len）;

412

returnout;

413

}

414

415

/**

416

*字符串右填充.

417

*

418

*@paramsrc

419

*@parampadchar

420

*@paramlen

421

*@return

422

*/

423

p