泛型

1、规定List定义的容器只能存储某种类型的元素。

不用泛型的话是什么类型的元素都可以插入，因为插入集合是忽略其类型，把它看成为Object类型，取出时需要强行转换对应的类型。

2、如何声明

List<Course> courseToSelect;  

在构造方法中(实例化的时候也可以不在构造方法，直接实例就可以)

this.courseToSelect=new ArrayList<Course>();   

3、添加

泛型集合中，不能添加泛型规定的类型以及其子类型以外的对象，否则会报错。

4、遍历

用foreach存储变量是泛型的类型。

for(Course a:courseToSelect),不用Object取出再强转，因为已经规定容器里装的都是Course类型。

package collection;

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

/**
 * @author ChristinaXinny
 * @create 2021-09-29 11:48 上午
 */

public class ListTest {

    //用于存放备选课程的list
    public List coursesToSelect;

    public ListTest() {
        this.coursesToSelect = new ArrayList();

    }

    //添加课程
    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);
    }

    //普通通过index遍历
    public void testGet() {
        int size = coursesToSelect.size();
        System.out.println("now have：");
        for (int i = 0; i < size; i++) {
            Course cr = (Course) coursesToSelect.get(i);
            System.out.println("course：" + cr.id + ":" + cr.name);
        }
    }

    //通过迭代器来遍历list
    public void testIterator() {
        Iterator it = coursesToSelect.iterator();
        System.out.println("now have:");
        while (it.hasNext()) {
            Course cr = (Course) it.next();
            System.out.println("course：" + cr.id + ":" + cr.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);
        }
    }

    //修改list中的元素
    public void testModify(){
        coursesToSelect.set(4,new Course("7","编译原理"));
    }

    //删除list中的元素
    public void testDelete(){
        //方法1
        /**Course cr=(Course)coursesToSelect.get(4);
         System.out.println("我是课程："+cr.id+";"+cr.name+",我即将被删除");
         coursesToSelect.remove(cr);*/

        //方法2
        /**System.out.println("即将删除4位置上的课程");
         coursesToSelect.remove(4);
         System.out.println("成功删除课程！");*/

        //方法3
        System.out.println("delete index=4 and index = 5 course");
        Course[] courses={(Course)coursesToSelect.get(4),(Course)coursesToSelect.get(5)};
        coursesToSelect.removeAll(Arrays.asList(courses));//将数组转换为集合
        System.out.println("delete success！");
        testForEach();
    }


    public static void main(String[] args) {
        ListTest it=new ListTest();
        it.testInsert();
        it.testGet();
        it.testIterator();
        it.testForEach();
        it.testModify();
        it.testForEach();
        it.testDelete();
    }
}

List是接口，看作是一种特殊的抽象类，仅此方便理解而已。

06：16 List 这里是变量的类型；类型后加<规定该类型中可以处理的变量类型>  被处理的变量名

泛型就是这个被处理的变量类型，比如这里 courses是变量名，Course就是泛型，List是courses变量的类型，只不过这个类型被规定了更细节的，要处理的泛型是Course而已，

好处就是更容易处理courses这样的数据了。因为List集合里面处理的对象是obj，每次处理都要强转，并且不认识进来的数据，这样会降低数据的处理效率。

泛型：规定集合只能存特定类型对象，这样存放类型固定，取出类型不用担心出问题

List<Course> courses = new ArrayList<Course>();

有泛型Course，每个元素类型就是Course而非Object

泛型使用方法如下：

List<Course> courseToSelect = new ArrayList<Course>();

使用泛型可以规范集合中的元素为规定的类型及其子类型；

泛型

集合中的元素,可以是任意类型的对象(对象的引用)

如果把某个对象放入集合,则会忽略他的类型，而把他当做Object处理

泛型则是规定了某个集合只可以存放特定类型的对象，会在编译期间进行类型检查，可以直接按指定类型获取集合元素

package lmr;
public class TestGeneric{
public List<Course>courses;
public TestGeneric(){
thid.courses  = new ArrayList<Course>
}
public static void main(String[] args){
}
}

public void testType(){
coursesToSelect.add("lmr");
}
public static void main(String[] args){
ListTest lt = new ListTest();
lt.testAdd(); 
lt.testType();
lt.testForEach(); 
}

泛型

• 集合中的元素，可以时任意类型的对象（对象的引用）。

  如果把某个的对象放入集合，则会忽略它的类型，而把它当作Object处理。

