Java基础学习（11）

news2024/11/23 18:46:02

Java基础学习

  • 一、集合进阶
    • 1.1 数据结构（树）
      • 1.1.1 二叉查找树
      • 1.1.2 二叉树的遍历
    • 1.2 平衡二叉树
        • 树的演变
    • 1.3 数据结构 ( 平衡二叉树 )左旋
    • 1.4 数据结构 ( 平衡二叉树 )右旋
      • 数据结构 (平衡二叉树)需要转的四种情况
    • 1.5 红黑树
        • 添加节点规则
  • 二、Set系列集合
    • 2.1 HashSet
    • 2.2 LinkedHashSet
    • 2.3 TreeSet
    • 2.4 综上几个集合的使用情况
    • 2.5 双列集合
  • 三、Map
    • 3.1 Map的常见的API
    • 3.2 Map遍历
    • 3.3 HashMap
    • 3.4 LinkedHashMap
    • 3.5 TreeMap
    • 3.6 可变参数
    • 3.7 collections
  • 四、不可变集合
    • 4.1 创建不可变集合

一、集合进阶

1.1 数据结构（树）

节点：

在这里插入图片描述

  • 度:每一个节点的子节点数量
  • 二叉树：二叉树中，任意节点的度<=2
  • 树高: 树的总层数
  • 根节点: 最顶层的节点
  • 左子节点: 左下方的节点
  • 右子节点:右下方的节点
  • 根节点的左子树: 蓝色虚线
  • 根节点的右子树: 绿色虚线
    在这里插入图片描述

1.1.1 二叉查找树

特点：

  • 每一个节点上最多有两个子节点
  • 任意节点左子树上的值都小于当前节点
  • 任意节点右子树上的值都大于当前节点
    规则:
    小的存左边大的存右边一样的不存

1.1.2 二叉树的遍历

  • 前序遍历： 从根结点开始，然后按照当前结点，左子结点，右子结点的顺序遍历
    在这里插入图片描述
  • 中序遍历：从最左边的子节点开始，然后按照左子结点，当前结点，右子结点的顺序遍历
    在这里插入图片描述
  • 后序遍历：从最左边的子节点开始，然后按照左子结点，右子结点，当前结点的顺序遍历
    在这里插入图片描述
  • 层序遍历： 从根节点开始一层一层的遍历
    在这里插入图片描述

1.2 平衡二叉树

规则:任意节点左右子树高度差不超过1
在这里插入图片描述

树的演变

在这里插入图片描述

  • 起初是乱序的排列着二叉树，使得在查找数据的时候只能通过遍历所有的数据去查找，这样运行的速度太慢。
  • 后面就出现了二叉查找树，使得在节点的左边都是比节点小的，右边都是比节点大的，这样使得查找的速度显著提升。
  • 由于在这样排列的话，会出现一边的子节点数过多，是的查找的效率有降低，最后出现了平衡二叉树，解决了这个问题

1.3 数据结构 ( 平衡二叉树 )左旋

确定支点:从添加的节点开始，不断的往父节点找不平衡的节点
步骤：
简单

  • 以不平衡的点作为支点
  • 把支点左旋降级，变成左子节点
  • 晋升原来的右子节点

复杂

在这里插入图片描述

  • 以不平衡的点作为支点
  • 将根节点的右侧往左拉
  • 原先的右子节点变成新的父节点，并把多余的左子节点出让，已经降级的根节点当右子节点
    在这里插入图片描述

1.4 数据结构 ( 平衡二叉树 )右旋

步骤：
简单

  • 以不平衡的点作为支点
  • 把支点右旋降级，变成右子节点
  • 晋升原来的左子节点

复杂
在这里插入图片描述

  • 以不平衡的点作为支点
  • 就是将根节点的左侧往右拉
  • 原先的左子节点变成新的父节点，并把多余的右子节点出让，已经降级的根节点当左子节点
    在这里插入图片描述

数据结构 (平衡二叉树)需要转的四种情况

左左： 一次右旋
在这里插入图片描述

左右： 先局部左旋，再整体右旋
在这里插入图片描述
再右旋

右右： 一次左旋
在这里插入图片描述

右左： 先局部右旋，再整体左旋
在这里插入图片描述
再左旋

