java 集合框架 泛型--15

Java面试题(基础篇),15个经典面试问题及回答思路 金三银四到了,送上一个小福利!利![外链图片转存中…(img-qvSxwqCw-1711755580359)][外链图片转存中…(img-CYtxVCp6-1711755580360)][外链图片转存中…(img-k2wnA5eT-1711755580360)] 阅读详情

TreeSet

Set:无序,不可重复元素
——|–hashSet:数据结构是哈希表。线程是非同步的
————保证元素唯一性的原理:判断元素的hasCode值是否相同
————如果相同,还会继续判断元素的equals方法,是否为true

——|–treeSet:可以对Set集合中的元素进行排序。
————底层数据结构是二叉树
————保证元素唯一性的依据:
————compareto方法return 0。

TreeSet排序的第一种方式:
让元素自身具备比较性,元素需要实现Comparable接口。覆盖compareTo方法
这种方式也称为元素的自然顺序,或者叫做默认顺序。

TreeSet的第二种排序方式。
当元素自身不具备比较性时,或者具备的比较性不是所需要的
这时就需要让集合自身具备比较性。
在集合初始化时,就有了比较方式。

需求:
往TreeSet集合中存储自定义对象学生
想按照学生的年龄进行排序

import java.util.*;

class TreeSetDemo
{
    public static void main(String[] args)
    {
        TreeSet ts = new TreeSet();

        ts.add(new Student("lisi02",11));
        ts.add(new Student("lisi02",12));
        ts.add(new Student("lisi06",20));
        ts.add(new Student("lisi07",20));
        ts.add(new Student("lisi09",17));

        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            Student stu = (Student)it.next();
            System.out.println(stu.getName()+"...."+stu.getAge());
        }
    }
}

class Student implements Comparable//该接口强制让学生具备比较性
{
    private String name;
    private int age;

    Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }

    public int compareTo(Object obj)
    {
        if(!(obj instanceof Student))
            throw new RuntimeException("不是学生对象");

        Student s = (Student)obj;

        System.out.println(this.name+"...compareTo..."+s.name);

        if(this.age > s.age)
            return 1;
        else if(this.age == s.age)
            return this.name.compareTo(s.name);//排序时,当主要条件相同,一定要判断次要条件

        return -1;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}

这里写图片描述

本代码先比较年龄,如果年龄相同,再比较姓名。实现了Comparable接口,复写并调用了compareTo方法进行比较。

TreeSet的第二种排序方式。
当元素自身不具备比较性时,或者具备的比较性不是所需要的
这时就需要让集合自身具备比较性。
在集合初始化时,就有了比较方式。

当元素自身不具备比较性,或者具备的比较性不是所需要的
这时需要让容器自身具备比较性
定义了比较器,将比较器对象作为参数传递给TreeSet集合的构造函数。

import java.util.*;
/*
class Student implements Comparable//该接口强制让学生具备比较性
{                                  //这个类在本代码中并没有起作用
    private String name;
    private int age;

    Student(String name,int age)
    {
        this.name= name;
        this.age = age;
    }
    public int compareTo(Object obj)
    {
        if(!(obj instanceof Student))
            throw new RuntimeException("不是学生对象");
        Student s = (Student)obj;

        System.out.println(this.name+"...compareto..."+s.name);

        if(this.age>s.age)
            return 1;
        if(this.age==s.age)
            return this.name.compareTo(s.name);
        return -1;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}
*/
class TreeSetDemo2
{
    public static void main(String[] args)
    {
        TreeSet ts = new TreeSet(new MyCompare());

        ts.add(new Student("lisi002",11));
        ts.add(new Student("lisi03",12));
        ts.add(new Student("lisi02",13));
        ts.add(new Student("lisi06",20));
        ts.add(new Student("lisi07",22));
        ts.add(new Student("lisi09",17));

        Iterator it = ts.iterator();

        while(it.hasNext())
        {
            Student stu = (Student)it.next();
            System.out.println(stu.getName()+"..."+stu.getAge());
        }
    }
}

class MyCompare implements Comparator //真正起作用的是这个
{
    public int compare(Object o1,Object o2)
    {
        Student s1 = (Student)o1;
        Student s2 = (Student)o2;

        int num = s1.getName().compareTo(s2.getName());

        if(num==0)
        {
            return s1.getAge()-s2.getAge();//这三块代码都是一样的,下面两个比较麻烦。

            //return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));

            /*
            if(s1.getAge()>s2.getAge())
                return 1;
            if(s1.getAge()==s2.getAge())
                return 0;   
            return -1;
            */              

        }

        return num;
    }
}

