Java阶段三-集合框架，Collection，List，Queue，泛型机制

Posted 2021-06-19 Recently 祝祝

今天内容： (1)集合框架 (2)Collection集合 (3)List集合 (4)泛型机制 (5)Queue集合

1.集合(容器)框架

集合：何谓集合–》集合相当于一个容器，就把他理解成用来装东西的

重点框架，最好背下来，背不下来是不可能的，背不下来你还是程序员不，其实背不下来也是，哈哈，搜一下就完了

1.1 集合的由来
当需要在程序中记录单个数据内容时，则声明一个变量即可；str=“111”;
当需要在程序中记录多个类型相同的数据内容时，则声明一个一维数组即可；int【】arr =new int[4];
当需要在程序中记录多个类型不同的数据内容时，则构造一个对象即可；class student{方法体}
当需要在程序中记录多个类型相同的对象时，则声明一个对象数组即可；student[] arr=new student(属性)
当需要在程序中记录多个类型不同的对象时，则声明一个集合即可；

1.2 集合框架结构
在Java语言中集合框架的顶层是：java.util.Collection集合 和 java.util.Map集合
其中Collection集合中操作元素的基本单位是：单个元素。（一个一个的取）
其中Map集合中操作元素的基本单位是：单对元素。（两个两个的一对一对的取）

在以后的开发中很少直接使用Collection集合，也就是说很少使用顶层集合，而是使用该集合的子集合：List集合、Queue集合、Set集合等。

2.Collection集合(重点)

在前面我们也学过两个用来存东西的工具：一个是数组（可以存放多个类型相同的数据内容），一个是变量（一次性只能存放单个数据内容）

2.1 基本概念
java.util.Collection集合是集合框架的根接口，其它接口是该接口的子接口。
集合是接口，接口代表着不能new对象
new的是其子集合的对象
Collection c1=new ArrayList();

2.2 常用的方法(练熟、记住)

提示：
1:add，contains,remove,isEmpty都是返回Boolean类型的对象
2:object表示可以添加所有的元素对象
3：使用contains需要重写equals方法，不然会判断不准确，当类中没有重写equals方法时，调用从Object继承的版本 比较地址，若希望比较两个对象的内容，则应该重写equals方法

一般习惯性去Java手册里去查找相关的方法：https://tool.oschina.net/apidocs/apidoc?api=jdk-zh

集合中调用了Student类下的toString方法

Demo：
1：add

package setTest;
import FIFI.Student;

