学习韩顺平老师java基础笔记(自用)3.30

最新推荐文章于 2022-09-11 18:45:21 发布
最新推荐文章于 2022-09-11 18:45:21 发布
阅读量786 收藏
点赞数
分类专栏： 学习记录 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47828100/article/details/123858404
版权

学习内容：

  1. 集合的理解和好处
  2. 集合的框架体系
  3. Collection 接口和常用方法
  4. List 接口和常用方法
  5. ArrayList 底层结构和源码分析
  6. Vector 底层结构和源码剖析
  7. LinkedList 底层结构
  8. ArrayList 和 LinkedList 比较

学习产出：

1.集合的理解和好处

1.1 数组

1)长度开始时必须指定，而且一旦指定，不能更改
2)保存的必须为同一类型的元素
3)使用数组进行增加/删除元素的示意代码一比较麻烦

1.2 集合

1)可以动态保存任意多个对象，使用比较方便!
2)提供了一系列方便的操作对象的方法: add、remove、 set、 get等
3)使用集合添加,删除新元素的示意代码-简洁了

2. 集合的框架体系

单列数组
Collection
在这里插入图片描述

3. Collection 接口和常用方法

3.1 Collection 接口实现类的特点

public interface Collection<E> extends Iterable <E>
1) collection实现子类可以存放多个元素，每个元素可以是Object
2)有些Collection的实现类，可以存放重复的元素，有些不可以
3)有些Collection的实现类， 有些是有序的(List), 有些不是有序(Set)
4) Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的

案例:

public class CollectionMethod {
    public static void main(String[] args) {
        List list = new ArrayList();
        //add:添加单个元素
        list.add("jack");
        list.add(10);//list.add(new Integer(10))
        list.add(true);
        System.out.println("list="+list);

        //remove 删除指定元素
        list.remove(0);//删除第一个元素
//        list.remove(true);//指定删除某个元素
//        list.remove((Integer)10);//删除Integer类型
        System.out.println("list="+list);

        //contains 查找元素是否存在
        System.out.println(list.contains(10));

        //size 获取元素的个数
        System.out.println(list.size());

        //isEmpty 判断是否为空
        System.out.println(list.isEmpty());

        //clear 清空
        list.clear();
        System.out.println(list);

        //addAll 添加多个元素
        ArrayList list1 = new ArrayList();
        list1.add("红楼梦");
        list1.add("三国演义");
        list.addAll(list1);
        System.out.println("list="+list);

        //containAll 判断多个元素是否都存在
        System.out.println(list.containsAll(list1));

        //removeAll 删除多个元素
        list.removeAll(list1);
        System.out.println(list);
        System.out.println(list1);
    }
}

3.2 Collection 接口遍历元素方式 1-使用 Iterator(迭代器)

1) Iterator对象称为迭代器，主要用于遍历Collection集合中的元素
2)所有实现了Collection接口的集合类都有一个iterator(方法， 用以返回一个实现了Iterator接口的对象，
 即可以返回一个迭代器。
3) Iterator的结构.[看一-张图]
4) Iterator仅用于遍历集合，Iterator本身并不存放对象。

迭代器的执行原理:
迭代器的执行原理

Iterator接口的方法
Iterator接口的方法
案例:

