从零开始学Java_第十二章

最新推荐文章于 2024-09-05 10:39:00 发布
最新推荐文章于 2024-09-05 10:39:00 发布
阅读量80 收藏
点赞数
分类专栏： 从零开始学java 文章标签： java 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46618025/article/details/131423616
版权
本文详细介绍了几种常见的排序算法，包括基本查找、二分查找、插值查找、斐波那契查找以及分块查找。此外，还讨论了Java中的Arrays工具类及其常用方法，并讲解了Lambda表达式在简化匿名内部类和实现函数式编程中的应用。
摘要由CSDN通过智能技术生成

十二、常见算法和Lambda

12.1 常见算法

查找算法

基本查找

基本查找也叫做顺序查找。

说明：顺序查找适合于存储结构为数组或者链表。

基本思想：顺序查找也称为线形查找，属于无序查找算法。从数据结构线的一端开始，顺序扫描，依次将遍历到的结点与要查找的值相比较，若相等则表示查找成功；若遍历结束仍没有找到相同的，表示查找失败。

public class A01_BasicSearchDemo1 {
    public static void main(String[] args) {
        //基本查找/顺序查找
        //核心：
        //从0索引开始挨个往后查找
        //需求：定义一个方法利用基本查找，查询某个元素是否存在
        //数据如下：{131, 127, 147, 81, 103, 23, 7, 79}
        int[] arr = {131, 127, 147, 81, 103, 23, 7, 79};
        int number = 82;
        System.out.println(basicSearch(arr, number));
    }
    //参数：
    //一：数组
    //二：要查找的元素
    //返回值：
    //元素是否存在
    public static boolean basicSearch(int[] arr, int number){
        //利用基本查找来查找number在数组中是否存在
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == number){
                return true;
            }
        }
        return false;
    }
}

二分查找

二分查找也叫做折半查找。

说明：元素必须是有序的，从小到大，或者从大到小都是可以的。

如果是无序的，也可以先进行排序。但是排序之后，会改变原有数据的顺序，查找出来元素位置跟原来的元素可能是不一样的，所以排序之后再查找只能判断当前数据是否在容器当中，返回的索引无实际的意义。

基本思想：也称为是折半查找，属于有序查找算法。用给定值先与中间结点比较。比较完之后有三种情况：

  • 相等说明找到了。
  • 要查找的数据比中间节点小，说明要查找的数字在中间节点左边。
  • 要查找的数据比中间节点大，说明要查找的数字在中间节点右边。
package com.itheima.search;
public class A02_BinarySearchDemo1 {
    public static void main(String[] args) {
        //二分查找/折半查找
        //核心：
        //每次排除一半的查找范围

        //需求：定义一个方法利用二分查找，查询某个元素在数组中的索引
        //数据如下：{7, 23, 79, 81, 103, 127, 131, 147}

        int[] arr = {7, 23, 79, 81, 103, 127, 131, 147};
        System.out.println(binarySearch(arr, 150));
    }
    public static int binarySearch(int[] arr, int number){
        //1.定义两个变量记录要查找的范围
        int min = 0;
        int max = arr.length - 1;
        //2.利用循环不断的去找要查找的数据
        while(true){
            if(min > max){
                return -1;
            }
            //3.找到min和max的中间位置
            int mid = (min + max) / 2;
            //4.拿着mid指向的元素跟要查找的元素进行比较
            if(arr[mid] > number){
                //4.1 number在mid的左边
                //min不变，max = mid - 1；
                max = mid - 1;
            }else if(arr[mid] < number){
                //4.2 number在mid的右边
                //max不变，min = mid + 1;
                min = mid + 1;
            }else{
                //4.3 number跟mid指向的元素一样
                //找到了
                return mid;
            }
        }
    }
}

插值查找

二分查找中查找点计算如下：

mid=(low+high)/2, 即mid=low+1/2*(high-low);

我们可以将查找的点改进为如下：

mid=low+(key-a[low])/(a[high]-a[low])*(high-low)，

这样，让mid值的变化更靠近关键字key，这样也就间接地减少了比较次数。

基本思想：基于二分查找算法，将查找点的选择改进为自适应选择，可以提高查找效率。当然，差值查找也属于有序查找。

细节：对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。反之，数组中如果分布非常不均匀，那么插值查找未必是很合适的选择。

