day17学习总结

已于 2022-08-06 09:54:28 修改
阅读量119 收藏
点赞数
分类专栏： 学习总结 文章标签： 学习 java 数据结构
于 2022-08-02 20:26:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53884348/article/details/126115607
版权
本文介绍了Java中的LinkedHashSet的特点及其使用案例，详细讲解了Map接口，包括HashMap与HashSet的区别，以及Map接口的主要实现类、遍历方法。此外，文章还深入探讨了泛型的概念、好处、使用方式以及泛型接口和通配符的应用，并给出了具体的实战案例。
摘要由CSDN通过智能技术生成

一、LinkedHashSet

特点：

        具有可预知迭代顺序  即有序

        数据结构为：哈希表和链接列表(链表)实现

        此实现是不同步的，即在多线程中是不安全的

二、案例

需求：键盘录入一串字符 abcabdc 按照顺序排列这一串字符(去除重复 ) ==> abcd

代码：

package com.qf.test.test01;

import java.lang.reflect.Array;
import java.util.*;

public class Test01 {
    public static void main(String[] args) {
        //实例化Scanner
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一串字符");
        String line = input.next();
        //将字符转换为字符数组
        char[] array = line.toCharArray();
        Arrays.sort(array);
        //实例化集合
        LinkedHashSet link = new LinkedHashSet();
        //使用增强for循环遍历数组
        for (char c :array){
                link.add(c);
        }
        System.out.println(link);
    }
}

三、Map

1.简介

        Map是双列集合的顶级接口

2.特点：

        将键映射到值的对象  键：key   值：value

        一个映射不能包含重复的键，每个键最多只能映射一个值  即键值对  键是唯一的

3.主要实现类：

        HashMap       TreeMap

4.总结：

        Map是 键值对映射的集合

5.单列集合与双列集合的比较：

6.Map集合常用的方法：

7.方法测试：

package com.qf.test.test02;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
        //实例化集合
        Map m = new HashMap();
        //存入数据
        m.put("阿陆","班长");
        m.put("黑福","屌丝");
        m.put("阿甘","肝王");
        //打印集合
        System.out.println(m);
        //修改集合数据
        m.put("阿陆","足浴小王子");
        System.out.println(m);
        //判断是否有该键
        System.out.println(m.containsKey("阿陆"));
        System.out.println(m.containsKey("阿文"));
        //判断是否有该值
        System.out.println(m.containsValue("足浴小王子"));
        System.out.println(m.containsValue("爆写"));
        //通过键查找值
        System.out.println(m.get("阿陆"));
        //返回所有键
        Set set = m.keySet();
        System.out.println(set);
        //返回所有值
        Collection values = m.values();
        System.out.println(values);
        //返回集合大小
        System.out.println(m.size());
        //通过键删除值
        m.remove("阿甘");
        System.out.println(m);
        //清除所有键值
        m.clear();
        //判断集合是否为空
        System.out.println(m.isEmpty());

    }
}

 8..Map集合遍历的方法

        第一种方法：

                先获取所有的key，然后使用增强for循环遍历，获取对应的值

        第二种方法：

                通过entrySet方法，然后使用增强for循环 使用getKey  和  getValue 方法获取键值

 测试代码

package com.qf.test.test03;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
        //实例化集合
        Map m = new HashMap();
        //给集合添加数据
        m.put("阿陆","足浴小王子");
        m.put("阿甘","卷王");
        m.put("黑福","阴阳虚");
        //第一种遍历方法
        Set set = m.keySet();
        for (Object obj :set) {
            System.out.println(obj+"\t"+m.get(obj));
        }
        System.out.println("==================================");
        //第二种遍历方法
        Set set1 = m.entrySet();
        for (Object obj:set1){
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey()+"\t"+entry.getValue());
        }
    }
}

9.案例

需求：键盘输入一串字符串，打印每个字符出现的次数

分析：先实例化Scanner  然后将字符串转换为字符数组    在使用增强for循环遍历字符数组  使用Map集合中的containsKey()方法判断

代码：

package com.qf.test.test04;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //实例化Scanner
        Scanner input =new Scanner(System.in);
        System.out.println("请输入一串字符串");
        String line = input.next();
        //将字符串转换为字符数组
        char[] array = line.toCharArray();
        //实例化集合
        Map m = new HashMap();
        //使用增强for循环
        for (char c : array){
            //使用if语句判断
//            if(m.containsKey(c)){
//                m.put(c,(Integer)(m.get(c))+1);
//            }else{
//                m.put(c,1);
//            }
            //使用三元运算符简化代码
            m.put(c,m.containsKey(c) ? (Integer)(m.get(c))+1 : 1);
        }
        System.out.println(m);
    }
}

 四、HashMap