public class CollectionIterator {
    public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(new Book("三国演义","罗贯中",10.1));
        col.add(new Book("水浒传","施耐庵",5.1));
        col.add(new Book("红楼梦","曹雪芹",36.5));
        //System.out.println("col="+col);
        //现在希望能够遍历集合
        //1.先得到 col 对应的迭代器
        Iterator iterator = col.iterator();
        //2.使用while遍历即可
//        while (iterator.hasNext()){//判断是否还有数据
//            //返回下一个元素，类型为Ovject
//            Object obj = iterator.next();
//            System.out.println("obj="+obj);
//        }
        //快捷键，快速生成 while ==>itit 回车
        //显示所有快捷键的快捷键 ctrl+j
        while (iterator.hasNext()) {
            Object obj =  iterator.next();
            System.out.println("obj="+obj);
        }
        //3.当退出while循环后 这是iterator迭代器,指向最后的元素
        //4.如果想再次遍历，需要充值迭代器
        iterator=col.iterator();//充值迭代器
        System.out.println("===第二次遍历===");
        while (iterator.hasNext()) {
            Object obj =  iterator.next();
            System.out.println("obj="+obj);
        }
    }
}
class Book{
    private String name;
    private String author;
    private double price;

    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

3.3 Collection 接口遍历对象方式 2-for 循环增强
代码实现:

public class CollectionFor {
    public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(new Book("三国演义","罗贯中",10.1));
        col.add(new Book("水浒传","施耐庵",5.1));
        col.add(new Book("红楼梦","曹雪芹",36.5));

        //1.使用增强for  在collecton集合
        //2.增强for，底层仍然是迭代器
        //3.增强for可以理解成就是简化版本的 迭代器遍历
        //4.快捷键 I
        for (Object book :col) {
            System.out.println("Book="+book);
        }

        //1.使用增强for  在数组使用
        int[] arr = {1,2,5,6};
        for (int i: arr) {
            System.out.println(i);
        }
    }
}

4.List接口和常用方法

4.1 List 接口基本介绍

List接口是Collection接口的子接口
1) List集合 类中元素有序(即添加顺序和取出顺序-致)、 且可重复[案例]
2) List集 合中的每个元素都有其对应的顺序索引，即支持索引。[案例]
3) List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
4) JDK API中List接口的实现类有:
	ArrayList、LinkedList和Vector

4.2 List 接口的常用方法

案例:

public class ListMethod {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("张三丰");
        list.add("贾宝玉");
        // void add(int index, Object ele):在 index 位置插入 ele 元素
        //在index = 1 的位置插入一个对象
        list.add(1, "武松");
        System.out.println("list=" + list);
        // boolean addAll(int index, Collection eles):从 index 位置开始将 eles 中的所有元素添加进来
        List list2 = new ArrayList();
        list2.add("jack");
        list2.add("tom");
        list.addAll(1,list2);
        System.out.println("list="+list);
        // Object get(int index):获取指定 index 位置的元素
        //说过
        // int indexOf(Object obj):返回 obj 在集合中首次出现的位置
        System.out.println(list.indexOf("tom"));
        // int lastIndexOf(Object obj):返回 obj 在当前集合中末次出现的位
        list.add("武松");
        int i = list.lastIndexOf("武松");
        System.out.println(i);
        // Object remove(int index):移除指定 index 位置的元素，并返回此元
        list.remove(1);
        System.out.println("list="+list);
        // Object set(int index, Object ele):设置指定 index 位置的元素为 ele , 相当于是替换
        list.set(1,"玛丽");
        System.out.println("list="+list);
        // Object set(int index, Object ele):设置指定 index 位置的元素为 ele , 相当于是替换
        // 注意返回的子集合 fromIndex <=subList < toIndex
        List list1 = list.subList(0, 2);
        System.out.println("list1="+list1);
    }
}

4.3 List 接口练习
在这里插入图片描述
代码实现:

public class ListExercise {
    public static void main(String[] args) {
        List list = new ArrayList();
        for (int i = 0; i < 12; i++) {
            list.add("hello"+i);
        }
        System.out.println("list="+list);
        //在二号位插入一个元素 "韩顺平教育"
        list.add(1,"韩顺平教育");
        //获取第5个元素
        System.out.println("第5个元素="+list.get(4) );
        //删除第6个元素
        list.remove(5);
        System.out.println("list="+list);
        //修改第7个元素
        list.set(6,"三国演义");
        System.out.println("list="+list);
        //使用迭代器遍历
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object obj =  iterator.next();
            System.out.println(obj);
        }
    }
}

4.4 List 的三种遍历方式 [ArrayList, LinkedList,Vector]

代码实现:

