急~ java中根据某一属性比较两个list集合是否相同 5C

两个集合list1,list2, 只有一个相同的属性(AliasId)

以list1为准,根据AliasId检测list2在list1中是否存在

(1)找出list2中_不存在的_元素并新增该记录

(2)找出list2中_多余的_元素并删除

求代码~

图片说明

图片说明

13个回答

写一个双层for循环遍历两个list 外层遍历list2 内层遍历list2
for(j=list2.size()-1;j>=0;j--){
boolean flag =true
for(i=0;i<list1.size();i++){
//如果两个集合都是对象的list
if(list1.get(i).getAliasId()==list2.get(j).getAliasId()){//如果是int类型比较用== 如果是string类型换成equal
flag =false;
}
}
if(flag){
list2.remove(j);
}
}
上面的操作中定义flag的作用是用于在list2 中的值和list1中的所有值都不相等的情况下flag=true 直接执行remove操作

zyh18511041004
jokingZY 下面给你贴了一份代码,你看下 第一个方法是返回boolean 证明有不同的,第二个是返回要删除的list
2 年多之前 回复
Sweet__dream
Sweet__dream 返回要删除的数据
2 年多之前 回复
zyh18511041004
jokingZY 回复Sweet__dream: 那现在这两个私有的方法都要什么返回值呢 一个比较有没有不同的 返回一个boolean类型 然后那个删除的方法返回删除后的新的list还是要那些被删除的数据
2 年多之前 回复
Sweet__dream
Sweet__dream 刚刚又跟我说要保存到新的list中
2 年多之前 回复
zyh18511041004
jokingZY 大兄弟,你到底要啥 要有返回值, 然后还要返回结果,返回值咋定义,我有点蒙了,你要是返回boolean返回值就是 boolean类型 你要是要集合 返回值类型就是set 你不能又要set 又要boolean啊
2 年多之前 回复
Sweet__dream
Sweet__dream 然后保存到新的集合中
2 年多之前 回复
Sweet__dream
Sweet__dream 要求弄两个私有函数,一个找不存在的,一个找多余的
2 年多之前 回复
Sweet__dream
Sweet__dream 每个人的编码风格不同,他要求这样搞,我有点晕~
2 年多之前 回复
Sweet__dream
Sweet__dream 嗯嗯呢,我就是不明白为什么一定要分开判断,还必须要求这样for (Group group : groups)的遍历,不都是一样的么
2 年多之前 回复
zyh18511041004
jokingZY 回复Sweet__dream: 如果有不同的就返回false是么
2 年多之前 回复
Sweet__dream
Sweet__dream 比较完再返回
2 年多之前 回复
zyh18511041004
jokingZY 回复Sweet__dream: 那就定义一个方法被,如果不允许其他类调用直接写private void checkList(list1,list2){写上之前写的那个循环 } 你说的那个boolean是这个方法的返回值么 什么时候要返回Boolean值 是检查到有不相同的地方就返回还是比较完最后再返回一个结果 如果有不同的返回false相同返回true
2 年多之前 回复
Sweet__dream
Sweet__dream 我是说我之前写的就是你回答的这个,但是组长说我写的不合格,不知道该怎么写才来提问的,我也是分开说的,算明确了吧,555~
2 年多之前 回复
zyh18511041004
jokingZY 说你那不合格了么,你这范畴太广了。。。需求不明确==
2 年多之前 回复
Sweet__dream
Sweet__dream for (Group group : groups)要求在函数中这样遍历判断,我晕~
2 年多之前 回复
Sweet__dream
Sweet__dream 问题贴了两个集合的图,反正就是要分别找出不存在的,存在的
2 年多之前 回复
Sweet__dream
Sweet__dream 我一开始就是这样写的,但是不合格,才来提问的
2 年多之前 回复
zyh18511041004
jokingZY 回复Sweet__dream: 为什么要两个检查函数,这两个for循环就是一个操作啊 你分开 了怎么比较,而且我没懂你什么时候要boolean 你是要每次比较的结果都有一个boolean值么
2 年多之前 回复
Sweet__dream
Sweet__dream 要求定义两个私有的boolean检查函数怎么写呢
2 年多之前 回复
zyh18511041004
jokingZY 回复Sweet__dream: 如果你想找不存在的你可以在循环外定义一个list 然后在remove之前把list2.get(j)的对象add到你新定义的list里面
2 年多之前 回复
Sweet__dream
Sweet__dream 所以想写两个函数,分别找出不存在的,多余的部分
2 年多之前 回复
zyh18511041004
jokingZY 注意遍历外层list2的时候 一定要从大往小遍历 不然会有问题因为长度一直在变化,remove会出错
2 年多之前 回复
Sweet__dream
Sweet__dream 我之前就是这样写的,但是不能直接这样删除
2 年多之前 回复