1.5 红黑树

  • 它是一种特殊的二叉查找树红黑树的每一个节点上都有存储位表示节点的颜色
  • 红黑树不是高度平衡的，它的平衡是通过"红黑规则"进行实现的每一个节点可以是红或者黑

红黑规则：

  • 每一个节点或是红色的，或者是黑色的
  • 根节点必须是黑色
  • 如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为NiL，这些N1视为叶节点，每个叶节点(Nil）是黑色的
  • 如果某一个节点是红色，那么它的子节点必须是黑色(不能出现两个红色节点相连的情况)
  • 对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点
    在这里插入图片描述

添加节点规则

  1. 默认颜色: 添加节点默认是红色的 (效率高)

因为如果是全为黑节点，要调整两次，如果全为红色节点，只调整一次。

在这里插入图片描述

二、Set系列集合

特点：

  1. 无序:存取顺序不一致
  2. 不重复:可以去除重复
  3. 无索引: 没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素

Set接口中的方法上基本上与Collection的API一致

package SetDome;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class CreatSet {
    public static void main(String[] args) {
        // 创建对象
        Set<String> s = new HashSet<>();

        //添加对象 （不能添加相同的）
        s.add("张三");
        s.add("历史");
        boolean a = s.add("语文");
        boolean b = s.add("语文");
        System.out.println(a);//true
        System.out.println(b);//false
        System.out.println(s);//[张三, 历史, 语文]

        //通过迭代器遍历
        Iterator<String> it = s.iterator();
        while (it.hasNext()){
            String str = it.next();
            System.out.println(str);
        }
        //通过增强For遍历
        for (String s1 : s) {
            System.out.println(s1);
        }

        //通过lambda遍历
        s.forEach(str -> System.out.println(str));
         }
}

2.1 HashSet

  • 哈希值:
  1. 根据hashCode方法算出来的int类型的整数
  2. 该方法定义在obiect类中，所有对象都可以调用，默认使用地址值进行计算
  3. 一般情况下，会重写hashCode方法，利用对象内部的属性值计算哈希值
  • 对象的哈希值特点:
  • 如果没有重写hashCode方法，不同对象计算出的哈希值是不同的
  • 如果已经重写hashcode方法，不同的对象只要属性值相同，计算出的哈希值就是一样的
  • 在小部分情况下，不同的属性值或者不同的地址值计算出来的哈希值也有可能一样。(哈希碰撞)

HashSet 底层原理

  • HashSet集合底层采取哈希表存储数据
  • 哈希表是一种对于增删改查数据性能都较好的结构

底层原理

  1. 创建一个默认长度16，默认加载因为0.75的数组，数组名table
  2. 根据元素的哈希值跟数组的长度计算出应存入的位置
    int index = (数组长度-1) & 哈希值
  3. 判断当前位置是否为null，如果是null直接存入
  4. 如果位置不为null，表示有元素，则调用equals方法比较属性值
  5. 一样:不存 ; 不一样: 存入数组，形成链表
    JDK8以前: 新元素存入数组，老元素挂在新元素下面
    JDK8以后: 新元素直接挂在老元素下面 JDK8以后，当链表长度超过8而且数组长度大于等于64时自动转换为红黑树

注意：

如果集合中存储的是自定义对象，必须要重hashCode和equals方法

集合去重小练习

package SetDome;
//创建一个集合去存储多个学生对象，并且满足去重，属性值相同就代表相同

import java.util.HashSet;

public class HashSetRemoveChong {
    public static void main(String[] args) {
        //创建学生对象
        Student s1 = new Student("zhangsan",21);
        Student s2 = new Student("lis",31);
        Student s3 = new Student("wangwy",29);
        Student s4 = new Student("zhangsan",21);

        //创建一个集合
        HashSet<Student> hs = new HashSet<>();
        //添加对象
        System.out.println(hs.add(s1));//true
        System.out.println(hs.add(s2));//true
        System.out.println(hs.add(s3));//true
        System.out.println(hs.add(s4));//false

        System.out.println(hs);//[Student{name = wangwy, age = 29}, Student{name = lis, age = 31}, Student{name = zhangsan, age = 21}]
    }
}

2.2 LinkedHashSet

LinkedHashSet底层原理:

  • 有序、不重复、无索引。
  • 这里的有序指的是保证存储和取出的元素顺序一致
  • 原理:底层数据结构是依然哈希表，只是每个元素又额外的多了一个双链表的机制记录存储的顺序

2.3 TreeSet

TreeSet特点：

  1. 不重复、无索引、可排序
  2. 可排序:按照元素的默认规则 (有小到大)排序。
  3. TreeSet集合底层是基于红黑树的数据结构实现排序的，增删改查性能都较好

TreeSet集合默认的规则：
在这里插入图片描述

  1. this: 表示当前要添加的元素
  2. o:表示已经在红黑树存在的元素
  3. 返回值:
    负数:认为要添加的元素是小的，存左边
    正数:认为要添加的元素是大的，存右边
    0:认为要添加的元素已经存在，舍弃
package SetDome;
/*需求:创建TreeSet集合，并添加3个学生对象学生对象属性:
姓名，年龄。
要求按照学生的年龄进行排序
同年龄按照姓名字母排列 (暂不考虑中文)
同姓名，同年龄认为是同一个人

方式一:
默认的排序规则/自然排序
student实现Comparable接口，重写里面的抽象方法，再指定比较规则

方法二：

* */

import java.util.TreeSet;

public class TreeSetDomeExercise {
    public static void main(String[] args) {
        //创建学生对象
        Student s1 = new Student("zhangsan",22);
        Student s2 = new Student("zhangsan",12);
        Student s3 = new Student("zhangsan",32);
        Student s4 = new Student("zhangsan",29);

        //创建TreeSet对象存储多个数据
        TreeSet<Student> ts = new TreeSet<>();
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);

        System.out.println(ts);/*[Student{name = zhangsan, age = 12}, Student{name = zhangsan, age = 22},
                                             Student{name = zhangsan, age = 29}, Student{name = zhangsan, age = 32}]*/

    }
}

