java高级开发 第十三章——泛型与集合框架

最新推荐文章于 2024-05-21 15:32:45 发布
最新推荐文章于 2024-05-21 15:32:45 发布
阅读量959 收藏 24
点赞数 30
文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NLxxxxX/article/details/135970699
版权

一、泛型 

1.泛型类   

                 

E是其中的泛型，代表一种数据类型，可以是类或接口，不能是基本数据类型。泛型可以作为类的成员变量的类型，方法的类型，局部变量的类型。

带有泛型的类称为泛型类。

使用泛型类声明对象

(1)用具体的类型代替E

(2)使用通配符？

Cone<? extends Geometry> cone=new Cone<Circle>(c);

//Geometry类或Geometry的子类或实现了Geometry接口的类

Cone<? super B> cone;   //B类或者B的任何父类

Cone<?> cone=new Cone<Circle>(c);

2.泛型接口   

    interface Computer<E,F>{

             void makeChorus(E x,F y);

    }

通过类实现这个接口时可以指定泛型的具体类型，也可以不指定。

3.练习
（1）泛型类、三棱锥

public class xx {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Circle c = new Circle(4);// 调用该类的构造方法
        Cone<Circle> cone = new Cone<Circle>(c, 10);
        System.out.println(cone);
        Triangle d=new Triangle(3.2,5.3,9.4);
        Cone<Triangle> de = new Cone<Triangle>(d,2);
        System.out.println(de);
     }

}

class Cone<E> {
    E bottom;
    double height;

    public Cone(E bottom, double height) {
        super();
        this.bottom = bottom;
        this.height = height; // 构造方法：生成一个全参构造方法
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    @Override
    public String toString() {
        return "Cone [bottom=" + bottom + ", height=" + height + "]";
    }

}

class Circle {
    double r;

    public Circle(double r) {
        super();
        this.r = r;
    }

    public double getR() {
        return r;
    }

    public void setR(double r) {
        this.r = r;
    }

    @Override
    public String toString() {
        return "Circle [r=" + r + "]";
    }

}
class Triangle{                //三棱锥
    double a,b,c;

    public Triangle(double a, double b, double c) {
        super();
        this.a = a;
        this.b = b;
        this.c = c;
    }

    public double getA() {
        return a;
    }

    public void setA(double a) {
        this.a = a;
    }

    public double getB() {
        return b;
    }

    public void setB(double b) {
        this.b = b;
    }

    public double getC() {
        return c;
    }

    public void setC(double c) {
        this.c = c;
    }

    @Override
    public String toString() {
        return "Triangle [a="+ a + ", b=" + b + ", c=" + c + ";]";
    }
}


（2）泛型接口

public class xx {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Printer p1=new Printer();//构造方法
        People people=new People("小明");
        p1.print(people);
            }

        }
            interface printable<E>{        //泛型接口
            public void print(E x);//抽象方法，无方法体--{}        
            }
        class Printer implements printable<People> {
            
            @Override
            public void print(People x) {
                // TODO Auto-generated method stub
                System.out.println(x.getName());
            }
            
        }
        class People{
            String name;

            public People(String name) {
                super();
                this.name = name;
            }

            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }
            
        }
          

二、链表

  • 链表  

是由若干个结点组成的一种数据结构，每个结点含有一个数据和一个(两个)引用，指向上一结点或下一结点。

LinkedList<E>泛型类

该泛型类创建的对象以链表结构存储数据，常称为链表对象。

LinkedList<String> mylist=new LinkedList<String>();

public boolean add(E element) 

public void add(int index,E element) 

public void clear() 

public E remove(int index)  

public boolean remove(E element)   //删除首次出现的element

public E get(int index)  

public int indexOf(E element)  

public int lastIndexOf(E element)  

public E set(int index,E element)   //返回被替换的数据

public int size()  

public boolean contains(Object element)   

public void addFirst(E element)   

public void addLast(E element)   

public E getFirst()   

public E getLast()   

public E removeFirst()   

