【Java从入门到大牛】集合进阶上篇

最新推荐文章于 2024-11-11 00:03:55 发布
最新推荐文章于 2024-11-11 00:03:55 发布
阅读量204 收藏 1
点赞数
分类专栏： Java从入门到大牛 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62511863/article/details/131963864
版权

🔥 本文由 程序喵正在路上 原创，CSDN首发！
💖 系列专栏：Java从入门到大牛
🌠 首发时间：2023年7月29日
🦋 欢迎关注🖱点赞👍收藏🌟留言🐾
🌟 一以贯之的努力 不得懈怠的人生

目录

集合体系概述

集合体系结构
在这里插入图片描述

单列集合和双列集合

在这里插入图片描述

  • Collection 代表单列集合，每个元素（数据）只包含一个值
  • Map 代表双列集合，每个元素包含两个值，即一个键值对

Collection集合体系

在这里插入图片描述

Collection集合特点

List 系列集合：添加的元素是有序的、可重复的、有索引的

  • ArrayList、LinkedList：有序、可重复、有索引

Set 系列集合：添加的元素是无序的、不重复的、无索引的

  • HashSet：无序、不重复、无索引
  • LinkedHashSet：有序、不重复、无索引
  • TreeSet：按照大小默认升序排序、不重复、无索引

Collection的常用方法

为什么要先学 Collection 的常用方法 ？

因为 Collection 是单列集合的祖宗，它规定的方法（功能）是全部单列集合都会继承的

Collection 的常见方法如下：
在这里插入图片描述

具体应用

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

/**
    目标：掌握Collection集合的常用API
 */
public class CollectionTest2API {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>(); // 多态写法
        // 1.public boolean add(E e)：添加元素, 添加成功返回true。
        c.add("java1");
        c.add("java1");
        c.add("java2");
        c.add("java2");
        c.add("java3");
        System.out.println("c: " + c);

        // 2.public void clear()：清空集合的元素。
        //c.clear();
        //System.out.println("c: " + c);

        // 3.public boolean isEmpty()：判断集合是否为空 是空返回true,反之。
        System.out.println("isEmpty: " + c.isEmpty()); // false

        // 4.public int size()：获取集合的大小。
        System.out.println("size: " + c.size());

        // 5.public boolean contains(Object obj)：判断集合中是否包含某个元素。
        System.out.println("contains(\"java1\"): " + c.contains("java1")); // true
        System.out.println("contains(\"Java1\"): " + c.contains("Java1")); // false

        // 6.public boolean remove(E e)：删除某个元素:如果有多个重复元素默认删除前面的第一个！
        System.out.println("remove(\"java1\"): " + c.remove("java1"));
        System.out.println("c: " + c);

        // 7.public Object[] toArray()：把集合转换成数组
        Object[] arr1 = c.toArray();
        System.out.println("arr1: " + Arrays.toString(arr1));

        String[] arr2 = c.toArray(new String[c.size()]);
        System.out.println("arr2: " + Arrays.toString(arr2));

        System.out.println("--------------------------------------------");
        // 把一个集合的全部数据倒入到另一个集合中去。
        Collection<String> c1 = new ArrayList<>();
        c1.add("java1");
        c1.add("java2");
        Collection<String> c2 = new ArrayList<>();
        c2.add("java3");
        c2.add("java4");
        c1.addAll(c2); // 就是把c2集合的全部数据倒入到c1集合中去。
        System.out.println("c1: " + c1);
        System.out.println("c2: " + c2);
    }
}

在这里插入图片描述

Collection的遍历方式

迭代器

迭代器概述

迭代器是用来遍历集合的专用方式（数组没有迭代器），在 Java 中迭代器的代表是 Iterator

Collection集合获取迭代器的方法
在这里插入图片描述

Iterator迭代器中的常用方法

在这里插入图片描述

具体应用

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
    目标：Collection集合的遍历方式一：使迭代器Iterator遍历
 */