代码跟二分查找类似，只要修改一下mid的计算方式即可。

斐波那契查找

基本思想：也是二分查找的一种提升算法，通过运用黄金比例的概念在数列中选择查找点进行查找，提高查找效率。同样地，斐波那契查找也属于一种有序查找算法。

斐波那契查找也是在二分查找的基础上进行了优化，优化中间点mid的计算方式即可。

public class FeiBoSearchDemo {
    public static int maxSize = 20;

    public static void main(String[] args) {
        int[] arr = {1, 8, 10, 89, 1000, 1234};
        System.out.println(search(arr, 1234));
    }

    public static int[] getFeiBo() {
        int[] arr = new int[maxSize];
        arr[0] = 1;
        arr[1] = 1;
        for (int i = 2; i < maxSize; i++) {
            arr[i] = arr[i - 1] + arr[i - 2];
        }
        return arr;
    }

    public static int search(int[] arr, int key) {
        int low = 0;
        int high = arr.length - 1;
        //表示斐波那契数分割数的下标值
        int index = 0;
        int mid = 0;
        //调用斐波那契数列
        int[] f = getFeiBo();
        //获取斐波那契分割数值的下标
        while (high > (f[index] - 1)) {
            index++;
        }
        //因为f[k]值可能大于a的长度，因此需要使用Arrays工具类，构造一个新法数组，并指向temp[],不足的部分会使用0补齐
        int[] temp = Arrays.copyOf(arr, f[index]);
        //实际需要使用arr数组的最后一个数来填充不足的部分
        for (int i = high + 1; i < temp.length; i++) {
            temp[i] = arr[high];
        }
        //使用while循环处理，找到key值
        while (low <= high) {
            mid = low + f[index - 1] - 1;
            if (key < temp[mid]) {//向数组的前面部分进行查找
                high = mid - 1;
                /*
                  对k--进行理解
                  1.全部元素=前面的元素+后面的元素
                  2.f[k]=k[k-1]+f[k-2]
                  因为前面有k-1个元素没所以可以继续分为f[k-1]=f[k-2]+f[k-3]
                  即在f[k-1]的前面继续查找k--
                  即下次循环,mid=f[k-1-1]-1
                 */
                index--;
            } else if (key > temp[mid]) {//向数组的后面的部分进行查找
                low = mid + 1;
                index -= 2;
            } else {//找到了
                //需要确定返回的是哪个下标
                if (mid <= high) {
                    return mid;
                } else {
                    return high;
                }
            }
        }
        return -1;
    }
}

分块查找

当数据表中的数据元素很多时，可以采用分块查找。

汲取了顺序查找和折半查找各自的优点，既有动态结构，又适于快速查找。

分块查找适用于数据较多，但是数据不会发生变化的情况，如果需要一边添加一边查找，建议使用哈希查找。

分块查找的过程：

  1. 需要把数据分成N多小块，块与块之间不能有数据重复的交集。
  2. 给每一块创建对象单独存储到数组当中
  3. 查找数据的时候，先在数组查，当前数据属于哪一块
  4. 再到这一块中顺序查找
package com.itheima.search;

public class A03_BlockSearchDemo {
    public static void main(String[] args) {
        /*
            分块查找
            核心思想：
                块内无序，块间有序
            实现步骤：
                1.创建数组blockArr存放每一个块对象的信息
                2.先查找blockArr确定要查找的数据属于哪一块
                3.再单独遍历这一块数据即可
        */
        int[] arr = {16, 5, 9, 12,21, 18,
                     32, 23, 37, 26, 45, 34,
                     50, 48, 61, 52, 73, 66};

        //创建三个块的对象
        Block b1 = new Block(21,0,5);
        Block b2 = new Block(45,6,11);
        Block b3 = new Block(73,12,17);

        //定义数组用来管理三个块的对象（索引表）
        Block[] blockArr = {b1,b2,b3};

        //定义一个变量用来记录要查找的元素
        int number = 37;

        //调用方法，传递索引表，数组，要查找的元素
        int index = getIndex(blockArr,arr,number);
        //打印一下
        System.out.println(index);
    }