public E removeLast()   

public Object clone()   

链表的遍历

使用iterator()方法获得Iterator迭代器，用迭代器遍历。

Iterator<String> iter=mylist.iterator();

练习：链表、整数链表

import java.util.Iterator;
import java.util.LinkedList;
public class xx {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //链表数据是字符串
        LinkedList<String> list1=new LinkedList<String>();
        list1.add("小白");
        list1.add("小黑");
        list1.add("小粉");
        Iterator<String> iter=list1.iterator();//获得迭代器
        while(iter.hasNext()) {  //判断是否有下一个元素
            String s=iter.next();  //得到下一个原素
            System.out.println(s);
        }
        //链表数据是整数
        LinkedList<Integer> list2=new LinkedList<Integer>();
        list2.add(3);
        list2.add(4);
        list2.add(5);
        Iterator<Integer> itera=list2.iterator();//获得迭代器
        while(itera.hasNext()) {  //判断是否有下一个元素
            Integer s=itera.next();  //得到下一个原素
            System.out.println(s);
            }

        }
        }
         

三、堆栈、散列映射、树集

  • 堆栈 

是一种“后进先出”的数据结构。只能从一端输入输出数据。使用Stack<E>泛型类可以创建堆栈对象。

创建堆栈对象：

Stack<Integer> stack=new Stack<Integer>();

方法：

public E push(E item);    //入栈

public E pop();   //出栈

public boolean empty();   //判断堆栈是否为空

public E peek();  //获取堆栈顶端的数据，但不删除该数据。

public int search(Object data);  //获取数据在堆栈中的位置，最顶端的位置是１，向下依次增加，如果堆栈不含此数据，则返回-1。

  • 散列映射    

映射表(map)依照“键/值”对(key,value)来存储元素。映射表将键和值一起保存，一个键和它对应的值构成一个条目保存在映射表中。键不能重复，可以是任意类型的对象,每个键对应一个值。键又称搜索键，用来查找相应的值。

散列一般指哈希(hash),散列函数(哈希函数)是一种将键映射到表(map)中索引上的函数。散列函数从一个键获得索引，并使用索引来获得该键的值。散列就是一种无须执行搜索，即可通过键得到索引来获取值的技术。

HashMap<K,V> 泛型类创建的对象称为散列映射。

HashMap<String,Student> hashmap=new HashMap<String,Student>();

常用方法：

public V put(K key,V value);   //添加键值对

public boolean containsKey(Object key)  

public boolean containsValue(Object value) 

public V get(Object key)  

public int size() 

遍历：

Collection<Student> collection=hashmap.values();
        Iterator<Student> iter=collection.iterator();
        while(iter.hasNext()) {
            Student stu=iter.next();
            System.out.println(stu.getName()+stu.getNumber());
        }

  • 树集 

树集采用树结构存储数据，树结点中的数据会按存放数据的“大小"顺序依次排列，在同一层中的结点从左到右从小到大的顺序递增排列，下一层比上一层小。

TreeSet<E>泛型类创建的对象称为树集。

TreeSet<String> tree=new TreeSet<String>();

常用方法：

public boolean add(E o)　

public void clear()

public boolean contains(Object o)

public E first()

public E last()

注意：树集中的结点要能比较大小。

练习
1.栈

import java.util.Stack;

public class xx {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Stack<Integer> s1 = new Stack<Integer>();
        s1.push(1);
        s1.push(1);
//循环十次
        int n = 1;
        while (n <= 10) {

            int f2 = s1.pop();
            int f1 = s1.pop();
            int next = f1 + f2;
            s1.push(f2);
            s1.push(next);
//打印
            System.out.print(next + " ");
            n++;

        }
    }
}

2.散列映射

（1)Student类的定义