public class CollectionDemo01 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("小明");
        c.add("小红");
        c.add("小刚");
        System.out.println(c);

        // 使用迭代器遍历集合
        // 1、从集合对象中获取迭代器对象
        Iterator<String> it = c.iterator();

        // 2、我们应该使用循环结合迭代器遍历集合
        while (it.hasNext()){
            String ele = it.next();
            System.out.println(ele);
        }
    }
}

在这里插入图片描述

增强for

增强版for循环的格式

for (元素的数据类型 变量名 : 数组或者集合) {
}

Collection<String> c = new ArrayList<>();
...
for (String s : c) {
	System.out.println(s);
}
  • 增强 for 可以用来遍历集合或者数组
  • 增强 for 遍历集合，本质就是迭代器遍历集合的简化写法

增强for修改变量值会出现什么问题 ？

修改增强 for 中的变量值不会影响到集合中的元素

lambda表达式

Lambda表达式遍历集合

得益于 JDK8 开始的新技术 Lambda 表达式，提供了一种更简单、更直接的方式来遍历集合

需要使用 Collection 的如下方法来完成
在这里插入图片描述

在这里插入图片描述

具体应用

import java.util.ArrayList;
import java.util.Collection;

/**
     目标：Collection集合的遍历方式三：JDK8开始新增的Lambda表达式
 */
public class CollectionDemo03 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("小明");
        c.add("小红");
        c.add("小刚");

        c.forEach(s -> System.out.println(s));
        System.out.println("-----------------------");
        c.forEach(System.out::println);
    }
}

在这里插入图片描述

案例：遍历集合中的自定义对象

需求：展示多部电影信息

分析

  1. 每部电影都是一个对象，多部对象要使用集合装起来
  2. 遍历集合中的电影对象，输出每部电影的详情信息

案例代码实现

Movie 类

public class Movie {
    private String name;
    private double score;
    private String actor;

    public Movie() {
    }

    public Movie(String name, double score, String actor) {
        this.name = name;
        this.score = score;
        this.actor = actor;
    }

    public String getName() {
        return name;
    }

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

    public double getScore() {
        return score;
    }

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

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }

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

测试类

import java.util.ArrayList;
import java.util.Collection;

/**
 *       目标：完成电影信息的展示
 */
public class CollectionTest04 {
    public static void main(String[] args) {
        // 1、创建一个集合容器负责存储多部电影对象
        Collection<Movie> movies = new ArrayList<>();
        movies.add( new Movie("《肖生克的救赎》" , 9.7 ,  "罗宾斯"));
        movies.add( new Movie("《霸王别姬》" , 9.6 ,  "张国荣、张丰毅"));
        movies.add( new Movie("《阿甘正传》" , 9.5 ,  "汤姆.汉克斯"));
        System.out.println(movies);

        for (Movie movie : movies) {
            System.out.println("电影名：" + movie.getName());
            System.out.println("评分：" + movie.getScore());
            System.out.println("主演：" + movie.getActor());
            System.out.println("---------------------------------------------");
        }
    }
}

执行结果

在这里插入图片描述

集合存储对象的原理

在这里插入图片描述
可以发现，集合中存储的是元素对象的地址

List集合

特点、特有方法

List系列集合特点：有序、可重复、有索引

  • ArrayList：有序、可重复、有索引
  • LinkedList：有序、可重复、有索引

List集合的特有方法

List 集合因为支持索引，所以多了很多与索引相关的方法，当然，Collection 的功能 List 也都继承了
在这里插入图片描述
具体应用

import java.util.ArrayList;
import java.util.List;

/**
      目标：掌握List系列集合的特点，以及其提供的特有方法
 */