当两种排序都存在时,以比较器为主,就是Comparator:
方法是定义一个类,实现Comparator接口。覆盖compare方法。

这里写图片描述

Comparator里面是compare方法
Comparable里面是compareTo方法

练习:按照字符串长度排序。

字符串本身具备比较性,但是他的比较方式不是所需要的
这时就只能使用比较器

import java.util.*;

class TreeSetTest
{
    public static void main(String[] args)
    {
        TreeSet ts = new TreeSet();
        ts.add("abcd");
        ts.add("cc");
        ts.add("cba");
        ts.add("a2a");
        ts.add("z");
        ts.add("hahaha");

        Iterator it = ts.iterator();

        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}
class StrLenComparator implements Comparator
{
    public int compare(Object o1,Object  o2)
    {
        String s1 = (String)o1;
        String s2 = (String)o2;

        int num = new Integer(s1.length()).compareTo(new (s2.length()));

        if(num == 0)
            return s1.compareTo(s2);
        return num;
    }
}

这里写图片描述

泛型

泛型:JDK1.5以后出现新特性,用于解决安全问题,是一个类型安全机制

好处
1.将运行时期出现的问题ClassCastException转移到编译时期
方便于程序员解决问题,让运行时期问题减少,安全

2.避免了强转麻烦

泛型格式:
通过<>来定义要操作的引用数据类型
在使用java提供的对象时,什么时候写泛型?

通常在集合框架中很常见,只要见到<>就要定义泛型

其实<>就是用来接受类型的。
当使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可

import java.util.*;

class GenericDemo
{
    public static void main(String[] args)
    {

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

        al.add("abc01");
        al.add("abc0991");
        al.add("abc014");

        Iterator<String> it = al.iterator();

        while(it.hasNext())
        {
            String s = it.next();

            System.out.println(s+":"+s.length());
        }
    }
}

这里写图片描述

import java.util.*;

class GenericDemo2
{
    public static void main(String[] args)
    {
        TreeSet<String> ts = new TreeSet<String>(new LenComparator()    );

        ts.add("abcd");
        ts.add("cc");
        ts.add("cba");
        ts.add("aaa");
        ts.add("z");
        ts.add("hahaha");

        Iterator<String> it = ts.iterator();

        while(it.hasNext())
        {
            String s = it.next();
            System.out.println(s);
        }

    }
}

class LenComparator implements Comparator<String>
{
    public int  compare(String s1,String s2)
    {
        //int num = new Integer(s2.length()).compareTo(new Integer(s1.length()));
        int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));

        if(num==0)
            return s1.compareTo(s2);
        return num;
    }
}

s1和s2位置调换,分别按照不同的方式打印。从短到长,从长到短。

这里写图片描述

泛型出现前后的不同做法

class Worker
{

}

class Student
{

}
//泛型前做法
class Tool
{
    private Object obj;
    public void setObject(Object obj)
    {
        this.obj = obj;
    }
    public Object getObject()
    {
        return obj;
    }
}

//泛型出现的做法
//当类中要操作的引用数据类型不确定的时候
//早期定义Object来完成扩展,现在定义泛型来完成扩展
class Utils<qq>
{
    private qq q;
    public void setObject(qq q)
    {
        this.q = q;
    }
    public qq getObject()
    {
        return q;
    }
}
class GenericDemo3
{
    public static void main(String[] args)
    {
        /*泛型前做法
        Tool t = new Tool();
        t.setObject(new Worker());
        Worker w = (Worker)t.getObject();
        */

        Utils<Worker> u = new Utils<Worker>();
        u.setObject(new Worker());
        //Worker w = (Worker)u.getObject();有泛型就不用强转了。
        Worker w = u.getObject();
    }
}

泛型类定义的泛型,在整个类中有效。如果被方法使用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了
为了让不同的方法可以操作不同类型,而且类型还不确定
那么可以将泛型定义在方法上

class Demo
{
    public <T> void show(T t)
    {
        System.out.println("show:"+t);
    }
    public <Q> void print(Q q)
    {
        System.out.println("print:"+q);
    }

}
class GenericDemo4
{
    public static void main(String[] args)
    {

        Demo d = new Demo();
        d.show("hah");
        d.show(9);
        d.show(new Integer(5));
        d.print(7);

    }
}