public class Student implements Comparable{
    //属性:学号，姓名
        int num;
        String name;
        int englishfen;
        //全参构造方法
        public Student(int num, String name) {
            super();
            this.num = num;
            this.name = name;
        }
        //
        public Student(int num, String name, int englishfen) {
            super();
            this.num = num;
            this.name = name;
            this.englishfen = englishfen;
        }
        public Student(String name, int englishfen) {
            super();
            this.name = name;
            this.englishfen = englishfen;
        }
        public Student(int num, int englishfen) {
            super();
            this.num = num;
            this.englishfen = englishfen;
        }
        //get.set
        public int getNum() {
            return num;
        }
        public void setNum(int num) {
            this.num = num;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    @Override
        public String toString() {
            return "Student [num=" + num + ", name=" + name + ", englishfen=" + englishfen + "]";
        }
        
        
    @Override
    public int compareTo(Object arg0) {
        // TODO Auto-generated method stub
        Student stu=(Student) arg0; //强制类型转换
        
        return this.englishfen-stu.englishfen;    //    用英语课程成绩排序
    }
    }

（2）main方法

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;

public class xx {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        HashMap<String, Student> hashmap = new HashMap<String, Student>();
        hashmap.put("201", new Student(01,"小白"));
        //仿照，再加2条目
        hashmap.put("202", new Student (02,"小黑"));
        hashmap.put("203", new Student(03,"小粉"));

        Collection<Student> collection=hashmap.values();//获得所有values，放在集合collection中
        Iterator<Student> iter=collection.iterator();//通过集合获得迭代器
        while(iter.hasNext()) {    // 使用迭代器打印信息
            Student stu=iter.next();
            System.out.println(stu);
        }
    }

}

3.树集

（1）Student类的定义

public class Student implements Comparable{
    //属性:学号，姓名
        int num;
        String name;
        int englishfen;
        //全参构造方法
        public Student(int num, String name) {
            super();
            this.num = num;
            this.name = name;
        }
        //
        public Student(int num, String name, int englishfen) {
            super();
            this.num = num;
            this.name = name;
            this.englishfen = englishfen;
        }
        public Student(String name, int englishfen) {
            super();
            this.name = name;
            this.englishfen = englishfen;
        }
        public Student(int num, int englishfen) {
            super();
            this.num = num;
            this.englishfen = englishfen;
        }
        //get.set
        public int getNum() {
            return num;
        }
        public void setNum(int num) {
            this.num = num;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    @Override
        public String toString() {
            return "Student [num=" + num + ", name=" + name + ", englishfen=" + englishfen + "]";
        }
        
        
    @Override
    public int compareTo(Object arg0) {
        // TODO Auto-generated method stub
        Student stu=(Student) arg0; //强制类型转换
        
        return this.englishfen-stu.englishfen;    //    用英语课程成绩排序
    }
    }

（2）main方法

import java.util.Iterator;
import java.util.TreeSet;
public class xx {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TreeSet <String> t=new TreeSet<> ();
        t.add("aa");
        t.add("ee");
        t.add("cc");
        Iterator<String> i=t.iterator();
        
        while(i.hasNext()) {
            String te=i.next();
            System.out.println(te);
        }
        
        TreeSet<Integer> tr=new TreeSet<>();
        tr.add(11);
        tr.add(99);
        tr.add(25);
        Iterator<Integer> it=tr.iterator();
        while(it.hasNext()) {
            Integer in=it.next();
            System.out.println(in);
        }
        
        TreeSet<Student> st=new TreeSet<>();

        st.add(new Student(11,"小夜",65));
        st.add(new Student(60,"小多",60));
        st.add(new Student(30,"小云",95));
        Iterator<Student> ite=st.iterator();
        while(ite.hasNext()) {
            Student s=ite.next();
            System.out.println(s);
        }
        }
    }
 

四、树映射、集合

  • 树映射 

称TreeMap<K,V>对象为树映射。如：

TreeMap<Key,Student> treemap=new TreeMap<Key,Student>();

常用方法：public V put(K key,V value);

按key升序排列。

遍历：

Collection<Student> collection=treemap.values();
        Iterator<Student> iter=collection.iterator();
        while(iter.hasNext()) {
            Student stu=iter.next();
            System.out.println(stu.getName()+stu.getEnglish());
        }

  • 集合 