public class ListTest1 {
    public static void main(String[] args) {
        // 1.创建一个ArrayList集合对象（有序、可重复、有索引）
        List<String> list = new ArrayList<>();  // 一行经典代码
        list.add("蜘蛛精");
        list.add("至尊宝");
        list.add("至尊宝");
        list.add("牛夫人");
        System.out.println(list); // [蜘蛛精, 至尊宝, 至尊宝, 牛夫人]

        // 2.public void add(int index, E element): 在某个索引位置插入元素。
        list.add(2, "紫霞仙子");
        System.out.println(list);

        // 3.public E remove(int index): 根据索引删除元素,返回被删除元素
        System.out.println(list.remove(2));
        System.out.println(list);

        // 4.public E get(int index): 返回集合中指定位置的元素。
        System.out.println(list.get(3));

        // 5.public E set(int index, E element): 修改索引位置处的元素,修改成功后，会返回原来的数据
        System.out.println(list.set(3, "牛魔王"));
        System.out.println(list);
    }
}

在这里插入图片描述

遍历方式

List集合支持的遍历方式

  1. for 循环（因为 List 集合有索引）
  2. 迭代器
  3. 增强 for 循环
  4. Lambda 表达式

具体应用

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
    拓展：List系列集合的遍历方式
 */
public class ListTest2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("糖宝宝");
        list.add("蜘蛛精");
        list.add("至尊宝");

        //（1）for循环
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }
        System.out.println("--------------------");

        //（2）迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println("--------------------");

        //（3）增强for循环（foreach遍历）
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("--------------------");
        
        //（4）JDK 1.8开始之后的Lambda表达式
        list.forEach(s -> {
            System.out.println(s);
        });
    }
}

在这里插入图片描述

ArrayList集合的底层原理

ArrayList的特点

  • 基于数组实现的，数组的特点就是查询快、增删慢
  • 查询速度快（注意：是根据索引查询数据快）：查询数据通过地址值和索引定位，查询任意数据耗时相同
  • 删除效率低：可能需要把后面很多的数据进行前移
  • 添加效率极低：可能需要把后面很多的数据后移，再添加数据；或者也可能需要进行数组的扩容

ArrayList集合的底层原理

  1. 利用无参构造器创建的集合，会在底层创建一个默认长度为 0 的数组
  2. 添加第一个元素时，底层会创建一个新的长度为 10 的数组
  3. 存满时，会扩容 1.5 倍
  4. 如果一次添加多个元素，1.5 倍还放不下，则新创建数组的长度以实际为准

ArrayList集合适合的应用场景

  • ArrayList 适合：根据索引查询数据，比如根据随机索引取数据（高效），或者数据量不是很大时
  • ArrayList 不适合：数据量大的同时，又要频繁地进行增删操作

LinkedList集合的底层原理

LinkedList集合的底层原理

  • 基于双链表实现的
    在这里插入图片描述

  • 特点：查询慢，增删相对较快，但对首尾元素进行增删改查的速度是极快的

LinkedList新增了很多首尾操作的特有方法
在这里插入图片描述

LinkedList集合的应用场景

  1. 可以用来设计队列，队列的特点是先进先出、后进后出，队列只是在首尾增删元素，所以用 LinkedList 来实现很合适
  2. 可以用来设计栈，栈的特点是后进先出、先进后出，栈只是在首部增删元素，用 LinkedList 来实现很合适

具体应用

import java.util.LinkedList;

/**
 * 目标：掌握LinkedList集合的使用
 */
public class ListTest3 {
    public static void main(String[] args) {
        // 1、创建一个队列
        LinkedList<String> queue = new LinkedList<>();
        // 入队
        queue.addLast("第1号");
        queue.addLast("第2号");
        queue.addLast("第3号");
        queue.addLast("第4号");
        System.out.println(queue);
        // 出队
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue);
        System.out.println("--------------------------------------------------");

        // 2、创建一个栈对象
        LinkedList<String> stack = new LinkedList<>();
        // 压栈(push)
        stack.push("第1颗子弹");		// addFirst
        stack.push("第2颗子弹");
        stack.push("第3颗子弹");
        stack.push("第4颗子弹");
        System.out.println(stack);
        // 出栈(pop)
        System.out.println(stack.pop());	// removeFirst
        System.out.println(stack.pop());
        System.out.println(stack);
    }
}