    //利用分块查找的原理，查询number的索引
    private static int getIndex(Block[] blockArr, int[] arr, int number) {
        //1.确定number是在那一块当中
        int indexBlock = findIndexBlock(blockArr, number);

        if(indexBlock == -1){
            //表示number不在数组当中
            return -1;
        }
        //2.获取这一块的起始索引和结束索引   --- 30
        // Block b1 = new Block(21,0,5);   ----  0
        // Block b2 = new Block(45,6,11);  ----  1
        // Block b3 = new Block(73,12,17); ----  2
        int startIndex = blockArr[indexBlock].getStartIndex();
        int endIndex = blockArr[indexBlock].getEndIndex();
        //3.遍历
        for (int i = startIndex; i <= endIndex; i++) {
            if(arr[i] == number){
                return i;
            }
        }
        return -1;
    }

    //定义一个方法，用来确定number在哪一块当中
    public static int findIndexBlock(Block[] blockArr,int number){ //100
        //从0索引开始遍历blockArr，如果number小于max，那么就表示number是在这一块当中的
        for (int i = 0; i < blockArr.length; i++) {
            if(number <= blockArr[i].getMax()){
                return i;
            }
        }
        return -1;
    }
}

class Block{
    private int max;//最大值
    private int startIndex;//起始索引
    private int endIndex;//结束索引
    public Block() {
    }
    public Block(int max, int startIndex, int endIndex) {
        this.max = max;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }
    /**
     * 获取
     * @return max
     */
    public int getMax() {
        return max;
    }
    /**
     * 设置
     * @param max
     */
    public void setMax(int max) {
        this.max = max;
    }
    /**
     * 获取
     * @return startIndex
     */
    public int getStartIndex() {
        return startIndex;
    }
    /**
     * 设置
     * @param startIndex
     */
    public void setStartIndex(int startIndex) {
        this.startIndex = startIndex;
    }
    /**
     * 获取
     * @return endIndex
     */
    public int getEndIndex() {
        return endIndex;
    }
    /**
     * 设置
     * @param endIndex
     */
    public void setEndIndex(int endIndex) {
        this.endIndex = endIndex;
    }
    public String toString() {
        return "Block{max = " + max + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";
    }
}

排序算法

冒泡排序

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。

它重复的遍历过要排序的数列，一次比较相邻的两个元素，如果他们的顺序错误就把他们交换过来。

这个算法的名字由来是因为越大的元素会经由交换慢慢"浮"到最后面。

算法步骤

  • 相邻的元素两两比较，大的放右边，小的放左边

  • 第一轮比较完毕之后，最大值就已经确定，第二轮可以少循环一次，后面以此类推

  • 如果数组中有n个数据，总共我们只要执行n-1轮的代码就可以

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

选择排序

算法步骤

  • 从0索引开始，跟后面的元素一一比较

  • 小的放前面，大的放后面

  • 第一次循环结束后，最小的数据已经确定

  • 第二次循环从1索引开始以此类推

  • 第三轮循环从2索引开始以此类推

  • 第四轮循环从3索引开始以此类推。

插入排序

插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过创建有序序列和无序序列，然后再遍历无序序列得到里面每一个数字，把每一个数字插入到有序序列中正确的位置。

插入排序在插入的时候，有优化算法，在遍历有序序列找正确位置时，可以采取二分查找。

插入排序步骤

将0索引的元素到N索引的元素看做是有序的，把N+1索引的元素到最后一个当成是无序的。

遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如遇到相同数据，插在后面。

N的范围：0~最大索引

public static void insertionSort(int[] arr) {
    int n = arr.length;
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = key;
    }
}

快速排序

快速排序是由东尼·霍尔所发展的一种排序算法。

快速排序又是一种分而治之思想在排序算法上的典型应用。

快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快，而且效率高！

它是处理大数据最快的排序算法之一了。

private static void sort(int[] arr, int low, int high) {
	// 枢轴的索引
    int pivotIndex;
    if (low < high) {
        // 将数组一分为二，并返回枢轴的索引
        pivotIndex = partition(arr, low, high);
        // 对低子表递归排序
        sort(arr, low, pivotIndex - 1);
        // 对高子表递归排序
        sort(arr, pivotIndex + 1, high);
    }
}

private static int partition(int[] arr, int low, int high) {
    int pivot = arr[low];
    while (low < high) {
        while (low < high && arr[high] >= pivot) high--;//找到右边比基准小的
        arr[low] = a[high];
        while (low < high && arr[low] <= pivot) low++;//找到左边比基准大的
        arr[high] = arr[low];
    }
    arr[low] = pivot;
    return low;
}

