set

Set接口及其实现类——HashSet

Set是元素无序并且不可以重复的集合，被称为集；

HashSet——哈希集，是Set的一个重要实现类。

1、Set没有像List中set()方法一样就修改，因为List是有序的，可以指定位置，而Set是无序的。

2、查询遍历时，Set不能用get()方法去获取，因为无序没有指定索引ID，但可以使用foreach和iterator来遍历，但是每次遍历出来可能顺序都不一样，还是因为无序造成的。

3、Set中的size(),add(),addAll(),remove(),removeAll()与List类似。

4、Set还可以添加null

1、List<>()这是一个有序序列。因为List是一个接口，并不能实例化。因此我们需要将用Arraylist来实现。
2、Arraylist是一个数组序列也是list的一个重要的实现类，用来执行list的增删改查等。
List<>() a=new Arraylist<>(); 或者通过构造参数的形式实现。
3、在现实开发当中，课程等成员变量是私有化的，需要用get（）和set（）方法。
4、对象被存入集合都变成object类型了 取出时需要类型强转。但在List<类型>()声明了类型的就只能存入该类型的数据，并且提取时也只会是该类型，不用强转。
例：Course temp = (Course)coursesToSelect.get(0);//强转
5、调用Add()方法添加到List中。有两种方法：
a) 直接添加，例：CoursesToSelect.add(cr1);
b) 可以指定添加的位置，例：CoursesToSelect.add(0,cr1);
6、如果添加到List中的长度大于他目前的长度，则系统会出现异常，即数组下表越界异常
7、list中还有addAll(List list)
就是将一个List里面的元素一股脑的全都加进去
一般定义一个数组，如何把一个数组转换成List？ 调用方法Arrays.asList(Object[] obs);//可以将一个数组转换为一个List，然后可以将这个元素传进addAll()里面
当然还有addAll（index,List list）方法
8、迭代器只是用来遍历集合中的元素，本身不具备任何存储元素的功能，换而言之，迭代器是依赖于某个集合而存在的，本身不能独立存在。
读取元素三种方法：
a)for（）
b)Iterator是一个接口,依赖于集合存在的
Iterator it=courseToSelect.iterator();
while(it.hasNext()){} //迭代
c)foreach
9、使用set（index,Object element）修改元素，index表示索引位置，element表示新对象。

1、List<>()这是一个有序序列。因为List是一个接口，并不能实例化。因此我们需要将用Arraylist来实现。
2、Arraylist是一个数组序列也是list的一个重要的实现类，用来执行list的增删改查等。
List<>() a=new Arraylist<>(); 或者通过构造参数的形式实现。
3、在现实开发当中，课程等成员变量是私有化的，需要用get（）和set（）方法。
4、对象被存入集合都变成object类型了 取出时需要类型强转。但在List<类型>()声明了类型的就只能存入该类型的数据，并且提取时也只会是该类型，不用强转。
例：Course temp = (Course)coursesToSelect.get(0);//强转
5、调用Add()方法添加到List中。有两种方法：
a) 直接添加，例：CoursesToSelect.add(cr1);
b) 可以指定添加的位置，例：CoursesToSelect.add(0,cr1);
6、如果添加到List中的长度大于他目前的长度，则系统会出现异常，即数组下表越界异常
7、list中还有addAll(List list)
就是将一个List里面的元素一股脑的全都加进去
一般定义一个数组，如何把一个数组转换成List？ 调用方法Arrays.asList(Object[] obs);//可以将一个数组转换为一个List，然后可以将这个元素传进addAll()里面
当然还有addAll（index,List list）方法
8、迭代器只是用来遍历集合中的元素，本身不具备任何存储元素的功能，换而言之，迭代器是依赖于某个集合而存在的，本身不能独立存在。
读取元素三种方法：
a)for（）
b)Iterator是一个接口,依赖于集合存在的
Iterator it=courseToSelect.iterator();
while(it.hasNext()){} //迭代
c)foreach
9、使用set（index,Object element）修改元素，index表示索引位置，element表示新对象。