在这里插入图片描述

Set集合

特点

Set 系列集合特点：无序——添加数据的顺序和获取出的数据顺序不一致；不重复；无索引

  • HashSet：无序、不重复、无索引
  • LinkedHashSet：有序、不重复、无索引
  • TreeSet：排序、不重复、无索引

注意：Set 要用到的常用方法，基本上就是 Collection 提供的，自己几乎没有额外新增一些常用功能

HashSet集合的底层原理

什么是哈希值 ？

  • 就是一个 int 类型的数值，Java 中每个对象都有一个哈希值

  • Java 中的所有对象，都可以调用 Object 类提供的 hashCode 方法，返回该对象自己的哈希值

    public int hashCode(): 返回对象的哈希码值

对象哈希值的特点

  • 同一个对象多次调用 hashCode() 方法返回的哈希值是相同的
  • 不同的对象，它们的哈希值一般不相同，但也有可能会相同（哈希碰撞）

HashSet集合的底层原理

  • 基于哈希表实现
  • 哈希表是一种增删改查数据性能都较好的数据结构

哈希表

  • JDK8 之前，哈希表 = 数组+链表
  • JDK8 开始，哈希表 = 数组+链表+红黑树

JDK8之前HashSet集合的底层原理，基于哈希表：数组+链表

  1. 创建一个默认长度为 16 的数组，默认加载因子为 0.75，数组名为 table
  2. 使用元素的哈希值对数组的长度求余计算出应存入的位置
  3. 判断当前位置是否为 null，如果是 null 直接存入
  4. 如果不为 null，表示当前位置有元素，则调用 equals 方法比较。相等，则不存；不相等，则存入数组
    JDK8 之前，新元素存入数组，占据老元素位置，老元素挂下面
    JDK8 开始之后，新元素直接挂在老元素下面
  5. 当数组存满到 16*0.75=12 时，就自动扩容，每次扩容为原先的两倍

如果数组快占满了，会出什么问题？该咋办？

链表会过长，导致查询性能降低，这时候就需要扩容了

JDK8开始HashSet集合的底层原理，基于哈希表：数组+链表+红黑树

JDK8 开始，当链表长度超过 8，且数组长度 >= 64时，自动将链表转成红黑树

深入理解HashSet集合去重复的机制

HashSet 集合默认不能对内容一样的两个不同对象去重复

比如有内容一样的两个学生对象存入到 HashSet 集合中去，HashSet 集合是不能去重复的

怎么让 HashSet 集合能够实现对内容一样的两个不同对象也能去重复？

如果希望 Set 集合认为两个内容一样的对象是重复的，必须重写对象的 hashSet() 和 equals() 方法

案例：Set集合去重复

需求：创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合，要求学生对象的成员变量值一样，我们就认为是同一个对象

分析

  1. 定义学生类，创建 HashSet 集合对象，创建学生对象
  2. 把学生添加到集合
  3. 在学生类中重写两个方法，hashCode() 和 equals()，自动生成即可
  4. 遍历集合（增强for）

自动生成步骤：在编辑器界面右击鼠标，选择 Generate，再选择 equals() and hashCode() 即可

代码示例

Student 类

import java.util.Objects;

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

    public Student() {
    }

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

    // 只要两个对象内容一样就返回true
    @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 && Double.compare(student.height, height) == 0 && Objects.equals(name, student.name);
    }

    // 只要两个对象内容一样，返回的哈希值就是一样的
    @Override
    public int hashCode() {
        // 姓名 年龄 身高计算哈希值的
        return Objects.hash(name, age, height);
    }

    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 double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

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

测试类

import org.w3c.dom.ls.LSOutput;

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