重写作为元素的equals和hashcode方法,按照你说的规则比较判断是否相同
然后参考:http://blog.csdn.net/high2011/article/details/50493028

Sweet__dream
Sweet__dream 还是不太明白,能不能写两个函数出来
2 年多之前 回复
caozhy
贵阳老马马善福专业维修游泳池堵漏防水工程 回复Sweet__dream: 对,你重写这两个方法,在里面只使用AliasId作为比较依据
2 年多之前 回复
Sweet__dream
Sweet__dream 只能根据AliasId这一属性来判断的噢
2 年多之前 回复

for(int i = 0; i < list2.cout; ++i)
{
for (int j = 0; j < list1.count; ++j)
{
if (list2[j].AliasId == list1[i].AliasId)
break;
}
list2.remove[i];
}

Sweet__dream
Sweet__dream 回复weixin_41004809: ......
2 年多之前 回复
weixin_41004809
weixin_41004809 急求c币
2 年多之前 回复
qq_28976599
qq_86352497 回复Sweet__dream: 的,提供思路啊
2 年多之前 回复
qq_28976599
qq_86352497 回复Sweet__dream: 我都不是写java
2 年多之前 回复
Sweet__dream
Sweet__dream 不能这样写~
2 年多之前 回复
qq_28976599
qq_86352497 急求c币
2 年多之前 回复

可以提供这两份List数据的具体json格式吗?好多细节都不清楚,不敢给代码的,比如说List, List等,这个List中的数据类型都不确定

Sweet__dream
Sweet__dream 回复一只会打酱油的小程序猿: 2就是以list1数据为准,在list2中把list1没有的找出来删除掉
2 年多之前 回复
baidu_30809315
Jalen备忘录 回复Sweet__dream: (1)找出list2中_不存在的_元素并新增该记录:意思是2不存在就把1的增加进去吗?(2)找出list2中_多余的_元素并删除:2中多余的元素是什么意思?2中自己重复的还是指1中没有而2中有的?
2 年多之前 回复
Sweet__dream
Sweet__dream 图片贴出来了,麻烦看一下,谢谢~
2 年多之前 回复
baidu_30809315
Jalen备忘录 额,这个CSDN问答提交回答的时候带有尖括号,竟然被转译了。。。
2 年多之前 回复

遍历list1,取到AliasId属性放入set1
遍历list2,取到AliasId属性放入set2

List<Object> list = new ArrayList<Object>();
//不存在
for (String aliasId : set2) {
    if (!set1.contains(aliasId)) {
      list.add(Object对象);
        list2.remove(Object对象);
    }
}
//多余
for (String aliasId : set2) {
    if (set1.contains(aliasId)) {
      list.add(Object对象);
        list2.remove(Object对象);
    }
}

遍历后对比应该是最简单的方案

public class CompareListDemo {
public static void main(String[] args) {
GroupVO gv1 = new GroupVO().setId(1).setAliasId("0001").setName("first");
GroupVO gv2 = new GroupVO().setId(2).setAliasId("0002").setName("second");
GroupVO gv3 = new GroupVO().setId(3).setAliasId("0003").setName("third");

    Group g1 = new Group().setId(1).setAliasId("0001").setName("first");
    Group g3 = new Group().setId(4).setAliasId("0003").setName("third");
    Group g4 = new Group().setId(4).setAliasId("0004").setName("fourth");
    Group g6 = new Group().setId(4).setAliasId("0006").setName("sixth");
    List<GroupVO> groupList = new LinkedList();
    List<Group> groups = new LinkedList();
    groupList.add(gv1);groupList.add(gv2);groupList.add(gv3);
    groups.add(g1);groups.add(g3);groups.add(g4);groups.add(g6);

    //找出list2中_多余的_元素并删除
    Iterator<Group> iterator = groups.iterator();
    Group gTemp = null;
    while(iterator.hasNext()){
        gTemp = iterator.next();
        Boolean flag = false;//存在标志,当前group在grouplist中存在则为true
        for (GroupVO groupVO : groupList) {
            if(gTemp.getAliasId().equals(groupVO.getAliasId())){
                flag = true;
                break;
            }
        }
        //不存在则进行删除
        if(!flag){
            iterator.remove();
        }
    }
    //找出list2中_不存在的_元素并新增该记录
    List<Group> addGroups = new LinkedList();
    for (GroupVO groupVO : groupList) {
        Boolean flag = false;//存在标志,当前groupVO在group中存在则为true
        for (Group group : groups) {
            if(group.getAliasId().equals(groupVO.getAliasId())){
                flag = true;
                break;
            }
        }
        //不存在则进行增加
        if(!flag){
            Group groupNew = new Group()
                    .setAliasId(groupVO.getAliasId())
                    .setId(groupVO.getId())
                    .setName(groupVO.getName());
            addGroups.add(groupNew);
        }
    }
    //合并list
    groups.addAll(addGroups);

    for (Group group : groups) {
        System.out.println(group.getName());
    }
    System.out.println("=============================");
    for (GroupVO groupVO : groupList) {
        System.out.println(groupVO.getName());
    }
}

}