重写TreeSet:

//重写TreeSet
    @Override
    public int compareTo(Student o) {
        //按照年龄的升序排序
        return this.getAge() - o.getAge();
    }

比较器排序：
在这里插入图片描述

package SetDome;

import java.util.TreeSet;

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

        //创建TreeSet对象存储多个数据
        TreeSet<String> ts = new TreeSet<>((o1, o2) -> {
            //先按照长度排
            int i = o1.length() - o2.length();
            //长度相同按照常规排
            i = i == 0 ? o1.compareTo(o2) : i ;
            return i;
        });

        ts.add("asd");
        ts.add("as");
        ts.add("bcd");
        ts.add("es");

        System.out.println(ts);//[as, es, asd, bcd]
    }
}

2.4 综上几个集合的使用情况

 
1. 如果想要集合中的元素可重复
用ArrayList集合，基于数组的。(用的最多)

2. 如果想要集合中的元素可重复，而且当前的增删操作明显多于查询
用LinkedList集合，基于链表的。

3. 如果想对集合中的元素去重
用HashSet集合，基于哈希表的。(用的最多)

4. 如果想对集合中的元素去重，而且保证存取顺序用
LinkedHashSet集合，基于哈希表和双链表，效率低于HashSet.

5. 如果想对集合中的元素进行排序
用TreeSet集合，基于红黑树。后续也可以用List集合实现排序

2.5 双列集合

特点：

  1. 双列集合一次需要存一对数据，分别为键和值
  2. 键不能重复，值可以重复
  3. 键和值是一一对应的，每一个键只能找到自己对应的值
  4. 键+值这个整体 我们称之为“键值对”或者“键值对对象”，在Java中叫做“Entry对象

三、Map

3.1 Map的常见的API

Map是双列集合的顶层接口，它的功能是全部双列集合都可以继承使用的

方法名称说明
V put(K key,V value)添加元素
V remove(Object key)根据键删除键值对元素
void clear()移除所有的键值对元素
boolean containsKey(object key)判断集合是否包含指定的键
boolean containsValue(object value)判断集合是否包含指定的值
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中键值对的个数

细节：

  • 添加：

在添加数据的时候
如果键不存在，那么直接把键值对对象添加到map集合当中,方法返回null。
如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值进行返回。

3.2 Map遍历