/**
 * 目标：自定义的类型的对象，比如两个内容一样的学生对象，如果让HashSet集合能够去重复！
 */
public class SetTest3 {
    public static void main(String[] args) {
        Set<Student> students = new HashSet<>();
        Student s1 = new Student("至尊宝", 28, 169.6);
        Student s2 = new Student("蜘蛛精", 23, 169.6);
        Student s3 = new Student("蜘蛛精", 23, 169.6);
        System.out.println(s2.hashCode());
        System.out.println(s3.hashCode());

        Student s4 = new Student("牛魔王", 48, 169.6);
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);

        for(Student s : students) {
            System.out.println(s);
        }
    }
}

在这里插入图片描述

LinkedHashSet集合的底层原理

  • 依然是基于哈希表（数组、链表、红黑树）实现的
  • 但是，它的每个元素都额外地多了一个双链表的机制记录它前后元素的值

TreeSet集合

  • 特点：不重复、无索引、可排序（默认升序排序，按照元素的大小，由小到大排序）
  • 底层是基于红黑树实现的排序

注意：

  • 对于数值类型：Integer、Double 默认按照数值本身的大小进行升序排序
  • 对于字符串类型：默认按照首字符的编号升序排序
  • 对于自定义类型如 Student 对象，TreeSet 默认是无法直接排序的

自定义排序规则

TreeSet 集合存储自定义类型的对象时，必须指定排序规则，支持如下两种方式来指定比较规则

  • 方式一：让自定义的类（如学生类）实现 Comparable 接口，重写里面的 compareTo 方法来指定比较规则

    public class Student implements Comparable<Student>

  • 方式二：通过调用 TreeSet 集合有参数构造器，可以设置 Comparator 对象（比较器对象，用于指定比较规则）

    public TreeSet(Comparator<? super E> comparator)

两种方式中，关于返回值的规则：

  • 如果认为第一个元素大于第二个元素，返回正整数即可
  • 如果认为第一个元素小于第二个元素，返回负整数即可
  • 如果认为第一个元素等于第二个元素，返回 0 即可，此时 TreeSet 集合只会保留一个元素，认为两者重复

注意：如果类本身有实现 Comparable 接口，TreeSet 集合同时也自带比较器，默认使用集合自带的比较器排序

具体应用

import java.util.Set;
import java.util.TreeSet;

/**
 * 目标：掌握TreeSet集合的使用。
 */
public class SetTest4 {
    public static void main(String[] args) {
        Set<Integer> set1 = new TreeSet<>();
        set1.add(6);
        set1.add(5);
        set1.add(5);
        set1.add(7);
        System.out.println(set1);

        // TreeSet就近选择自己自带的比较器对象进行排序
//        Set<Student> students = new TreeSet<>(new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
//                // 需求：按照身高升序排序
//                return Double.compare(o1.getHeight() , o2.getHeight());
//            }
//        });
        
        Set<Student> students = new TreeSet<>(( o1,  o2) ->  Double.compare(o1.getHeight() , o2.getHeight()));
        students.add(new Student("蜘蛛精",23, 169.7));
        students.add(new Student("紫霞",22, 169.8));
        students.add(new Student("至尊宝",26, 165.5));
        students.add(new Student("牛魔王",22, 183.5));
        System.out.println(students);
    }
}

在这里插入图片描述

集合的并发修改异常问题

集合的并发修改异常

  • 使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误
  • 由于增强 for 循环遍历集合就是迭代器遍历集合的简化写法，因此，使用增强 for 循环遍历集合，又在同时删除集合中的数据时，程序也会出现并发修改异常的错误

怎么保证遍历集合的同时删除数据而不出bug？

  • 使用迭代器遍历集合，但用迭代器自己的删除方法删除数据即可
  • 如果能用 for 循环遍历时，可以倒着遍历并删除；或者从前往后遍历，但删除元素后做 i-- 的操作

注意：使用增强 for 和 Lambda 表达式无法解决 bug

具体应用