class GroupVO{
private Integer id;
private String aliasId;
private String name;
public Integer getId() {return id;}
public GroupVO setId(Integer id) {this.id = id;return this;}
public String getAliasId() {return aliasId;}
public GroupVO setAliasId(String aliasId) {this.aliasId = aliasId;return this;}
public String getName() {return name;}
public GroupVO setName(String name) {this.name = name;return this;}
}

class Group{
private Integer id;
private String aliasId;
private String name;
public Integer getId() {return id;}
public Group setId(Integer id) {this.id = id;return this;}
public String getAliasId() {return aliasId;}
public Group setAliasId(String aliasId) {this.aliasId = aliasId;return this;}
public String getName() {return name;}
public Group setName(String name) {this.name = name;return this;}
}


Sweet__dream
Sweet__dream 谢谢,要求写两个私有函数要怎么改呢
2 年多之前 回复
u013253478
晓杰晓杰 格式有点乱了,不过你应该可以看得明白
2 年多之前 回复

我不太懂你的需求,写了一个大概的,你可以参考下:

 import org.springframework.beans.BeanUtils;

import java.util.*;

/**
 * <p>
 * <code>Test</code>
 * </p>
 * Description:
 *
 * @author Mcchu
 * @date 2017/12/12 18:06
 */
public class Test {

    /**
     * List2的重复次数map计数器
     * @param modelTwoList List2
     * @return map计数器
     */
    private static Map<String,Integer> mapCounter( List<ModelTwo> modelTwoList ){
        Map<String,Integer> dataRepeatCountMap = new HashMap<String,Integer>();//第二个List计数器
        for ( ModelTwo modelTwo : modelTwoList ){
            String aliasId = modelTwo.getAliasId();
            dataRepeatCountMap.put(aliasId, 0);//初始化计数器
        }

        for ( ModelTwo modelTwo : modelTwoList ){
            String aliasId = modelTwo.getAliasId();
            for( String key : dataRepeatCountMap.keySet() ){
                if( aliasId.equals(key) ){
                    int value = dataRepeatCountMap.get(key);
                    value++;
                    dataRepeatCountMap.put(key, value);//计数,重复+1
                }
            }
        }
        return dataRepeatCountMap;
    }

    /**
     * 找出list2中不存在的元素并新增该记录
     * (应该是将list1中的挪过去吧)
     * @param modelOneList List1
     * @param modelTwoList List2
     * @return 处理后的List2
     */
    private static List<ModelTwo> addNonExistData(List<ModelOne> modelOneList, List<ModelTwo> modelTwoList){

        for ( ModelOne modelOne: modelOneList ){
            Map<String,Integer> dataRepeatCountMap = mapCounter( modelTwoList );
            String aliasId = modelOne.getAliasId();

            boolean exist = false;
            for ( String key : dataRepeatCountMap.keySet() ){
                if ( aliasId.equals(key) ){
                    exist = true;
                    break;
                }
            }

            if ( !exist ){
                ModelTwo modelTwo = new ModelTwo();
                modelTwo.setAliasId( aliasId );
                //modelTwo.setName( );
                //... ...
                //modelTwo.setCreateBy(  );
                modelTwoList.add( modelTwo );
            }
        }

        return modelTwoList;
    }

    /**
     * 删除2中重复的数据
     * 如果多条记录的aliasId一样,只保留一个,删除其他(我这样理解多余对不对?)
     * @param modelTwoList List2
     * @return 去重后的List2
     */
    private static List<ModelTwo> deleteRepeatData( List<ModelTwo> modelTwoList ){
        Map<String,Integer> dataRepeatCountMap = mapCounter( modelTwoList );

        List<ModelTwo> modelTwoListNew = new ArrayList<ModelTwo>();
        for ( String key : dataRepeatCountMap.keySet() ){
            ModelTwo modelTwo = new ModelTwo();
            for ( ModelTwo modelTwoo: modelTwoList ){
                if ( key.equals(modelTwoo.getAliasId()) ){
                    BeanUtils.copyProperties(modelTwoo,modelTwo);
                }
            }

            modelTwoListNew.add(modelTwo);
        }
        return modelTwoListNew;
    }