1.简介：

        HashMap是Map接口的实现类

        HashMap基于哈希表结构存储

        HashMap运行使用null键和null值

        HashMap此实现是不同步的，所以在多线程中是不安全的

        HashMap的构造默认初始值为16

2.HashMap与HashSet的比较

        两个集合都是使用 哈希表结构 来进行存储    HashSet底层使用的是HashMap来进行存储

        HashSet使用了HashMap的键的数据结构  来保证数据的唯一性

五、LinkedHashMap

特点：

        A.Map 接口的哈希表和链接列表实现

        B.具有可预知的迭代顺序

        C.此实现不是同步的 在多线程中是不安全的

六、泛型

1.简介：

        在定义集合的时候不确定其数据类型，但是在实例化集合的时候可以确定其数据类型的时候，就可以使用泛型。  泛型其实就是一个变量，这个变量用于接收其数据类型

2.泛型的使用：

        在实例化对象的时候必须确定其数据类型

        如：List<泛型> 对象名 = new ArrayList<泛型>();

3.泛型的好处：

        避免强制类型转换

        将运行时的错误提前到编译期间

4.泛型的符号：

        泛型的符号可以是任意的大写字母，常用的有：E T K W Z......

5.定义泛型类：

        语法：

                访问修饰符   class   类名<泛型>{

                        类中的所有成员都可以使用类的泛型，除了静态方法

                }

        例子：代码

package com.qf.test.test06;

public class MyArrays<K> {
    public K[] showInfo(K [] array,int index1,int index2){
        K temp = array[index1];
        array[index1] = array[index2];
        array[index2] = temp;
        return array;
    }
}


package com.qf.test.test06;

import java.util.Arrays;

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

        MyArrays<Integer> my = new MyArrays();
        Integer[] nums=my.showInfo(new Integer[]{11,22,354,74,31},2,4);
        System.out.println(Arrays.toString(nums));
    }
}

6.定义泛型方法：

        语法：

                访问修饰符<泛型> 返回值类型   方法名称(参数列表){

                        方法体;

                        return 返回值;

                }

        说明：可以给普通方法加泛型 也可以给静态方法加泛型

        注意点：

                A.普通成员方法可以使用类的泛型

                B.静态方法不能使用类的泛型 因为静态资源优先加载

        例子：

        

package com.qf.test.test07;

public class MyShow {
    public <T> void showInfo(T t){
        System.out.println(t);
    }
    public static <T> void show(T t){
        System.out.println(t);
    }
}




package com.qf.test.test07;

public class Test {
    public static void main(String[] args) {
        MyShow m = new MyShow();
        m.showInfo("ss");
        m.showInfo(11);
        MyShow.show("ss");
        MyShow.show(222);
    }
}

7.定义泛型接口：

        体现：

                A.实现类确定其泛型

                B.实现类不确定其泛型

        语法：

        实现类确定型：

                public interface Iterator<E>{

                         E next()

                }

                public final class Scanner implements Iterator<String>{

                         public String next()

                }

        实现类不确定型：

             public interface List<E> {

                boolean add(E e)

             }

            public class ArrayList<E>  implements   List<E>{

                 public boolean add(E e)

             }    

//实现类确定型

package com.qf.test.test08;

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


package com.qf.test.test08;

public class My implements Inte<String> {
    @Override
    public void show(String s) {
        System.out.println(s);
    }
}


package com.qf.test.test08;

public class Test {
    public static void main(String[] args) {
        My m = new My();
        m.show("sss");

    }
}

//实现类不确定型
package com.qf.test.test09;

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



package com.qf.test.test09;

public class My<T> implements Inte<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}



package com.qf.test.test09;

public class Test {
    public static void main(String[] args) {
        Inte m = new My();
        m.show("ssss");
        m.show('a');
        m.show(132);
    }
}

8.泛型通配符

        1.泛型通配符 可以表示任意的数据类型 泛型通配符使用？来进行表示

        2.泛型通配符一般作为方法的参数使用 不能实例化集合的时候使用泛型通配符

        3.泛型没有继承的概念

        4.泛型通配符特殊符号

                ? extends E E本身或者是其子类

                ? super T T本身或者是其父类