第一种方式：键找值
通过获取所有键放到单列集合当中，再通过Map的get方法获取到所有对应键的值

package Maps;

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

public class MapCreat {
    public static void main(String[] args) {
        //创建对象
        Map<String,String> m = new HashMap<>();

        //添加对象
        m.put("hhh","lll");
        m.put("lll","zzz");
        m.put("xxx","aaa");

        //删除
        m.remove("hhh");

    /*    //清除
        m.clear();*/

        //判断是否为空
        boolean empty = m.isEmpty();
        System.out.println(empty);//false

        //判断是否包含值
        boolean result = m.containsKey("lll");
        System.out.println(result);//true

        //遍历对象
        //首先获取到所有的键装在单列集合当中
        Set<String> Keys = m.keySet();

        //增强for
        for (String key : Keys) {
            String str  = m.get(key);
            System.out.println(key+"=" +str);
        }
        System.out.println("---------------------");

        //lambda遍历
        Keys.forEach(s-> {
            String str = m.get(s);
            System.out.println(s+"=" +str);
        });
        System.out.println("----------------");
        //迭代器遍历
        Iterator<String> i = Keys.iterator();
        while (i.hasNext()){
            String str1 = i.next();
            String str = m.get(str1);
            System.out.println(str1+"=" +str);
        }

    }
}

第二种方式：键值对

  • 通过一个方法获取所有的键值对对象，返回一个Set集合
  • 再通过获取到的Set集合中的getKey()和getValue()分别来获取键和值
package Maps;

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

public class MapForLam {
    public static void main(String[] args) {
        //创建对象，并且添加数据
        Map<String,String> map = new HashMap<>();
        map.put("hhh","lll");
        map.put("lll","zzz");
        map.put("xxx","aaa");

        //Map第二个遍历方式
        Set<Map.Entry<String, String>> entries = map.entrySet();
        //强For
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key +"= " +value);
        }
        //lambda
        entries.forEach(str->{
            String key = str.getKey();
            String value = str.getValue();
            System.out.println(key +"= " +value);
        });
        //迭代器
        Iterator<Map.Entry<String, String>> i = entries.iterator();
        while (i.hasNext()){
            Map.Entry<String, String> next = i.next();
            System.out.println(next.getKey() + "= " + next.getValue());
        }
    }
}

第三种方式：Lambda
在这里插入图片描述
底层原理：ForEach其实就是利用第二种方式进行遍历，依次得到每一个键和值再调用accept方法

 //第三种遍历方式
        map.forEach((key,value)->{
            System.out.println(key +"= " +value);
        });

3.3 HashMap

HashMap特点：

  1. HashMap是Map里面的一个实现类
  2. 没有额外需要学习的特有方法，直接使用Map里面的方法就可以了
  3. 特点都是由键决定的:无序、不重复、无索引
  4. HashMap跟HashSet底层原理是一模一样的，都是哈希表结构
package Maps.HashMap;

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

/*创建一个HashMap集合，键是学生对象(Student)，值是籍贯(String)
        存储三个键值对元素，并遍历
        要求:同姓名，同年龄认为是同一个学生*/
public class exercise1 {
    public static void main(String[] args) {
        //创建一个HashMap对象
        HashMap<Student,String> hs = new HashMap<>();
        //添加学生对象
        Student s1 = new Student("zhangsan",25);
        Student s2 = new Student("lisi",24);
        Student s3 = new Student("wangwu",18);
        Student s4 = new Student("wangwu",18);

        //添加学生对象到Map
        hs.put(s1,"sichuan");
        hs.put(s2,"guangzhou");
        hs.put(s3,"tianjin");
        hs.put(s4,"tianjin");

        //遍历对象（第三种遍历方式）
        hs.forEach((key,value)->{
            System.out.println(key + "= " + value);
        });
        System.out.println(" ------------------------------");
        //第一种遍历方式
        Set<Student> str = hs.keySet();
        str.forEach(s-> {
            String ss = hs.get(s);
            System.out.println(s+"="+ss);
        });

        //第二种遍历方式
        Set<Map.Entry<Student, String>> entries = hs.entrySet();
        entries.forEach(s->{
            String value = s.getValue();
            Student key = s.getKey();
            System.out.println(key);
            System.out.println(value);
        });
    }
}