public class ListFor {
    public static void main(String[] args) {
        //  List list = new ArrayList();
        List list = new LinkedList();
        list.add("北京烤鸭");
        list.add("京酱肉丝");
        list.add("烤全羊");
        list.add("鱼香肉丝");

        //遍历
        //1.迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object obj =  iterator.next();
            System.out.println(obj);
        }
        //2.增强for
        System.out.println("===增强for===");
        for (Object o :list) {
            System.out.println(o);
        }

        //3.使用普通for循环
        System.out.println("===普通for===");
        for (int i = 0; i < list.size(); i++) {
            System.out.println("对象="+list.get(i));
        }
    }
}

4.5 实现类的练习2
在这里插入图片描述
代码 实现：

public class ListExercise02 {
    public static void main(String[] args) {
        List list= new ArrayList();
        list.add(new Book("水浒传",25.6,"施耐庵"));
        list.add(new Book("西游记",38.5,"吴承恩"));
        list.add(new Book("红楼梦",35.5,"曹雪芹"));
        list.add(new Book("三国志",22.5,"罗贯中"));

        //遍历
        for (Object o :list) {
            System.out.println(o);
        }
        //冒泡排序
        sort(list);
        System.out.println("===排序后===");
        for (Object o :list) {
            System.out.println(o);
        }

    }
    public static void sort(List list){
        int listsize=list.size();
        for (int i = 0; i < listsize-1; i++) {
            for (int j = 0; j < listsize-1-i; j++) {
                //取出对象Book
                Book book1 = (Book) list.get(j);
                Book book2 = (Book) list.get(j+1);
                if (book1.getPrice()>book2.getPrice()){
                    list.set(j,book2);
                    list.set(j+1,book1);
                }
            }
        }

    }
}
class Book{
    private String name;
    private double price;
    private String author;

    public Book(String name, double price, String author) {
        this.name = name;
        this.price = price;
        this.author = author;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    @Override
    public String toString() {
        return "名称: " + name  +
                "\t 价格: " + price +
                "\t作者: " + author ;
    }
}

5 ArrayList 底层结构和源码分析

5.1 ArrayList 的注意事项

  1. permits all elements, including null , ArrayList可以加入null,并且多个
  2. ArrayList是由数组来实现数据存储的[后面老师解读源码]
  3. ArrayList基本等同于Vector，除了ArrayList是线程不安全(执行效率高)看源码
    在多线程情况下，不建议使用ArrayList

5.2 ArrayList 的底层操作机制源码分析(重点，难点.)

ArrayListSource.java
先说结论，在分析源码(示意图)

  1. ArrayList中维护了-个Object类型的数组elementData. [debug看源码]
    transient Object[] elementData; //transient表示瞬间，短暂的，表示该属性不会被序
    列号
  2. 当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0,第1
    次添加，则扩容elementData为10,如需要再次打容，则扩容elementData为1 .5倍。
  3. 如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，
    则直接扩容elementData为1.5倍。

在这里插入图片描述

6 Vector 底层结构和源码剖析

6.1 Vector 的基本介绍