9.案例

需求：千锋有两个学科 Html5 与java 使用map集合来存储不同的学员 遍历获取学员的信息

代码：

package com.qf.test.test10;

public class Student {
    private int sid;
    private String name;
    private String sex;
    private String hobby;

    public Student() {
    }

    public Student(int sid, String name, String sex, String hobby) {
        this.sid = sid;
        this.name = name;
        this.sex = sex;
        this.hobby = hobby;
    }

    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }

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




package com.qf.test.test10;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
        //实例化学生对象
        //java学生
        Student stu01 = new Student(10001,"阿陆","男","洗脚");
        Student stu02 = new Student(10002,"阿甘","男","卷王");
        //定义一个集合存储对象
        HashMap<Integer,Student> map1 = new HashMap<>();
        map1.put(10001,stu01);
        map1.put(10002,stu02);
        //HTML5学生
        Student stu03 = new Student(10003,"黑福","女","按摩");
        Student stu04 = new Student(10004,"阿文","男","观摩");
        //定义一个集合存储对象
        HashMap<Integer,Student> map2 = new HashMap<>();
        map2.put(10003,stu03);
        map2.put(10004,stu04);

        //定义一个大集合存储两个学生集合
        HashMap<String , Map<Integer,Student>> bigMap= new HashMap<>();
        bigMap.put("java学生",map1);
        bigMap.put("HTML学生",map2);

        //打印学生信息  第一种方法
        //获取大集合的键
        Set<String> strings = bigMap.keySet();
        //使用增强for循环遍历
        for (String s : strings){
            //打印大集合的键
            System.out.println(s);
            //根据键获取大集合的值  类型为Map集合
            Map<Integer, Student> m1 = bigMap.get(s);
            //获取学生集合的所有键
            Set<Integer> set = m1.keySet();
            //使用增强for循环遍历
            for (Integer in : set){
                //打印学生集合的键和值
                System.out.println(in +"\t"+m1.get(in));
            }
        }
        System.out.println("===========================================");
        //第二种方法 大集合调用entrySet方法
        Set<Map.Entry<String, Map<Integer, Student>>> entries = bigMap.entrySet();
        //使用增强循环遍历Set集合
        for (Map.Entry<String, Map<Integer, Student>> m :entries){
            //打印大集合的键
            System.out.println(m.getKey());
            //获取大集合的值   值的类型为Map集合
            Map<Integer, Student> m2 = m.getValue();
            //学生集合将调用entrySet方法
            Set<Map.Entry<Integer, Student>> entries1 = m2.entrySet();
            //使用增强for循环遍历Set集合
            for (Map.Entry<Integer, Student> m3 :entries1){
                //打印学生集合的键和值
                System.out.println(m3.getKey()+"\t"+m3.getValue());
            }

        }

    }
}

七、案例---斗地主

需求：生成54张扑克牌，然后随机发给三个人 和三张底牌

分析:

代码：

package com.qf.test.test11;

import java.util.*;

public class Test {
    public static void main(String[] args) {
        //生成扑克牌
        //定义一个数组表示花色
        String [] color = {"♦","♣","♥","♠"};
        //定义一个数组表示点数
        String [] nums = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        //定义一个变量表示索引
        int index = 0;
        //定义一个Map集合存储点数
        Map<Integer,String> map = new HashMap<>();
        //定义一个list集合存储索引
        List<Integer> list = new ArrayList<>();
        //使用嵌套for循环生成52张牌
        for (String n : nums){
            for (String c : color){
                //将花色与点数拼接
                String s = c+n;
                //将索引和牌存入map集合
                map.put(index,s);
                //将索引存入list集合
                list.add(index);
                //索引自增
                index++;
            }
        }
        //生成大小王
        map.put(index,"小王");
        list.add(index);
        map.put(index+1,"大王");
        list.add(index+1);

        //洗牌  将索引随机排序
        //调用jdk提供方法
        Collections.shuffle(list);

        //发牌  发索引
        //使用TreeSet集合存储  因为可以自动排序
        //底牌
        TreeSet<Integer> dipai = new TreeSet<>();
        TreeSet<Integer> lu = new TreeSet<>();
        TreeSet<Integer> zhong = new TreeSet<>();
        TreeSet<Integer> gan = new TreeSet<>();
        //使用循环遍历集合list
        for (int i=0;i<list.size();i++){
            //使用if语句进行判断
            if (i>=list.size()-3){
                //发给底牌
                dipai.add(list.get(i));
            }else if (i%3==0){
                //发给lu
                lu.add(list.get(i));
            }else if (i%3==1){
                //发给zhong
                zhong.add(list.get(i));
            }else if (i%3==2){
                //发给gan
                gan.add(list.get(i));
            }
        }

        //看牌
        show("底牌",dipai,map);
        show("阿陆",lu,map);
        show("黑福",zhong,map);
        show("阿甘",gan,map);
    }
    public static void show(String name,TreeSet<Integer> t,Map<Integer,String> map){
        //定义一个空字符串变量
        String s = "";
        //使用循环遍历TreeSet集合
        for (Integer in : t){
            String s1 = map.get(in);
            s +=s1+" ";
        }
        System.out.println(name+"\t"+s);
    }
}