3.4 LinkedHashMap

  • 由键决定:有序、不重复、无索引。
  • 这里的有序指的是保证存储和取出的元素顺序一致
  • 原理:底层数据结构是依然哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序

3.5 TreeMap

  1. TreeMap跟TreeSet底层原理一样，都是红黑树结构的。
  2. 由键决定特性: 不重复、无索引、可排序
  3. 可排序:对键进行排序
  4. 注意:默认按照键的从小到大进行排序，也可以自己规定键的排序规则

Integer Double 默认情况下都是按照升序排列的
string 按照字母再ASCII码表中对应的数字升序进行排列

3.6 可变参数

格式:属性类型...名字
底层原理： 就是一个数组，Java自动就生成了，我们不在自己手动完成创建数组

public class Test {
    public static void main(String[] args) {
           int result = getsum(1);
        System.out.println(result);
    }

    private static int getsum(int ...huanglei) {
        int sum = 0;
        for (int i : huanglei) {
            sum += i;
        }
        return sum;
    }
}

细节：

  1. 创建可变参数时，函数传入的形参只能有一个。因为如果创建多个，那么第一个就会把所有的数据吸收。
  2. 有多个形参时，要把可变参数放在最后，因为可变参数是个大胖子，会把后面传入的所有参数放在自己当中。

3.7 collections

  • java.util.Collections:是集合工具类
  • 作用: Collections不是集合，而是集合的工具类
    在这里插入图片描述
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Test {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list = new ArrayList<>();
        //添加元素
        Collections.addAll(list,"12","asd","wes","456");
//        System.out.println(list);//[12, asd, wes, 456]

        //打乱数据位置
        Collections.shuffle(list);
//        System.out.println(list);//位置随机打乱

        //默认排序
        Collections.sort(list);
//        System.out.println(list);//[12, 456, asd, wes]

        //按照我的排序规则排序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //按照长度排序，从大到小
                return o2.length()-o1.length();
            }
        });
        System.out.println(list);//[456, asd, wes, 12]
    }
    
}

四、不可变集合

4.1 创建不可变集合

不可变集合：就是不可以改变集合内容，长度

运用场景：

  1. 如果某个数据不能被修改，把它防御性地拷贝到不可变集合中是个很好的实践
  2. 或者当集合对象被不可信的库调用时，不可变形式是安全的

简单理解:不想让别人修改集合中的内容

书写格式：

  • 在List、Set、Map接口中，都存在静态的of方法，可以获取一个不可变的集合。

主要方法

方法名称说明
static List of(E…elements)创建一个具有指定元素的List集合对象
static Set of(E…elements)创建一个具有指定元素的Set集合对象
static <K .V> Map<K，V> of(E…elements)创建一个具有指定元素的Map集合对象

注意： 这个集合不能添加，不能删除，不能修改。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/479584.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

基础算法(五)：DFS、BFS与剪枝

基础算法(五)：DFS、BFS与剪枝

前言 前面的基础算法笔记已经断更好久了&#xff0c;因为荔枝觉得还是得先学一下基础的数据结构知识之后才能更好的入门算法。在这篇文章中荔枝主要记录DFS和BFS的相关基础知识、答题的模板以及自己的一些浅薄理解&#xff0c;同样的也会涉及到相关的剪枝操作。 一、搜索算法概…
阅读更多...
java基础学习-7

java基础学习-7

文章目录 异常小总结编译时异常和运行时异常小总结 异常在代码中的两个作用异常的方式JVM虚拟机默认处理异常的方式自己处理&#xff08;捕获异常&#xff09;灵魂四问抛出异常异常中的常见方法小总结小练习 自定义异常 File----路径File的概述和构造方法小总结 File的成员方法…
阅读更多...
线性表之顺序表(C语言实现)

线性表之顺序表(C语言实现)

前言 &#x1f388;个人主页:&#x1f388; :✨✨✨初阶牛✨✨✨ &#x1f43b;推荐专栏: &#x1f354;&#x1f35f;&#x1f32f; c语言初阶 &#x1f511;个人信条: &#x1f335;知行合一 &#x1f349;本篇简介:>:讲解数据结构的入门知识,线性结构之顺序表. 金句分享:…
阅读更多...
机器学习笔记 基于深度学习的边缘检测