import java.util.*;

/**
 * 目标：理解集合的并发修改异常问题，并解决。
 */
public class CollectionTest1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("王麻子");
        list.add("小李子");
        list.add("李爱花");
        list.add("张全蛋");
        list.add("晓李");
        list.add("李玉刚");
        System.out.println(list);

        // 需求：找出集合中全部带“李”的名字，并从集合中删除。

        // 使用for循环遍历集合并删除集合中带李字的名字
//        for (int i = 0; i < list.size(); i++) {
//            String name = list.get(i);
//            if(name.contains("李")){
//                list.remove(name);
//                i--;
//            }
//        }
//        System.out.println(list);


        // 需求：找出集合中全部带“李”的名字，并从集合中删除。
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String name = it.next();
            if(name.contains("李")){
                // list.remove(name); // 并发修改异常的错误
                it.remove(); // 删除迭代器当前遍历到的数据，每删除一个数据后，相当于也在底层做了i--
            }
        }
        System.out.println(list);
    }
}

在这里插入图片描述

程序喵正在路上
关注
专栏目录
【Java从入门到大牛】集合进阶下篇
一以贯之的努力 不得懈怠的人生
08-02 648
本文主要讲解了Map集合和Stream流的应用。
完整的Java从小白到大牛的自学路线
程序员高级码农的博客
03-15 1358
我相信这些读者或多或少都有一些 Java 基础，但由于看不到全貌，学了一段时间很容易迷失。所以我在寻思着能不能写一个学习的地图或者路线，让读者能知道下一步该学什么，自己离大厂的 offer还有多远的距离。一个人最怕的不是路途遥远，而是看不到胜利曙光。这篇文章主要内容包括(干货满满)：学Java有哪些就业方向？数据结构和算法设计模式计算机基础Java 入门Java 高手进阶基础框架（SSM）微服务框架常用中间件数据库分布式架构必须掌握的工具软件学习资源网站列表汇总。
牛逼！Java 从入门到精通，超全汇总版
热门推荐
程序员cxuan的个人主页
05-06 7万+
文章目录Java 基础Head First JavaJava 核心技术卷一Java 编程思想设计模式Head First 设计模式图解设计模式设计模式重学 Java 设计模式Java 进阶Java 并发编程实战Java 并发编程艺术Java 并发编程之美图解Java多线程设计模式JVM深入理解 Java 虚拟机Java 虚拟机规范HotSpot 实战自己动手写 Java 虚拟机MySQLMySQL 基础教程SQL 基础教程深入浅出 MySQLMySQL 必知必会SQL 必知必会高性能 MySQLMySQL
java从入门到进阶
misaka___的博客
10-07 5591
在博主认为，对于入门级学习java的最佳学习方法莫过于视频+博客+书籍+总结，前三者博主将淋漓尽致地挥毫于这篇博客文章中，至于总结在于个人，实际上越到后面你会发现学习的最好方式就是阅读参考官方文档其次就是国内的书籍，博客次之，这又是一个层次了，这里暂时不提后面再谈。博主将为各位入门java保驾护航，各位只管冲鸭！！！上天是公平的，只要不辜负时间，时间自然不会辜负你。 何谓学习？博主所理解的学习，它是一个过程，是一个不断累积、不断沉淀、不断总结、善于传达自己的个人见解以及乐于分享的过程。 文章目录 一、Jav
关东升老师从小白到大牛系列丛书（由清华大学出版社出版）
hacker707的博客
12-15 1万+
关东升老师从小白到大牛系列丛书（由清华大学出版社出版），感兴趣的可以购买!!!
java从入门到精通pdf脚本之家，大牛深入讲解
2401_84415234的博客
04-23 998
由于文案过于长，在此就不一一介绍了，这份Java后端架构进阶笔记内容包括：Java集合，JVM、Java并发、微服务、SpringNetty与 RPC 、网络、日志 、Zookeeper 、Kafka 、RabbitMQ 、Hbase 、MongoDB、Cassandra 、Java基础、负载均衡、数据库、一致性算法、Java算法、数据结构、分布式缓存等等知识详解。本知识体系适合于所有Java程序员学习，关于以上目录中的知识点都有详细的讲解及介绍，掌握该知识点的所有内容对你会有一个质的提升，
java培训出来怎么成大牛_Java从入门到精通，大牛是怎样炼成的？
weixin_42298507的博客
03-02 176
我们总想和大牛一样，对java语言精通一些，但是大牛也是从小白过来的，我们在校期间或者刚工作，需要好好的练习自己的java技术，找出不足之处，进行练习，那么java入门到精通，大牛是怎样炼成的呢？首先是java基础教程我们在java培训班学习的基础一定要打牢，毕竟基础稳了才能谈其他，例如： jdk的安装和环境配置、变量和常量、条件判断语句,、循环语句，这些Java基础语法需要掌握。其次是java的...
C语言推荐书籍从入门到进阶带你走上大牛之路（珍藏版）
weixin_40769843的博客
10-21 954
C语言推荐书籍从入门到进阶带你走上大牛之路（珍藏版）2018年11月24日 10:38:31 杨柳_ 阅读数：981 前言：技术书阅读方法论一.速读一遍（最好在1~2天内完成） 人的大脑记忆力有限，在一天内快速看完一本书会在大脑里留下深刻印象，对于之后复习以及总结都会有特别好的作用。 对于每一章的知识，先阅读标题，弄懂大概讲的是什么主题，再去快速看一遍，不懂也没有关系，但是一定要在不懂的地方做个记...
【Java刷题进阶】基础入门篇⑩
zhangxia_的博客
09-05 2273
Java基础学习主要以练习为主，很多朋友听完视频课程学会基础以后感觉对练手项目无从下手，这里推荐去牛客网看看，这里的IT题库内容很丰富，属于国内做的很好的IT学习网站，而且是课程+刷题+面经+求职+讨论区分享，一站式求职学习网站，最最最重要的里面的资源全部免费！！📩从基础开始练习，知识点编排详细，题目安排合理，题目表述以指导的形式进行。整个题单覆盖了java入门的全部知识点以及全部语法，通过知识点分类逐层递进，从基础开始到最后的实践任务，都会非常详细地指导你应该使用什么函数，应该怎么输入输出。
Java零基础到大牛实战进阶指南
08-31
《Java零基础到大牛实战进阶指南》是一部专为Java初学者及希望深化技能的开发者量身打造的全面学习资源。从Java语言基础语法讲起，逐步深入面向对象编程、集合框架、多线程、网络编程等核心知识，并结合实际项目案例...
牛客网Java学习资源推荐：从入门到进阶经典教材
这四本书籍构成了一个从入门到进阶的完整学习路径，无论是初次接触Java还是想要进一步提升Java技能的开发者，都能在这些资料中找到适合自己的学习材料，通过理论与实践相结合的方式，逐步掌握Java编程的精髓。...
Java学习进阶：免费下载《从小白到大牛精简版》笔记
资源摘要信息:"本书是专门为Java初学者设计的一本入门指南，涵盖了从Java基础到面向对象编程再到高级特性的完整学习路径。本书内容精简，注重实际操作和实践，旨在帮助读者快速理解并掌握Java编程的核心概念和技能。...
java架构师进阶之路
henhenha的博客
03-30 4781
包含了计算机基础、算法和数据结构、常用工具、java核心知识、性能优化、基础框架、数据库、消息队列、缓存中间件、搜索引擎、大数据、RPC、网关、容器、面试等知识
Java基础07
最新发布
m0_74977981的博客
11-11 532
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
JAVA-01-变量
LJH_laura_li的博客
11-08 397
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 235
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 912
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 650
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

程序喵正在路上

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

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

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

打赏作者

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

抵扣说明：

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

余额充值