白昼乌龙茶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Day19学习总结
qq_53884348的博客
08-04 106
day19学习总结：重点掌握IO流
day11学习总结
qq_53884348的博客
08-31 158
day11学习总结：web框架、服务器、idea中的web项目、Servlet、登录案例
Java泛型基础
忘尘的博客
03-16 104
目录什么是泛型使用泛型的好处泛型类通配符泛型方法泛型类中的泛型方法静态方法与泛型泛型类派生出的子类子类明确泛型类的类型参数变量 什么是泛型 泛型，即“参数化类型”，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制...
对json数据key进行替换
清水的专栏
11-16 4866
这是专门为json数据key值替换所做 import java.util.HashMap; import java.util.Map; import java.util.Set; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; /** * * 对json数据key进行替换 * @author hongji * @date 2018-10-26 * */ public cl..
2 Day DBA 学习总结
u011868279的博客
02-04 1119
2 Day DBA 学习总结
python学习总结day04.txt
04-28
Day03回顾 1、requests模块方法 1、get()参数 1、查询参数 ：params -> 字典 2、代理 ：proxies -> 字典 1、普通代理 ：{"协议":"协议://IP地址:端口号"} 2、私密代理 {"协议":"协议://用户名:密码@IP地址:...
python学习总结day03.txt
04-28
Day02回顾 1、关于正则解析 1、分组(想要抓取什么内容就加小括号()) 2、正则方法 p = re.compile('....') r_list = p.findall(html) 结果 ：[(),(),(),()] 3、贪婪匹配 ： .* 4、非贪婪匹配 ：.*? 2、抓取...
day01课后总结.docx
11-23
### Day01课后总结知识点概述 #### 一、软件测试流程详解 ##### 1. 测试流程概览 在软件开发过程中，测试流程是非常关键的一环，它确保了最终产品的质量。根据提供的部分内容，我们可以将测试流程概括为以下几个...
c语言学习总结.docx
07-06
C 语言学习总结 C 语言是一门面向过程、抽象化的通用程序设计语言，广泛应用于底层开发。C 语言能够以简易的方式编译，处理低级存储器。C 语言是产生少量的机器语言以及不需要任何环境便能支持运转的高效率程序设计...
Day17
03-28
总结第17天的学习，我们将JavaScript的核心概念与实际应用相结合，通过DOM操作实现了对网页内容的动态更新，同时掌握了如何响应用户操作，增强了网页的交互性。这些都是JavaScript开发者必备的基础技能。随着技术的...
VTK-vtkStructuredGrid学习
weixin_69505365的博客
08-14 362
可以理解为单元格顺序沿着坐标轴排列，但是每个单元格可以不一样。维度理解为X/Y/Z方向的点数，如草图所示分别是4，3，1。此时只提供了12个点，只能构造一层，5.点图、线图、面图如下，对应行的代码改一下出现不同效果图。7.增加Z方向维度，点也要增加，点序保持一致。6.点可以不在同一个平面，随机改变点Z数值。2.获取这些点信息，点顺序要严格按照图示。直接赋值第一层的12个点，改一下Z值。所以Z方向维度是1，不能是其他数据。1.使用CAD随意绘制个网格草图。4.将上面的网格显示出来。
fme处理空间数据入门v0
weixin_43229258的博客
08-13 734
本教程是最最最基本的fme处理空间数据内容，给新同事介绍我以前是怎么干活用的，基本啥有用的东西。本教程主要说如何在 FME Workbench中创建模板文件（一般我们把fme写的工作空间就叫模板），教程里面主要是利用GIS数据。按照分步说明操作，1.了解如何从读取数据；2.添加转换器以在空间上过滤数据；3.将过滤后的数据写入 Esri Shapefile;4.如何运行模板文件。
【Python】python中抽象类学习笔记
qq_42761751的博客
08-12 416
抽象类是一个不能被实例化的类，通常作为其他类的基类抽象方法是一个没有具体实现的方法一个抽象类可以有或者没有抽象方法, 但是一般来说定义抽象类的时候总会在类中定义抽象方法Python并没有直接支持抽象类，但是提供了一个模块（abc）来允许定义抽象类通过继承abc.ABC类定义一个抽象类pass上述代码中类虽然继承了ABC但是没有定义抽象方法，仍然可以被实例化。"""使用@abstractmethod来定义抽象方法"""passmain()代码报错：不能实例化一个带有抽象方法的抽象类。
CVPR2024 | PromptAD: 仅使用正常样本进行小样本异常检测的学习提示
08-16 616
本文提出的PromptAD模型结构如图2所示。PromptAD建立在VV-CLIP之上，其视觉编码器用于提取全局和局部的特征。本文提出的语义串联（SC）用来设计提示。具体来说，将N个可学习的普通前缀与目标名称串联起来获得普通提示（NPs），然后将这N个普通提示分别与M个手动设置的异常后缀和L个可学习的异常后缀串联，以获得N×M个异常提示（MAPs）和N×L个可学习的异常提示（LAPs）。视觉特征和提示特征用于通过对比损失和本文提出的显式异常边界（EMA）损失来完成提示学习。
如何学习Kubernetes？
CloudJourney的博客
08-13 662
在云计算和容器化技术日新月异的今天，Kubernetes（简称K8s）作为容器编排领域的领头羊，已经成为现代应用部署和管理的标准工具。本文旨在为有志于学习Kubernetes的读者提供一条清晰的学习路径，从基础概念到高级特性，再到实战应用，帮助大家逐步掌握这门强大的技术。通过本文提供的学习路径和实战建议，希望能够帮助你逐步掌握这门强大的技术，并在实际项目中灵活应用。同时，Kubernetes还提供了强大的社区支持和丰富的生态系统，使得开发者可以轻松地找到适合自己的解决方案。
如何高效记录并整理编程学习笔记
vvvae1234的博客
08-13 1250
在编程学习的旅程中，好的笔记记录和整理方法不仅能帮助我们更有效地吸收知识，还能在复习时提供清晰的参考。下面，我将为您提供一些建立高效笔记系统的建议，以帮助您在繁忙学习中保持笔记的条理性，从而打造属于自己的编程学习“知识宝库”。方向一：笔记工具选择方向二：笔记结构设计方向三：实践与复习策略
如何高效记录并整理编程学习笔记？
最新发布
探索IT世界
08-16 482
建立一个高效的编程学习笔记系统是一个持续的过程。选择合适的工具，设计清晰的笔记结构，并结合实践与复习，可以帮助我们更好地掌握编程知识。记住，笔记的价值在于其使用，不断优化你的笔记系统，让它成为你学习路上的得力助手。希望这篇博客能够为你在IT行业的职业发展提供一些启发和指导。如果你有任何问题或需要进一步的建议，欢迎在评论区留言交流。让我们一起探索IT世界的无限可能！《IT入门知识大纲（0/10）》《IT入门知识第一部分《IT基础知识》（1/10）》《IT入门知识第二部分《编程语言》（2/10）》
零基础学习Redis(1) -- Redis简介
2303_78892316的博客
08-13 539
Redis是一个在存储数据的一个中间组件，可用作数据库或数据缓存，通常在分布式系统中使用（
EmguCV学习笔记 VB.Net 2.2 Matrix类
UruseiBest 的技术专栏
08-15 663
Matrix类是EmguCV中的一个矩阵类，它可以用来存储和处理矩阵数据，可以处理任意维度的矩阵。与Mat类相比，Matrix类提供了更多的矩阵运算方法，如矩阵加减、乘法、逆矩阵等，也更加灵活，而且底层实现也更加高效。例如，当均值为0，标准差为1时，生成的随机矩阵的像素值符合标准正态分布。当均值为0，标准差为0.5时，生成的随机矩阵的像素值分布更加集中，更接近于均值。该控件位于【工具箱】|【Emgu.CV】下面。SetRandNormal方法只能生成正态分布的随机矩阵，不能生成其他分布的随机矩阵。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

白昼乌龙茶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值