机器学习笔记 基于深度学习的边缘检测

一、Holistically-Nested Edge Detection 边缘检测是视觉工作中十分常用的技术，传统边缘检测已经包含了很多经典的诸如Canny、Robert等等，都是各有擅场，不过有一点问题，就是很多参数需要人工调试，所以深度学习研究人员提出了基于卷积神经网络的边缘检测算法。 即HED，该算…
阅读更多...
uniapp拍照离线定位，获取图片信息，经纬度解析地址

uniapp拍照离线定位，获取图片信息，经纬度解析地址

✅作者简介&#xff1a; 我是痴心阿文&#xff0c;你们的学友哥&#xff0c;今天给大家分享uniapp拍照离线定位&#xff0c;获取图片信息&#xff0c;经纬度解析地址 &#x1f4c3;个人主页:痴心阿文的博客_CSDN博客-Vue.js,数组方法,前端领域博主 &#x1f525;本文前言&#…
阅读更多...
【数据结构】超详细之顺序表（利用C语言实现）

【数据结构】超详细之顺序表（利用C语言实现）

文章目录 前言一、顺序表是什么&#xff1f;二、顺序表的实现步骤 1.顺序表的初始化以及开辟空间2.实现顺序表的头插、尾插以及打印3.实现顺序表的头删、尾删以及打印4.实现顺序表的查找5.实现顺序表指定位置插入6.实现顺序表指定位置删除7.释放内存总结 前言 数据结构是一个程…
阅读更多...
离散数学_九章：关系（3）

离散数学_九章：关系（3）

9.3 关系的表示 1、用集合表示关系2、用矩阵表示关系矩阵表示关系⭐集合上的关系矩阵 R 自反时 R 对称时 R 反对称时 ⭐确定关系合成的矩阵 3、用有向图表示关系有向图⭐从有向图中 确定关系具有的属性 自反性对称性反对称性传递性 本节及本章的剩余部分研究的所有关系均为二…
阅读更多...
函数（详解）——C语言

函数（详解）——C语言

Hello&#xff0c;友友们前段时间忙拖更了这么久&#xff0c;趁着五一假期好好卷上一波哈哈哈。好的&#xff0c;我们本期主要对C语言中的函数进行讲解。 1.什么是函数 在数学中也常常用到函数&#xff0c;但你对C语言中的函数有了解吗&#xff1f; 在C语言中函数是一段可重…
阅读更多...
数据结构学习分享之单链表详解

数据结构学习分享之单链表详解

数据结构第三课 1. 前言2. 链表的概念以及结构3. 链表的分类4.链表的实现4.1 初始化结构4.2 尾插函数4.3 尾删函数4.4 头插函数4.5 头删函数4.6 开辟新节点4.7 销毁链表 5. 单链表OJ题目6. 顺序表和链表的区别7. 总结 1. 前言 &#x1f493;博主CSDN:杭电码农-NEO&#x1f493;…
阅读更多...
五年开发经验前端程序员，刚入职一个月就要离职，我来聊聊看法

五年开发经验前端程序员，刚入职一个月就要离职，我来聊聊看法

最近有一个新来的同事&#xff0c;估计又要离职了吧。从他的工作经历来看&#xff0c;大概有5年的前端工作经验&#xff0c;但是头发看起来挺少的&#xff0c;不知道是工作加班导致的&#xff0c;看他的性格不太像是经常加班的。 他这个人就是我们公司人事面试的&#xff0c;虽…
阅读更多...
操作系统——进程管理

操作系统——进程管理

0.关注博主有更多知识 操作系统入门知识合集 目录 0.关注博主有更多知识 4.1进程概念 4.1.1进程基本概念 思考题&#xff1a; 4.1.2进程状态 思考题&#xff1a; 4.1.3进程控制块PCB 4.2进程控制 思考题&#xff1a; 4.3线程 思考题&#xff1a; 4.4临界资源与临…
阅读更多...
躺平减脂减重法补充篇——无需控制碳水摄入的有效方法，另推一种健康的运动和防止老年慢性病的方式...

躺平减脂减重法补充篇——无需控制碳水摄入的有效方法，另推一种健康的运动和防止老年慢性病的方式...