当方法上跟类上都有泛型

class Demo<T>
{
    public void show(T t)
    {
        System.out.println("show:"+t);
    }
    public <Q> void print(Q q)
    {
        System.out.println("print:"+q);
    }
}
class GenericDemo4
{
    public static void main(String[] args)
    {

        Demo<String> d = new Demo<String>();
        d.show("hah");
        d.show(4);//会编译失败
        d.print(7);

    }
}

show方法类型跟着类上的规定泛型走,print方法有自己的泛型。

特殊之处:
静态方法不可以访问类上定义的泛型
如果静态方法操作的引用数据类型不确定,可以将泛型定义在方法上

class Demo<T>
{
    public void show(T t)
    {
        System.out.println("show:"+t);
    }
    public <Q> void print(Q q)
    {
        System.out.println("print:"+q);
    }
    public static<W> void method(W t)//特殊之处
    {
        System.out.println("method:"+t);
    }
}
class GenericDemo4
{
    public static void main(String[] args)
    {

        Demo<String> d = new Demo<String>();
        d.show("hah");
        d.print(7);

        Demo.method("hahhahahha");
    }
}

这里写图片描述

泛型定义在接口上

interface Inter<T>
{
    void show(T t);
}

/*
class InterImpl implements Inter<String>//第一种
{
    public void show(String t)
    {
        System.out.println("show:"+t);
    }
}
*/

class InterImpl<T> implements Inter<T>
{
    public void show(T t)
    {
        System.out.println("show:"+t);
    }
}

class GenericDemo5
{
    public static void main(String[] args)
    {
        //第一种在类初始化的时候就规定了参数类型
        //InterImpl i = new InterImpl();
        //i.show("haha");

        //第二种可以定义不同的对象,指定不同的参数类型
        InterImpl<Integer> i = new InterImpl<Integer>();
        i.show(5);

        InterImpl<String> in = new InterImpl<String>();
        in.show("java");

    }
}

这里写图片描述

通配符 ? 的使用

? 通配符,也可以理解成站位符,明确不了泛型,用?占位一下。
泛型的限定:
? extends E:可以接受 E类型或者E类型的子类,上限限定
? super E:可以接收E类型或者E的父类型。下限限定

import java.util.*;

class GenericDemo6
{
    public static void main(String[] args)
    {
        ArrayList<String> al = new ArrayList<String>();

        al.add("abc1");
        al.add("abc2");
        al.add("abc3");

        ArrayList<Integer> al1 = new ArrayList<Integer>();
        al1.add(4);
        al1.add(5);
        al1.add(6);

        printColl(al);
        printColl(al1);
    }   
    public static void printColl(ArrayList<?> al)
    {
        Iterator<?> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }

}
import java.util.*;

class GenericDemo6
{
    public static void main(String[] args)
    {
        ArrayList<Person> al = new ArrayList<Person>();
        al.add(new Person("absc2d"));
        al.add(new Person("ab3"));
        al.add(new Person("ab56d"));
        al.add(new Person("abqd"));
        printColl(al);


        ArrayList<Student> al1 = new ArrayList<Student>();
        al1.add(new Student("122"));
        al1.add(new Student("huj"));
        al1.add(new Student("sd"));
        al1.add(new Student("vxd"));
        printColl(al1);
    }   

    public static void printColl(ArrayList<? extends Person> al)
    {
        Iterator<? extends Person> it = al.iterator();

        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        }
    }

}

class Person
{
    private String name;
    Person (String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }

}
class Student extends Person
{
    Student(String name)
    {
        super(name);
    }
}

泛型限定用于泛型扩展

import java.util.*;
class GenericDemo7
{
    public static void main(String[] args)
    {
        TreeSet<Student> ts = new TreeSet<Student>(new Comp());

        ts.add(new Student("abc01"));
        ts.add(new Student("abc05"));
        ts.add(new Student("abc03"));
        ts.add(new Student("abc07"));

        Iterator<Student> it = ts.iterator();

        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        }

        TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());

        ts1.add(new Worker("Wabc02"));
        ts1.add(new Worker("Wabc06"));
        ts1.add(new Worker("Wabc04"));
        ts1.add(new Worker("Wabc08"));

        Iterator<Worker> it1 = ts1.iterator();

        while(it1.hasNext())
        {
            System.out.println(it1.next().getName());
        }

    }
}

class Comp implements Comparator<Person>
{
    public int compare(Person p1, Person p2)
    {
        return p2.getName().compareTo(p1.getName());
    }
}

class Person
{
    private String name;
    Person (String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }
    public String toString()
    {
        return "person:"+name;
    }

}
class Student extends Person
{
    Student(String name)
    {
        super(name);
    }

}
class Worker extends Person
{
    Worker(String name)
    {
        super(name);
    }
}

这里写图片描述

一窥Memory测试算法及自我修复机制 摘要 为了满足新一代设备的需求,Memory的大小每三年就会增加4倍。深亚微米设备包含大量面积更小、访问速度更快的Memory。针对此类设计制定自动测试策略可以减少ATE(自动测试设备)的时间和成本。 内存故障的行为与经典的“Stuck-At”故障不同。因此,Memory的故障模型(由于其阵列结构)与标准逻辑的设计也是不同的。Memory测试除了进行故障检测和定位,还可以实现用冗余单元对... 阅读详情

相关推荐

【AutoDL】使用云服务器跑深度学习代码

1.算力市场 租用服务器,选择自己心仪的服务器2.镜像可以选择一些基础的镜像,社区镜像里是git上有的环境。3.上传文件在文件存储中,选择上传的区,在右边点击上传,选择自己的文件上传到云服务器中。

weixin_45768644的博客 3706

Java集合框架与泛型详解

一、java集合框架 1、集合类与容器 为什么出现集合类? 面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就要对对象进行存储,集合就是存储对象最常用的一种方式。 数组和集合类同是容器,有何不同? 数组元素既可以是基本数据类型的数据,也可以是引用数据类型的数据。而集合里只能存储引用数据类型。 数组一旦定义后,长度不可变。而集合的长...

Iefegend的专栏 864

从理想光源到部分相干:Abbe与Hopkins模型在计算光刻中的演进与选择

本文深入探讨了计算光刻中Abbe模型与Hopkins模型的演进与选择,分析了理想光源与部分相干光源在光刻仿真中的关键差异。Abbe模型基于理想点光源假设,计算简洁但存在精度局限;Hopkins模型则通过互强度函数和TCC技术,更准确地模拟现实中的部分相干光源,尤其适用于先进节点光刻工艺。文章还提供了模型选择的实用建议,帮助工程师在精度与效率间取得平衡。

weixin_29217235的博客 300

java第15章总结(泛型与集合框架)

教材内容总结 泛型 其主要目的是可以建立具有类型安全的集合框架,如链表、散列映射等数据结构。 可以使用“class 名称&lt;泛型列表&gt;”声明一个类,为了和普通的类有所区别,这样声明的类称作泛型类, 如:class People&lt;E&gt; 。  使用泛型类声明 Cone&lt;Ciecle&gt; coneOne; coneOne = new Cone&lt;Circ...

weixin_41842123的博客 898

告别误唤醒!S32K3xx低功耗设计避坑指南:Fast Standby模式与WISR寄存器操作详解

本文深入解析了NXP S32K3xx系列MCU在低功耗设计中常见的误唤醒问题,并提供了基于Fast Standby模式的解决方案。文章重点剖析了DCMRWF5寄存器的配置方法、WISR/WISR_64唤醒中断状态寄存器的标志位处理策略,以及如何利用32KB Standby SRAM保存唤醒状态,从而帮助开发者构建稳定可靠的汽车电子低功耗系统。

weixin_29163857的博客 366

手把手教你用vLLM在昇腾910B上部署Qwen3-Embedding-8B模型(保姆级避坑指南)

本文详细介绍了如何在昇腾910B芯片上使用vLLM推理引擎部署Qwen3-Embedding-8B模型的全流程,包括环境准备、vLLM-ascend定制化安装、模型获取与校验、环境变量配置、服务启动参数优化、性能压测及生产级部署建议。特别针对昇腾生态的开发者,提供了保姆级的避坑指南和实用技巧,帮助实现高效稳定的模型部署。

weixin_28726671的博客 466

15.为什么要使用Java集合框架(List、Set、Map...)?泛型集合?