算法步骤

  • 从数列中挑出一个元素，一般都是左边第一个数字，称为 “基准数”;

  • 创建两个指针，一个从前往后走，一个从后往前走。

  • 先执行后面的指针，找出第一个比基准数小的数字

  • 再执行前面的指针，找出第一个比基准数大的数字

  • 交换两个指针指向的数字

  • 直到两个指针相遇

  • 将基准数跟指针指向位置的数字交换位置，称之为：基准数归位。

  • 第一轮结束之后，基准数左边的数字都是比基准数小的，基准数右边的数字都是比基准数大的。

  • 把基准数左边看做一个序列，把基准数右边看做一个序列，按照刚刚的规则递归排序

12.2 Arrays

Arrays介绍

Arrays是操作数组的工具类。

Arrays常用方法

  • public static String toString(数组) 把数组拼接成一个字符串
  • public static int binarySearch(数组，查找的元素) 二分法查找数组
  • public static int[] copyOf(原数组，新数组长度)
  • public static int[] copyOfRange(原数组，起始索引，结束索引)
  • public static void fill(数组，元素) 填充数组
  • public static void sort(数组) 按照默认方式进行数组排序
  • public static void sort(数组，排序规则) 按照指定规则排序
public class SortDemo {
    public static void main(String[] args) {
        Integer[] arr = {2, 3, 1, 5, 7,8, 4, 9};
        //底层原理：利用插入排序+二分查找的方式进行排序。
        //默认把0索引的数据当作是有序的序列，1索引到最后是无序的序列。
        //遍历无序的序列得到每一个元素。假设当前遍历得到的元素是A元素
        //把A往有序序列进行插入，在插入的时候，是利用二分查找确定A元素的插入点。
        //拿着A元素跟插入点进行比较，比较规则就是compare方法的方法体
        //如果返回方法的返回值是负数，拿着A继续跟前面的元素进行比较
        //如果返回方法的返回值是正数，拿着A继续跟后面的元素进行比较
        //如果返回方法的返回值是0，拿着A继续跟后面的元素进行比较
        //知道能确定A的最终位置
        //compare方法的形参：
        //参数一 o1：表示无序序列中得到的每一个元素
        //参数二 o2：有序序列中的元素
        //返回值
        //负数：表示当前要插入的元素是小的，放在前面。
        //整数：表示当前要插入的元素是大的，放在前面。
        //0：表示当前要插入的元素和现在的元素一样，放在后面。
        //简单理解：o1 - o2 升序 o2 - o1 降序
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        System.out.println(Arrays.toString(arr));

    }
}
12.3 Lambda表达式

Lambda表达式

Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
//lambda表达式
Arrays.sort(arr, (Integer o1, Integer o2)->{
                return o1 - o2;
			}
);

函数式编程

函数式编程(Functional programming)是一种思想特点。这种思想忽略面向对象复杂的语法，强调做什么，而不是谁去做。

面向对象：先找对象，让对象做事情。

Lambda表达式是JDK8开始后的一种新语法形式。

() ->{
    
}
  • ()对应方法的形参
  • ->固定格式
  • {} 对应方法的方法体

注意事项

  • Lambda表达式可以用来简化匿名内部类的书写。
  • Lambda表达式只能简化函数式接口的匿名内部类的写法。
    • 有且仅有一个抽象方法的接口叫做函数式接口，接口上方可以加@FuncitonalInterface注解
public static void main(){
    method(new Swim(){
        @Override
        public void swimming() {
            System.out.println("正在游泳")
        }
    });
    //利用lambda改写
    method(()->{
        	System.out.println("正在游泳")
    });
}

public static void method(Swim s) {
	s.swimming();
}
interface Swim{
    public abstract void swimming();
}

Lambda表达式的省略写法

省略核心：可推导，可省略。

省略规则：

  • 参数类型可以省略不写。
  • 如果只有一个参数，参数类型可以省略不写，同时()也可以省略。
  • 如果Lambda表达式的方法体只有一行，大括号，分号return可以省略不写，需要同时省略。
Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
//lambda表达式完整格式
Arrays.sort(arr, (Integer o1, Integer o2)->{
                return o1 - o2;
			}
);
//lambda表达式省略写法
Arrays.sort(arr, (o1, o2) -> o1 - o2);