    public static void main(String[] args) {

        List<ModelOne> modelOneList = new ArrayList<ModelOne>();
        modelOneList.add(new ModelOne("1","id1","name1"));
        modelOneList.add(new ModelOne("1","id2","name1"));
        modelOneList.add(new ModelOne("1","id3","name1"));
        modelOneList.add(new ModelOne("1","id4","name1"));
        List<ModelTwo> modelTwoList = new ArrayList<ModelTwo>();
        modelTwoList.add(new ModelTwo("1","id1","name1","createBy","updateBy","createTime","updateTime"));
        modelTwoList.add(new ModelTwo("1","id2","name1","createBy","updateBy","createTime","updateTime"));
        modelTwoList.add(new ModelTwo("1","id4","name1","createBy","updateBy","createTime","updateTime"));
        modelTwoList.add(new ModelTwo("1","id6","name1","createBy","updateBy","createTime","updateTime"));
        modelTwoList.add(new ModelTwo("1","id6","name1","createBy","updateBy","createTime","updateTime"));

        // 1.比较List1和List2,找出list2中不存在的元素,如不存在,新增
        List<ModelTwo> modelTwoListNew = addNonExistData(modelOneList,modelTwoList);
        System.out.println(modelTwoListNew.toString());

        // 2.找出list2中多余的元素并删除,去重
        List<ModelTwo> modelTwoListNewer = new ArrayList<ModelTwo>();
        modelTwoListNewer.add(new ModelTwo("1","id1","name1","createBy","updateBy","createTime","updateTime"));
        modelTwoListNewer.add(new ModelTwo("1","id2","name1","createBy","updateBy","createTime","updateTime"));
        modelTwoListNewer.add(new ModelTwo("1","id2","name1","createBy","updateBy","createTime","updateTime"));
        modelTwoListNewer.add(new ModelTwo("1","id6","name1","createBy","updateBy","createTime","updateTime"));
        modelTwoListNewer.add(new ModelTwo("1","id6","name1","createBy","updateBy","createTime","updateTime"));
        List<ModelTwo> modelTwoListN = deleteRepeatData(modelTwoListNewer);
        System.out.println(modelTwoListN.toString());

    }
}

 import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * <p>
 * <code>ModelOne</code>
 * </p>
 * Description:
 *
 * @author Mcchu
 * @date 2017/12/12 18:04
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ModelOne {

    private String id;

    private String aliasId;

    private String name;
}

 import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * <p>
 * <code>ModelTwo</code>
 * </p>
 * Description:
 *
 * @author Mcchu
 * @date 2017/12/12 18:05
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ModelTwo {

    private String id;

    private String aliasId;

    private String name;

    private String createBy;

    private String updateBy;

    private String createTime;

    private String updateTime;

}

baidu_30809315
Jalen备忘录 额,总算明白你的意思了,但是不想写了,还在上班。。。
2 年多之前 回复
Sweet__dream
Sweet__dream 不用计数器的话要怎么写呢
2 年多之前 回复
Sweet__dream
Sweet__dream 那么就把list1中的1加到list2中,把list2中的4删除
2 年多之前 回复
Sweet__dream
Sweet__dream 假如list1的数据有1,2,3,list2的数据有2,3,4. 那么就吧
2 年多之前 回复
Sweet__dream
Sweet__dream aliasId是唯一的
2 年多之前 回复
private boolean checkList(ArrayList<Entity> list1,ArrayList<Entity> entity1) {
    boolean returnFlag = false;
    for (Entity entity : list1) {
        for (Entity entity1 : list2) {
            checkFlag = false;
            // 如果两个集合都是对象的list
            if (entity.getAliasId() == entity1.getAliasId()) {// 如果是int类型比较用==
                                                                            // 如果是string类型换成equal
                checkFlag = true;
            }
        }
        if (checkFlag) {
            break;
        }
    }
    return returnFlag;//如果是false证明有不同的
}

private ArrayList<Entity> returnDelList(ArrayList<Entity> list1,ArrayList<Entity> entity1){
    ArrayList<Entity> returnList = new ArrayList<Entity>();
    boolean returnFlag = true;
    for (Entity entity : list1) {
        for (Entity entity1 : list2) {
            // 如果两个集合都是对象的list
            if (entity.getAliasId() == entity1.getAliasId()) {// 如果是int类型比较用==
                                                                            // 如果是string类型换成equal
                checkFlag = false;
            }
        }
        if (checkFlag) {
            returnDelList.add(entity);
        }
    }
    return returnDelList;
}

zyh18511041004
jokingZY 回复Sweet__dream: 共勉~
2 年多之前 回复
Sweet__dream
Sweet__dream 已经写出来了,还是要谢谢你噢,辛苦了大神~
2 年多之前 回复

根据AliasId检测list2在list1中是否存在 这是什么意思?有毛病描述

Sweet__dream
Sweet__dream 亲,您没看清上下文呢
2 年多之前 回复
共13条数据 1 尾页
Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
立即提问
相关内容推荐