HashSet<E>泛型类创建的对象称为集合。如：

HashSet<Student> set=new HashSet<Student>();

添加到集合中的数据称做集合的元素。集合不允许有相同的元素。

集合的遍历

集合的运算

boolean retainAll(HashSet set)当前集合成为两个集合的交集。

boolean addAll(HashSet set)当前集合成为两个集合的并集。

boolean removeAll(HashSet set)当前集合成为两个集合的差集。

这就是鱼头
关注
  • 30
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java高级特性 第一章 集合框架和泛型
10-23
简单地做了下笔记作为参考。（不是很详细）
《Java面向对象程序设计》学习笔记——第 13 章 泛型与集合框架
weixin_45940369的博客
08-31 2128
Java 提供了实现常见数据结构的类，这些实现数据结构的类通称为 Java 集合框架。 在 JDK1.5 后， Java 集合框架开始支持泛型，本章首先介绍泛型，然后讲解常见数据结构类的用法。
基于《java2实用教程》的java知识点复习整理【第十五章——Java泛型与集合框架】
农夫的码，没有草原
05-07 731
第十五章——Java泛型与集合框架 一、知识结构框架 二、知识点详解 ###1、泛型 编写的代码可以被不同类型的对象所重用，主要目的是可以建立具有类型安全的集合框架。 1.1 泛型类 具有泛型变量的类，在类名后用代表引用类型，如ArrayList，HashMap，HashSet //ArrayList部分源码 public class ArrayList<E> extends AbstractList<E> implements List<E>,RandomAc
张小飞的Java之路——第三十五章——泛型类
x_ai_bian_cheng的博客
05-14 45
张小飞的Java之路——第三十五章——泛型类
张小飞的Java之路——第三十四章——泛型
x_ai_bian_cheng的博客
05-11 54
张小飞的Java之路——第三十四章——泛型
Java教学课件PPT第7章 泛型和集合框架.ppt
08-06
Java教学课件PPT
Java集合框架及泛型
10-11
集合框架及泛型的介绍和基础理解，方便大家了解集合框架及泛型。
学士后Java集合框架和泛型课后习题答案
02-28
学士后Java集合框架和泛型课后习题答案 希望能够帮助大家更好的学习JAVA，这些知识还是比较基础的，并没有多大难度 一起共同进步
JAVA泛型与集合框架PPT课件PPT学习教案.pptx
10-07
JAVA泛型与集合框架PPT课件PPT学习教案.pptx
jar包增量更新分析
junlaiyan的专栏
05-16 263
借助jdeps分析出jar包的增量文件
SpringBoot接入Knife4j接口文档
博主是个二次元死肥宅~
05-18 697
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
java实现拼图小游戏
monkey108的博客
05-16 625
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 906
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
SpringBoot Validation自定义注解之校验指定最小整数
thinkers
05-21 25
1，引入核心关键依赖。
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 248
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
JVM学习-执行引擎
最新发布
丢爸
05-21 418
当然是否需要启动JIT编译器将字节码直接编译为对应平台的本地机器指令，则需要根据代码被调用。大部分的程序代码转换为物理机的目标代码或虚拟机能执行的指令集之前，都需要经过下图各个步骤。，将其直接编译为对应平台的本地机器指令，以此提升Java程序的执行性能。”，JIT编译器在运行时会针对那些频繁被调用的热点代码做出。Java代码编译是由Java源码编译器来完成，流程图如下。而定，关于那些需要被编译为本地代码的字节码，称为“Java字节码的执行是由JVM执行引擎来完成。
C++ 11
qq_65112813的博客
05-17 655
对于类类型，如果定义了接受。
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1025
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
泛型与集合框架--随机点名小程序
05-19
好的，让我们来一起编写一个随机点名的小程序，使用到泛型和集合框架。 首先，我们需要定义一个学生类，包含学生的姓名和学号： ```java public class Student { private String name; private String id; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值