java 集合框架 泛型--15_飞鸿踏雪泥-的博客-程序员秘密

技术标签： java  TreeSet  泛型  

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);
    }
}

这里写图片描述
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java19930623/article/details/47336937

智能推荐

使用 SSH 和 shell 脚本部署 Docker 镜像_weixin_34037977的博客-程序员秘密

译者按：在本专栏的前面的文章中，我们已经提到过使用 Docker 的基本方法，因此本次讲解一下 使用 SSH 和 shell 脚本进行 Docker 镜像的自动化部署，原文仅供参考，因为对于 Docker 镜像，我们可以有更好的解决方案：Docker Registry Hub。但是，本文仍然可以作为 shell 脚本的参考范例。...

一条Fofa搜索语法，实现批量挖洞_fofa语法搜索 && app_WinHly的博客-程序员秘密

不过我认为我的学习时间还长，要尽量从基础学起，这就需要动手写写代码，理解那些工具底层用的什么逻辑。

实验吧 逆向 bin100_bin(100)_pipixia233333的博客-程序员秘密

实验吧又把这道题给下价了，最近都是在写一些自己以前没事思路的题 老师为了赶进度 也没有 让我做windows下的逆向，让我学习pwn 那么问题来了 到底什么事pwn 网上的资料少的要死 我特别的想知道怎么做........ 唉 一步一步的找资料吧.. 然后开始今天的思路 emm 老方法 od 然后 发现输入在这个call里面 然后 进入call 然后继续寻找 这个输入函数 以及对比的函数 在这里 ...

npm ERR! [email protected] build: `gulp`问题解决_"build\": \"gulp"_CodingPioneer的博客-程序员秘密

npm ERR! [email protected] build: `gulp`问题解决renren-fast-vue下载环境说明问题描述问题解决1、第一步是升级gulp到4.02、第二步是修改gulpfile.js文件3、第三步是重新执行生产环境打包命令renren-fast 是一个轻量级的 Spring Boot 快速开发平台，能快速开发项目并交付【接私活利器】 完善的 XSS 防范及脚本过滤，彻底杜绝 XSS 攻击，实现前后端分离，通过 token 进行数据交互。renren-fast-vu

mysql 事务补偿_分布式事务之消息补偿解决方案_weixin_39732027的博客-程序员秘密

一、数据库本地事务先看看数据库事务的定义：单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行这个比较容易理解，操作过数据库的一般都懂，既是业务需求涉及到多个数据表操作的时候，需要用到事务要么一起更新，要么一起不更新，不会出现只更新了部分数据表的情况，下边看看数据库事务的使用1 begin tran2 begintry3 update Table1 set F...

Document.querySelectorAll_stefan321的博客-程序员秘密

Document.querySelectorAllSummaryReturns a list of the elements within the document (using depth-first pre-order traversal of the document's nodes) that match the specified group of selectors. ...

随便推点

chrome插件中遇到的坑（一）_weixin_30753873的博客-程序员秘密

简单说，懂chrome插件开发的人都知道，chrome插件主要有三层（姑且这么称谓）。这三层经纬可谓明确，可以从功能和权限的角度去理解他们：1、background层，chrome插件底层，控制整个chrome插件的大脑，具有最高权限；2、content层，content-script脚本工作平台，本质上是chrome插件脚本注入层，权限最低只能影响页面DOM，不能跨域操作，但是可以通过c...

C# winform调用接口 传参方式_c# winform 执行一次url_凤凰花匪的博客-程序员秘密

public string Post(string Url, string jsonParas){string strURL = Url;//创建一个HTTP请求HttpWebRequest request = (HttpWebRequest)WebRequest.Create(strURL);//Post请求方式request.Method = “POST”;//内容类型requ...

大乱斗ps4好玩吗_IG被DOM追着锤 Theshy却在赛后呼吁队友多玩大乱斗_weixin_39842611的博客-程序员秘密

LPL夏季赛已经开赛三天了，在6月3号的比赛中，SN与VG，IG与DMO分别展开了角逐。可能是因为赛季刚开始，每个战队都在尝试一些新东西，比如VG在比赛中就掏出了奥拉夫上单，并且取得了不错的效果，一路推平了SN的水晶。SN和VG的比赛结束后就是IG和DOM的比赛了，IG更换了辅助Baolan，用新人lucas上场，第一把IG超级大劣势，但是凭借DOM的一波运营失误直接反拿大龙，成功翻盘。第二盘比赛...

求点到直线的垂足和最近点_城南的花的博客-程序员秘密

1.公式(比较稳啊) 设直线方程为ax+by+c=0,点坐标为(m,n) 则垂足为((b*b*m-a*b*n-a*c)/(a*a+b*b),(a*a*n-a*b*m-b*c)/(a*a+b*b)) 2.计算点到线段的最近点如果该线段平行于X轴（Y轴），则过点point作该线段所在直线的垂线，垂足很容 易求得，然后计算出垂足，如果垂足在线段上则返回垂足，否则返回离垂足近的端 ...

【Python】使用Turtle库画图_怎么打开turtle_姚巨龙的博客-程序员秘密

【Python】使用Turtle库画图绘图窗体布局基本语句小案例在Python中一般是引用turtle这个函数库来画图，其画图方法就好像一只海龟在白纸上爬，爬行轨迹就是所画的图形。绘图窗体布局turtle绘图窗体，就是Python绘图的一个画图空间，它的最小单位是像素。使用 turtle.setup(width, heigh, startx, starty) 函数，来设置启动turtle窗......

【Abp VNext】实战入门（五）：【4】前端管理界面 vue-element-admin —— 登录获取 Access_Token_abp vnext免密码登录_liuyonghong159632的博客-程序员秘密

一、前言：接口没有权限，无异于裸奔，风险很大！AbpVnext 默认权限获取接口 在Swagger中没有显示，这个有点儿坑爹，找了好久才在网上找到！二、获取Token:1、接口地址：https://localhost:44349/connect/token2、接口需要以：application/x-www-form-urlencoded 的方式调用；3、接口参数：//接口参数{ client_id: 'GasMonitoring_App', //client_se..

推荐文章

热门文章

相关标签