精华内容
下载资源
问答
  • 去重指的是当把一个列表变成了集合,其中重复的内容就自动的被去掉了关系测试指的是,测试两组数据之间的交集、差集、并集等关系。去重测试代码如下:#创建一个列表--里面存在一些重复值test_list = [1,2,3,4,2,2,3,...

    匿名用户

    1级

    2018-11-20 回答

    集合是一个无序的,不重复的数据组合,它有着两个主要作用:去重以及关系测试。去重指的是当把一个列表变成了集合,其中重复的内容就自动的被去掉了

    关系测试指的是,测试两组数据之间的交集、差集、并集等关系。

    去重测试代码如下:

    # 创建一个列表 -- 里面存在一些重复值

    test_list = [1,2,3,4,2,2,3,4,3,2,3,4]

    # 利用集合将列表中重复的内容去掉

    test_list = set(test_list)

    # 打印测试并且查看test_list 被赋予新值后的数据类型print(test_list,type(test_list))   #  {1, 2, 3, 4}

    Tip:需要注意的是,集合和字典一样都是无序的。

    获取交集需要使用集合中的方法intersection方法,获取两个集合中的交集代码如下:

    # 创建两个集合,并且获取集合的交集

    test_list_01 = set([\'YanYan\',\'LiBai\',\'LuLu\',\'YangMi\'])

    test_list_02 = set([\'YanYan\',\'LiuDeHua\',\'ZhangXueYou\',\'LiBai\'])

    # 在上面的两个集合中,存在相同的值,那么现在我们取出两个集合中的交集

    test_intersection = test_list_01.intersection(test_list_02)print(test_intersection)  # {\'YanYan\', \'LiBai\'}

    获取并集的方式需要采用集合中union方法,获取两个集合的并集代码如下:

    # 创建两个集合,并且获取集合的交集

    test_list_01 = set([\'YanYan\',\'LiBai\',\'LuLu\',\'YangMi\'])

    test_list_02 = set([\'YanYan\',\'LiuDeHua\',\'ZhangXueYou\',\'LiBai\'])

    # 采用集合中的union方法获取并集

    test_list_union = test_list_01.union(test_list_02)

    print(test_list_union)  # {\'LiBai\', \'LuLu\', \'ZhangXueYou\', \'LiuDeHua\', \'YangMi\', \'YanYan\'}

    获取差集的方式要采用集合中的difference方法,获取两个集合的差集的代码如下所示:

    # 创建两个集合,并且获取集合的交集

    test_list_01 = set([\'YanYan\',\'LiBai\',\'LuLu\',\'YangMi\'])

    test_list_02 = set([\'YanYan\',\'LiuDeHua\',\'ZhangXueYou\',\'LiBai\'])

    # 使用集合中的difference 方法来获取差集

    test_difference = test_list_01.difference(test_list_02)

    test_difference2 = test_list_02.difference(test_list_01)

    print(test_difference) # {\'LuLu\', \'YangMi\'}print(test_difference2) # {\'ZhangXueYou\', \'LiuDeHua\'}

    判断一个集合是否是另外一个集合的子集可以使用issubset()方法,同样,还可以使用issuperset()方法判断一个集合是否是另外一个集合的父级

    代码如下:

    # 创建两个集合

    list_set  = set([1,2,3,4])

    list_son = set([2,3])

    # 判断list_son是否是list_set的子集print(list_son.issubset(list_set))  # True# 判断list_set 是否是list_son的父级print(list_set.issuperset(list_son)) # True

    对称差集(又有人称之为叫做反向差集),指的是取出两个集合中互相都没有的值取出放在一个集合中。

    代码如下:

    # 创建两个集合

    list_set_num1 = set([1,3,5,7,9])

    list_set_num2 = set([2,3,4,6,9,10])

    # 获取两个集合的对称差集print(list_set_num1.symmetric_difference(list_set_num2))  # {1, 2, 4, 5, 6, 7, 10}

    如果上述的难以理解的话,可以对 对称差集理解为去掉两个集合中都存在的内容,将剩余的内容取到一个新的集合中。

    除了上述的这些方法实现的关系功能之外,还有一个方法 isdisjoint() ,功能是判断两个集合中是否有相同的值,如果两个集合中没有相同的值(即没有交集),那么返回True

    代码如下:

    # 创建集合

    test_set_num1 = set([1,2,3,4])

    test_set_num2 = set([5,6,7,8])

    test_set_num3 = set([1,3,7,8])

    # 使用isdisjoint()方法来判断print(test_set_num1.isdisjoint(test_set_num2)) # Trueprint(test_set_num1.isdisjoint(test_set_num3)) # False

    通过运算符来进行关系测试

    在上面的应用中,主要是通过python中的方法进行的关系测试,那么在python中,除了使用方法以外,还可以使用关系运算符来进行关系测试。

    实例代码如下:

    test_list_01 = set([\'YanYan\',\'LiBai\',\'LuLu\',\'YangMi\'])

    test_list_02 = set([\'YanYan\',\'LiuDeHua\',\'ZhangXueYou\',\'LiBai\'])

    # 获取交集 &print(test_list_01 & test_list_02) # {\'LiBai\', \'YanYan\'}

    # 获取并集 |print(test_list_01 | test_list_02) # {\'LuLu\', \'LiBai\', \'LiuDeHua\', \'YanYan\', \'ZhangXueYou\', \'YangMi\'}

    # 获取差集  -print(test_list_01 - test_list_02) # {\'LuLu\', \'YangMi\'}print(test_list_02 - test_list_01) # {\'LiuDeHua\', \'ZhangXueYou\'}

    # 获取对称差集print(test_list_01 ^ test_list_02) # {\'ZhangXueYou\', \'YangMi\', \'LuLu\', \'LiuDeHua\'}

    集合的增删改查

    添加

    语法: Set.add()

    代码如下:

    # 创建一个集合

    test_set = set([\'YanYan\'])

    # 添加

    test_set.add(\'LiBai\') # 添加一项

    test_set.update([\'LuLu\',\'JingJing\']) # 一次性向集合中添加多项

    # 输出集合

    print(test_set) # {\'YanYan\', \'LuLu\', \'LiBai\', \'JingJing\'}

    删除

    删除集合中的某一个元素可以使用remove方法

    代码如下:

    # 创建一个集合

    test_set = set([\'YanYan\'])

    # 使用remove方法删除元素

    test_set.remove(\'YanYan\')print(test_set)  # set()

    删除项目除了使用remove以外,还可以使用pop()方法,但是pop()方法删除内容不能够指定,只是随机删除。

    pop方法会把删除的内容返回,示例代码如下:

    # 创建一个集合

    test_set = set([20,9,\'a\',1,2,3,4])print(test_set.pop()) # 1print(test_set.pop()) # 2print(test_set.pop()) # 3

    删除元素还可以使用discard()方法,这个方法没有返回值,如果打印返回值的话会输出None

    # 创建一个集合

    test_list = set([1,2,3,4,5])

    # 使用discard()方法删除 -- 注意,discard()方法删除返回None,也就是没有返回值print(test_list.discard(3))  # None# 此时原集合中的3已经被删除了print(test_list)  # {1, 2, 4, 5}

    查询

    x in s # 判断 x是否是s 的成员

    x not in s  判断x 是否是s的成员

    len(x) # 查看x的长度

    s <= t # 测试是否s中的每一个元素都在t中

    s >= t # 测试是否 t 中的每一个元素都在 s 中

    展开全文
  • 集合 集合中任何个数据元素之间都没有逻辑关系,组织形式松散. ② 线性结构 线性结构中 结点按逻辑关系依次排列形成一个“锁链”. ③ 树形结构 树形结构具有分支、层次特性,其形态有点象自然界中树. ④ ...
    ① 集合 集合中任何两个数据元素之间都没有逻辑关系,组织形式松散.
    ② 线性结构 线性结构中的 结点按逻辑关系依次排列形成一个“锁链”.
    ③ 树形结构 树形结构具有分支、层次特性,其形态有点象自然界中的树.
    ④ 图状结构 图状结构中的结点按逻辑关系互相缠绕,任何两个结点都可以邻接

    集合:结构中的数据元素之间除了同属于一种类型外,别无其它关系
    线性结构:结构中的数据元素之间存在一对一的关系
    树形结构: 结构中的数据元素之间存在一对多的关系
    图状结构或是网状结构:结构中的数据元素之间存在多对多的关系
    展开全文
  • 该类要实现Comarable接口,在接口compareTo()方法中规定个Book类实例大小关系为二者price属性大小关系。在主函数中,选择合适的集合类型存放Book类若干个对象,然后创建一个新Book类对象,并检查...

    【问题描述】编写一个Book类,该类至少有name和price两个属性。该类要实现Comarable接口,在接口的compareTo()方法中规定两个Book类实例的大小关系为二者的price属性的大小关系。在主函数中,选择合适的集合类型存放Book类的若干个对象,然后创建一个新的Book类的对象,并检查该对象与集合中的哪些对象相等。

    【输入形式】每一行输入一个Book类的对象,名字和价格之间用逗号分隔,集合类的输入结束符号是#,然后输入一个新的Book类对象。

    【输出形式】
    显示查找结果,如果找到了,就显示具体对象的信息,没找到,就不显示。

    【样例输入1】
    input several Book,in the end #
    yuwen,10
    shuxue,12
    yingyu,11

    input a new Book:
    kexue,12

    【样例输出1】
    new book:as same books
    shuxue,12.0

    【样例输入2】
    input several Book,in the end #
    yuwen,10
    shuxue,12
    waiyu,11

    input a new Book:
    kexue,13

    【样例输出2】
    new book:as same books

    【样例说明】
    输入和输出的格式要和指定格式严格匹配,否则不得分。

    【评分标准】
    结果完全正确得满分。

    【备注】
    从键盘读入一行字符串,可以用如下代码:
    Scanner in = new Scanner(System.in);
    name = in.nextLine();
    可以用String.split(",")方法对字符串以逗号分成若干部分。
    使用Scanner类,需要导入import java.util.Scanner;

    package nine;
    
    import java.util.Scanner;
    
    
    class Book implements Comparable{
    	String name;
     	double price;
     public Book(String name,double price) {
     this.name=name;
     this.price=price;
     
     }
    	public int compareTo(Object b) {
    		 Book book=(Book)b;
    		return (int) (this.price-book.price);
    	}
    }
    
    public class One {
    	  
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		System.out.println("input several Book,in the end #");
    		Scanner sc=new Scanner(System.in);
    		String a=sc.nextLine();
    		int i=0;
    		Book b[]=new Book[10];
    		for(int j=0;;j++)
    		{
    			String[] a1=a.split(",");
    			double d=Double.parseDouble(a1[1]);
    			b[i]=new Book(a1[0],d);
    			i++;
    			a=sc.nextLine();
    			String x="#";
    			 if(a.equals(x)==true){
    				 break;
    		      }
    		}
    		System.out.println("input a new Book:");
    		a=sc.nextLine();
    		String[] a1=a.split(",");
    		double d=Double.parseDouble(a1[1]);
    		b[i]=new Book(a1[0],d);
    		System.out.println("new book:<"+b[i].name+">as same books");
    		for(int j=0;j<i;j++)
    		{
    			int t=b[i].compareTo(b[j]);
    			if(t==0)
    			{
    				System.out.println(b[j].name+","+b[j].price);
    				break;
    			}
    		}
    	}
    }
    
    
    
    展开全文
  • 单边对多对指个实体之间是多对多关系,但是只有一个实体中另一个实体的集合。本例引用一本书山demo(论坛文章和文章标签)实现单边多对多关系。 demo实例: 文章和文章标签关系,一个文章可以多个标签...

    单边的对多对指两个实体之间是多对多关系,但是只有一个实体中有另一个实体的集合。本例引用一本书山的demo(论坛文章和文章标签)实现单边的多对多关系。


    demo实例:

    文章和文章标签关系,一个文章可以有多个标签,每个标签下可以有多篇文章。标签实体类为tag,文章的实体类为post,其中post中有tag的一个集合用于存储该文章属于哪些标签,而标签中没有post的集合。他们的关系将被保存在一个中间表(tb_tag_post)中。


    1、建立java工程


    2、导入hibernate和MySql相关类库。

      详见之前的博客hibernate单边一对多关系中的配置。


    3、建立实体类

    实体类tag为标签类,文件Tag.java代码和注解配置如下:

    package com.arvinfei.hibernate.bean;
    
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.Table;
    
    @Entity
    @Table(name = "tb_tag")
    public class Tag {
    	@Id
    	@GeneratedValue(strategy = GenerationType.AUTO)
    	private Integer id;
    
    	private String name;
    
    	public Integer getId() {
    		return id;
    	}
    
    	public void setId(Integer id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    }
    

    文章实体类Post,Post.java的代码和注解配置如下:

    package com.arvinfei.hibernate.bean;
    
    import java.util.HashSet;
    import java.util.Set;
    
    import javax.persistence.CascadeType;
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.FetchType;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.JoinColumn;
    import javax.persistence.JoinTable;
    import javax.persistence.ManyToMany;
    import javax.persistence.Table;
    
    @Entity
    @Table(name = "tb_post")
    public class Post {
    
    	@Id
    	@GeneratedValue(strategy = GenerationType.AUTO)
    	private Integer id;
    
    	@ManyToMany(fetch = FetchType.EAGER, cascade = { CascadeType.PERSIST })
    	@JoinTable(name = "tb_tag_post", joinColumns = @JoinColumn(name = "post_id", referencedColumnName = "id"), inverseJoinColumns = @JoinColumn(name = "tag_id", referencedColumnName = "id"))
    	private Set<Tag> tags = new HashSet<Tag>();
    
    	private String title;
    
    	@Column(columnDefinition = "text")
    	private String content;
    
    	public Integer getId() {
    		return id;
    	}
    
    	public void setId(Integer id) {
    		this.id = id;
    	}
    
    	public Set<Tag> getTags() {
    		return tags;
    	}
    
    	public void setTags(Set<Tag> tags) {
    		this.tags = tags;
    	}
    
    	public String getTitle() {
    		return title;
    	}
    
    	public void setTitle(String title) {
    		this.title = title;
    	}
    
    	public String getContent() {
    		return content;
    	}
    
    	public void setContent(String content) {
    		this.content = content;
    	}
    
    }
    
    主键id配置为自增长型;

    content使用@Column(columnDefinition = "text")注解,表示该属性在数据库中使用text大文本类型。

    @ManyToMany制定该列为多对多属性;

    @fetch指定加载方式;

    多对多属性必须使用@joinTable指定中间表的配置,其中name制定中间表的表名;joinColumns指定该表与中间表的对应关系,inverseJoinColumns指定另一端中、与中间表的对应关系。

    4、在hibernate的配置文件中添加实体类映射关系

    <?xml version='1.0' encoding='UTF-8'?>
    <!DOCTYPE hibernate-configuration PUBLIC
              "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
              "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
    
    <!-- Generated by MyEclipse Hibernate Tools. -->
    <hibernate-configuration>
    
    <session-factory>
    	<property name="dialect">
    		org.hibernate.dialect.MySQLDialect
    	</property>
    	<property name="connection.url">
    		jdbc:mysql://localhost:3306/Many2Many?characterEncoding=UTF-8
    	</property>
    	<property name="connection.username">root</property>
    	<property name="connection.password">admin</property>
    	<property name="connection.driver_class">
    		com.mysql.jdbc.Driver
    	</property>
    	<property name="show_sql">true</property>
    	<property name="hbm2ddl.auto">create</property>
    	<mapping class="com.arvinfei.hibernate.bean.Post" />
    	<mapping class="com.arvinfei.hibernate.bean.Tag" />
    
    </session-factory>
    
    </hibernate-configuration>

    本例中使用的是Mysql数据库,本例子的数据库为Many2Many数据库。配置了两个实体类Post和Tag。


    5、新建测试代码

    新建Many2Manyjava文件用于测试。代码如下:

    package com.arvinfei.hibernate.test;
    
    import java.util.List;
    
    import org.hibernate.Session;
    
    import com.arvinfei.hibernate.bean.Post;
    import com.arvinfei.hibernate.bean.Tag;
    import com.arvinfei.hiernate.util.HibernateSessionFactory;
    
    public class Many2Many {
    
    	@SuppressWarnings("all")
    	public static void main(String[] args) throws Exception {
    
    		Tag tag = new Tag();
    		tag.setName("幽默");
    
    		Tag tag2 = new Tag();
    		tag2.setName("浪漫");
    
    		Post post = new Post();
    		post.setTitle("推荐一个好玩的广告,很有浪漫气息哦");
    		post.setContent("见视频。自己看吧");
    		post.getTags().add(tag);
    		post.getTags().add(tag2);
    
    		Session session = HibernateSessionFactory.getSession();
    		session.beginTransaction();
    
    		// 保存进数据库
    		session.persist(post);
    
    		List<Post> list = session
    				.createQuery(
    						" select p from Post p left join fetch p.tags t "
    								+ " where t.name = :name ")
    				.setParameter("name", "幽默").list();
    
    		System.out.println("与标签“幽默”相关的帖子:");
    		for (Post p : list) {
    			// session.refresh(p);
    			System.out.println("标题:" + p.getTitle());
    			System.out.print("所属标签:");
    			for (Tag t : p.getTags()) {
    				System.out.print(t.getName() + ", ");
    			}
    			System.out.println();
    		}
    
    		session.refresh(tag);
    		session.getTransaction().commit();
    		session.close();
    
    	}
    
    }
    

    6、修改HibernateSessionFactory

    修改HibernateSessionFactory中的sessionFactory配置方式,默认为xml配置方式,demo中使用注解进行配置,所以需要进行简单修改。


    7、运行测试

    (1)、打开并连接到mysql数据库;

    (2)、在mysql中创建Many2Many数据库

    create database Many2Many character set 'utf8';

    (3)、运行本测试工程,查看log输出。



    8、源码下载

    http://download.csdn.net/detail/yxtouch/9158719

    展开全文
  • Stateful Session Bean 与 Stateless Session Bean ,这 Session Bean都可以将系统逻辑放在 method之中执行,不同是 Stateful Session Bean 可以记录呼叫者状态,因此通常来说,一个使用者会一个相对应...
  • 更多精彩内容,请关注公众号【平凡而诗意】~前言迭代是Python中常用且非常强大的一个功能,它可以用于访问...这些问题对于初学者而言却是很少去细致的研究,本文就来详细阐述一下它们之间的关系已经它们的特别之处。...
  • 前言 现在已经进入招聘季节,本篇文章旨在分享知名互联网企业面试官面试方法和心得,希望通过本文的阅读能给...3、列举java的集合以及集合之间的继承关系 4、(手写算法)如何判断一个链环/条链交叉 5、容器类
  • 53、线程的基本概念、线程的基本状态以及状态之间的关系 34 54、简述synchronized和java.util.concurrent.locks.Lock的异同 ? 34 55、设计4个线程,其中个线程每次对j增加1,另外个线程对j每次减少1。写出程序...
  • 每一个视图是一个管理对象,视图中可以包括原材料、半成品、零件、部件等构件及它们之间的关系,这些构件可以同时与多个视图相关联,不同视图间的区别在于构件集合的不同以及构件间关系的不同。从一个产品配置视图...
  • 在GitHub找到大神整理的一份学习Android非常好的...3、列举java的集合以及集合之间的继承关系 4、(手写算法)如何判断一个链环/条链交叉 5、容器类介绍以及之间的区别 6、List,Set,Map的区别 7、HashMap的实现原.
  • 阶段汇总集合:++小Flag实现,一百期面试题汇总++全文目录什么是微服务?微服务之间如何独立通讯?SpringCloud 和 Dubbo 有哪些区别?SpringBoot 和 SpringCloud 之间关系?...你所知道微服务技术栈有哪些?...
  • 1.基本数据类型有哪些? 2.面向对象的基本特征有哪些?分别解释下?(核心:多态的解释) 3.==和equals的区别和联系? 4.包装类型与基本类型的...11.线程的基本状态以及状态之间的流转关系? 12.为什么需要同步,
  • Apriori算法和FP-growth算法比较

    万次阅读 2016-11-28 11:11:38
    ”之类的问题关联分析是在大规模数据集中寻找有趣关系的任务,这些关系可以有两种形式:频繁项集:是经常出现在一块儿的物品的集合关联规则:按时种物品之间可能存在很强的关系。支持度是针对项集来说的,因此可以...
  • 1.2.7 请分析 MaxCompute 产品与分布式技术的关系、当前大数据计算平台类产品的市场现状和发展趋势 1.2.8 对大数据平台中的元数据管理是怎么理解的,元数据收集管理体系是怎么样的,会对大数据应用什么样的影响 ...
  • 树与二叉树(1)

    2020-11-15 20:30:34
    在学习新内容之前,让我们先来回顾一下数据逻辑结构都有哪些吧! 一.树型结构: 1.结点之间有分支 2.具有层次关系 1.树定义 树是n个结点有限集。 若n=0,称为空树; 若n>0,则它满足如下个条件 ①有且仅...
  • LINGO软件学习

    2009-08-08 22:36:50
    男学生和女学生的联系集:友好程度属性friend,[0,1]之间的数。 ; linkmf(students,students)|sex(&1) #eq# 1 #and# sex(&2) #eq# 0: friend; !男学生和女学生的友好程度大于0.5的集; linkmf2(linkmf) | friend...
  • 你必须知道495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    数组和指针基本关系 6.1 我在一个源文件中定义了chara[6],在另一个源文件中声明了externchar*a。为什么不行? 6.2 可是我听说chara[]和char*a是等价。是这样吗? 6.3 那么,在C语言中“指针和数组等价...
  • SpringCloud 和 Dubbo 有哪些区别?SpringBoot 和 SpringCloud 之间关系?什么是熔断?什么是服务降级?微服务优缺点是什么?说下你在项目中碰到坑。eureka和zookeeper都可以提供服务注册与发现功能,请说说....
  • 它显示了根和它的导出类之间的关系。 子类从它先辈类那里继承了代码和数据,这样,它就可以执行先辈类的功能和访问先辈 类的数据。一个纯面向对象程序设计的语言将具有严格的继承性。 通过对象、类,我们实现了封装...
  • 图数据结构及操作

    2020-10-07 13:37:32
    之前被提问:如果想知道个城市之间的距离适合采用哪种数据结构? 回答:图(我发音:头:tou) 再被提问:什么头,头的,你说的是什么呀? 回答:tewutu 图 图结构 又说道:说的什么,不知道你在说什么? ...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 164
精华内容 65
关键字:

两集合之间的关系有哪些