package com.worthtech.app.util;
import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import javax.servlet.http.HttpServletRequest;
public class Util {
public static String error = "";
public static String lastKey = "";
public static String tel = "";
private static MessageDigest digest = null;
public String hash(String data) {//MD5加密
if (digest == null)
try {
digest = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException nsae) {
System.err.println("Failed to load the MD5 MessageDigest. We will be unable to function normally.");
nsae.printStackTrace();
}
digest.update(data.getBytes());
return encodeHex(digest.digest());
}
public String encodeHex(byte bytes[]) {
StringBuffer buf = new StringBuffer(bytes.length * 2);
for (int i = 0; i < bytes.length; i++) {
if ((bytes[i] & 0xff) < 16)
buf.append("0");
buf.append(Long.toString(bytes[i] & 0xff, 16));
}
return buf.toString().toUpperCase();
}
public static String getCurrentDate(){
Calendar day=Calendar.getInstance();
day.add(Calendar.DATE,0);
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
String date1 = sdf.format(day.getTime());
return date1;
}
public static String getCurrentDate(String format){
Calendar day=Calendar.getInstance();
day.add(Calendar.DATE,0);
SimpleDateFormat sdf=new SimpleDateFormat(format);//"yyyy-MM-dd"
String date = sdf.format(day.getTime());
return date;
}
public static String getYesterdayDate(String format){
Calendar day=Calendar.getInstance();
day.add(Calendar.DATE,-1);
SimpleDateFormat sdf=new SimpleDateFormat(format);//"yyyy-MM-dd"
String date = sdf.format(day.getTime());
return date;
}
/**
* @param date1 需要比较的时间 不能为空(null),需要正确的日期格式 ,如:2009-09-12
* @param date2 被比较的时间 为空(null)则为当前时间
* @param stype 返回值类型 0为多少天,1为多少个月,2为多少年
* @return
* 举例:
* compareDate("2009-09-12", null, 0);//比较天
* compareDate("2009-09-12", null, 1);//比较月
* compareDate("2009-09-12", null, 2);//比较年
*/
public static int compareDate(String startDay,String endDay,int stype){
int n = 0;
String[] u = {"天","月","年"};
String formatStyle = stype==1?"yyyy-MM":"yyyy-MM-dd";
endDay = endDay==null?getCurrentDate("yyyy-MM-dd"):endDay;
DateFormat df = new SimpleDateFormat(formatStyle);
Calendar c1 = Calendar.getInstance();
Calendar c2 = Calendar.getInstance();
try {
c1.setTime(df.parse(startDay));
c2.setTime(df.parse(endDay));
} catch (Exception e3) {
System.out.println("wrong occured");
}
//List list = new ArrayList();
while (!c1.after(c2)) { // 循环对比,直到相等,n 就是所要的结果
//list.add(df.format(c1.getTime())); // 这里可以把间隔的日期存到数组中 打印出来
n++;
if(stype==1){
c1.add(Calendar.MONTH, 1); // 比较月份,月份+1
}
else{
c1.add(Calendar.DATE, 1); // 比较天数,日期+1
}
}
n = n-1;
if(stype==2){
n = (int)n/365;
}
// System.out.println(startDay+" -- "+endDay+" 相差多少"+u[stype]+":"+n);
return n;
}
////////////////////////////////////////////////////
public static String genNumPassword(int length) {
if (length < 1)
return null;
String strChars[] = { "1", "2", "3", "4", "5", "6", "7", "8", "9" };
StringBuffer strPassword = new StringBuffer();
int nRand = (int) Math.round(Math.random() * 100D);
for (int i = 0; i < length; i++) {
nRand = (int) Math.round(Math.random() * 100D);
strPassword.append(strChars[nRand % (strChars.length - 1)]);
}
return strPassword.toString();
}
public static String getPrefixLine(int level, String txt) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < level * 2; i++) {
sb.append(txt);
}
return sb.toString();
}
public static String getActionMappingURL(String action,HttpServletRequest request) {
StringBuffer value = new StringBuffer(request.getContextPath());
// Use our servlet mapping, if one is specified
String servletMapping = "*.portal";
if (servletMapping != null) {
String queryString = null;
int question = action.indexOf("?");
if (question >= 0) {
queryString = action.substring(question);
}
String actionMapping = getActionMappingName(action);
if (servletMapping.startsWith("*.")) {
value.append(actionMapping);
value.append(servletMapping.substring(1));
} else if (servletMapping.endsWith("/*")) {
value.append(servletMapping.substring(0, servletMapping.length() - 2));
value.append(actionMapping);
} else if (servletMapping.equals("/")) {
value.append(actionMapping);
}
if (queryString != null) {
value.append(queryString);
}
}else {
if (!action.startsWith("/")) {
value.append("/");
}
value.append(action);
}
return (value.toString());
}
public static String getActionMappingName(String action) {
String value = action;
int question = action.indexOf("?");
if (question >= 0) {
value = value.substring(0, question);
}
int slash = value.lastIndexOf("/");
int period = value.lastIndexOf(".");
if ((period >= 0) && (period > slash)) {
value = value.substring(0, period);
}
if (value.startsWith("/")) {
return (value);
} else {
return ("/" + value);
}
}
public static String FormatSum(String sum){//00000012345->123.45
if(sum==null||sum.length()<2){
return "0.00";
}
String decimal = "." + sum.substring(sum.length()-2, sum.length());
String integer = killZero(sum.substring(0, sum.length()-2));
integer += decimal;
return integer;
}
public static String killZero(String sum){//00001234500->1234500
String temp = "";
for(int i = 0 ;i<sum.length();i++){
if(sum.charAt(i) != '0' || i == sum.length()-1){
temp = sum.substring(i,sum.length());
break;
}
}
return temp;
}
public static String getTranamt(String str) {
String tmp = "";
if(str.equals("-")){
return str;
}
char c[] = str.toCharArray();
if (str.length() != 1) {
for (int i = 0; i < c.length; i++) {
if (!String.valueOf(c[i]).equals("0")) {
tmp = str.substring(i, str.length());
break;
}
}
} else {
tmp = str;
}
StringBuffer sb = new StringBuffer();
sb.append(tmp);
if (sb.length() > 2) {
sb.insert(sb.length() - 2, ".");
}
if (sb.length() == 2) {
sb.insert(0, "0.");
}
if (sb.length() == 1) {
sb.insert(0, "0.0");
}
return sb.toString();
}
public static String numtochinese(String input) {
String s1 = "零壹贰叁肆伍陆柒捌玖";
String s4 = "分角整元拾佰仟万拾佰仟亿拾佰仟";
String temp = "";
String result = "";
if (input == null)
return "输入字串不是数字串只能包括以下字符(′0′~′9′,′.′),输入字串最大只能精确到仟亿,小数点只能两位!";
temp = input.trim();
float f;
try {
f = Float.parseFloat(temp);
} catch (Exception e) {
return "输入字串不是数字串只能包括以下字符(′0′~′9′,′.′),输入字串最大只能精确到仟亿,小数点只能两位!";
}
int len = 0;
if (temp.indexOf(".") == -1)
len = temp.length();
else
len = temp.indexOf(".");
if (len > s4.length() - 3)
return ("输入字串最大只能精确到仟亿,小数点只能两位!");
int n1, n2 = 0;
String num = "";
String unit = "";
for (int i = 0; i < temp.length(); i++) {
if (i > len + 2) {
break;
}
if (i == len) {
continue;
}
n1 = Integer.parseInt(String.valueOf(temp.charAt(i)));
num = s1.substring(n1, n1 + 1);
n1 = len - i + 2;
unit = s4.substring(n1, n1 + 1);
result = result.concat(num).concat(unit);
}
if ((len == temp.length()) || (len == temp.length() - 1))
result = result.concat("整");
if (len == temp.length() - 2)
result = result.concat("零分");
return result;
}
//左补0
public static String addZero(String str, int destLen){
String temp = str;
if(temp == null){
System.out.println("null in AddZero");
temp = "";
}
if(temp.length() >= destLen){
return temp.substring(temp.length()-destLen, temp.length());
}
while(temp.length() < destLen){
temp = "0" + temp;
}
return temp;
}
public static String getNewString(String old,int num){
String tmp = "";
if(old==null){
old = "";
}
old = old.replace(" ", "");
if(old.getBytes().length<=num){
for(int i = old.getBytes().length;i<num;i++){
tmp += " ";
}
old = old + tmp;
}else{
old = old.substring(0,num);
}
return old;
}
//右补0,直到满12位
public static String getAMT(String old){
if(old==null){
old = "";
}
String tmp = "";
for(int i = old.length();i<12;i++){
tmp += "0";
}
old = tmp+old;
return old;
}
public static String getFormatString(String s){//去“-”
StringBuffer sb=new StringBuffer();
char[] c=s.toCharArray();
for(int i=0;i<c.length;i++){
if(c[i]=='-'){
}else{
sb.append(c[i]);
}
}
return sb.toString();
}
public static String anti_getFormatString(String s){//20090909->2009-09-09
if(s==null||s.length()<8){
return "";
}
return s.substring(0,4)+"-"+s.substring(4,6)+"-"+s.substring(6);
}
public static String moneyFormat(String money,int length){//123.45->00000012345
if(money==null||money.equals("")){
return "";
}
int iTemp = money.indexOf(".");
String sTemp="";
if (iTemp == -1) {
sTemp = money + "00";
} else if (iTemp + 2 == money.length()) {
sTemp = money.substring(0, iTemp)
+ money.charAt(iTemp + 1) + "0";
} else {
sTemp = money.substring(0, iTemp)
+ money.substring(iTemp + 1,
iTemp + 3);
}
return Util.addZero(sTemp, length);
}
public static String moneyFormat2(String money){//23->23.00
StringBuffer sb=new StringBuffer();
if(money==null){
return "0.00";
}
int index=money.indexOf(".");
if(index==-1){
return money+".00";
}else{
String s0=money.substring(0,index);//整数部分
String s1=money.substring(index+1);//小数部分
if(s1.length()==1){//小数点后一位
s1=s1+"0";
}else if(s1.length()>2){//如果超过3位小数,截取2位就可以了
s1=s1.substring(0,2);
}
sb.append(s0);
sb.append(".");
sb.append(s1);
}
return sb.toString();
}
/**
* 在list中查询以prefix开头的子项,返回符合匹配的list
* @param list
* @param prefix
* @return
*/
public static List findMatches(List list,String prefix) {
String prefix_upper = prefix.toUpperCase();
List matches = new ArrayList();
Iterator iter = list.iterator();
while (iter.hasNext()) {
String name = (String) iter.next();
String name_upper = name.toUpperCase();
if (name_upper.startsWith(prefix_upper)) {
matches.add(name);
}
}
return matches;
}
/**
* 统计字符出现次数
* @param s
*/
public static void statistics(String s) {
Map<Character, Integer> map = new HashMap<Character, Integer>();
int i, size = s.length();
for (i = 0; i < size; i++) {
char c = s.charAt(i);
map.put(c, map.containsKey(c) ? ((Integer) map.get(c) + 1) : 1);
}
// System.out.println(map);
}
// 生成不重复随机数1
/**
* 根据给定的最小数字和最大数字,以及随机数的个数,产生指定的不重复的数组
* @param begin 最小数字(包含该数)
* @param end 最大数字(不包含该数)
* @param size 指定产生随机数的个数
*/
public static int[] generateRandomNumber(int begin, int end, int size) {
// 加入逻辑判断,确保begin<end并且size不能大于该表示范围
if (begin >= end || (end - begin) < size) {
return null;
}
// 种子你可以随意生成,但不能重复
int[] seed = new int[end - begin];
for (int i = begin; i < end; i ++) {
seed[i - begin] = i;
}
int[] ranArr = new int[size];
Random ran = new Random();
// 数量你可以自己定义。
for (int i = 0; i < size; i++) {
// 得到一个位置
int j = ran.nextInt(seed.length - i);
// 得到那个位置的数值
ranArr[i] = seed[j];
// 将最后一个未用的数字放到这里
seed[j] = seed[seed.length - 1 - i];
}
return ranArr;
}
// 生成不重复随机数2
/**
* 根据给定的最小数字和最大数字,以及随机数的个数,产生指定的不重复的数组
* @param begin 最小数字(包含该数)
* @param end 最大数字(不包含该数)
* @param size 指定产生随机数的个数
*/
public static Integer[] generateBySet(int begin, int end, int size) {
// 加入逻辑判断,确保begin<end并且size不能大于该表示范围
if (begin >= end || (end - begin) < size) {
return null;
}
Random ran = new Random();
Set<Integer> set = new HashSet<Integer>();
while (set.size() < size) {
set.add(begin + ran.nextInt(end - begin));
}
Integer[] ranArr = new Integer[size];
ranArr = set.toArray(new Integer[size]);
//ranArr = (Integer[]) set.toArray();
return ranArr;
}
public static String toUTF(String iso){
if(iso==null){
return null;
}
String data="";
try {
data = new String(iso.getBytes("ISO-8859-1"),"UTF-8");
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return data;
}
public static String toChinese(String chinese){
if(chinese==null){
return null;
}
String data="";
try {
data=java.net.URLDecoder.decode(chinese,"UTF-8");
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return data;
}
// 判断时间是否符合时间格式
public static boolean isDate(String date, String dateFormat) {
if (date != null) {
java.text.SimpleDateFormat format = new java.text.SimpleDateFormat(dateFormat);
format.setLenient(false);
try {
format.format(format.parse(date));
} catch (ParseException e) {
// TODO Auto-generated catch block
return false;
}
return true;
}
return false;
}
/**
* 实现给定某日期,判断是星期几
* date:必须yyyy-MM-dd格式
*/
public static String getWeekday(String date){
SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat sdw = new SimpleDateFormat("E");
Date d = null;
try {
d = sd.parse(date);
} catch (ParseException e) {
e.printStackTrace();
}
return sdw.format(d);
}
// 用来全局控制 上一周,本周,下一周的周数变化
private static int weeks = 0;
// 获得当前日期与本周一相差的天数
private static int getMondayPlus() {
Calendar cd = Calendar.getInstance();
// 获得今天是一周的第几天,星期日是第一天,星期二是第二天......
int dayOfWeek = cd.get(Calendar.DAY_OF_WEEK);
if (dayOfWeek == 1) {
return -6;
} else {
return 2 - dayOfWeek;
}
}
// 获得本周星期一的日期
public static String getCurrentMonday(String format) {
weeks = 0;
int mondayPlus = getMondayPlus();
Calendar currentDate=Calendar.getInstance();
currentDate.add(Calendar.DATE, mondayPlus);
SimpleDateFormat sdf=new SimpleDateFormat(format);//"yyyy-MM-dd"
String date = sdf.format(currentDate.getTime());
return date;
}
// 获得上周星期一的日期
public static String getPreviousMonday(String format) {
weeks--;
int mondayPlus = getMondayPlus();
Calendar currentDate=Calendar.getInstance();
currentDate.add(GregorianCalendar.DATE, mondayPlus + 7 * weeks);
SimpleDateFormat sdf=new SimpleDateFormat(format);//"yyyy-MM-dd"
String date = sdf.format(currentDate.getTime());
return date;
}
// 获得下周星期一的日期
public static String getNextMonday(String format) {
weeks++;
int mondayPlus = getMondayPlus();
// GregorianCalendar currentDate = new GregorianCalendar();
Calendar currentDate=Calendar.getInstance();
currentDate.add(GregorianCalendar.DATE, mondayPlus + 7 * weeks);
SimpleDateFormat sdf=new SimpleDateFormat(format);//"yyyy-MM-dd"
String date = sdf.format(currentDate.getTime());
return date;
}
// 获得相应周的周日的日期
public static String getSunday(String format) {
int mondayPlus = getMondayPlus();
Calendar currentDate=Calendar.getInstance();
currentDate.add(Calendar.DATE, mondayPlus + 7 * weeks + 6);
SimpleDateFormat sdf=new SimpleDateFormat(format);//"yyyy-MM-dd"
String date = sdf.format(currentDate.getTime());
return date;
}
//判断String是否是整数
public static boolean isInteger(String s){
if((s != null)&&(s!=""))
return s.matches("^[0-9]*$");
else
return false;
}
/**
* 判断字符串是否是浮点数
*/
public static boolean isDouble(String value) {
try {
Double.parseDouble(value);
if (value.contains("."))
return true;
return false;
} catch (NumberFormatException e) {
return false;
}
}
/**
* 判断字符串是否是数字
*/
public static boolean isNumber(String value) {
return isInteger(value) || isDouble(value);
}
public static void main(String[] args){
// System.out.println(new Util().hash("111111"));
// Util util=new Util();
// if(util.isDate("20090817", "yyyyMMdd")){
// System.out.println("yes");
// }else{
// System.out.println("no");
// }
// statistics("adfsfsadfsadfsadfasdf");
// int[] ranArr = generateRandomNumber(1,35,7);
// System.out.println(Arrays.toString(ranArr));
// System.out.println("numtochinese="+numtochinese("1234567890"));
}
}
/**
* 在第一个字符串中查找匹配字符串的个数
* @param str
* @param regexStr
* @return
*/
public static int count(String str,String regexStr){
int count = 0;
Pattern pt = Pattern.compile(regexStr);
Matcher m = pt.matcher(str);
int start = 0;
while(m.find()){
count++;
}
return count;
}
/**
* 根据正则表达式分割str字符串成为一个一个的小的单元!
* (实际使用:在一个类似语法分析的模块中发挥重要作用)
* 例如:3+5*4 根据正则表达式+-\* 分割成数组 3,+,5,*,4
* @param str
* @param regexStr
* @return
*/
public static List splitByStr(String str,String regexStr){
List temp = new ArrayList();
Pattern pt = Pattern.compile(regexStr);
Matcher m = pt.matcher(str);
int start = 0;
while(m.find()){
//去掉下面的字符串中为空串的情况!
if(m.start()!=start)
temp.add(str.substring(start, m.start()));
temp.add(str.substring(m.start(),m.end()));
start = m.end();
}
temp.add(str.substring(start));
return temp;
}
/**
* 检查是否含有指定的正则表达式匹配的子串.
* @param str 目标字符串
* @param regex 正则表达式,如果正则表达式含有"^......$"就是查找整个字符串对象是否符合正则表达式.
* @return
*/
public static boolean checkInclude(String str,String regex){
Pattern pattern = Pattern.compile(regex);
Matcher matcher = null;
matcher = pattern.matcher(str);
return matcher.find();
}
/**
* 方法字符串中符合正则表达式的子串的集合.
* @param str
* @param regex
* @return
*/
public static List getRightSubStr(String str, String regex) {
List ans = new ArrayList();
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
while (matcher.find()) {
//注意要下面的goup()函数中可以含有数字,表示查找得到正则表达式中的goup匹配串.
ans.add(matcher.group());
System.out.println("找到匹配的字符串 \"" + matcher.group()
+ "\" 开始于 " + matcher.start()
+ " 结束于 " + matcher.end() + ".");
}
return ans;
}
/**
* 超大整数相加:
* 题目要求:如果系统要使用超大整数(超过long的范围),请你设计一个数据结构来存储这种
* 超大型数字以及设计一种算法来实现超大整数的加法运算
* @author Administrator
*
*/
public class VeryBigNumAdd {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
String a="1223232";
for(int i=a.length()-1;i>=0;i--)
{
System.out.print(a.charAt(i));
}
*/
VeryBigNumAdd vbn=new VeryBigNumAdd();
String a="123453243455535634535252345234677576252241234123523453664563634";
String b="123453243455535634535252345234677576252241234123523453664563634";
String result=vbn.doAdd(a,b);
System.out.println("result:"+result);
}
/**
*
* @param a 加数字符串1
* @param b 加数字符串2
* @return 结果字符串
* 分析:
* 1、取得两个字符串的长度
* 2、把两个的长度做比较,并得出较长的长度,及较短的长度
* 3、把长度较短的加数字符串,在左面补0,使之与较长的字符串一样长
* 4、从最高位,一个个数的取出来相加,当然首先得转换为整型
* 5、设置进位,如果两个数相加及加上进位大于等于10,并且这不是最左边一个字符相加,相加结果等于
* (取出1+取出2+进位)-10,并把进位设为1;如果没有大于10,就把进位设为0,如些循环,把
* 相加的结果以字符串的形式结合起来,就得到最后的结果
*/
String doAdd(String a,String b)
{
String str="";
int lenA=a.length();
int lenB=b.length();
int maxLen=(lenA>lenB) ? lenA : lenB;
int minLen=(lenA<lenB) ? lenA : lenB;
String strTmp="";
for(int i=maxLen-minLen;i>0;i--)
{
strTmp+="0";
}
//把长度调整到相同
if(maxLen==lenA)
{
b=strTmp+b;
}else
a=strTmp+a;
int JW=0;//进位
for(int i=maxLen-1;i>=0;i--)
{
int tempA=Integer.parseInt(String.valueOf(a.charAt(i)));
int tempB=Integer.parseInt(String.valueOf(b.charAt(i)));
int temp;
if(tempA+tempB+JW>=10 && i!=0)
{
temp=tempA+tempB+JW-10;
JW=1;
}
else
{
temp=tempA+tempB+JW;
JW=0;
}
str=String.valueOf(temp)+str;
}
return str;
}
}
1.写一个方法,用一个for循环打印九九乘法表
/** *//**
* 打印九九乘法口诀表
*/
public void nineNineMulitTable(){
for (int i = 1,j = 1; j <= 9; i++) {
System.out.print(i+"*"+j+"="+i*j+" ");
if(i==j){
i=0;
j++;
System.out.println();
}
}
}
2.给定一个java.util.Date对象,如何转化为”2007-3-22 20:23:22”格式的字符串
/** *//**
* 将某个日期以固定格式转化成字符串
* @param date
* @return str
*/
public String date2FormatStr(Date date)
{
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = sdf.format(date);
return str;
}
3.写一个方法,能够判断任意一个整数是否素数
/** *//**
* 判断任意一个整数是否素数
* @param num
* @return boolean
*/
public boolean isPrimeNumber(int num)
{
for (int i = 2; i <= Math.sqrt(num); i++) {
if(num%i==0)
{
return false;
}
}
return true;
}
4.写一个方法,输入任意一个整数,返回它的阶乘
/** *//**
*获得任意一个整数的阶乘
*@param n
*@returnn!
*/
public int factorial(int num)
{
//递归
if(num == 1)
{
return 1;
}
return num*factorial(num-1);
}
5.写一个方法,用二分查找法判断任意整数在任意整数数组里面是否存在,若存在就返回它在数组中的索引位置,不存在返回-1
/** *//**
*二分查找特定整数在整型数组中的位置(递归)
*@param dataset
*@param data
*@param beginIndex
*@param endIndex
*@return index
*/
public int binarySearch(int[] dataset,int data,int beginIndex,int endIndex){
int midIndex = (beginIndex+endIndex)/2;
//如果查找的数要比开始索引的数据要小或者是比结束索引的书要大,或者开始查找的索引值大于结束的索引值返回-1没有查到
if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex){
return -1;
}
if(data <dataset[midIndex]){
return binarySearch(dataset,data,beginIndex,midIndex-1);
}else if(data>dataset[midIndex])
{
return binarySearch(dataset,data,midIndex+1,endIndex);
}else {
return midIndex;
}
}
/** *//**
*二分查找特定整数在整型数组中的位置(非递归)
*@param dataset
*@param data
*@return index
*/
public int binarySearch(int[] dataset ,int data)
{
int beginIndex = 0;
int endIndex = dataset.length - 1;
int midIndex = -1;
if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex){
return -1;
}
while(beginIndex <= endIndex) {
midIndex = (beginIndex+endIndex)/2;
if(data <dataset[midIndex]) {
endIndex = midIndex-1;
} else if(data>dataset[midIndex]) {
beginIndex = midIndex+1;
}else {
return midIndex;
}
}
return -1;
}
一,冒泡排序:
package com.sort;
import java.util.Random;
public class No1Maopao {
public static void main(String[] args) {
Random rd = new Random();
//生成随即数组
int [] src = new int[10];
for(int i=0;i<10;i++){
src[i]=rd.nextInt(100);
}
//排序前打印数组所有元素
for(int i:src)
System.out.println(i);
System.out.println("---------------可爱的分割线-------------------");
src = sort(src);
//排序后打印数组所有元素
for(int i:src)
System.out.println(i);
}
public static int[] sort(int [] src){
for (int i = 0; i < src.length; i++) {
for(int j=i;j<src.length;j++){
if(src[j]<src[i]){
int temp = src[j];
src[j]=src[i];
src[i]=temp;
}
}
}
return src;
}
}
二、选择排序:
package com.sort;
import java.util.Random;
public class No2XuanZhe {
public static void main(String[] args) {
Random rd = new Random();
int[] src = new int[10];
for (int i = 0; i < 10; i++) {
src[i] = rd.nextInt(100);
}
for (int i : src)
System.out.println(i);
System.out.println("---------------可爱的分割线-------------------");
src = sort(src);
for (int i : src)
System.out.println(i);
}
public static int[] sort(int[] src) {
int min;
for (int i = 0; i < src.length; i++) {
min = src[i];
for (int j = i + 1; j < src.length; j++) {
if (src[j] < min) {
min = src[j];
int temp = src[i];
src[i] = src[j];
src[j] = temp;
}
}
}
return src;
}
}
三、插入排序:
package com.sort;
import java.util.Random;
public class No3ChaRu {
public static void main(String[] args) {
Random rd = new Random();
int[] src = new int[10];
for (int i = 0; i < 10; i++) {
src[i] = rd.nextInt(100);
}
for (int i : src)
System.out.println(i);
System.out.println("---------------可爱的分割线-------------------");
src = sort(src);
for (int i : src)
System.out.println(i);
}
public static int[] sort(int[] src) {
int in, out;
for (in = 1; in < src.length; in++) {
int temp = src[in];
out = in;
while (out > 0 && src[out - 1] >= temp) {
src[out] = src[out - 1];
--out;
}
src[out] = temp;
}
return src;
}
}
四、希尔排序:
package com.sort;
import java.util.Random;
public class No4Xier {
public static void main(String[] args) {
Random rd = new Random();
int[] src = new int[10];
for (int i = 0; i < 10; i++) {
src[i] = rd.nextInt(100);
}
for (int i : src)
System.out.println(i);
System.out.println("---------------可爱的分割线-------------------");
src = sort(src);
for (int i : src)
System.out.println(i);
}
public static int[] sort(int[] src) {
int len = src.length;
int temp, i, j;
int h = 1;
while (h <= len / 3)
h = h * 3 + 1;
while (h > 0) {
for (i = h; i < len; i++) {
temp = src[i];
j = i;
while (j > h - 1 && src[j - h] >= temp) {
src[j] = src[j - h];
j -= h;
}
src[j] = temp;
}
h = (h - 1) / 3;
}
return src;
}
}
五、快速排序:
public class No5Kuaisu {
public static void quickSort(int[] array) {
quickSort(array, 0, array.length - 1);
}
private static void quickSort(int[] array, int low, int high) {
if (low < high) {
int p = partition(array, low, high);
quickSort(array, low, p - 1);
quickSort(array, p + 1, high);
}
}
private static int partition(int[] array, int low, int high) {
int s = array[high];
int i = low - 1;
for (int j = low; j < high; j++) {
if (array[j] < s) {
i++;
swap(array, i, j);
}
}
swap(array, ++i, high);
return i;
}
private static void swap(int[] array, int i, int j) {
int temp;
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
public static void main(String[] args) {
Random rd = new Random();
int[] src = new int[10];
for (int i = 0; i < 10; i++) {
src[i] = rd.nextInt(100);
}
for (int i : src)
System.out.println(i);
System.out.println("---------------可爱的分割线-------------------");
quickSort(src);
for (int i : src)
System.out.println(i);
System.out.println("---------------可爱的分割线-------------------");
}
}
分享到:
相关推荐
Java 经典算法例子,Java 经典算法例子,Java 经典算法例子,Java 经典算法例子,Java 经典算法例子,Java 经典算法例子,Java 经典算法例子,Java 经典算法例子,Java 经典算法例子,Java 经典算法例子,Java 经典...
JAVA 经典算法集合(1),JAVA 经典算法集合(1),JAVA 经典算法集合(1),JAVA 经典算法集合(1),JAVA 经典算法集合(1),JAVA 经典算法集合(1),JAVA 经典算法集合(1)JAVA 经典算法集合(1),JAVA 经典...
JAVA 经典算法书集合(2),JAVA 经典算法书集合(2),JAVA 经典算法书集合(2),JAVA 经典算法书集合(2),JAVA 经典算法书集合(2),JAVA 经典算法书集合(2),JAVA 经典算法书集合(2)JAVA 经典算法书集合...
Java经典算法合集是Java编程语言中的一些经典算法的集合,这些算法涵盖了字符串处理、文件操作、数组处理等多个方面。下面,我们将对这些算法进行解读和分析。 1. 算法与编程 在这个算法中,我们需要编写一个程序...
在Java编程语言的浩瀚世界中,掌握一些经典的算法对于任何开发者来说都是一项宝贵的能力。这些算法不仅能够帮助我们解决特定的编程问题,而且能够锻炼我们的逻辑思维能力和编程技巧。通过研究和实现这些算法,我们...
JAVA经典算法40题.pdf 本资源是JAVA经典算法40题的PDF文件,该文件包含了40个经典算法题目,每个题目都有相应的Java代码实现。以下是对标题、描述、标签和部分内容的知识点解释: 标签:“数据库” 虽然标签是...
Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法集题大全Java算法...
首先,让我们详细探讨一下Java算法的重要性。算法是解决问题的步骤或方法,是计算机科学的基础。在Java编程中,良好的算法设计和实现能力能够极大地提高代码的效率和可读性。通过解决这些算法题,开发者可以锻炼逻辑...
java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法大全源码java算法...
本文将详细探讨39道JAVA经典算法面试题目,每题都附带答案和解析,从而帮助读者深入理解并提升自身在JAVA编程中的算法应用能力。 首先,我们必须明确算法的定义和重要性。算法是计算机科学的核心,它是一系列解决...
Java经典算法汇总 Java经典算法汇总.pdf中提供了多种排序算法的实现,包括冒泡排序、选择排序和插入排序。这些算法都是Java语言中最基本和最常用的排序算法。 冒泡排序算法 冒泡排序算法是一种简单的排序算法,它...
在这个名为"AlgorithmGossip"的压缩包文件中,我们可以期待找到一些与Java算法相关的知识点和实践示例。 在Java中,经典算法主要包括排序、查找、图算法、动态规划、贪心算法、回溯法等。以下是对这些关键概念的...
JAVA经典算法40面试题 本资源摘要信息涵盖了JAVA经典算法40面试题,包含基本的算法面试代码题。以下是对标题、描述、标签和部分内容的详细解释: 一、标题:“JAVA经典算法40面试题” 该标题表明该资源是关于JAVA...
JAVA经典算法题
本文将重点介绍Java中的四十个经典算法问题,它们覆盖了递归、素数判断、水仙花数和质因数分解等领域,是所有Java程序员学习和参考的宝贵资料。 首先,我们从递归算法开始探讨。递归是一种常见的编程技术,它允许...
在编程领域,特别是Java开发,熟练掌握算法是提升技术能力的关键。"JAVA经典算法90题【含源码】"的资源集合为Java初学者提供了...所以,对于初学者来说,这套资料是提高Java算法能力的宝贵资源,应充分利用并深入研究。
在学习编程语言的过程中,算法是核心技术之一,尤其是对Java这样的经典编程语言。掌握了算法,不仅能够解决实际问题,还能提高编程能力,培养逻辑思维。对于Java程序员而言,掌握一系列经典的算法题是提升自身竞争力...
首先,让我们来看看Java算法中的基础部分——排序算法。Java中常见的排序算法有冒泡排序、插入排序、选择排序、快速排序、归并排序和堆排序等。冒泡排序和插入排序适用于小规模数据,而快速排序和归并排序则在大数据...
### JAVA绝对经典算法知识点解析 #### 一、斐波那契数列算法 在《JAVA绝对经典算法》中,程序1展示了如何通过递归方法计算斐波那契数列。斐波那契数列是一个非常著名的数列,在自然界、艺术、建筑等众多领域都有其...
Java遗传算法排课系统是一种利用遗传算法解决复杂优化问题的软件应用。在教育领域,排课是一个典型的组合优化问题,需要考虑多方面的约束条件,如教师时间冲突、教室容量限制、课程时间安排等。遗传算法作为一种启发...