昨天开发的时候遇到一个需求，需要在两个不同的List对象中，取出所有不同的对象的集合，大家看的时候可能会觉得绕口，下面简单举例说明：
对象 Student 
属性 id,name
两个集合
1、List<Student> lists1 = new ArrayList<Student>();
Student student1 = new Student();
student1.setId(1):
student1.setName("1");


lists1.add(student1);






Student student2 = new Student();
student2.setId(2):
student2.setName("2");
lists1.add(student2);


2、List<Student> lists2 = new ArrayList<Student>();
Student student3 = new Student();
student3.setId(1):
student3.setName("1");

lists2.add(student3);

可以看到 list1 和 list2 集合中的对象是相同的，现在的需求是比较 list1 和 list2 取出所有不同的对象集合，也就是 student2

在这里我们主要用到的方法是重写Student类中的 equals 和 hashcode 方法。把属性 id 和 name作为比较的key，这样就可以实现了。

判断的时候可以这样操作：
通过循环的时候判断，我这里只是提供一种参考的是方式,以少的集合作为循环的集合

for(int i=0;i<list2.size();i++){
   
    if(! lists1.contains(lists2.get(i))){
           
//把对应的对象加入到返回的结果集List中去就可以了

     }
}

以上就是我个人的心得，亲测可用。

有时需要在方法末尾返回类型不同的对象，而return 语句只能返回一个或一组类型一样的对象。此时就需要用到泛型。

首先先解释个概念,  

元组: 它是将一组对象直接打包存储于其中的一个单一对象，这个容器对象允许读取其中元素，但不能修改。

利用泛型创建元组

public class ReturnTwo<A,B> {

    public final A first;
    public final B second;

    public ReturnTwo(A a,B b) {
        first = a;
        second = b;
    }

}

测试

public class Test {

    private String a = "abc";
    private int b = 123;

    public ReturnTwo<String, Integer> get() {
        ReturnTwo<String, Integer> rt = new ReturnTwo<String, Integer>(this.a, this.b);
        return rt;
    }

    public static void main(String[] args) {
        Test test = new Test();
        ReturnTwo<String, Integer> rt = test.get();
        System.out.println(rt.first);
        System.out.println(rt.second);
    }

}

输出结果： 

abc 
123

有时需要在方法末尾返回类型不同的对象，而return 语句只能返回一个或一组类型一样的对象。此时就需要用到泛型。

首先先解释个概念,  

元组: 它是将一组对象直接打包存储于其中的一个单一对象，这个容器对象允许读取其中元素，但不能修改。

利用泛型创建元组

public class ReturnTwo<A,B> {

    public final A first;
    public final B second;

    public ReturnTwo(A a,B b) {
        first = a;
        second = b;
    }

}


测试

public class Test {

    private String a = "abc";
    private int b = 123;

    public ReturnTwo<String, Integer> get() {
        ReturnTwo<String, Integer> rt = new ReturnTwo<String, Integer>(this.a, this.b);
        return rt;
    }

    public static void main(String[] args) {
        Test test = new Test();
        ReturnTwo<String, Integer> rt = test.get();
        System.out.println(rt.first);
        System.out.println(rt.second);
    }

}


输出结果：

abc 
123

程序运行截图如下：

解决此问题的关键是：
父类用一个虚函数返回一个值。
每个子类通过对这个值设置不同的数据。
从而判断不同的类，或不同的对象；
代码如下：
#include <iostream>
#include <vector>
using namespace std;

#define ImpleType 0
#define ApiType 1

class Base{
public:
	virtual int getClassType()const = 0;
protected:
	Base(){}
};

class MyImple :public Base{
public:
	int m_type;
	MyImple(const int type){
		m_type = type;
	}
	int getClassType()const{
		return m_type;
	}
};

class MyApi :public Base{
public:
	int m_type;
	MyApi(const int type){
		m_type = type;
	}
	int getClassType()const{
		return m_type;
	}
};

class MyFactory{
public:
	static Base* createData(int type){
		Base *base = nullptr;
		if (type == ImpleType){
			base = new MyImple(type);
		}
		else if (type == ApiType){
			base = new MyApi(type);
		}
		else{

		}
		return base;
	}
};

void main(){
	Base *myData1 = MyFactory::createData(ImpleType);
	Base *myData2 = MyFactory::createData(ApiType);
	Base *myData3 = MyFactory::createData(ImpleType);
	Base *myData4 = MyFactory::createData(ApiType);
	Base *myData5 = MyFactory::createData(ImpleType);

	vector<Base*> myVec;
	myVec.push_back(myData1);
	myVec.push_back(myData2);
	myVec.push_back(myData3);
	myVec.push_back(myData4);
	myVec.push_back(myData5);

	for (int i = 0; i < myVec.size(); i++){
		if (myVec[i]->getClassType() == ImpleType){
			cout << "第" << i << "个为：MyImple类\n";
		}
		else
			cout << "第" << i << "个为：MyApi类\n";

		delete myVec[i];
	}
	system("pause");
}