  1. Vector类的定义说明
    public class Vector
    extends AbstractList
    implements List, RandomAccess, Cloneable, Serializable
  2. Vector底层也是一个对象数组，protected Object[] elementData;
  3. Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized public synchronized E
    get(int index) { if (index > = elementCount) throw newArrayIndexOutOfBoundsException(index); return elementData(index);
  4. 在开发中，需要线程同步安全时，考虑使用Vector

6.2 Vector 和 ArrayList 的比较
Vector 和 ArrayList 的比较

7 LinkedList 底层结构

7.1 LinkedList 的全面说明

  1. LinkedList底层实现了双向链表和双端队列特点
  2. 可以添加任意元素(元素可以重复)，包括null
  3. 线程不安全，没有实现同步

7.2 LinkedList 的底层操作机制

  1. LinkedList底层维护了一个双向链表
  2. LinkedList中维护了两个属性first和last分别指向首节点和尾节点
  3. 每个节点(Node对象) ,里面又维护了prev, next、 item三个属性，其中通过prev指向前一个，通过next指向后一个节点。最终实现双向链表.
  4. 所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高。

LinkedList 的底层操作机制
模拟一个简单的双向链表:

public class LinkedList01 {
    public static void main(String[] args) {
        //模拟一个简单的双向链表
        Node jack = new Node("jack");
        Node tom = new Node("tom");
        Node rose = new Node("rose");

        //连接三个结点
        jack.next=tom;
        tom.next=rose;
        rose.pre=tom;
        tom.pre=jack;

        //创建一个头结点和一个尾结点
        Node first = jack;//头结点指向jack
        Node last = rose;//尾结点指向rose

        //从头到尾遍历
        while (true){//如果头结点为空，说明first指向最后一个元素的next
            if (first==null){
                break;
            }
            System.out.println(first);
            first=first.next;
        }

        //从尾到头遍历
        System.out.println("===从尾到头遍历===");
        while (true){
            if (last==null){//如果尾结点为空，说明last指向第一个元素的pre
                break;
            }
            System.out.println(last);
            last=last.pre;
        }

        //链表的添加对象/数据，是多么的方便
        //要求，是在 tom --------- rose直接，插入一个对象 smith
        //1.创建一个结点,name 就是smith
        Node smith = new Node("smith");
        //2.把smith加入到双向链表中
        smith.next=rose;
        smith.pre=tom;
        rose.pre=smith;
        tom.next=smith;

        //再次遍历集合
        //首先把first重置
        first=jack;
        System.out.println("再次遍历");
        while (true){//如果头结点为空，说明first指向最后一个元素的next
            if (first==null){
                break;
            }
            System.out.println(first);
            first=first.next;
        }
        System.out.println("再次从尾到头遍历");
        last=rose;
        while (true){
            if (last==null){//如果尾结点为空，说明last指向第一个元素的pre
                break;
            }
            System.out.println(last);
            last=last.pre;
        }
    }
}
class Node{
    public Object item;//存放数据
    public Node next;//指向后一个结点
    public Node pre;//指向前一个结点

    public Node(Object item) {
        this.item = item;
    }

    @Override
    public String toString() {
        return "Node{" +
                "item=" + item +
                '}';
    }
}

7.3 LinkedList 的增删改查案例

public class LinkedListCRUD {
public static void main(String[] args) {
			LinkedList linkedList = new LinkedList();
			linkedList.add(1);
			linkedList.add(2);
			linkedList.add(3);
			System.out.println("linkedList=" + linkedList);
			//演示一个删除结点的
			linkedList.remove(); // 这里默认删除的是第一个结点
			//linkedList.remove(2);
			System.out.println("linkedList=" + linkedList);
			//修改某个结点对象
			linkedList.set(1, 999);
			System.out.println("linkedList=" + linkedList);
			//得到某个结点对象
			//get(1) 是得到双向链表的第二个对象
			Object o = linkedList.get(1);
			System.out.println(o);//999
			//因为 LinkedList 是 实现了 List 接口, 遍历方式
			System.out.println("===LinkeList 遍历迭代器====");
			Iterator iterator = linkedList.iterator();
			while (iterator.hasNext()) {
			Object next = iterator.next();
			System.out.println("next=" + next);
			}
			System.out.println("===LinkeList 遍历增强 for====");
			for (Object o1 : linkedList) {
			System.out.println("o1=" + o1);
			}
			System.out.println("===LinkeList 遍历普通 for====");
			for (int i = 0; i < linkedList.size(); i++) {
			System.out.println(linkedList.get(i));
			}
			//老韩源码阅读. /* 1. LinkedList linkedList = new LinkedList();
			public LinkedList() {}
			2. 这时 linkeList 的属性 first = null last = null
			3. 执行 添加
			public boolean add(E e) {
			linkLast(e);
			return true;
			}
			4.将新的结点，加入到双向链表的最后
			void linkLast(E e) {
			final Node<E> l = last;
			final Node<E> newNode = new Node<>(l, e, null);
			last = newNode;
			if (l == null)
			first = newNode;
			else
			l.next = newNode;
			size++;
			modCount++;
			}
			*/
			/*
			老韩读源码 linkedList.remove(); // 这里默认删除的是第一个结点
			1. 执行 removeFirst
			public E remove() {
			return removeFirst();
			}
			2. 执行
			public E removeFirst() {
			final Node<E> f = first;
			if (f == null)
			throw new NoSuchElementException();
			return unlinkFirst(f);
			}
			3. 执行 unlinkFirst, 将 f 指向的双向链表的第一个结点拿掉
			private E unlinkFirst(Node<E> f) {
			// assert f == first && f != null;
			final E element = f.item;
			final Node<E> next = f.next;
			f.item = null;
			f.next = null; // help GC
			first = next;
			if (next == null)
			last = null;
			else
			next.prev = null;
			size--;
			modCount++;
			return element;
		}
*/
	}
}

在这里插入图片描述

8 ArrayList 和 LinkedList 比较

8.1 ArrayList 和 LinkedList 的比较
ArrayList 和 LinkedList 的比较

如何选择ArrayList和LinkedList:

  1. 如果我们改查的操作多 ，选择ArrayList
  2. 如果我们增删的操作多，选择LinkedList
  3. 一般来说，在程序中，80%-90%都是查询， 因此大部分情况下会选择ArrayList
  4. 在一个项目中，根据业务灵活选择，也可能这样， 一个模块使用的是ArrayList,另 外一个模块是LinkedList,也就是说，要根据业务来进行选择
weixin_47828100
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
韩顺平 Java集合 自学笔记(Java30天基础)
心向阳光的天域的博客
10-18 3424
Java集合 韩顺平老师 Java基础学习笔记
韩顺平 2021零基础学Java 学习笔记（1）（自用）
热门推荐
weixin_43973189的博客
11-02 4万+
目录第 2 章 Java 概述第 3 章 变量第 4 章 运算符第 5 章 程序控制结构第 6 章 数组、排序和查找第 7 章 面向对象编程(基础部分)第 8 章 面向对象编程(中级部分) 第 2 章 Java 概述 2.1 Java 重要特点 Java 语言是面向对象的(oop) Java 语言是健壮的。Java 的强类型机制、异常处理、垃圾的自动收集等是 Java 程序健壮性的重要保证 Java 语言是跨平台性的。[即: 一个编译好的.class 文件可以在多个系统下运行，这种特性称为跨平台] Jav
韩顺平 2022零基础学 Java 学习笔记（1）
m0_56843184的博客
07-28 2515
节点流，它的灵活性和效率会受一些影响功能不是很强大处理流，可以理解为对节点流进行包装让我们这个流功能更加强大（也可以叫做包装流）httpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttpshttps。...
韩顺平java笔记完整版
09-07
java课件PPT、java基础，适合初次接触java的朋友，可以下载看看，ppt。大家最好还要看视频教程学习，一起对着看就可以。
韩顺平老师java视频全套
09-23
解压压缩包会有一个种子文件。直接迅雷下载即可，包含了韩顺平老师的java入门视频，jdbc,jsp,servlet,oracle,hibermate,spring,SHH框架，struct,linux,等十套视频，并且还包含了配套的源码。迅雷下载速度很快。20兆的宽带下载速度大概是2.3MB/s，没有开会员。
韩顺平编写的java学习笔记(全)
10-20
韩顺平编写的java学习笔记(全) 包含各种java的基本语法,以及3大项目的详细设计解释以及代码
韩顺平java笔记完整版.zip（无笔记，只是代码）
10-10
通过韩顺平老师的Java笔记完整版代码，学习者可以深入理解上述知识点，并通过实践加深对Java编程的理解和掌握。这些代码示例涵盖了广泛的Java应用领域，对于初学者和进阶开发者都是宝贵的资源。
韩顺平 java基础加强笔记整理
05-12
内容包括eclipse常用快捷键，可变参数，枚举，反射，泛型等等
java入门韩顺平所有资源笔记等B站对应学习视频
04-25
1) 以培养编程思想、提升编程能力为核心目标，达到能分析业务需求，并能用代码实现水平 ...8) 零基础的小伙伴，老韩强烈建议从第一阶段开始学习. 9) 因为课程内容非常全，录制周期长，老韩也会根据实际情况做微调
韩顺平Java学习资料【笔记+代码】
最新发布
05-12
内容概要：这份学习资料汇总了韩顺平老师的Java学习笔记和相关代码，旨在帮助学习者系统学习Java编程语言。笔记内容涵盖了Java语言基础、面向对象编程、数据结构与算法、网络编程、GUI编程等多个方面，通过清晰的...
韩顺平老师所有课程笔记
04-13
本文档包含韩顺平老师的linux，Java，Oracle，PHP，struts,j2ee,javascript课程笔记
韩顺平Java自学笔记 集合
m0_67946241的博客
09-06 958
笔记有很多缺陷，还有再完善
学习韩顺平老师java基础笔记(自用)3.29
weixin_47828100的博客
03-30 513
学习内容： 例如： System类 BigInteger 和 BigDecimal 类 日期类 学习产出： 1. System类 1.1 System 类常见方法和案例 1) exit退出当前程序 2) arraycopy :复制数组元素，比较适合底层调用，一般使用 Arrays.copyOf完成复制数组. int[] src={1,2,3}; int[] dest = new int[3]; System.arraycopy(src, 0, dest, 0, 3); 3) currentTimeMi
【笔记】Java 类与对象 快速复习（记录自 韩顺平 零基础30天学会Java 部分）
weixin_55935744的博客
03-09 550
1、重载 基本介绍 java中允许同一类中，多个同名方法的存在，但要求形参列表不一致。 注意事项和使用细节 方法名：必须相同 参数列表：必须不同（参数类型或个数或顺序，至少有一样不同，参数名无要求） 返回类型：无要求 2、可变参数 基本概念 Java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法 基本语法 访问修饰符 返回类型 方法名(数据类型... 形参名) 注意事项和使用细节 可变参数的实参可以为0个或任意多个 可变参数的实参可以为数组 可变参数的本质是数组 可变参数可
韩顺平 零基础30天学会Java第四章
暂未入门程序猿的博客
12-24 238
运算符 运算符介绍 运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等 算术运算符 赋值运算符 关系运算符[比较运算符] 逻辑运算符 位运算符[需要二进制基础] 三元运算符 算术运算符 算术运算符是对数值类型的变量进行运算的,在Java程序中使用的非常多。 ...
B站韩顺平java学习笔记（二十）-- 网络编程 章节
LW_20180806的博客
04-22 2315
一 网络的编程概念 1 网络通信 （1）概念 两台设备之间通过网络实现数据传输； （2）网络通信 将数据通过网络从一台设备传输到另一台设备； Java.net包下提供了一系列的类或接口，供程序员使用，完成网络通信。 2 网络 （1）概念 两台或多台设备通过一定物理设备连接起来构成了网络。 （2）基于网络的覆盖范围进行分类 局域网：覆盖范围最小，仅仅覆盖一个教师或一个机房； 城域网：覆盖范围较大，...
适合有编程基础的人看的《韩顺平零基础30天学java》笔记（P155~P171）
feifeide123的博客
09-11 350
研究生一枚，为后端实习和未来工作打基础。无意间发现韩顺平老师的课程，细心细致，讲课和吴恩达老师一样，都是保姆式讲解，各种基础知识都会补充，爱了。阅读提醒：本笔试适合有编程语言基础的伙伴阅读，因为本兔兔是本专业的，有c、c++、python 、sql基础，笔记中特别的基础的内容就没有记录。完全零基础的小伙伴建议跟着韩老师的课程自己记录。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值