1、List<>()这是一个有序序列。因为List是一个接口，并不能实例化。因此我们需要将用Arraylist来实现。
2、Arraylist是一个数组序列也是list的一个重要的实现类，用来执行list的增删改查等。
List<>() a=new Arraylist<>(); 或者通过构造参数的形式实现。
3、在现实开发当中，课程等成员变量是私有化的，需要用get（）和set（）方法。
4、对象被存入集合都变成object类型了 取出时需要类型强转。但在List<类型>()声明了类型的就只能存入该类型的数据，并且提取时也只会是该类型，不用强转。
例：Course temp = (Course)coursesToSelect.get(0);//强转
5、调用Add()方法添加到List中。有两种方法：
a) 直接添加，例：CoursesToSelect.add(cr1);
b) 可以指定添加的位置，例：CoursesToSelect.add(0,cr1);
6、如果添加到List中的长度大于他目前的长度，则系统会出现异常，即数组下表越界异常
7、list中还有addAll(List list)
就是将一个List里面的元素一股脑的全都加进去
一般定义一个数组，如何把一个数组转换成List？ 调用方法Arrays.asList(Object[] obs);//可以将一个数组转换为一个List，然后可以将这个元素传进addAll()里面
当然还有addAll（index,List list）方法
8、迭代器只是用来遍历集合中的元素，本身不具备任何存储元素的功能，换而言之，迭代器是依赖于某个集合而存在的，本身不能独立存在。
读取元素三种方法：
a)for（）
b)Iterator是一个接口,依赖于集合存在的
Iterator it=courseToSelect.iterator();
while(it.hasNext()){} //迭代
c)foreach
9、使用set（index,Object element）修改元素，index表示索引位置，element表示新对象。

package collection;

import sun.applet.Main;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

/**
 * @author ChristinaXinny
 * @create 2021-09-30 12:37 下午
 */
public class SetTest {


    public List<Course> coursesToSelect;

    public SetTest() {
        this.coursesToSelect = new ArrayList<Course>();
    }



    //添加课程
    public void testInsert() {
        //创建课程对象
        Course c1 = new Course("1", "C++");
        coursesToSelect.add(c1);
        Course temp = (Course) coursesToSelect.get(0);
        //System.out.println("add" + temp.id + ":" + temp.name);

        Course c2 = new Course("2", "Python");
        coursesToSelect.add(0, c2);
        Course temp2 = (Course) coursesToSelect.get(0);
        //System.out.println("添加了课程:" + temp2.id + ":" + temp2.name);

        Course[] course = {new Course("3", "Java"), new Course("4", "Vue")};
        coursesToSelect.addAll(Arrays.asList(course));
        Course temp3 = (Course) coursesToSelect.get(2);
        Course temp4 = (Course) coursesToSelect.get(3);
        //System.out.println("add two course:" + temp3.id + ":" + temp3.name + ":" + temp4.id + ":" + temp4.name);
        Course[] course2 = {new Course("5", "高数"), new Course("6", "大英")};

        coursesToSelect.addAll(2, Arrays.asList(course2));
        Course temp5 = (Course) coursesToSelect.get(2);
        Course temp6 = (Course) coursesToSelect.get(3);
        //System.out.println("add two course：" + temp5.id + ":" + temp5.name + ":" + temp6.id + ":" + temp6.name);
    }


    //通过for each方法访问集合元素
    public void testForEach() {
        System.out.println("now have (for each):");
        for (Object obj : coursesToSelect) {
            Course cr = (Course) obj;
            System.out.println("course: " + cr.id + ":" + cr.name);
        }
    }

    public static void main(String[] args) {
        SetTest setTest = new SetTest();
        setTest.testInsert();
        setTest.testForEach();

        Student stu =new Student("1","xx");
        System.out.println(stu);

        Scanner in = new Scanner(System.in);

        for (int i=0; i<3; i++){
            System.out.println("input id :");
            String id = in.next();
            for (Course c : setTest.coursesToSelect){
                if (c.id.equals(id)){
                    stu.courses.add(c);
                    stu.courses.add(c);
                }
            }
        }
        setTest.testForEachSet(stu);

    }


    public void testForEachSet(Student stu ){
        for (Course c : stu.courses){
            System.out.println("select id:"+c.id + " name:"+c.name);
        }
    }



}

Set中遍历只能调用foreach方法和iterator方法

~Set是元素无序并且不可以重复的集合，被称为集。

~

Set的元素无序切不可以重复

