木舟0基础学习Java的第十五天(集合嵌套，Set集合，比较器，Map集合)

🕗 发布于 2024-07-12 17:23 学习 java idea 开发语言

集合嵌套

 public static void main(String[] args) {
        //集合嵌套
        //定义一个集合 放集合one,two 以ArrayList<Person> 为泛型
        ArrayList<ArrayList<Person>> list=new ArrayList();

        ArrayList<Person> one=new ArrayList();
        ArrayList<Person> two=new ArrayList();
        one.add(new Person("张三",23));
        one.add(new Person("李四",24));
        one.add(new Person("王五",25));

        two.add(new Person("李雷",18));
        two.add(new Person("韩梅梅",19));
        two.add(new Person("王铁钢",20));
        //将两个集合放入list集合中
        list.add(one);
        list.add(two);
        //循环遍历
        for (ArrayList<Person> lists : list) {
            for (Person p :lists ) {
                System.out.println(p.getName()+p.getAge());
            }
        }
    }

Set集合

接口无顺序不可重复

HashSet:底层为哈希算法

:LinkedSet：Set体系下唯一可以保证存取顺序的

TreeSet:底层为二叉树目的：对set集合中的数据进行排序

方法：与List中的方法相同

HashSet:

HashSet去重是底层通过哈希码和equals完成的

LinkedHashSet:特点可以保证怎么存就怎么取

TreeSet:

排序去重底层会把存入TreeSet集合的数据进行自然顺序排序

里面有compare:return (x<y)? -1:((x==y)?0:1)

使用二叉树存储对象排序去重需要实现（implements）Comparable<对象>

重写compareTo方法如果返回值为0 那么只存第一个对象

返回负数倒着存返回正数就按顺序存

public class Person {
    private String name;
    private int age;
    private float score;

    public Person() {
    }

    public Person(String name, int age, float score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public float getScore() {
        return score;
    }

    public void setScore(float score) {
        this.score = score;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Float.compare(score, person.score) == 0 && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, score);
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}

public class ComPerson implements Comparator<Person> {
    @Override
    public int compare(Person o1, Person o2) {
        int n1=(int)(o1.getScore()-o2.getScore());//分数
        int n2=o1.getAge()-o2.getAge();//年龄
        int n3=o1.getName().compareTo(o2.getName());//名字
        int result=0;
        //不是同一个人 按成绩降序
        if((n2+n3)!=0){
            result=-n1;
            //如果成绩相同 不去重 按年龄排序
            if(result==0){//成绩相同
                //比较年龄
                result=n2;//年龄相同
                result=result==0?1:result;//一前一后
            }
        }
        return result;
    }
}

   TreeSet<Person> ts=new TreeSet<>(new ComPerson());
        ts.add(new Person("张三",23,90f));
        ts.add(new Person("李四",24,95f));
        ts.add(new Person("李四",24,95f));
        ts.add(new Person("王五",22,91f));
        ts.add(new Person("王五",22,91f));
        System.out.println(ts);

比较器（降低程序之间的耦合度）

1.创建比较器 实现 Comparator<类>
2.重写compareTo方法 
3.修改想要比较的返回值
例：

public class CheckAge implements Comparator<Student> {
    //通过年龄排序
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getAge()-o2.getAge();
    }
}

public class CheckName implements Comparator<Student> {
    //通过名字排序
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getName().compareTo(o2.getName());
    }
}

 public static void main(String[] args) {
        //创建一个带比较器的集合
        TreeSet<Student> ts=new TreeSet(new CheckName());
        //TreeSet<Student> ts=new TreeSet(new CheckAge());
        ts.add(new Student("张三",23));
        ts.add(new Student("张三",23));
        ts.add(new Student("李四",24));
        ts.add(new Student("李四",24));
        ts.add(new Student("王五",25));
        ts.add(new Student("王五",25));
        System.out.println(ts);
    }

不去重但排序

public class ComString implements Comparator<Character> {
    //不去重 但排序
    @Override
    public int compare(Character o1, Character o2) {
        int num1=o1.compareTo(o2);
        int num2=num1==0?1:num1;
        return num2;
    }
}

案例：

 public static void main(String[] args) {
        //让其有序(按字典顺序) 不去重
        String s="liaoninglianningliaoning";
        sort(s);
    }
    public static void sort(String s){
        TreeSet<Character> ts=new TreeSet(new ComString());
        for(int i=0;i<s.length();i++){
            char c=s.charAt(i);
            ts.add(c);
        }
        System.out.println(ts);
    }

字符串转换回基本数据类型（parse）

 public static void main(String[] args) {
        int a=Integer.parseInt("123");//123
        float b=Float.parseFloat("123f");//123.0
        short c=Short.parseShort("123");//123
        byte d=Byte.parseByte("1");//1
        double e=Double.parseDouble("123");//123.0
      //  double f=Double.parseDouble("a");//报错 转换异常
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        System.out.println(e);
       // System.out.println(f);

    }

Map集合

HashMap:重点 springMVC携带服务器数据到前端

Map<key，value>键，值

Map集合添加元素特点：map.put();

如果键是第一次存储就直接存储元素返回null

如果键不是第一存储就用值将以前的值替换掉返回以前的值

Map<Integer,String> m=new HashMap();

根据键获取值：

m.get(键)；

返回所有键的集合：

方法1（有迭代器）

m.keySet();//.var

Set<Integer> s = m.keySet();

