标签：数组
/**
* * 判断修改会员等级的合法性
* 1.当sorts大于数据库中所有的sorts值时 （1，3） 5
* 2.当sorts小于于数据库中所有的sorts值时 1 （3，5）
* 3.当sorts等于数据库中所有的sorts值时 1 （1，3，5）
* 4.当sorts在数据库中能找到大于和小于它的值时 3 （1，5）
* 说明：1.首先判断list的长度，（大于1，等于1，等于0）三种情况
* 2.当list.size()>1,将数据库中的sort字段组成字符串，再转换成数组
* 2.1当sorts等于数据库中所有的sorts值时 1 （1，3，5）
* 2.2得到该数组中的最大，最小值
* 2.3.当sorts大于数据库中所有的sorts值时 （1，3） 5
* 2.4当sorts小于于数据库中所有的sorts值时 1 （3，5）
* 2.5当sorts在数据库中能找到大于和小于它的值时 3 （1，2，4，5）
* 2.5.1 拆分（1，2，4，5）得到3之前的数据组成 数组 [1,2] ，再得到 3之前一位数据 进行判断
* 2.5.2 拆分（1，2，4，5）得到3之后的数据组成 数组 [4,5] ，再得到3之后一位数据 进行判断
* @param sorts 会员等级排序
* @param limitMax 所需累计最小值 （用最小值保存累计数值，最大值留着以后用）
* @param upd 用于判断是否是修改验证 0 ：不是 1：是
* @param req
* @param resp
* @return
*/
@RequestMapping("/leveljudgetwo.jhtml")
@ResponseBody
public String levelJudgeTwo(@RequestParam int sorts,
@RequestParam int limitMax,@RequestParam int upd,@RequestParam String sortflag,HttpServletRequest req,
HttpServletResponse resp) {
int shop_id = 2;
String str = "yes";
String str1 = "";
boolean flag = true;
List<MemberLevel> list = this.memberLevelService.listObjectAll();//遍历所有的对象
System.out.println("sorts------------------"+sorts);
System.out.println("limitMax------------------"+limitMax);
/*
* 当list.size()>1,将数据库中的sort字段组成字符串，再转换成数组
*/
if (list.size() > 1) {
for (MemberLevel level : list) {
int sortsTwo = level.getSort();
str1 = str1 + sortsTwo + ",";
}
str1 = str1.substring(0, str1.length() - 1);
String[] arr = str1.split(",");
String [] arrOne = {sortflag};
String[] arrResult = this.memberLevelService.arrContrast(arr, arrOne);
for(int i=0;i<arrResult.length;i++){
if(sorts==Integer.parseInt(arrResult[i])){
flag = false;
}
}
// for (int i = 0; i < arr.length; i++) {
//// System.out.println("arr[]--------"+arr[i]);
// /*
// * 3.当sorts等于数据库中所有的sorts值时 1 （1，3，5）
// */
// if (sorts == Integer.parseInt(arr[i])) {//当数据库中已经有了该等级的sort, flag=false
// flag = false;
// break;
// }
// }
/*
* 得到该数组中的最大，最小值
*/
int nMax = Integer.parseInt(arr[0]);//最大值
int nMin = Integer.parseInt(arr[0]);//最小值
for (int i = 0; i < arr.length; i++) {
if (nMin > Integer.parseInt(arr[i])) {
nMin = Integer.parseInt(arr[i]);
}
if (nMax < Integer.parseInt(arr[i])) {
nMax = Integer.parseInt(arr[i]);
}
}
MemberLevel level2 = this.memberLevelService.getObjectBySort(shop_id, nMax);//通过店铺ID 和排序号找到对象
MemberLevel level3 = this.memberLevelService.getObjectBySort(shop_id, nMin);//通过店铺ID 和排序号找到对象
int limit_max1 = level2.getLimit_max();//所需累计最小值 （用最小值保存累计数值，最大值留着以后用）
int limit_max2 = level3.getLimit_max();//所需累计最小值 （用最小值保存累计数值，最大值留着以后用）
/*
* 1.当sorts等于于数据库中所有的sorts值时 （1，3，5） 5
*/
if (sorts >= nMax) {
int max = Integer.parseInt(arr[0]); //最大值
int second =Integer.parseInt(arr[1]); //次大值
for(int i = 0;i < arr.length;i++)
{
if(Integer.parseInt(arr[i]) > max) //更新最大值和次大值
{
second = max;
max = Integer.parseInt(arr[i]);
}
else if(Integer.parseInt(arr[i]) < max && Integer.parseInt(arr[i]) > second) //更新次大值
{
second = Integer.parseInt(arr[i]); //得到3的值
}
MemberLevel level5 = this.memberLevelService.getObjectBySort(shop_id, second);//通过店铺ID 和排序号找到对象
int limit_max5 = level5.getLimit_max();//所需累计最小值 （用最小值保存累计数值，最大值留着以后用）
if (limitMax <= limit_max5) {//不满足条件，flag=false
flag = false;
}
}
}
/*
* 2.当sorts等于最小值数据库中所有的sorts值时 1 （1，3，5）
*/
if (sorts <= nMin) {
int min = Integer.parseInt(arr[0]); //最大值
int second =Integer.parseInt(arr[1]); //次大值
if (min > second) { //找到数组中第二小的值
min = Integer.parseInt(arr[1]);
second = Integer.parseInt(arr[0]);
}
for (int i = 2; i < arr.length; ++ i) {
if (Integer.parseInt(arr[i]) < min) {
second = min;
min = Integer.parseInt(arr[i]);
} else if (Integer.parseInt(arr[i]) < second) {
second = Integer.parseInt(arr[i]);
}
}
MemberLevel level6 = this.memberLevelService.getObjectBySort(shop_id, second);//通过店铺ID 和排序号找到对象
int limit_max6 = level6.getLimit_max();//所需累计最小值 （用最小值保存累计数值，最大值留着以后用）
if (limitMax >= limit_max6) {//不满足条件，flag=false
flag = false;
}
}
System.out.println("flag----------------------"+flag);
/*
* 4.当sorts在数据库中能找到大于和小于它的值时 3 （1，2,3，4，5）
*/
String str2 = "";
String str3 = "";
if (nMin < sorts && sorts < nMax) {
for (int j = 0; j < arr.length; j++) {
int p1 = 0;
int p2 = 0;
/*
* sorts前面的数据组成数组
*/
if (Integer.parseInt(arr[j])< sorts) {
str2 = str2 + arr[j] + ",";
p1++;
}
if (p1 > 1) {//sort之前的数字超过1个
str2 = str2.substring(0, str2.length() - 1);
System.out.println("str2----------"+str2);
String[] arr2 = str2.split(",");
int nMax2 = Integer.parseInt(arr[0]);
for (int i = 1; i < arr2.length; i++) {
if (nMax2 < Integer.parseInt(arr2[i])) {
nMax2 = Integer.parseInt(arr2[i]);
}
}
MemberLevel level7 = this.memberLevelService.getObjectBySort(shop_id, nMax2);
int limit_max7 = level7.getLimit_max();
if (limitMax < limit_max7) {
flag = false;
}
} else {//sort之前的数字只有1个
if (limitMax <= limit_max1) {
flag = false;
}
}
/*
* sorts后面的数据组成数组
*/
if (Integer.parseInt(arr[j]) >sorts) {
str3 = str3 + arr[j] + ",";
p2++;
}
if (p2 > 1) {//sort之前的数字超过1个
str3 = str3.substring(0, str3.length() - 1);
System.out.println("str3----------"+str3);
String[] arr2 = str3.split(",");
int nMax3 = Integer.parseInt(arr[0]);
for (int i = 1; i < arr2.length; i++) {
if (nMax3 < Integer.parseInt(arr2[i])) {
nMax3= Integer.parseInt(arr2[i]);
}
}
MemberLevel level8 = this.memberLevelService.getObjectBySort(shop_id, nMax3);
int limit_max8 = level8.getLimit_max();
if (limitMax >= limit_max8) {
flag = false;
}
} else {//sort之后只有一个数
if (limitMax >=limit_max2) {
flag = false;
}
}
}
}
}
if(!flag){//flag状态用于判断
str = "no";
}
return str;
}
标签：数组
原文地址：http://blog.csdn.net/wuzhiweiwuzhiwei/article/details/44900833