首先在学生类当中创建Set类的属性：
Set<Course> courses = new HashSet();
然后创建一个SetTest类开始测试：
在测试中也创建一个Set类用来存放所有课程：
Set<Course> courses = new HashSet();
然后创建Course类对象，将其存放进Set类的实例化对象中：
Course cr1 = new Course("1","数据结构");
courses.add(cr1);
Course cr2 = new Course("2","C语言");
courses.add(cr2);
Course cr3 = new Course("3","计算机网络");
 courses.add(cr3);
用for each将集合中元素都打印出来：
System.out.println("能选择的课程如下：");
for(Course course:courses){
            System.out.print("课程：");
            System.out.println(course.id+":"+course.name);
        }
接着创建学生类对象，循环选课的次数，在每次循环中，输入课程ID，用for each来遍历判断输入的ID和集合中元素的ID是否相等，如果相等则将该Course元素插入学生对象的courses集合中：
Student student = new Student("1","文胸");
int size = courses.size();
for (int i = 0; i < 3; i++){
            System.out.print("请输入要选择的课程的序号：");
            Scanner console = new Scanner(System.in);
            String num = console.next();
            for(Course course : courses){
                if(course.id.equals(num)){
                    student.courses.add(course);
                }
            }
        }
最后再用for each循环打印出学生对象的courses集合的元素
System.out.println("学生："+student.name+"所选的课程为：");
        for(Course course:student.courses){
            System.out.println(course.id+":"+course.name);
        }

set遍历只能调用foreach和iterator，不能调用get（）方法，原因：Set 不像 List， 由于Set是无序的，所以无法给定一个位置进行修改

set中一个对象添加多次，只会保留第一次添加的

可添加空对象 null

public Set<Course> courses;
public Student(String id,String name){
this.id = id;
this.name = name;
this.courses = new HashSet<Course>();
}

package lmr;
public class SetTest{
public List<Course> coursesToSelect;
public SetTest(){
coursesToSelect = new ArrayList<Course>();
}
public static void main(String[] args){
SetTest st = new SetTest();
st.testAdd();
st.testForEach();
Studrnt student =new Student("1","小明");
Scanner console = new Scanner(System.in);
for(int i =0;i<3;i++){
System.out.println("请输入课程");
String couresId0 = console.next();
for(Course cr : st.coursesToSelect){
if(cr.id.equals(courseld))
}
}
}
}

注意：Set支持add添加一个空对象NULL

Set集只能使用foreach和iterator方法遍历，而不能像List一样通过get()方法。

for循环接收键盘输入，add添加进Set集

Set接口及其实现类——HashSet

Set是元素无序并且不可以重复的集合，被称为集。

HashSet——哈希集，是Set的一个重要实现类。 

注意：由于Set是无序的，所以没有和List一样的set方法。

Set接口：

1.Set是元素无序并且不可以重复的集合，被称为集（而不是集合）。

因为Set中的元素是无序的，所以在遍历的时候不能使用get方法，只能使用foreach或者iterator方法。

2.HashSet——哈希集是Set的一个重要实现类。

3.Set中，添加某个对象，无论添加多少次，最终只会保留一个该对象（的引用），并且，保留的是第一次添加的哪一个。

Set类型中没有set()方法 因为Set是无序的 无法给定索引位置.

Set无序并且不可重复

由于Set集合是无序的，所以Set遍历只能使用foreach方法或iterator方法，不能像List一样使用get()方式

Set中的元素是不可以重复的，无论将某个元素添加多少次最终只会保留一个该对象（的引用）且是第一次添加的那一个

Set接口是collection接口的一个子接口

1. Set是元素无序并且不可以重复的集合，被称为集

2. HashSet哈希集，是Set的一个重要实现类

Set集合无序并且不可重复

set集合

Set不能使用get()方法，因为它是无序的，不能用位置

Set中的元素是不能重复的，就算重复添加很多次也只会保留一个。并且Set中是可以添加null的。List是有序的Set是无序的。

Java中的Set接口

Set是元素无序并且不可以重复的集合，被称为集。

HashSet是Set的一个重要实现类，被称为哈希集。

获取Set中的元素只能用foreach方法或者iterator方法，因为它是无序的所以每次获取的元素顺序会不同。

在Set中可以添加空对象null

HashSet

Set 没有set()方法（不能修改元素）

因为Set是无序的

Set只能用循环或者迭代器访问，不能用get（）取值，因为他是无序的

Set。。