急~ java中根据某一属性比较两个list集合是否相同
两个集合list1，list2， 只有一个相同的属性（AliasId）
以list1为准，根据AliasId检测list2在list1中是否存在
（1）找出list2中_不存在的_元素并新增该记录
（2）找出list2中_多余的_元素并删除
求代码~
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;
}
重写作为元素的equals和hashcode方法，按照你说的规则比较判断是否相同
然后参考：http://blog.csdn.net/high2011/article/details/50493028
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];
}
写一个双层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操作
可以提供这两份List数据的具体json格式吗？好多细节都不清楚，不敢给代码的，比如说List, List等，这个List中的数据类型都不确定
遍历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;}
}
我不太懂你的需求，写了一个大概的，你可以参考下：
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;
}
根据AliasId检测list2在list1中是否存在 这是什么意思？有毛病描述
遍历集合 进行判读，
list.containsall,新增元素的话，我觉得你可以先list.addAll 加完了之后，再用循环，循环内判断list.contains如果不包含就删除就可以了
分别遍历两个集合,两个嵌套循环,用第一个循环中的每一个元素和另外一个集合中的每个元素相比较,然后进行你想要的操作