• 泛型则是规定了某个集合只可以存放特定类型的对象。

  会在编译期间进行类型检查，可以直接按指定类型获取集合元素。

public List coursesToSelect;
public ListTest(){
    this.coursesToSelect = new ArrayList();
}

集合中的元素，可以是任意类型的对象（对象的引用）

如果把某个对象放入集合，则会忽略他的类型，把它当做object处理

泛型则是规定了某个集合只可以存放特定类型的对象，会在编译期间进行类型检查，可以直接指定类型获取集合元素，泛型不接受基本数据类型（相当于一种规范）

集合中的元素，可以是任意类型的对象（对象的引用）

如果把某个对象放入集合，则会忽略他的类型，把它当做object处理

泛型则是规定了某个集合只可以存放特定类型的对象，会在编译期间进行类型检查，可以直接指定类型获取集合元素，泛型不接受基本数据类型

this.courses = new ArrayList<>(); //圆括号表示调用了构造方法

List的增删改查：

增 ：使用 add和addAll两种方法

add（新的元素）和addAll（新的数组元素）

//PS:新的数组元素要用Arrays.asList();把数组转换成集合

删：使用remove(元素位置)和removeALL(数组位置)，来删除集合中的元素

改：使用set(元素位置，新new的元素) 来改变原本的元素

查：使用 for循环，iterator迭代器，for each来遍历和查询List集合中的元素

// PS：其中要使用到 集合.size();来获取List中的元素长度。

// PS:  使用 iterator迭代器时，可以使用while(Iterator.XX.hasNext())来判断是否遍历了集合中的所有元素有效位，并配合 XX.next(),来循环打印每一个集合中的元素，

泛型的声明使用

Java的泛型的意思竟然是"特定类型"

泛型是规定了某个集合只可以存放特定类型的对象

会在编译期间进行类型检查

可以直接按指定类型获取集合元素

集合中的元素，可以是任意类型的对象（对象的引用）

如果把某个对象放入集合，则会忽略他的类型，二把它当做object处理

泛型则是规定了某个集合只可以存放特定类型的对象，会在编译期间进行类型检查，可以直接指定类型获取集合元素

泛型不接受基本数据类型

this.courses = new ArrayList<>(); //圆括号表示调用了构造方法

“集合中的元素，可以是任意类型的对象（对象的引用）”；

从一个集合中取出一个物体即可被理解为拿出这个对象来用及引用；

Java中的泛型

集合中的元素，可以是任意类型的对象（对象的引用）；

如果把某个对象放入集合，集合会忽略它的类型，将它当中Object类型处理；

泛型规定了某个集合只可以存放特定类型的对象，并且会在编译期间进行类型检查，而在取出集合中的对象时可以直接按指定类型获取；

泛型

集合中的元素可以是任意类型对象（对象的引用），集合中储存的都是一个个具体引用，

指向一个个对象的。把对象放入集合会忽略他的类型当成Object处理

泛型则是规定了某个集合只能存放特定类型的对象，并且会在编译期间进行检查。
取出元素时也不需要强制类型转换
Generic
public List<Course> courses;/*带有泛型——Course,的List属性*/
/*无参构造器，初始化courses属性*/
public TestGeneric(){
this.courses=new ArrayList<Course>();/*这里的圆括号是表示调用了构造函数*/
}

集合与泛型：

感觉这个比较重要啊

foreach遍历  注意类型是course而不是object

属性 是  泛型的

package com.kandy.imoockecheng.listmap;

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

public class TestGeneric {
    List<Course> list;

    public TestGeneric(){
       //使用前需要实例化
       this.list = new ArrayList<Course>();
    }
    //添加元素
    public void initialList(){
        Course[] courses = {
          new Course("1","C++"),
          new Course("2","Java")
        };
        list.addAll(Arrays.asList(courses));
        showList();
    }
    //显示list
    public void showList(){
        list.forEach(course -> {
            System.out.println(course.id+":"+course.name);
        });
    }

    public static void main(String[] args) {
        TestGeneric tg=new TestGeneric();
        tg.initialList();
    }
}
//课程类
package com.kandy.imoockecheng.listmap;

public class Course {
    public String id;
    public String name;
    public Course(String id,String name){
        this.id=id;
        this.name=name;
    }
}

带有泛型 的List类型属性

List<类型> 属性名

什么是泛型

泛型会对编译期间进行检查