import java.util.ArrayList;
import java.util.Collection;
//接口不能new对象
public class CollectionTest {
    public static void main(String[] args) {
        // 1.声明Collection类型的引用指向实现类ArrayList的对象
        // 接口类型的引用指向实现类的对象，形成了多态
        Collection coll =new ArrayList();
        // 2.调用方法实现元素的添加,
//        add(E e)说明add可以加载所有的数据类型
        boolean b1=coll.add(new String("one"));
        // 自动调用toString方法，最终调用实现类中的toString方法
        // 该方法的默认打印格式为：[元素1, 元素2, ...]
        System.out.println("b1="+b1);
        System.out.println("coll="+coll);//coll=[one]

        b1=coll.add(new Integer(2));
        System.out.println("b1="+b1);
        System.out.println("coll="+coll);//coll=[one, 2]
        b1=coll.add(new Student1(1001,"zhuzhu",18));
        System.out.println("b1="+b1);
        // [one, 2, Student [id=1001, name=zhangfei, age=18]]
        // 打印集合的本质就是打印每个元素值，本质上就是调用元素对应的toString方法
        System.out.println("coll="+coll);//coll=[one, 2, Student [id=1001, name=zhuzhu, age=18]]

2：contains

// 3.调用方法实现查找的功能
        b1=coll.contains(new Integer(1));
        System.out.println("b1="+b1);//false
        // contains方法的执行原理：(o==null ? e==null : o.equals(e))
        // 若传入的实参对象为null，则判断集合中所有元素是否有null值
        // 若传入的实参对象不为null，则使用参数对象调用equals方法与集合中
        // 元素依次比较是否相等
        b1=coll.contains(new Integer(2));
        System.out.println("b1="+b1);//true
        // 当Student类中没有重写equals方法时，调用从Object继承的版本 比较地址
        // 若希望比较两个对象的内容，则应该重写equals方法
        // 当Student类中重写equals方法后，调用重写的版本 比较内容
        b1=coll.contains(new Student1(1001,"zhuzhu", 18));
        System.out.println("b1="+b1);//true

3：remove

b1=coll.remove(new String("two"));
        System.out.println("b1="+b1);
        System.out.println("coll = " + coll);
        b1=coll.remove(new String("one"));
        System.out.println("b1="+b1);
        System.out.println("coll = " + coll);
         // 调用方法实现清空集合
        coll.clear();
        System.out.println("coll = " + coll);

4:size

  System.out.println("集合元素的个数："+coll.size());//集合元素的个数：0
  System.out.println((0==coll.size()?"集合已经空了":"集合没有空"));//集合已经空了

5:isEmpty

 System.out.println(coll.isEmpty()?"空集合":"集合非空");// // 空集合

3.List集合(重中之重)

3.1 基本概念
java.util.List集合是Collection集合的子集合，该集合中元素有先后次序且允许重复
该集合的主要实现类有：ArrayList类、 LinkedList类、Stack类、Vector类等
其中ArrayList类的底层是采用动态数组进行数据管理，访问方便，增删不方便。
动态：自动扩容
其中LinkedList类的底层是采用链表进行数据管理，增删方便，访问不方便。(例如：排队)
双向链表，从前往后找，从后往前找

其中Stack类主要用于描述具有后进先出特征的数据结构，叫做栈，last in first out，（例如：羽毛球筒，后放进去的羽毛球最先被拿出来），该类的底层是采用数组进行数据的管理。
其中Vector类的底层采用数组进行数据的管理，与ArrayList类相比属于线程安全的类，因此效率比较低，在以后的开发中推荐使用ArrayList类取代之。

3.2 常用的方法(练熟、记住)

Demo：
1：add

package setTest;
import java.util.List;
import  java.util.LinkedList;
public class ListTest {
    public static void main(String[] args) {
        // 1.声明List集合的引用指向实现类的对象
        // 接口类型的引用指向实现类的对象，形成了多态
        List lst=new LinkedList();
        // 2.调用方法向集合中添加元素  常量池
        // 实现向下标为0的位置添加元素 one，向开头位置插入元素
        lst.add(0,"one");
        System.out.println("lst="+ lst);//lst=[one]
        // 向末尾位置插入元素
        lst.add(1,2);//int类型也可以使用是使用了，自动装箱技术
        System.out.println("lst="+ lst);//lst=[one, 2]
        //Student类没有自动装箱技术，所需要自己new对象
        // 没有指定下标，默认插入到末尾
        lst.add(new Student1(1001,"zhuzhu",18));//lst=[one, 2, Student [id=1001, name=zhuzhu, age=18]]
        System.out.println("lst="+ lst);
        // 向中间位置插入元素three
        // [one, 2, three, Student[id = 1001, name = zhuzhu, age = 18]]
        lst.add(2,"three");
        System.out.println("lst="+ lst);

2：get

 // 自调用调用toString方法，最终打印String类型的整体
        // 3.调用方法实现集合中元素的获取并打印 重点
//      普通输出：
        for (int i= 0;i< lst.size();i++){

//            System.out.println("下标为："+i+"的元素是："+lst.get(i));

        }

        // 使用get方法可以取出任意元素，相当于toString方法更加灵活
        //System.out.println("下标为" + i + "的元素是：" + lt1.get(i));
        StringBuilder sb1 =new StringBuilder();
        sb1.append("lst=[");
        for (int i=0;i<lst.size();i++){
            if (lst.size()-1==i){
                sb1.append(lst.get(i)).append(']');
            }else {
                sb1.append(lst.get(i)).append(",").append(" ");
            }
        }
        System.out.println(sb1);

3：set

       // 4.调用方法实现集合中元素的修改操作,set
//        lst=[one, 2, three, Student [id=1001, name=zhuzhu, age=18]]
        Integer it=(Integer) lst.set(1,"two");//只拿当前对象
        System.out.println("被修改的元素是"+it);//2
        System.out.println("修改后集合中的元素有："+lst);//修改后集合中的元素有：[one, two, three, Student [id=1001, name=zhuzhu, age=18]]
        // 由于集合中存放的所有内容都是按照Object类型放入的，因此取出来
        // 也就是Object类型，为了表达真实的类型需要强制类型转换
        Student1 s1=(Student1) lst.set(lst.size()-1,"four");
        System.out.println("被修改的元素是"+s1);//被修改的元素是Student [id=1001, name=zhuzhu, age=18]
        System.out.println("修改后集合中的元素有："+lst);//修改后集合中的元素有：[one, two, three, four]

4：remove

     // 5.调用方法实现集合中元素的删除操作,remove按照参数指定的下标进行删除
        String s2=(String) lst.remove(0);//取出来的元素都需要进行强转
        System.out.println("被删除的元素是"+s2);//one
        System.out.println("删除后集合中的元素有："+lst);//[two, three, four]
//      删除所有元素,下面循环中如果加上i++，那么就会删不干净，因为没删掉一个元素，所有元素往前移动
//     方法一：
        for (int i=0;i<lst.size();/*i++*/){
            System.out.println("被删除的元素是"+lst.remove(i));
        }
//        方法二
        while(lst.size()>0){
            System.out.println("被删除的元素是"+lst.remove(0));
        }

//        方法三：
        for (int i =lst.size()-1;i>=0;i--){
            System.out.println("被删除的元素是"+lst.remove(i));
        }
        System.out.println("最终集合中的元素有"+lst);

5：subList

     // 6.获取集合中的一部分内容
        List lt2=lst.subList(1,lst.size());
        System.out.println("获取到的子集合是："+lt2);//[two, three, four]
        System.out.println("lst="+lst);//lst=[one, two, three, four]

        // 删除子集合中的第一个元素
        String st=(String) lst.remove(0);
        System.out.println("被删除的元素是："+st);//one
        System.out.println("lst="+lst);//[three, four]

4.泛型机制(重点)

4.1 基本概念
通常情况下集合中可以存放不同类型的对象，本质上是将这些对象全部看做Object类型放入的，因此从集合中取出元素时也是Object类型，为了表达元素最真实的数据类型就需要强制类型转换，而强制类型转换可能发生类型转换异常。
为了避免上述错误的发生，从jdk1.5开始提出泛型机制，也就是在集合名称的右侧使用<数据类型>的方式明确要求该集合可以存放的元素类型，若放入其它类型则编译报错
如：
List lt1 = new LinkedList(); - 可以放入任意类型对象，取出麻烦
List lt1 = new LinkedList(); - 只能放入String类型，取出方便

4.2 原理分析
泛型的本质就是参数化类型，也就是让数据类型作为参数传递，集合定义中的E相当于形式参数负责占位，而使用集合时<>中的数据类型相当于实际参数负责给形式参数初始化，当初始化完毕后所有E被替换为实际参数表示的类型进行使用。
由于E支持的数据类型非常广泛，因此得名为"泛型".
如：
// 其中i叫做形式参数，负责占位 其中E叫做形式参数，负责占位
// int i = 5; E = String;
// int i = 10; E = Student;
public void show(int i) { public interface List {
… …
} }
// 其中5叫做实际参数，用于给形式参数初始化 其中String叫做实际参数
show(5); List lt1 = …;
show(10); List lt2 = …;

package setTest;

import java.util.LinkedList;
import java.util.List;

public class LinkedListTest {
    public static void main(String[] args) {
        // 1.使用泛型机制声明List集合的引用指向实现类的对象
        List<String> lt2= new LinkedList<String>();
        // 2.放入元素并打印,add
       lt2.add("one");
       lt2.add("two");
       lt2.add("three");
        System.out.println("lt2:"+lt2);


        // 3.取出元素并打印get
        String str1=lt2.get(0);
        System.out.println("取出的元素为："+str1);

        // 从jdk1.7开始增加新特性：后面<>中的数据类型可以省略  菱形特性
        //List<Integer> lt2 = new LinkedList<Integer>();
        List<Integer> lt3=new LinkedList<>();

    }
}

总结：
1：以后不管遇到那个类只有有就表示它支持泛型

作业：
1.复习和练习集合的常用方法并进行整理。
2.查询java.util.Stack类，实现将11 22 33 44 55依次入栈再出栈。

package setTest;

import java.util.ArrayList;
import java.util.Stack;

//  2.查询java.util.Stack类，实现将11 22 33 44 55依次入栈再出栈。
public class workTest {
    public static void main(String[] args) {
        Stack sta=new Stack();
//        sta.push(11);
//        sta.push(22);
//        sta.push(33);
//        sta.push(44);
//        sta.push(55);
        for (int i =1;i<6;i++){
            System.out.println("入栈的元素是："+sta.push(i*10+i));
        }
        System.out.println("栈中所有元素："+sta);
        for (int i=0;i<sta.size(); ) {
            System.out.println("出栈的元素"+sta.pop());
        }
        System.out.println("最终栈的结果："+sta);


    }
}

本篇完，希望看完对你来说有收获。

一步一步去提升，稳赢！！！
今天写英语作文学到的一句话：共勉》》》
With wisdom in the mind, I suppose it is not hard to have money in the hand.