一个Java对象可以在内部持有若干其他Java对象,并对外提供访问接口,把这种Java对象称为集合(1)对外的接口(2)接口的实现(3)对集合运算的算法:表示集合的抽象数据类型,如Collection、List、Set、Map、Iterator:集合框架中接口的具体实现,最常用实现:ArrayList、LinkedList、HashMap、HashSet:在一个实现了集合框架中的接口的对象上完成某种有用的计算机算法。

相互学习 共同进步 581

基于C#的ASP.NET开发的党史学习网站课设

开展党史学习教育,就是要以史为镜、以史明志,把苦难辉煌的过去、日新月异的现在、光明宏大的未来贯通起来,在鉴往知来中砥砺前行,在乱云飞渡中把准航向,在凝心聚力中团结奋斗,共同创造新的历史伟业。登陆按钮与数据库进行连接,逻辑实现是如图3.1.3所示,自己定义一个SQL查询语句,将账号、密码放入SQL查询语句中,用sqlDataReader.HasRows语句进行逐一比较,找出结果,将用户名存入session并调用cookies,如果结果存在就关闭数据库,进行数据跳转,并弹出登陆成功的提示框,并关闭数据库。

m0_62408555的博客 975

Java学习第15-16天:集合框架之Map和泛型(半壁江山了)

------- android培训、java培训、期待与您交流! ---------- Until15 集合框架 1、Treeset 2、Treeset存储自定义对象 3、二叉树 4、实现comparator方法排序 5、Treeset练习 6、泛型概念 7、泛型使用 8、泛型类 9、泛型方法 10、静态方法泛型 11、泛型接口 12、泛型限定·   注意:

oBaiLan的专栏 1026

C#上位机入门全指南:从零搞懂工业自动化的「大脑中枢」,看完就能写第一个采集程序

C#上位机的入门门槛真的不高,它难的从来不是语言本身,是对工业场景的理解,是工程化的稳定落地。很多人学了一堆语法、背了一堆协议,还是做不好项目,就是因为忽略了最朴素的道理:工业软件的核心价值,是稳、是好用、是能解决现场的实际问题。如果你刚入行,不用焦虑,从第一个采集程序开始写,从第一个项目开始踩坑,慢慢积累,很快就能上手。工控这个领域,经验永远比新技术重要,沉下心做两年,你也能成为独当一面的工程师。

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 364

YOLOv8改进策略【Neck】| BiFPN:双向特征金字塔网络-跨尺度连接和加权特征融合

可扩展的高效物体检测BiFPN(加权双向特征金字塔网络)

Limiiiing的博客 1082

黑马程序员_JAVA笔记15——集合框架(泛型)

------- android培训、java培训、期待与您交流! ---------- 1、泛型:JDK1.5后出现的新特性,用于解决安全问题,是一个安全机制。 好处:         将运行时期出现问题ClassCastException异常,转移到编译时期,方便于程序员解决问题,让运行时期问题减少,提高安全。         避免了强制类型转换的麻烦 泛型理解:数组在

u011453546的专栏 725

Xilinx系FPGA学习笔记(三)Vivado的仿真及ILA使用

接着学习vivado的使用方法。

贾saisai的博客 2547

黑马毕向东Java课程笔记(day15-6——15-13):集合类(集合框架)——泛型+集合对象排序与比较+JDK9对集合的优化+Debug