本文此前已经连续发表了六篇相关文章&#xff0c;内容确实比较多&#xff0c;最近又做了一组实验&#xff0c;进食了大量的锅巴&#xff0c;看看是否会带来体重的增加&#xff0c;每天进食量都不少于200克锅巴&#xff0c;对&#xff0c;4两重&#xff0c;而且是在每天正常进食…
阅读更多...
SAPUI5 之XML Views (视图) 笔记

SAPUI5 之XML Views (视图) 笔记

文章目录 官网 Walkthrough学习-XML Views视图案例要求&#xff1a;我们把上面通过index.html body的展示放在XML中展示1.0.1 新增view文件夹1.0.2 在xml文件中新增一个Text 文本1.0.3 在index.js中实例化view视图1.0.4 执行刷新浏览器1.0.5 调试界面分析结果 官网 Walkthrough…
阅读更多...
假期给朋友介绍如何学习java和找工作的建议？

假期给朋友介绍如何学习java和找工作的建议？

Java学习 一、学习Java的建议1. 学习Java基础知识2. 学习Java框架3. 学习Java Web开发4. 学习Java数据库编程5. 学习Java工具6.学习Java中的多线程技术6. 练习编程 二、找工作的建议1. 准备好简历2. 寻找工作机会3. 准备面试4. 提高自己的技能5. 关注行业动态 学习Java和找工作…
阅读更多...
第十九章 观察者模式

第十九章 观察者模式

文章目录 前言普通方式解决问题CurrentConditions 显示当前天气情况WeatherData 管理第三方Clint 测试 一、观察者模式(Observer)原理完整代码SubjectObserverWeatherData implements SubjectCurrentConditions implements ObserverBaiduSite implements ObserverClint 前言 普…
阅读更多...
《软件工程教程》(第2版) 主编：吴迪 马宏茹 丁万宁 第十章课后习题参考答案

《软件工程教程》(第2版) 主编：吴迪 马宏茹 丁万宁 第十章课后习题参考答案

第十章 面向对象设计 课后习题参考答案 一、单项选择题 &#xff08;1&#xff09;A &#xff08;2&#xff09;B &#xff08;3&#xff09;B &#xff08;4&#xff09;D &#xff08;5&#xff09;A &#xff08;6&#xff09;C&#xff08;7&#xff09;D &#xff0…
阅读更多...
【学习心得】Python多版本控制

【学习心得】Python多版本控制

问题描述&#xff1a;本文主要解决Windows系统下的多个Python版本共存问题。 &#xff08;一&#xff09;安装不同版本Python 官方下载链接&#xff1a;Python Releases for Windows | Python.org 下载如图中所示的版本&#xff08;64位Windows系统可执行安装包版本&#xff0…
阅读更多...
赞！数字中国建设峰会上的金仓风采

赞！数字中国建设峰会上的金仓风采

4月30日&#xff0c;第六届数字中国建设成果展览会圆满落幕。人大金仓深度参与本届峰会&#xff0c;在会上发布产品新版本&#xff0c;展出国产数据库前沿的行业解决方案和创新应用成果&#xff0c;出席国资央企SaaS应用服务共享平台伙伴签约仪式&#xff0c;吸引众多用户、伙伴…
阅读更多...
面试官：你知道 Spring lazy-init 懒加载的原理吗？

面试官：你知道 Spring lazy-init 懒加载的原理吗？

普通的bean的初始化是在容器启动初始化阶段执行的&#xff0c;而被lazy-init修饰的bean 则是在从容器里第一次进行context.getBean(“”)时进行触发。 Spring 启动的时候会把所有bean信息(包括XML和注解)解析转化成Spring能够识别的BeanDefinition并存到Hashmap里供下面的初始…
阅读更多...
k210单片机定时器的应用

k210单片机定时器的应用

定时器应该是一个单片机的标准配置&#xff0c;所以k210也是有的&#xff0c;拥有3个定时器&#xff0c;具体的使用方法我们往下看&#xff1a; 分步介绍&#xff1a; 首先是相关模块的使用 构造函数&#xff1a; machine.Timer(id,channel,modeTimer.MODE_ONE_SHOT,period100…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023