nteger o2)->{
return o1 - o2;
}
);


**函数式编程**

函数式编程(Functional programming)是一种思想特点。这种思想忽略面向对象复杂的语法，强调做什么，而不是谁去做。

面向对象：先找对象，让对象做事情。

Lambda表达式是JDK8开始后的一种新语法形式。

```java
() ->{
    
}
  • ()对应方法的形参
  • ->固定格式
  • {} 对应方法的方法体

注意事项

  • Lambda表达式可以用来简化匿名内部类的书写。
  • Lambda表达式只能简化函数式接口的匿名内部类的写法。
    • 有且仅有一个抽象方法的接口叫做函数式接口，接口上方可以加@FuncitonalInterface注解
public static void main(){
    method(new Swim(){
        @Override
        public void swimming() {
            System.out.println("正在游泳")
        }
    });
    //利用lambda改写
    method(()->{
        	System.out.println("正在游泳")
    });
}

public static void method(Swim s) {
	s.swimming();
}
interface Swim{
    public abstract void swimming();
}

Lambda表达式的省略写法

省略核心：可推导，可省略。

省略规则：

  • 参数类型可以省略不写。
  • 如果只有一个参数，参数类型可以省略不写，同时()也可以省略。
  • 如果Lambda表达式的方法体只有一行，大括号，分号return可以省略不写，需要同时省略。
Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
//lambda表达式完整格式
Arrays.sort(arr, (Integer o1, Integer o2)->{
                return o1 - o2;
			}
);
//lambda表达式省略写法
Arrays.sort(arr, (o1, o2) -> o1 - o2);
代码叨位去
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
从零开始学Java系列汇总
一一哥
03-07 752
因为CSDN没有分类归纳博客的功能，所以特写本帖汇总《从零开始学Java系列》，方便大家查阅！希望各位小伙伴从本系列中可以从我的拙作中能对Java的高频面试题有所掌握，也希望各位可以多给与指教！
JAVA从零开始自学历程（第一周）
Forbidden_404的博客
03-13 4893
前言：本人25，之前从事工程方面工作，没有任何计算机基础。现已下定决心进军IT业，因产品的核心部分为研发，而研发的核心角色在我看来为后端研发，因此选择JAVA语言作为进军IT业的开始。此为前文，以后的成果整理不再表述前言。注：部分学习内容来自慕课网，有所借鉴。目录汇总：1、关键字2、标识符3、变量常量4、数据类型，类型转换5、注释6、运算符7、条件从句8、循环语句9、scanner用法10、数组1...
【从零开始学习JAVA | 第二十二篇】BigInteger
fckbb的博客
06-26 2213
本篇我们将介绍BigInteger这个比较实用一点的API，这个API在我们实际写项目中都是很实用的API，因此大家应该对这个API有更加熟练的掌握。
零基础学java web开发 pdf_从零开始学Java Web开发 PDF 扫描版[69M]
weixin_39997300的博客
02-13 361
java web是目前最流行的动态网页开发技术之一。本书由浅入深、循序渐进，使零基础的读者能够熟练掌握如何使用java web开发应用程序系统。本书分为4部分，第一部分是java语言基础篇，包括java基本语法、开发环境的安装和配置、java面向对象思想等基础知识。第二部分是jsp技术篇，包括jsp基本语法、jsp内置对象、jsp与javabean、jsp与jdbc、serverlet过滤器和监听...
mac 学习 java_Mac 新手从零学习JAVA 环境配置篇
weixin_35073484的博客
02-13 1097
前言笔者目前从事苹果移动端的开发，现在在学习Java后台开发，在此分享一下学习过程，也希望各位大佬指导下笔者，笔者先谢谢各位大佬了。正文一、检查电脑是否已经安装了jdk打开终端，输入 java -version图一若出现图一信息，则表示我们并未安装jdk，图二(1)图二(2)若出现图二信息，则表示我们已经安装jdk，请阅读 步骤三环境变量配置二、安装jdk安装方法有两个：1是传统安装，即下载jd...
从零开始学Java——基础篇
绝圣弃智-零的博客
12-12 9780
整理自菜鸟教程   Java 简介 Java是Java面向对象程序设计语言和Java平台的总称。 Java分为三个体系： JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版） JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版) JavaME(J2ME)(Java...
手把手 从零开始学习JAVA（入门基础）
Java_may的博客
06-25 9744
1、搭建JAVA开发环境 卸载JDK（未安装的请忽略） 将JDK的安装目录删除 删除JAVA_HOME以及CLASS_PATH 环境变量 删除PATH下与JAVA_HOME以及CLASS_PATH有关的环境变量 安装JDK 去Oracle官网下载JDK或者去一些国内镜像网站下载JDK安装文件 将JDK安装到本机中 新增环境变量JAVA_HOME，指定路径为JDK的安装目录 更新环境变量PATH，加入%JAVA_HOME\bin%、以及%JAVA_HOME\jre\bin% 打开电脑DOS命
从零开始学习Linux部署Java web项目
Code4Android
12-07 1万+
前言 最近越来越发现需要学习的东西太多了，前几天公司服务器出现问题，需要对服务器硬件进行维护，当然服务器上的服务需要部署到另一个服务器上。这对于我来说是很陌生的，虽然这件工作没有让我去做，但是还是很好奇web项目是如何部署到服务器的。其实很早之前就想学这学习这些，但是一直没有行动。所以趁着这股兴奋劲，就决定去学习一下，并做此次总结。 准备工作 虚拟机 ： VMware10 ja
从零开始学习 Java：简单易懂的入门指南之for循环（四）
热门推荐
m0_59230408的博客
07-28 2万+
流程控制语句，循环结构，switch，while，do...while
java实现爬虫_手把手教你从零开始用Java写爬虫
weixin_39937635的博客
02-12 3624
本文将手把手地教大家从零开始用Java写一个简单地爬虫！目标爬取全景网图片，并下载到本地收获通过本文，你将复习到：IDEA创建工程IDEA导入jar包爬虫的基本原理Jsoup的基本使用File的基本使用FileOutputStream的基本使用ArrayList的基本使用foreach的基本使用说明爬虫所用的HTM解析器为Jsoup。Jsoup可直接解析某个URL地址、HTML文本内容。它提供了一...
从零开始学JAVA第12章_内部类.ppt
11-14
Java内部类 Java内部类是Java编程语言中的一种特殊的类，它定义在另一个类的内部。内部类可以访问外部类的成员变量和成员方法，同时也可以被外部类访问。内部类可以分为非静态内部类、局部内部类、静态内部类和匿名...
从零开始学java
02-25
"从零开始学Java"是一套全面的学习资源，涵盖了从基础到进阶的21个章节内容，旨在帮助初学者逐步掌握这门语言的核心概念和技术。 在第1章，通常会介绍Java的历史和特点，让你对Java有一个整体的认识。它可能会涵盖...
从零开始学java web
02-25
本教程“从零开始学Java Web”旨在帮助初学者系统地掌握这一领域的基础知识，从第一章到第十七章，内容全面且详细。下面我们将逐一探讨这些章节可能涵盖的关键知识点。 第一章：Java Web入门 这一章通常会介绍Java ...
《从零开始学JAVA》配套PPT
04-06
《从零开始学JAVA》是一本面向初学者的优秀教程，配套的PPT旨在通过清晰易懂的方式，帮助读者逐步掌握Java编程语言的核心概念和技术。这21章的内容覆盖了从基础到进阶的全面知识体系，对于想要系统学习Java的你来说...
okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
追梦的鱼儿
09-04 620
OkHttp、Retrofit 和 RxJava 是 Android 开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。
JAVA基础：数据类型、命名规范
最新发布
weixin_53755148的博客
09-05 1287
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
SpringBoot 项目集成 xxl-job
qq_58159506的博客
09-03 738
SpringBoot 项目集成 xxl-job
nmt---Docker-compose自动化部署
qq_69920145的博客
09-03 1031
static-rr 权重, leastconn 最少连接, source 请求IP, 轮询 roundrobin。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 这⾥是容器中的IP地址，由于配置的是轮询roundrobin，weight 权重其实没有⽣效。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。# 在 mysql 创建⼀个没有权限的haproxy⽤户，密码为空。10. docker-compose移除容器。
JVM 垃圾回收机制：GC
m0_60462557的博客
09-04 1465
JVM的垃圾回收机制：GC，是Java提供的对于内存自动回收的机制。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值