1、泛型概述级示例   泛型的特点如下 泛型:JDK1.5版本以后出现新特性,用于解决安全问题,是一个类型安全机制。用于限定类型,避免出现ClassCastException类型转换异常! 好处 1.将运行时期出现问题ClassCastException,转移到了编译时期,方便于程序员解决问题,让运行时问题减少,安全。 2,避免了强制转换麻烦。   泛型示例1 /* 练习:按照字符串长度...

LKJgdut的博客 307

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

《Java 2 实用教程》课程学习(15)——第15章 泛型与集合框架

qq_34573534的博客 314

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

10个常见的Java面试问题及其答案

*答案:**反射API是Java提供的一组用于检查和修改类、接口、字段和方法的信息的API。**答案:**泛型是Java SE 5.0引入的一个新特性,它允许在定义类、接口和方法时使用类型参数。**答案:**Java集合框架提供了一套性能优化的、可灵活扩展的、以及协同操作的接口和类,用于组织和管理对象。**答案:**Java的垃圾回收机制是自动管理不再使用的对象的内存的过程。**答案:**Java的主要特性包括面向对象、平台无关、自动内存管理、安全性、多线程支持、丰富的API和强大的社区支持。

2509_92429708的博客 435

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

深入理解Java集合框架

Java集合框架是开发中非常重要的部分,它提供了一组用于存储和操作数据的类和接口。通过学习Java集合,我们可以更加灵活高效地处理数据。

2302_80084329的博客 605

泛型

Java 泛型是 Java 5 引入的一种特性,用来在定义类、接口和方法时使用类型参数。

m0_73603082的博客 356

Java 集合框架

特性:有序集合,可包含重复元素。:随机访问速度快,中间插入删除速度较慢尾部操作较快。(使用动态数组实现,由于数组的存储结构是连续的内存块,通过索引可以直接定位到任何一个元素,时间复杂度为 O(1),因此随机访问速度非常快,但是进行插入或删除操作时,尤其是在中间位置,可能需要移动大量元素以保持数组的连续性,因此在中间位置插入和删除操作较慢,在数组头尾的话插入和删除操作则较快):插入删除速度快,随机访问速度较慢。

weixin_44711513的博客 1667

Java泛型基础概念

通过掌握 Java 泛型的基本概念和实际应用,开发者能够编写更灵活、复用性更高且类型安全的代码。这不仅提高了代码的可维护性,还能在编译时避免许多潜在的错误。无界通配符:可以接受任何类型。有界通配符extends T>:类型必须是T或T的子类。下界通配符super T>:类型必须是T或T的超类。> list) {

qq_40697623的博客 751

Java笔试面试题AI答之集合(4)

综上所述,集合框架中的泛型通过提供类型安全、消除强制类型转换、提高代码的可读性和可维护性、提高性能以及与集合框架的集成等优点,极大地增强了Java集合框架的功能和实用性。总之,Java集合框架是Java平台中非常重要的一部分,它提供了一套统一的集合操作接口和实现,使得程序员可以更加方便地操作集合类,提高了程序的设计效率和运行质量。接口的主要原因是它们在 Java 集合框架中扮演着截然不同的角色,并提供了不同的功能集合。在Java集合框架中,如果需要支持克隆或序列化操作,通常是通过具体的集合实现类来实现的。

学无止境,止于至善 1249

【用Java学习数据结构系列】探索Java集合框架的无尽秘密pro

与C语言学习数据结构不同,Java在数据结构的学习和使用上我们必须要了解一下Java的集合框架。Java中的顺序表,链表,栈,队列,二叉树等,Java都是已经写好的了,其中队列是一个接口。那么既然Java已经实现了这些数据结构,那么我们只需要认识和会使用这些接口和类就好,那么想认识这些数据结构之前,我们必须要先了解一下Java的集合框架。集合框架是用于表示和操作集合的统一体系结构。这些是表示集合的抽象数据类型。接口允许独立于其表示的细节来操作集合。在面向对象的语言中,接口通常形成一个层次结构。

2302_81249757的博客 1168

集合及数据结构第一节————初识集合框架和数据结构

初始集合框架和数据结构 什么是集合框架? 集合框架的重要性 背后所涉及的数据结构以及算法 数据结构的基本概念和术语 逻辑结构和物理结构 数据类型

2301_79418684的博客 1058

java 各版本大全

Java 各版本大全 Java 是一种广泛使用的编程语言,由Sun Microsystems开发并于1995年正式发布。自发布以来,Java 不断更新迭代,新增了许多功能和改进。本文将为您介绍 Java 的各个版本,以及每个版本的主要特点。 Java 1.0 Java 1.0 是 Java 的第一个正式版本,它包含了基本的...

weixin_28782251的博客 570

第15章 Java集合框架

第15章 Java集合框架 Java集合类概述 定义:集合类存放的都是对象的引用,而非对象本身,称集合中的对象就是指集合中对象的引用(reference)。 通俗的说,集合就是一个放数据的容器,准确的说是放数据对象引用的容器。 集合类型主要有3种:set(集)、list(列表)和map(映射)。 Set(集): Set集合中,不能包含重复元素 List(列表): List是一个有序的,且存放元素...

qq_43039152的博客 231
上一篇: java 集合框架--14
下一篇: Java 集合框架工具类--17
飞鸿踏雪泥-
博客等级 码龄12年 4粉丝 48原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值