最近很多小伙伴都在问sql交集差集并集笛卡尔积和sql数据查询如何实现集合的并交差运算这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展C#Linq笛卡尔积、javalist交集并集
最近很多小伙伴都在问sql 交集 差集 并集 笛卡尔积和sql数据查询如何实现集合的并交差运算这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展C# Linq 笛卡尔积、java list 交集 并集 差集 去重复并集、java 两个list 交集 并集 差集 去重复并集、JS笛卡尔积算法与多重数组笛卡尔积实现方法示例等相关知识，下面开始了哦！
本文目录一览：- sql 交集 差集 并集 笛卡尔积（sql数据查询如何实现集合的并交差运算）
- C# Linq 笛卡尔积
- java list 交集 并集 差集 去重复并集
- java 两个list 交集 并集 差集 去重复并集
- JS笛卡尔积算法与多重数组笛卡尔积实现方法示例
sql 交集 差集 并集 笛卡尔积（sql数据查询如何实现集合的并交差运算）
sql 交集 差集 并集 笛卡尔积
1 交集 Join
1) inner join 其处理结果与等值/自然连接相同
如
mssql :
-- mssql 中 inner join 连接需要 on Connection条件 否则会报错, MysqL 不会,其结果等于cross join
select * from Major m inner JOIN
dbo.DepNmOrSubjectNm d on m.DepNoOrSubjectNo =d.DepNoOrSubjectNo
MysqL:
-- 其结果等于 crose join
select * from Major m inner join Department d ;
-- 等值连接
select m.*,d.* from Major m inner join Department d on m.dptId = d.dptId;
2) left join /left outer join 左连接/左外连接
在sql 中, left join 为 left outer join 的缩写
mssql:
select * from Major m left outer JOIN
dbo.DepNmOrSubjectNm d on m.DepNoOrSubjectNo =d.DepNoOrSubjectNo
MysqL:
select * from Major m left join `department` d on m.dptId = d.dptId;
3) right join/right outer join 右连接/右外连接
mssql:
select * from Major m right outer JOIN
dbo.DepNmOrSubjectNm d on m.DepNoOrSubjectNo =d.DepNoOrSubjectNo
MysqL:
select * from Major m right outer join `department` d on m.dptId = d.dptId;
4) full join 全连接
mssql:
a)
select * from Major m FULL OUTER JOIN
dbo.DepNmOrSubjectNm d on m.DepNoOrSubjectNo =d.DepNoOrSubjectNo
b)
select * from Major m left outer JOIN
dbo.DepNmOrSubjectNm d on m.DepNoOrSubjectNo =d.DepNoOrSubjectNo
union
select * from Major m right outer JOIN
dbo.DepNmOrSubjectNm d on m.DepNoOrSubjectNo =d.DepNoOrSubjectNo
c)
select * from Major m left outer JOIN
dbo.DepNmOrSubjectNm d on m.DepNoOrSubjectNo =d.DepNoOrSubjectNo
union all
select * from Major m right outer JOIN
dbo.DepNmOrSubjectNm d on m.DepNoOrSubjectNo =d.DepNoOrSubjectNo
where m.DepNoOrSubjectNo is null
MysqL:
MysqL 5.0版本还不支持 full join ,但可以采用 join + union方法实现,详细可以参考:
http://www.xaprb.com/blog/2006/05/26/how-to-write-full-outer-join-in-MysqL/
--
全连接 == 一个左连接 + 一个右连接 + union(去掉相同行)
a)select * from Major m left outer join `department` d on m.dptId = d.dptId
union
select * from Major m right outer join `department` d on m.dptId = d.dptId
b)select * from Major m left outer join `department` d on m.dptId = d.dptId
union all
select * from Major m right outer join `department` d on m.dptId = d.dptId
where m.dptId is null
--大力提倡使用b)
尤其是在处理很大的记录集时, union all 不会进行排序及消除相同的行(消除相同的行可能通过第二个join的条件进行实现),所以可以节省不少时间.
2. 差集 (not in)
sql:
select * from Major m where m.dptId not in(select dptId from department )
差集中, MysqL 与 mssql 语句可以直接采用 not in 来实现
3. 并集 union
mssql:
-- union 并, 默认取消相同 行
select * from Major m
union
select * from Major tm
-- union full 会有重复记录
select * from Major m
union all
select * from Major tm
MysqL:
-- union 默认会取消重复选项
select * from Major `major`
union select * from Major mj ;
-- union all 不会取消重复选项
select * from Major m
union all
select * from Major tm
4. 笛卡尔积
mssql:
-- 笛卡尔
select * from Major cross join
dbo.DepNmOrSubjectNm
MysqL:
-- 笛卡尔集
select * from Major m cross join `department` d;
带条件的笛卡尔积与等值连接功能相同.
http://bjxagu.javaeye.com/blog/407034
C# Linq 笛卡尔积
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp
{
public class Ye
{
public string Y { get; set; }
public string E { get; set; }
}
public class Hao
{
public string H { get; set; }
public string A { get; set; }
public string O { get; set; }
}
class Program
{
static void Main(string[] args)
{
List<Ye> yes = new List<Ye>() {
new Ye() { E = "e1", Y = "y1" },
new Ye() { E = "e2", Y = "y2" },
new Ye() { E = "e3", Y = "y3" },
};
List<Hao> haos = new List<Hao>()
{
new Hao(){ A="A1", H="H1", O="O1" },
new Hao(){ A="A2", H="H2", O="O2" },
new Hao(){ A="A3", H="H3", O="O3" }
};
//笛卡尔积
var data = from d in yes
from t in haos
select new { d, t };
//笛卡尔积
var data1 = from d in yes
from t in haos
select new
{
d.E,
d.Y,
t.A,
t.H,
t.O
};
Console.Read();
}
}
}
java list 交集 并集 差集 去重复并集
//并集
list1.addAll(list2);
//交集
list1.retainAll(list2);
//差集
list1.removeAll(list2);
//无重复并集
list2.removeAll(list1);
list1.addAll(list2);
java 两个list 交集 并集 差集 去重复并集
前提需要明白List是引用类型，引用类型采用引用传递。
我们经常会遇到一些需求求集合的交集、差集、并集。例如下面两个集合:
List<String> list1 = new ArrayList<String>();
list1.add("A");
list1.add("B");
List<String> list2 = new ArrayList<String>();
list2.add("B");
list2.add("C");
0.求差集
例如，求List1中有的但是List2中没有的元素:
public static void test3(List list1, List list2) {
list1.removeAll(list2);
System.out.println(list1);
}结果:
[A]
查看ArrayList的removeAll的源码
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, false);
}
再查看batchRemove的源码:(如果传的第二个参数是false，保留差集;如果传的是true，保留的是交集)
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
if (w != size) {
// clear to let GC do its work
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}
是重新定义elementData数组的元素，下面代码的作用是将本集合中不包含另一个集合的元素重新加入元素，以此实现删除的功能(注意上面调用的方法传的参数是false，也就是不包含的元素得以保留,实现差集的功能)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
1.求并集(不去重)---将一个集合全部加入另一个集合
public static void test(List list1, List list2) {
list1.addAll(list2);
System.out.println(list1);
}结果:
[A, B, B, C]
查看ArayList的addAll()源码是数组复制:
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
再查看System的arraycopy发现是一个native方法(本地方法):---其实system类的好多方法都是native方法
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
2.求并集(去重)
例如:求List1和List2的并集,并实现去重。
思路是:先将list中与list2重复的去掉，之后将list2的元素全部添加进去。
public static void test1(List list1, List list2) {
list1.removeAll(list2);
list1.addAll(list2);
System.out.println(list1);
}结果:
[A, B, C]
3.求交集
例如:求List1和List2中都有的元素。
public static void test2(List list1, List list2) {
list1.retainAll(list2);
System.out.println(list1);
}结果：
[B]
在上面2的实验过程中，我们知道batchRemove(Collection,true)也是求交集，所以猜想 retainAll 内部应该是调用 batchRemove(Collection,true)，查看ArrayList的源码如下:
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, true);
}
JS笛卡尔积算法与多重数组笛卡尔积实现方法示例
本文实例讲述了JS笛卡尔积算法与多重数组笛卡尔积实现方法。分享给大家供大家参考，具体如下：
js 笛卡尔积算法的实现代码，据对象或者数组生成笛卡尔积，并介绍了一个javascript多重数组笛卡尔积的例子，以及java实现笛卡尔积的算法与实例代码。
一、javascript笛卡尔积算法代码
例子，根据对象或者数组生成笛卡尔积。
调用方法：
