精华内容
下载资源
问答
  • 定义一学生Student,包含三属性姓名、年龄、性别, 创建三学生对象存入ArrayList集合中。...
    千次阅读
    2020-11-26 19:17:00

    Java基础

    定义一个学生类Student,包含三个属性姓名、年龄、性别, 创建三个学生对象存入ArrayList集合中。 A:使用迭代器遍历集合。 B:求出年龄最大的学生,然后将该对象的姓名变为:小猪佩奇。

    package com.itfxp.log.Demo02;
    
    public class Student {
        String name;
        int age;
        char sex;
    
        public Student() {
        }
    
        public Student(String name, int age, char sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public char getSex() {
            return sex;
        }
    
        public void setSex(char sex) {
            this.sex = sex;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", sex=" + sex +
                    '}';
        }
    }
    
    
    package com.itfxp.log.Demo02;
    
    import java.util.ArrayList;
    
    /*二、定义一个学生类Student,包含三个属性姓名、年龄、性别,
    创建三个学生对象存入ArrayList集合中。
    	A:使用迭代器遍历集合。
    	B:求出年龄最大的学生,然后将该对象的姓名变为:小猪佩奇。*/
    public class Work02 {
        public static void main(String[] args) {
            ArrayList<Student> str=new ArrayList<>();
            str.add(new Student("二哈",33,'女'));
            str.add(new Student("皮皮虾",35,'男'));
            str.add(new Student("臭鱼烂虾",34,'女'));
            str.add(new Student("臭鱼",37,'女'));
            for (Student s : str) {  //遍历集合
                System.out.println(s);
            }
            int max=0;
            for (int i = 1; i < str.size(); i++) {
                if (str.get(i).getAge()>str.get(max).getAge()){//比较年龄
                    max=i;
                }
            }
            System.out.println("~~~~~~~");
            str.get(max).setName("小猪佩奇");//修改年龄最大的名字
            for (Student s : str) {  //遍历修改后的
                System.out.println(s);
            }
        }
        }
    
    
    更多相关内容
  • py代码-输入包含若干集合的列表,输出这些集合的并集。 提示:使用reduce()函数和operator模块中的运算实现多集合的并集。
  • Java基础【自定义 ArrayList集合

    千次阅读 2018-10-21 20:38:19
     ArrayList集合 第1章 引用数据类型() 1.1 引用数据类型分类 提到引用数据类型(),其实我们对它并不陌生,如使用过的Scanner、Random。 我们可以把的类型为两种:  第一种,Java为我们提供好...

    第6天 Java基础语法

    今日内容介绍
     自定义类
     ArrayList集合

    第1章 引用数据类型(类)

    1.1 引用数据类型分类

    提到引用数据类型(类),其实我们对它并不陌生,如使用过的Scanner类、Random类。
    我们可以把类的类型为两种:

     第一种,Java为我们提供好的类,如Scanner类,Random类等,这些已存在的类中包含了很多的方法与属性,可供我们使用。
     第二种,我们自己创建的类,按照类的定义标准,可以在类中包含多个方法与属性,来供我们使用。
    这里我们主要介绍第二种情况的简单使用。

    1.2 自定义数据类型概述

    我们在Java中,将现实生活中的事物抽象成了代码。这时,我们可以使用自定义的数据类型(类)来描述(映射)现实生活中的事物。
    类,它是引用数据类型,与之前学习的所有引用数据类型相同,自定义类也是一种数据类型。只是自定义类型并非Java为我们预先提供好的类型,而是我们自己定义的一种引用数据类型用来描述一个事物。

    1.3 类的定义与使用

    java代码映射成现实事物的过程就是定义类的过程。
    我们就拿一部手机进行分析,它能用来做什么呢?它可以打电话,上网,聊微信等,这些就是手机所提供的功能,也就是方法;手机也有它的特征,如颜色、尺寸大小、品牌型号等,这些就是手机的特征,也就是属性。
    目前,我们只关注类中的属性,类中的方法在面向对象部分再进行学习。

    1.3.1 类的定义格式

     类的定义格式:
    创建java文件,与类名相同

    public class 类名{
    数据类型  属性名称1;
    数据类型  属性名称2;
    …}
    

    通过类的定义格式,来进行手机类的描述,如下所示

    public class Phone {
    	/*
    	 * 属性
    	 */
    	String brand;// 品牌型号
    	String color;// 颜色
    	double size; // 尺寸大小
    }
    

    上述代码,就是创建一个类的的过程,类的名称我们给起名为Phone,类中包含了三个属性(brand品牌型号、color颜色、size尺寸大小)。注意,类中定义的属性没有个数要求。

    1.3.2 类的使用格式

    Phone类定义好后,我们就可以使用这个类了,使用方式和使用引用数据类型Scanner类相似。格式如下:

    导包:我们将所有的类放到同一个文件夹下,可以避免导包。
    创建对象:数据类型 变量名 = new 数据类型();
    调用方法:目前我们定义的自定义类不涉及方法,只是属性(自定义类中的方法部分在面向对象部分讲解)
    访问属性:变量名.属性 (这是当前的方式,后期会采取调用方法的方式替代掉直接访问的方式来完成对属性的访问。)

    当有了Phone数据类型的变量后,我们就可以使用Phone类中的属性了。对属性的访问我们来演示一下,如下所示:

    public class Test {
    	public static void main(String[] args) {
    		//定义了一个Phone类型的变量p
    		Phone p = new Phone();
    		/*
    		 * 通过p,使用Phone中的属性
    		 */
    		//访问p中的brand品牌属性
    p.brand = "苹果6s";
    //访问p中的color颜色属性
    		p.color = "白色";
    //访问p中的size尺寸大小属性
    p.size = 5.5;
    
    System.out.println("手机品牌为" + p.brand);
    System.out.println("手机颜色为" + p.color);
    System.out.println("手机尺寸大小为" + p.size);
    	}
    }
    
    运行结果如下所示
    

    在这里插入图片描述 图1-1 运行结果

    1.3.3 自定义类型注意事项与内存图

    上述代码中,通过类Phone创建出来的变量p,它相当于我们生活中的盒子,里面包含了它能够使用的属性。
     通过 p.属性名 就可以对属性进行操作
     与引用类型数组类似,引用类型的自定义类型的变量,直接变量时,结果为对象地址值,这里可以通过内存图简单解释。
    在这里插入图片描述

    1.4 自定义类型练习

    学习了引用数据类型(类)以后,我们就能够使用类描述任何东西了。看几个具体的描述,如下:

     电饭锅,包含属性(品牌、容量大小、颜色等)
     汽车,包含属性(品牌、排量、类型等)
     学生,包含属性(姓名,年龄,性别等)


    第2章 ArrayList集合

    在前面我们学习了数组,数组可以保存多个元素,但在某些情况下无法确定到底要保存多少个元素,此时数组将不再适用,因为数组的长度不可变。例如,要保存一个学校的学生,由于不停有新生来报道,同时也有学生毕业离开学校,这时学生的数目很难确定。为了保存这些数目不确定的元素,JDK中提供了一系列特殊的类,这些类可以存储任意类型的元素,并且长度可变,统称为集合。在这里,我们先介绍ArrayList集合,其他集合以后在学习。
    ArrayList集合是程序中最常见的一种集合,它属于引用数据类型(类)。在ArrayList内部封装了一个长度可变的数组,当存入的元素超过数组长度时,ArrayList会在内存中分配一个更大的数组来存储这些元素,因此可以将ArrayList集合看作一个长度可变的数组

    2.1 集合的创建

    创建集合的常用格式在此说明一下:

    导包:import java.util.ArrayList;
    创建对象:与其他普通的引用数据类型创建方式完全相同,但是要指定容器中存储的数据类型
    ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();
     集合中存储的元素,只能为<>括号中指定的数据类型元素;
     “<要存储元素的数据类型>”中的数据类型必须是引用数据类型,不能是基本数据类型;

    下面给出8种基本数据类型所对应的引用数据类型表示形式:
    在这里插入图片描述

    我们通过举几个例子,来明确集合的创建方式:
    

    存储String类型的元素:

    ArrayList<String> list = new ArrayList<String>();
    

    存储int类型的数据:

    ArrayList<Integer> list = new ArrayList<Integer>(); 
    

    存储Phone类型的数据:

    ArrayList<Phone> list = new ArrayList<Phone>();
    

    2.2 集合中常用方法

    接下来,我们来学习下ArrayList集合提供的一些常用方法,如下表:
    在这里插入图片描述
    通过代码演示上述方法的使用。ArrayListDemo01.java

    import java.util.ArrayList;
    public class ArrayListDemo01 {
    	public static void main(String[] args) {
    		// 创建ArrayList集合
    		ArrayList<String> list = new ArrayList<String>();
    		// 向集合中添加元素
    		list.add("stu1");
    		list.add("stu2");
    		list.add("stu3");
    		list.add("stu4");
    		// 获取集合中元素的个数
    		System.out.println("集合的长度:" + list.size());
    		// 取出并打印指定位置的元素
    		System.out.println("第1个元素是:" + list.get(0));
    		System.out.println("第2个元素是:" + list.get(1));
    		System.out.println("第3个元素是:" + list.get(2));
    		System.out.println("第4个元素是:" + list.get(3));
    	}
    }
    

    强调一点,ArrayList集合相当于是一个长度可变的数组,所以访问集合中的元素也是采用索引方式访问,第一个元素存储在索引0的位置,第二个元素存储在索引1的位置,依次类推。

    2.3 集合的遍历

    通过集合遍历,得到集合中每个元素,这是集合中最常见的操作。集合的遍历与数组的遍历很像,都是通过索引的方式,集合遍历方式如下:ArrayListDemo02.java

     1	import java.util.ArrayList;
     2	public class ArrayListDemo02 {
     3		public static void main(String[] args) {
     4			//创建ArrayList集合
     5			ArrayList<Integer> list = new ArrayList<Integer>();
     6			//添加元素到集合
     7			list.add(13);
     8			list.add(15);
     9			list.add(22);
     10			list.add(29);
     11			//遍历集合
     12			for (int i = 0; i < list.size(); i++) {
     13				//通过索引,获取到集合中每个元素
     14				int n = list.get(i);
     15				System.out.println(n);
     16			}
     17		}
     18	}
    

    上述代码中,第5行定义了一个可以存储int元素的集合;第7-10行,实现将int类型数值存储到集合中;第12-16行,实现遍历集合元素。这里要强调一点,get方法返回值的类型为集合中元素的类型。

    2.4 集合中的常用方法补充

    ArrayList集合提供的一些常用方法,如下表:
    在这里插入图片描述

     boolean add(int index, Object obj)
    	功能:在集合中指定index位置,添加新元素obj
    	功能说明:假设集合list中有元素[“java”,“javaEE”],当使用add(1,“javaWeb”)后,集合list中的元素为[“java”,“javaWeb”,“JavaEE”]。
    
     Object set(int index, Object obj)
    	功能:用指定元素obj替代集合中指定index位置的元素
    	功能说明:假设集合list中有元素[“java”,“javaEE”],当使用set(0,“javaWeb”)后,集合list中的元素为[“javaWeb”,“JavaEE”]。
    
     Object remve(int index)
    	功能:从集合中删除指定index处的元素,返回该元素
    	功能说明:假设集合list中有元素[“java”,“javaEE”],当使用remove(0)后,集合list中的元素为[“JavaEE”],返回值为“java”。
    
     void clear()
    	功能:清空集合中所有元素
    	功能说明:假设集合list中有元素[“java”,“javaEE”],当使用clear()后,集合list中的元素为空[]。
    

    第3章 随机点名器案例

    3.1 案例介绍
    随机点名器,即在全班同学中随机的找出一名同学,打印这名同学的个人信息。
    此案例在我们昨天课程学习中,已经介绍,现在我们要做的是对原有的案例进行升级,使用新的技术来实现。
    我们来完成随机点名器,它具备以下3个内容:

     存储所有同学姓名
     总览全班同学姓名
     随机点名其中一人,打印到控制台

    3.2 案例需求分析
    全班同学中随机的找出一名同学,打印这名同学的个人信息。
    我们对本案例进行分析,得出如下分析结果:

    1.存储全班同学信息(姓名、年龄)
    2.打印全班同学每一个人的信息(姓名、年龄)
    3.在班级总人数范围内,随机产生一个随机数,查找该随机数所对应的同学信息(姓名、年龄)
    随机点名器明确地分为了三个功能。如果将多个独立功能的代码写到一起,则代码相对冗长,我们可以针对不同的功能可以将其封装到一个方法中,将完整独立的功能分离出来。
    而在存储同学姓名时,如果对每一个同学都定义一个变量进行姓名存储,则会出现过多孤立的变量,很难一次性将全部数据持有。此时,我们采用ArrayList集合来解决多个学生信息的存储问题。

    3.3 实现代码步骤
    每名学生都拥有多项个人信息,为了方便管理每个人的信息,我们对学生信息进行封装,编写Student.java文件

    /**
     * 学生信息类
     */
    public class Student {
    	String name; //姓名
    	int age; //年龄
    }
    
    上述代码中,对学生信息(姓名、年龄)进行了封装。这样做的好处在于,以后只要找到这名学生,就能够知道他的每项个人信息了。
    

    接下来我们编写CallName.java文件,完成程序的编写。

     main方法中调用三个独立方法

    public static void main(String[] args) {
    	ArrayList<Student> list = new ArrayList<Student>(); //1.1创建一个可以存储多个同学名字的容器
    	/*
    	 * 1.存储全班同学信息
    	 */
    	addStudent(list);
    	/*
    	 * 2.打印全班同学每一个人的信息(姓名、年龄)
    	 */
    	printStudent(list);
    	/*
    	 * 3.随机对学生点名,打印学生信息
    	 */
    	randomStudent(list);
    }
    

     存储所有学生的个人信息

    /**
     * 1.存储全班同学名字
     */
    public static void addStudent(ArrayList<Student> list) {
    	//键盘输入多个同学名字存储到容器中
    	Scanner sc = new Scanner(System.in);
    	for (int i = 0; i < 3; i++) {
    		//创建学生
    		Student s = new Student();
    		System.out.println("存储第"+i+"个学生姓名:");
    		s.name = sc.next();
    		System.out.println("存储第"+i+"个学生年龄:");
    		s.age = sc.nextInt();
    		//添加学生到集合
    		list.add(s);
    	}
    }
    上述方法中,方法参数list中用来表示已存储所有学生。通过Scanner,完成新学生信息(姓名,年龄)的录入,并将学生添加到集合中。
    

     打印全班同学每一个人的信息

    /**
     * 2.打印全班同学每一个人的信息(姓名、年龄)
     */
    public static void printStudent (ArrayList<Student> list) {
    	for (int i = 0; i < list.size(); i++) {
    		Student s = list.get(i);
    		System.out.println("姓名:"+s.name +",年龄:"+s.age);
    	}
    }
    上述方法中,方法参数list中用来表示已存储所有学生。通过遍历集合中的每个元素,得到每个同学信息,并输出打印。
    

     随机对学生点名,打印学生信息

    /**
     * 3.随机对学生点名,打印学生信息
     */
    public static void randomStudent (ArrayList<Student> list) {
    	//在班级总人数范围内,随机产生一个随机数
    	int index = new Random().nextInt(list.size());
    	//在容器(ArrayList集合)中,查找该随机数所对应的同学信息(姓名、年龄)
    	Student s = list.get(index);
    	System.out.println("被随机点名的同学:"+s.name + ",年龄:" + s.age);
    }
    上述方法中,通过随机数类Random产生一个从0到集合长度的随机索引。使用该索引获取ArrayList集合中对应的值,便得到了全班同学的随机学生信息并打印。
    

    第4章 库存管理案例

    4.1 案例介绍
    现在,我们将原有的库存管理案例,采用更好的集合方式实现。
    在这里插入图片描述

    将对下列功能进行方法封装:
     打印库存清单功能
     库存商品数量修改功能
     退出程序功能

    4.2 案例需求分析
    管理员能够进行的操作有3项(查看、修改、退出),我们可以采用(switch)菜单的方式来完成。
    -------------库存管理------------

    1.查看库存清单
    2.修改商品库存数量
    3.退出
    请输入要执行的操作序号:
    每一项功能操作,我们采用方法进行封装,这样,可使程序的可读性增强。
    选择“1.查看库存清单”功能,则控制台打印库存清单
    选择“2.修改商品库存数量”功能,则对每种商品库存数进行更新
    选择“3.退出”功能,则退出库存管理,程序结束

    4.3 实现代码步骤
    每种库存商品都拥有多项商品信息,为了方便管理每种商品的信息,我们对商品信息进行封装,编写Goods.java文件

    /*
     * 库存商品类
     */
    public class Goods {
    	String brand; // 商品品牌型号
    	double size; // 商品尺寸大小
    	double price; // 商品价格
    	int count; // 商品库存个数
    }
    
    上述代码中,对商品信息(品牌、尺寸、价格、库存数)进行了封装。这样做的好处在于,以后只要找到这个商品,就能够知道该商品的每项信息了。
    

    编写Demo库存管理.java,完成如下功能:
     功能菜单

    /**
     * 库存管理功能菜单
     * @return 管理员键盘输入的功能操作序号 
     */
    public static int chooseFunction() {
    	System.out.println("-------------库存管理------------");
    	System.out.println("1.查看库存清单");
    	System.out.println("2.修改商品库存数量");
    	System.out.println("3.退出");
    	System.out.println("请输入要执行的操作序号:");
    	//接收键盘输入的功能选项序号
    	Scanner sc = new Scanner(System.in); 
    	int choose = sc.nextInt();
    	return choose;
    }
    上述方法用来完成库存管理功能菜单的显示、接收管理员选择的功能操作序号。这是完成了案例的第一步。接下来完成“查看、修改、退出”这三项功能。
    

     编写main主方法,调用库存管理功能菜单方法,与“查看、修改、退出”这三个方法。

    public static void main(String[] args) {
    	//记录库存商品信息
    	ArrayList<Goods> list = new ArrayList<Goods>();
    	//添加商品到库存
    	addStore(list);
    	
    	//通过while循环模拟管理员进行功能重复选择操作
    	while (true) {
    		//打印功能菜单操作,接收键盘输入的功能选项序号
    		int choose = chooseFunction();
    		//执行序号对应的功能
    		switch (choose) {
    		case 1://查看库存清单
    			printStore(list);
    			break;
    		case 2://修改商品库存数量
    			update(list);
    			break;
    		case 3://退出
    			exit();
    			return;
    		default:
    			System.out.println("----------------------------------");
    			System.out.println("功能选择有误,请输入正确的功能序号!");
    			break;
    		}
    	}
    }
    

    在主方法中,创建了ArrayList集合,用来存储库存商品信息,通过接收到的功能选项序号,进行switch语句判断后,调用对应的功能方法。

     查看库存清单功能

    /**
     * 查看库存清单
     */
    public static void printStore(ArrayList<Goods> list) {
    	//统计总库存个数、统计库存总金额
    	int totalCount = 0;
    	double totalMoney = 0.0;
    	//列表顶部
    	System.out.println("---------------------------查看库存清单--------------------------");
    	System.out.println("品牌型号		尺寸	价格	库存数");
    	//列表中部
    	for (int i = 0; i < list.size(); i++) {
    		Goods item = list.get(i);
    		System.out.println(item.brand+"	"+item.size+"	"+item.price+"	"+ item.count);
    		//统计总库存个数、统计库存总金额
    		totalCount += item.count;
    		totalMoney += item.count * item.price;
    	}
    	//列表底部
    	System.out.println("-------------------------------------------------------------");
    	System.out.println("总库存数:"+totalCount); 
    	System.out.println("库存商品总金额:"+totalMoney);
    }
    上述方法用来完成打印库存清单功能,参数list表示库存商品相关信息集合。
    

     修改商品库存数量功能

    /**
     * 修改商品库存数量
     */
    public static void update(ArrayList<Goods> list){
    	System.out.println("------------修改商品库存数量-----------");
    	for (int i = 0; i < list.size(); i++) {
    		Goods item = list.get(i);
    		System.out.println("请输入"+ item.brand +"商品库存数量");
    		item.count = new Scanner(System.in).nextInt();
    		list.set(i, item);
    	}
    }
    上述方法用来完成修改商品库存数量功能,参数list表示库存商品相关信息集合。
    

     退出功能

    /**
     * 退出
     */
    public static void exit(){
    	System.out.println("----------------退出---------------");
    	System.out.println("您已退出系统");
    }	
    上述方法用来完成退出程序的功能
    

    第5章 总结

    5.1 知识点总结

    1.	引用数据类型(类)
    

     类的类型为两种:
     第一种,Java为我们提供好的类,如Scanner类,Scanner类等,这些已存在的类中包含了很多的方法与属性,可供我们使用。
     第二种,我们自己创建的类,按照类的定义标准,可以在类中包含多个方法与属性,来供我们使用。
     创建类的格式
    public class 类名 {
    //可以定义属性
    //也可以定义方法
    }
     使用类的格式:
    类名 变量名 = new 类名();
     使用类中的属性与方法格式
    使用属性: 变量名.属性
    使用方法: 变量名.方法()

    2.	ArrayList集合
    

     它属于引用数据类型(类)。我们可以看作一个长度可变的数组。
     创建集合的方式
    ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();

    集合中的常用方法
     boolean add(Object obj)
     Object get(int index)
     int size()
     boolean add(int index, Object obj)
     Object set(int index, Object obj)
     Object remve(int index)
     void clear()**

    展开全文
  • 编写程序,输入包含若干集合的列表,输出这些集合的并集。要求使用reduce()函数和lambda表达式完成。 2、题目解读: (1)reduce() 函数: 语法 reduce(function, iterable[, initializer]) function – 函数,有...

    1、题目要求:

    编写程序,输入包含若干集合的列表,输出这些集合的交集。要求使用reduce()函数和lambda表达式完成。

    2、题目解读:

    (1)reduce() 函数:

    语法

    reduce(function, iterable[, initializer])

    • function – 函数,有两个参数
    • iterable – 可迭代对象
    • initializer – 可选,初始参数

    实例

    以下实例展示了 reduce() 的使用方法(采用“菜鸟教程案例”):

    >>>def add(x, y) :            # 两数相加
    ...     return x + y
    ... 
    >>> reduce(add, [1,2,3,4,5])   # 计算列表和:1+2+3+4+5
    15
    
    >>> reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数
    15
    
    (1)lambda表达式:

    介绍
    lambda表达式,通常是在需要一个函数,但是又不想费神去命名一个函数的场合下使用,也就是指匿名函数。

    实例

    # x,y为函数参数,‘:’后面的就为函数里的操作,由于是匿名函数,所以这里并没有定义函数名称
    # 所以这个匿名函数做的事情就是把传入的下x,y相加
    add = lambda x, y : x+y
    add(1,2)  # 结果为3
    

    3、代码:

    #!/usr/bin/python
    
    from functools import reduce
    
    # 定义变量
    numArr = []
    
    # 接收用户输入集合个数,根据用户输入是数字,循环让用户输入集合
    n = input("请输入集合个数:")
    # 判断n是否为整数
    if n.isdigit() == False:
        print("输入非法字符,程序退出!")
    else:
        for k in range(int(n)):
            tip = "第输入 %s 个集合列表 : " % str(k+1)
            # 输入集合,将 numSet 指向用户输入的集合
            numSet = {n for n in input(tip).split(' ')}
            # 将集合放入 numArr 列表中
            numArr.append(numSet)
    
        # 使用reduce()函数计算所有集合的交集
        # reduce(function - 函数, iterable - 可迭代对象)
        # lambda 匿名函数 ':'前是参数,后面是方法
        result = reduce(lambda a, b: a & b, numArr)
        # 输出结果
        if result:
            print(result)
        else:
            print("所有集合的并集为空!")
    
    

    4、验证:

    输入样例:
    在这里插入图片描述
    样例输出:
    在这里插入图片描述

    展开全文
  • c++求若干个集合的笛卡尔积

    千次阅读 2016-10-31 15:04:06
    大家都知道求任意两个集合的笛卡尔积一般是如下方式

    大家都知道求任意两个集合的笛卡尔积一般是如下这种方式

    #include <stdio.h>
    
    #define m 3
    
    #define n 2
    
    int main() {
    
        int i,j;
    
        char a[m],b[n];
    
        for (i=0;i<m;i++) scanf("%c",&a[i]);
    
        getchar();//吃掉\n
    
        for (j=0;j<n;j++) scanf("%c",&b[j]);
    
        printf("集合a:\n");
    
        for (i=0;i<m;i++) printf("%c\t",a[i]);
    
        printf("\n集合b:\n");
    
        for (j=0;j<n;j++) printf("%c\t",b[j]);
    
        printf("\n{");
    
        for (i=0;i<m;i++)
    
            for (j=0;j<n;j++)
    
                printf("<%c,%c> ",a[i],b[j]);
    
        printf("}\n");
    
        return 0;
    
    }
    

    例如输入两个集合“ABC”和“12”,结果如下

    这里写图片描述

    但是对于一个复杂字符串来说,例如"[A|B|C] D [E|F|G] [M|N]"(“[A|B|C]”代表一个集合,其他类是,集合中的元素用“|”隔开)这种形式的该怎么处理呢?

    第一步,熟悉python的同学第一反应当然是利用split方法来处理喽,但是c++中没有split方法,但是提供了strtok函数来处理,方法如下

    //分割字符串,spl代表分割规则
    int StrSplit(char dst[][80], char* str, const char* spl)
    {
        int n = 0;
        char *result = NULL;
        result = strtok(str, spl);
        while (result != NULL)
        {
            strcpy(dst[n++], result);
            result = strtok(NULL, spl);
        }
        return n; //返回分割集合的个数
    }

    具体调用如下

    StrSplit(dst, StrToChArr(m), " ")//以空格分割

    接下来,最关键的方法就是求笛卡尔积了,我们使用STL中的vector来处理,方法如下

    //求若干集合的笛卡尔积
    string decare(const vector<vector<string>> &sets, string add)
    {
        vector<vector<string>> rs;
        int n = sets.size();
        vector<string> tmp;
        string word, result;
        for (int i = 0; i < n; ++i)
        {
            tmp.push_back(sets[i][0]);
        }
        rs.push_back(tmp);
        for (int i = n - 1; i >= 0; --i)
        {
             int nRsSize = rs.size();
            for ( int k = 1; k < sets[i].size(); ++k)
            {
                for ( int j = 0; j < nRsSize; ++j)
                {
                    tmp = rs[j];
                    tmp[i] = sets[i][k];
                    rs.push_back(tmp);
                }
            }
        }
        for (vector<vector<string> >::iterator iter = rs.begin(); iter != rs.end(); iter++)
        {
            word += add;
            for ( int i = 0; i < (*iter).size(); i++)
            {
                word += (*iter)[i] + " ";//词之间添加空格
            }
            if (iter != rs.end() - 1) {
                word += "\n";//末尾不需要换行
            }
            else {
                word += "";
            }
        }
        return word;
    }

    完整程序如下

    #include"stdafx.h"
    #include "fstream"
    #include "vector"
    #include "string"
    #include "algorithm"
    #include "regex"
    #include "iterator"
    #include "iostream"
    #include "windows.h"
    #include "wchar.h"
    #include "io.h"
    #include "stdlib.h"
    #include "vector"
    #include "set"
    //#define TXT_NAME "word.xml"//保存合并后的xml结果
    using namespace std;
    //utf8转string
    std::string UTF8_To_string(const std::string & str)
    {
        int nwLen = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, NULL, 0);
    
        wchar_t * pwBuf = new wchar_t[nwLen + 1];
        memset(pwBuf, 0, nwLen * 2 + 2);
    
        MultiByteToWideChar(CP_UTF8, 0, str.c_str(), str.length(), pwBuf, nwLen);
    
        int nLen = WideCharToMultiByte(CP_ACP, 0, pwBuf, -1, NULL, NULL, NULL, NULL);
    
        char * pBuf = new char[nLen + 1];
        memset(pBuf, 0, nLen + 1);
    
        WideCharToMultiByte(CP_ACP, 0, pwBuf, nwLen, pBuf, nLen, NULL, NULL);
    
        std::string retStr = pBuf;
    
        delete[]pBuf;
        delete[]pwBuf;
    
        pBuf = NULL;
        pwBuf = NULL;
    
        return retStr;
    }
    
    //分隔字符串
    int StrSplit(char dst[][80], char* str, const char* spl)
    {
        int n = 0;
        char *result = NULL;
        result = strtok(str, spl);
        while (result != NULL)
        {
            strcpy(dst[n++], result);
            result = strtok(NULL, spl);
        }
        return n;
    }
    
    //判断是否需要做分隔处理
    bool IncludeCh(char str[], char ch) {
        int i;
        bool has = false;
        for (i = 0; str[i]; ++i) {
            if (str[i] == ch)
                return true;
        }
        return false;
    }
    //string转化成char数组
    char* StrToChArr(string src)
    {
        char *dst = new char[255];
        int i;
        for (i = 0; i < src.length(); i++)
            dst[i] = src[i];
        dst[i] = '\0';
        return dst;
    }
    //求若干集合的笛卡尔积
    string decare(const vector<vector<string>> &sets, string add)
    {
        vector<vector<string>> rs;
        int n = sets.size();
        vector<string> tmp;
        string word, result;
        for (int i = 0; i < n; ++i)
        {
            tmp.push_back(sets[i][0]);
        }
        rs.push_back(tmp);
        for (int i = n - 1; i >= 0; --i)
        {
            int nRsSize = rs.size();
            for (int k = 1; k < sets[i].size(); ++k)
            {
                for (int j = 0; j < nRsSize; ++j)
                {
                    tmp = rs[j];
                    tmp[i] = sets[i][k];
                    rs.push_back(tmp);
                }
            }
        }
        for (vector<vector<string> >::iterator iter = rs.begin(); iter != rs.end(); iter++)
        {
            word += add;
            for (int i = 0; i < (*iter).size(); i++)
            {
                word += (*iter)[i] + " ";//词之间添加空格
            }
            if (iter != rs.end() - 1) {
                word += "\n";//末尾不需要换行
            }
            else {
                word += "";
            }
        }
        return word;
    }
    //输出笛卡尔积结果保存到文件, add为扩充词
    string  Descarte(string m, string add)
    {
        vector<vector<string>> charSet;
        vector<string> tmp[100];
        char dst[10][80];
        int k = StrSplit(dst, StrToChArr(m), " ");//第一次分隔,得到 "[A|B|C]"、"D" 、"[E|F|G]""[M|N]"4组数据
        char dsts[10][80];
        for (int m = 0; m < k; m++)
        {
            int u = StrSplit(dsts, dst[m], "|[]");//第二次分隔,得到每组数据中的具体值,例如"[A|B|C]"中的"A"、"B"、"C"
            for (int f = 0; f < u; f++) {
                tmp[m].push_back(dsts[f]);
            }
            charSet.push_back(tmp[m]);
        }
        return decare(charSet, add);
    }
    
    
    int  main() {
        string m = "[A|B|C] D [E|F|G] [M|N]";
        if (IncludeCh(StrToChArr(m), '[') && IncludeCh(StrToChArr(m), ']')) {
            cout << Descarte(m, "") << endl;
        }
        system("pause");
        return 0;
    
    }
    
    

    如果您使用VS,在编译时往往会出现以下错误

    This function or variable may be unsafe. Consider using strcpy_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.

    原因是Visual C++ 2012 以上版本使用了更加安全的 run-time library routines 。新的Security CRT functions(就是那些带有“_s”后缀的函数)

    解决办法是即在预编译头文件 stdafx.h 里加入下面两句:

    #define _CRT_SECURE_NO_DEPRECATE
    
    #define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1

    注意这两句话的位置要在没有include任何头文件之前

    修改后的完整stdafx.h如下

    // stdafx.h : 标准系统包含文件的包含文件,
    // 或是经常使用但不常更改的
    // 特定于项目的包含文件
    //
    
    #pragma once
    //消除his function or variable may be unsafe警告
    #define _CRT_SECURE_NO_DEPRECATE
    
    #define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
    #include "targetver.h"
    
    #include <stdio.h>
    #include <tchar.h>
    
    
    
    // TODO:  在此处引用程序需要的其他头文件
    

    接下来看下运行结果

    换一个简单一点的字符串,比如“[A|B] [C|D]”(注意集合直接要有空格)

    结果如下,ok

    展开全文
  • 有些时候我们需要对一批数据进行分批处理, 使用subList方法可以实现对List集合进行固定长度的分割./** List分割*/public static List> groupList(Listlist) {List> listGroup = new ArrayList>();int list...
  • 求两个集合的交集和并集

    千次阅读 2020-02-21 23:27:27
    用两“指针”分别指向两数组的头部。如果其中一元素比另一小,后移小的那个数组的指针;如果相等,那么把该元素添加到交集里,同时后移两数组的指针。一直这样操作下去,直到有一指针超过数组范围。 ...
  • Student.java: package diertian; public class Student { private String name; private int age; private String banji;... public Student(String name, int age, String banji) { ... this....
  • java集合及concurrent并发整理总结

    万次阅读 多人点赞 2018-02-28 16:49:22
    1.集合包 集合包最常用的有Collection和Map两接口的实现,Colleciton用于存放多单对象,Map用于存放Key-Value形式的键值对。 Collection中最常用的又分为两种类型的接口:List和Set,两者最明显的差别为List...
  • 集合:求A、B两个集合的交集、并集和补集的代码(C语言)     #include #define N 100 main(){ int a[N],b[N],c[N],d[N]; int aa[N],bb[N]; int i,j,k=1; int x=1,y=1,z; int m,n; int flag; printf(...
  • 1、测试数据 @Test public void test_split(){ List<Integer> list = new ArrayList<>(); list.add(1); list.add(2); list.add(3); list.add(4);...2、方法一使用google guava下的
  • //注意:isAjax()和printJSONData()都是我写好的封装,在这里就直接拿过来调用了。 Long uid = getParameterLong("uid");// 从url中获取参数uid List<L_cecodelog> list = lcecodelogDAO.ListL_...
  • public class MyText2 ...定义List集合,存入多字符串 * 2.删除集合元素字符串中包含0-9数字的字符串 * (只要字符串中包含0-9中的任意一数字就需要删除此整个字符串)  * 3.然后利用迭代器遍历集合元素并输出 *
  • python求列表交集的方法汇总

    千次阅读 2020-11-30 03:01:42
    具体方法如下:交集对于给定的两个集合A 和 集合B 的交集是指含有所有既属于 A 又属于 B 的元素,而没有其他元素的集合叫交集了,下面给出几python求列表交集例子供大家参考。方法1遍历b1,如果某个元素同时也存在...
  • 题目首先要求要有四学生对象,那我们首先得先建立学生呀,为了方便起见,学生的对象我就只有名字和年龄好了。 除了成员变量是我自己写的,其他都是电脑点点鼠标就好了,之前的博文有介绍了,可以去看看~ ...
  • 第一题:(30分) 创建一Student,包含学生姓名、年龄、成绩(5分) 从控制台接收5学生信息,创建5学生对象,并使用List集合保存(5分) 使用集合工具和比较器的方式对集合按成绩进行排序并在控制台显示排序后的...
  • Python练习题

    千次阅读 2020-11-29 13:48:33
    T1.编写程序,输入一自然数字符串,然后输出各位数字之和。a=input("输入一串数字:")b=0for i in a:b=b+eval(i)print("数字之和为:{}".format(b))T2.输入一字符串,输出反转后的字符...输入一包含若干整数的...
  • 集合的模拟实现(模板)

    千次阅读 2015-06-29 11:50:49
    我们可以用一个类来模拟集合集合运算,add运算用以实现集合元素的增加,delete运算用于实现集合元素的删除,find运算用以实现集合元素的查找,但是目前集合元素类型未知,可以是int、char、double等基本数据类型,...
  • 如何使用C#自己创建一和List集合功能大致相同的自定义集合 首先在介绍如何自己创建一个集合之前,先介绍几概念:数据结构、数据(data)、数据元素(Data Element)、数据项(Data Item)、数据对象(Data ...
  • 数 据:是描述客观事物的符号,是计算机可以操作的对象,是能被计算机识别,并输入给计算机处理的符号集合,数据不仅仅指我们通常所说的数值类型, 还包括字符及声音,图像,视频等非数值类型 。 数 据 项:在数据...
  • 集合及concurrent并发包总结

    千次阅读 2016-10-04 01:08:27
    1. 集合包集合包最常用的有Collection和Map两接口的实现,Colleciton用于存放多单对象,Map用于存放Key-Value形式的键值对。Collection中最常用的又分为两种类型的接口:List和Set,两者最明显的差别为List...
  • 带你玩转Postman的集合

    千次阅读 2021-11-14 23:59:16
    创建一新的集合  3.保存请求到集合  4.从“History”选项卡中保存请求到集合  5.复制一已存在的集合三、共享集合 一、前言   集合可以理解成请求的总和或集合。使用集合是Postman工具实现自动化测试的...
  • Java基础之超大集合数据分片策略

    千次阅读 2019-12-13 11:35:04
    超大集合数据分片策略 一、实际场景 实际项目开发中常常为遇到超大数据量的集合,比如说一size为100w的List。...将大集合拆分成若干个集合,然后分别发送或处理这些子集合。 三、实现方法 3.1 Guavas p...
  • Guava是对Java API的补充,对Java开发中常用功能进行更优雅的实现,本文介绍了Google guava工具中Lists、Maps、Sets简单使用。
  • 题意 将N张卡分成若干个集合集合不为空,有多少种分法 思路 :贝尔数 Recommend lcy 飞机票:http://acm.hdu.edu.cn/showproblem.php?pid=2512 S(P,K)=S(P-1,K-1)+K*S(P-1,K);表示P...
  • 浅谈java集合类以及示例

    万次阅读 2020-05-04 14:28:56
    聊一聊java 的集合类 概述 Java中集合分为两种类型 第一种:以单个元素存储。其超级父接口是:java.util.Collection; 第二种:以键值对存储。(类似于python的集合)其超级父接口是:java.util.Map; 前者每位置...
  • 面试官都扯不过你系列之集合框架总结

    千次阅读 多人点赞 2020-04-08 14:02:02
    文章目录前言框架概述说一说集合类有什么特点及与数组的比较说一说集合类之间的主要关系List、Map、Set 三接口,存取元素时,各有什么特点?集合类全息图哪些集合类是线程安全的?Java集合的快速失败机制 “fail-...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 158,133
精华内容 63,253
关键字:

包是若干个类的集合