一个List中有多个表的对象 表对象有5个字段，所有对象的count字段都为1，现在想把name相等的对象合并，并且count会变成合并了几个就变为几。。。就是List中有10个表对象，其中3个对象的name相等，就把他们合并为8个，并且那个3合一的对象count是3
1.重写equals方法，name相同即为相等
2.新建一个List，用来放结果。
3.遍历旧的List，如果新的list中存在名字相同的，则新的List中该元素的count+1. 如果不存在，则放入新的List
示例代码：
//测试类
public class ListTest {
public static void main(String[] args) {
List<ListTestObject> oldList = new ArrayList<>();
//模拟数据
oldList.add(new ListTestObject("jack", 1));
oldList.add(new ListTestObject("jerry", 1));
oldList.add(new ListTestObject("jone", 1));
oldList.add(new ListTestObject("jerry", 1));
oldList.add(new ListTestObject("jone", 1));
List<ListTestObject> newList = new ArrayList<>();
for (ListTestObject testObjOld : oldList) {
// 遍历新的List，看是否存在，存在则count加一，不存在则放入新的List
boolean flag = false;
for (ListTestObject testObjNew : newList) {
if (testObjNew.equals(testObjOld)) {
// 新的List中存在名字相同的，则count+1
testObjNew.setCount(testObjNew.getCount() + 1);
flag = true;
}
}
// 新的List中不存在
if (!flag) {
newList.add(testObjOld);
}
}
System.out.println(newList);
}
}
//实体类
public class ListTestObject {
private String name;
private int count;
//因为示例只用了name，count，另外3个属性先不写。
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public ListTestObject(String name, int count) {
super();
this.name = name;
this.count = count;
}
@Override
public boolean equals(Object obj) {
ListTestObject testObj;
try {
testObj = (ListTestObject) obj;
} catch (Exception e) {
//类不同，直接返回false
return false;
}
if(testObj.getName().equals(this.getName())){
return true;
}
return false;
}
@Override
public String toString() {
return "ListTestObject [name=" + name + ", count=" + count + "]";
}
}
把他们放到一个map中，name做key，再拿出来，就可以了
说下我的思路：
1. List中的每个对象的类型中写Compare()方法（根据name字段判断对象是否相等）
2. 新建HashSet set, 将List中的每个对象加入到set中去
有点像wordcount, 按name字段将表进行哈希，添加到hashmap中，若已存在就将count值加1。最后将hashmap中每一个元素加入到list中。
首先，抽象你的表对象为TableObject，有两个属性name和count，可以重写它的equal方法，以name属性为基础。
其次，就是编写合并算法，可以先定义一个空的列表，然后遍历原来的列表，往新的空列表里面添加，如果新列表中不存在该对象，则加入，否则就将对象的count加一。
实现如下：
public class TableObject {
private String name;
private int count;
/**
* @param name
* @param count
*/
public TableObject(String name, int count) {
super();
this.name = name;
this.count = count;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
TableObject other = (TableObject) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString() {
return "TableObject [name=" + name + ", count=" + count + "]";
}
}
另一个合并 工具类如下：
import java.util.ArrayList;
import java.util.List;
public class TableObjectMerge {
public static List<TableObject> merge(List<TableObject> target){
if(target==null||target.isEmpty()){
return null;
}
List<TableObject> lastResult = new ArrayList<TableObject>(target.size());
for(TableObject t:target){
//重新过equal后，contains判断会以name为基础判断是否存在的
if(lastResult.contains(t)){
//找到目标列表中的对象，修正count
TableObject old = findObjectInList(lastResult,t);
//修正已经存在的对象的count值
int count = old.getCount();
old.setCount(count+1);
}else{
//没有就加入
lastResult.add(t);
}
}
return lastResult;
}
private static TableObject findObjectInList(List<TableObject> list,TableObject object){
for(TableObject o:list){
if(o.equals(object)){
return o;
}
}
return null;
}
public static void main(String[] args) {
List<TableObject> target = new ArrayList<TableObject>(10);
TableObject t1 = new TableObject("obj1",1);
TableObject t2 = new TableObject("obj1",1);
TableObject t3 = new TableObject("obj1",1);
TableObject t4 = new TableObject("obj4",1);
TableObject t5 = new TableObject("obj5",1);
TableObject t6 = new TableObject("obj6",1);
TableObject t7 = new TableObject("obj7",1);
TableObject t8 = new TableObject("obj8",1);
TableObject t9 = new TableObject("obj9",1);
TableObject t10 = new TableObject("obj10",1);
target.add(t1);
target.add(t2);
target.add(t3);
target.add(t4);
target.add(t5);
target.add(t6);
target.add(t7);
target.add(t8);
target.add(t9);
target.add(t10);
List<TableObject> merge = merge(target);
for(TableObject m:merge){
System.out.println(m);
}
}
}
测试结果：
TableObject [name=obj1, count=3]
TableObject [name=obj4, count=1]
TableObject [name=obj5, count=1]
TableObject [name=obj6, count=1]
TableObject [name=obj7, count=1]
TableObject [name=obj8, count=1]
TableObject [name=obj9, count=1]
TableObject [name=obj10, count=1]
重点就是查找列表中已经存在的对象，然后修正它的count值的操作；判断列表中是否存在某个对象可以直接用contains只要指定比较依据的属性。
两个测试类都直接放在src目录下面就可以了，有问题及时联系。祝好。
public class ListTest {
public static void main(String[] args) {
//这是5个实体
String biao1 = "name,count,field2,field3,field4";
String biao2 = "name,count,field2,field3,field4";
String biao3 = "name,count,field2,field3,field4";
String biao4 = "name,count,field2,field3,field4";
String biao5 = "name,count,field2,field3,field4";
List<Object> list = new ArrayList<Object>();
list.add(biao1);
list.add(biao2);
list.add(biao3);
list.add(biao4);
list.add(biao5);
List<String> list1 = new ArrayList<String>();
for(int i=0;i<list.size();i++){
list1.add(list.get(i).getName());
}
for(int i=0;i<list1.size();i++){
comParato(list1.get(i));
}
}
private static void comParato(String string) {
if(biao1.getName().equals(string)){
biao1.setCount(count++);
}
}
}
怎么感觉就是遍历List，比较name，相同的就删除一个，另一个count+1.
1.在对象的类中重写equals（）方法
2.从list中遍历出对象然后在将取出的对象存放到对象数组中去
3.在对象的数组中进行比较（写个嵌套for()循环逐一比较）如果对象相同的话，count++
逻辑就像大家说的，不赘述了。
集合变换类操作，用java8很适合。不妨参考以下代码，包治百病。
import com.google.common.base.Objects;
import com.google.common.collect.Lists;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
/**
* Created by LIHAO845 on 2016-10-29.
*/
public class StreamTest {
public static void main(String[] args) {
List<A> list = Lists.newLinkedList();
list.add(new A("hello", 1));
list.add(new A("hello", 2));
list.add(new A("world", 3));
Collection<Optional<A>> result = list.stream().collect(Collectors.groupingBy(A::getName, Collectors.reducing(A::addCount))).values(); // 这一行，就能完成所有逻辑
System.out.println(result);
}
}
class A {
String name;
int count;
A(String name, int count) {
this.name = name;
this.count = count;
}
public String getName() {
return name;
}
public A addCount(A a) {
count += a.count;
return this;
}
@Override
public String toString() {
return Objects.toStringHelper(this)
.add("name", name)
.add("count", count)
.toString();
}
}
为啥不再查数据库的时候直接 根据name 分组查询呢 然后 count 出来就 搞定了 写这么长的类文件 好像挺费神的