//遍历map 通过遍历装有键的Set集合获得对应的所有值

Iterator<Integer> i=s.iterator();

while(i.hasNext()){

Integer key = i.next();

String value = m.get(key);

System.out.println("key"+key+",value"+value);

}

方法2（增强for循环）

for (Integer key : m.keySet())

{ System.out.println("key"+key+",value"+m.get(key)); }

方法3（映射Map.Entry）

Map<Integer,String> m=new HashMap();

m.put(1,"沈阳"); m.put(2,"大连"); m.put(3,"营口");

Set<Map.Entry<Integer,String>> me=m.entrySet();//视图

for (Map.Entry<Integer, String> mm : me) {

mm.getKey();

mm.getValue();

System.out.println( mm.getKey()+ mm.getValue());

}

获取集合中所有值的集合

Collection<String> values = m.values().var;

获取键值对的个数

m.size();

LinkedHashMap(底层是链表)

特点：怎么存就怎么取

 public static void main(String[] args) {
        LinkedHashMap<Integer,String> lhm=new LinkedHashMap<>();
        lhm.put(1,"营口");
        lhm.put(1,"营口");
        lhm.put(3,"大连");
        lhm.put(3,"大连");
        lhm.put(2,"沈阳");
        lhm.put(2,"沈阳");
        Set<Map.Entry<Integer, String>> ent = lhm.entrySet();
        Iterator<Map.Entry<Integer, String>> i=ent.iterator();
        while(i.hasNext()){
            Map.Entry<Integer, String>me= i.next();
            Integer key = me.getKey();
            String value = me.getValue();
            System.out.println(key+value);
        }
    }

TreeMap

public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class ComStu implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getAge()-o2.getAge();
    }
}

   public static void main(String[] args) {
        TreeMap<Student,String> tm=new TreeMap(new ComStu());
        tm.put(new Student("张三",23),"沈阳");
        tm.put(new Student("张三",23),"沈阳");
        tm.put(new Student("李四",22),"大连");
        tm.put(new Student("李四",22),"大连");
        tm.put(new Student("王五",25),"营口");
        tm.put(new Student("王五",25),"营口");
        System.out.println(tm);
    }

原文地址：https://blog.csdn.net/tzh525/article/details/140312611

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：代码随想录打卡第二十一天
下一篇：智充科技营收增速放缓：经营成本飙升，应收账款大幅增长

Chainlit集成LlamaIndex实现知识库高级检索（BM25全文检索器）
类是一个基于BM25算法设计的检索器，它主要用于从一组文档或节点中检索出与查询最相关的文档或节点。这个类的设计目的是为了提高文本检索的效率和准确性，尤其是在处理大量文本数据时。BM25（Best Ma
阅读更多2024-09-24
【数据结构与算法 | 灵神题单 | 自底向上DFS篇】力扣508, 1026, 951
请返回出现次数最多的子树元素和。如果有多个元素出现的次数相同，返回所有出现次数最多的子树元素和（不限顺序）。（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A
阅读更多2024-09-24
职业技能大赛-自动化测试笔记（PageObject）分享-4
PageObject 模式的核心思想是将每个 UI 页面抽象为一个独立的对象（即 Page 类），该对象不仅包含页面中元素的信息，还封装了与这些元素交互的方法。这种封装使得测试用例与页面的具体实现细节
阅读更多2024-09-24
计算机毕业设计之：基于微信小程序的中药材科普系统（源码+文档+讲解）
博主介绍： ✌我是阿龙，一名专注于Java技术领域的程序员，全网拥有10W+粉丝。作为CSDN特邀作者、博客专家、新星计划导师，我在计算机毕业设计开发方面积累了丰富的经验。同时，我也是掘金、华为云、
阅读更多2024-09-24
LabVIEW软件维护的内容是什么呢？
LabVIEW软件维护涉及多个方面，确保程序的正常运行和长期稳定性。
阅读更多2024-09-24
【openwrt-21.02】openwrt PPTP Passthrough 不生效问题解决方案
电脑PPTP拨号提示端口未打开。
阅读更多2024-09-24
【中国数据库前世今生】80 年代中国数据库发展史
中国的科技工作者们意识到，要想实现国家的信息化建设，必须加快数据库技术的研究和发展。同时，也有一些企业尝试自主开发数据库管理系统，虽然在技术水平和功能上与国外产品还有一定差距，但为中国数据库产业的发展
阅读更多2024-09-24
Matlab simulink建模与仿真第十五章（信号源库）
（1）‌白噪声具有常量功率谱‌，这意味着白噪声在所有频率上出现的强度相同，不随着频率的增加而衰减，白噪声的这一特性使其在功率谱上趋近为常值，即在整个频谱上都有成分，从低频到高频都有分布。（2）白噪声的
阅读更多2024-09-24
DAY20信息打点-红蓝队自动化项目&资产侦察&武器库部署&企查产权&网络空间
第20天：信息打点-红蓝队自动化项目&资产侦察&企查产权&武器库部署&网络空间_enscango-CSDN博客。./enscan-0.0.10-windows-amd6
阅读更多2024-09-24
初认识类的定义
在C++中，类（Class）是面向对象编程（OOP）的核心概念之一。它允许你将数据（属性）和操作这些数据的方法（成员函数）封装在一起。类定义了对象的蓝图，而对象则是根据这个蓝图创建的实例。C++中的类
阅读更多2024-09-24