算法—学习、练习和总结

已于 2022-05-22 14:46:58 修改
阅读量282 收藏
点赞数 1
分类专栏： 算法 JAVA核心技术 文章标签： 算法 学习 排序算法
于 2022-05-21 23:30:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Andya_net/article/details/124895790
版权

文章目录

引言

  总结算法基本概念以及常见的算法思路。

基本概念

时间复杂度

  1. 在表达式中，只需要高阶项，去除低阶项和高阶项的系数，剩余部分f(n)，则时间复杂度为O(f(n))。

常数

  1. 常数操作：若一个操作和样本的数据量无关，每次都是固定时间内完成操作，则成为常数操作。

空间复杂度

排序算法

冒泡排序

算法

大的往后冒泡：

  1. 将序列中所有元素两两比较，将最大的数往后交换，冒泡到最后面。
  2. 将剩余序列中所有元素两两比较，将最大的数往后交换，冒泡到最后。
  3. 重复第2步，直到只剩下一个数。

代码

时间复杂度：O(n^2)

package com.test.selfcoding.algorithm.sort;

import com.test.selfcoding.utils.RandomArrayUtil;

import java.util.Arrays;

/**
 * @ClassNAME BubbleSort
 * @Description TODO
 * @Author Andya
 * @Version 1.0
 */
public class BubbleSort {

    public static void bubbleSort1(int[] arr) {
        /*
        1. 将序列中所有元素两两比较，将最大的数往后交换，冒泡到最后面n-1。
        2. 将剩余序列中所有元素两两比较，将最大的数往后交换，冒泡到上一次的最后前一个数n-1-i。
        3. 重复第2步，直到只剩下一个数。
         */
        int count = 0;
        // 第一层循环i: 0 ~ n-1
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                }
                count++;
            }
        }

        System.out.println("times: " + count);
    }

    public static void bubbleSort2(int[] arr) {
        /*
        1. 将序列中所有元素两两比较，将最大的数往后交换，冒泡到最后面n-1。
        2. 将剩余序列中所有元素两两比较，将最大的数往后交换，冒泡到上一次的最后前一个数n-1-i。
        3. 重复第2步，直到只剩下一个数。
         */
        int count = 0;
        // 第一层循环i: 0 ~ n-1
        for (int i = 0; i < arr.length - 1; i++) {
            boolean flag = true;
            // 循环后若发现已经排序完毕，则无需进入交换
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                    flag = false;
                }
                count++;
            }

            //无任何交换，发现是顺序的，直接退出
            if (flag) {
                break;
            }

        }

        System.out.println("times: " + count);

    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
//        int[] arr = {1, 2, 5, 2, 3, 6, 6, 8, 7, 4};
//        bubbleSort1(arr);
//        System.out.println(Arrays.toString(arr));

        int[] arr = {1, 2, 3, 4, 5, 6, 6, 7, 8};
        bubbleSort1(arr);
        System.out.println(Arrays.toString(arr));
        bubbleSort2(arr);
        System.out.println(Arrays.toString(arr));

        int[] arr1 = RandomArrayUtil.generateRandomArray(1000, 1000);
        int[] arr2 = RandomArrayUtil.copyArray(arr1);

        bubbleSort1(arr1);
        System.out.println(Arrays.toString(arr1));

        bubbleSort2(arr2);
        System.out.println(Arrays.toString(arr2));

    }

}

//结果
times: 36
[1, 2, 3, 4, 5, 6, 6, 7, 8]
times: 8
[1, 2, 3, 4, 5, 6, 6, 7, 8]
times: 8646
[-860, -843, -776, -760, -731, -696, -694, -694, -674, -659, -658, -655, -651, -641, -617, -604, -558, -556, -547, -544, -540, -524, -524, -519, -512, -496, -463, -439, -429, -407, -401, -362, -346, -335, -303, -291, -290, -277, -271, -267, -248, -239, -231, -228, -227, -221, -221, -219, -202, -181, -178, -153, -143, -142, -134, -113, -101, -75, -68, -50, -33, -33, -22, -16, 6, 16, 27, 36, 37, 41, 47, 57, 67, 75, 91, 96, 109, 119, 135, 146, 152, 159, 160, 175, 176, 192, 202, 211, 217, 218, 281, 281, 299, 313, 334, 354, 359, 359, 375, 377, 404, 409, 441, 445, 446, 459, 459, 472, 478, 488, 510, 514, 532, 553, 567, 580, 582, 583, 612, 635, 643, 661, 662, 680, 682, 693, 715, 742, 790, 792, 795, 814]
times: 8510
[-860, -843, -776, -760, -731, -696, -694, -694, -674, -659, -658, -655, -651, -641, -617, -604, -558, -556, -547, -544, -540, -524, -524, -519, -512, -496, -463, -439, -429, -407, -401, -362, -346, -335, -303, -291, -290, -277, -271, -267, -248, -239, -231, -228, -227, -221, -221, -219, -202, -181, -178, -153, -143, -142, -134, -113, -101, -75, -68, -50, -33, -33, -22, -16, 6, 16, 27, 36, 37, 41, 47, 57, 67, 75, 91, 96, 109, 119, 135, 146, 152, 159, 160, 175, 176, 192, 202, 211, 217, 218, 281, 281, 299, 313, 334, 354, 359, 359, 375, 377, 404, 409, 441, 445, 446, 459, 459, 472, 478, 488, 510, 514, 532, 553, 567, 580, 582, 583, 612, 635, 643, 661, 662, 680, 682, 693, 715, 742, 790, 792, 795, 814]

选择排序

算法

  1. 第一层循环先定义一个记录最小元素的下标，然后第二层循环一次后面的数组，找到最小的元素，最后将它放到前面排序好的序列。

代码

时间复杂度：O(n^2)，空间复杂度：O(1)

package com.test.selfcoding.algorithm;

import java.util.Arrays;

/**
 * @ClassNAME SelectionSort
 * @Description TODO
 * @Author Andya
 * @Date 2022/5/21 11:30
 * @Version 1.0
 */
public class SelectionSort {
    public static void selectionSort(int[] arr) {
        //空或者长度小于等于1，则直接返回，无需排序
        if (arr == null || arr.length < 2) {
            return;
        }

        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            // i ~ n-1上找到最小值下标
            for (int j = i + 1; j < arr.length; j++) {
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            }

            if (minIndex != i) {
                swap(arr, i, minIndex);
            }
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    public static void main(String[] args) {
        int[] arr = {1,5,3,7,8,4,2,1,2,6};
        selectionSort(arr);
        System.out.println(Arrays.toString(arr));
    }

}

插入排序

算法

  1. 将第一个数和第二个数排序，构成一个有序序列；
  2. 将后面第三个数插入进去，构成一个新的有序序列；
  3. 依次对第四个数、第五个数……直到最后一个数，重复第二步。

代码

时间复杂度：O(n^2)，空间复杂度：O(1)

package com.test.selfcoding.algorithm;

import java.util.Arrays;

/**
 * @ClassNAME InsertionSort
 * @Description TODO
 * @Author Andya
 * @Version 1.0
 */
public class InsertionSort {

    public static void insertionSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }

        for (int i = 1; i < arr.length; i++) {
            // 让第 0~i 有序
            for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
                //左边的大于右边的，则左右换位置，并且右边的一直往前比较，一直到下标为0或数比左边的大时就不用进入循环了。
                swap(arr, j, j + 1);
            }
        }

    }

    private static void swap(int[] arr, int j, int i) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 5, 3, 4, 2, 7, 6, 9, 8};
        insertionSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

二分查找法

算法

常见应用

  1. 在一个有序数组中，找某个数是否存在。
  2. 在一个有序数组中，找大于等于某个数最左侧的位置。
  3. 局部最小值问题。（此处就不一定是有序， 找中间数，若是局部最小值，则返回，若不是，左侧相邻的数和右侧相邻的数谁小，则二分到此区间必定有局部最小）

代码

时间复杂度：O(logN)

异或运算

算法

a ^ 0 == a
a ^ a == 0
满足交换律和结合律。

常见应用

  1. 不用额外的变量交换两个数。
  2. 一个数组中有1个数出现了奇数次，其他数都出现偶数次，查找这1个数。
  3. 一个数组中有2个数出现了奇数次，其他数都出现偶数次，查找这2个数。

算法应用：136. 只出现一次的数字

136. 只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1
示例 2:

输入: [4,1,2,1,2]
输出: 4

这种题目，我们就可以使用异或的如下两个特性进行求解：

  1. 一个数与本身异或，结果总是为 0
  2. 一个数与0异或，结果总是其自身
package com.test.selfcoding.algorithm;

/**
 * @ClassNAME SingleNumber
 * @Description TODO
 * @Author Andya
 * @Date 2022/5/21 17:01
 * @Version 1.0
 */
public class SingleNumber {

    public static int singleNumber(int[] nums) {
        int ans = nums[0];
        for (int i = 1; i < nums.length; i++) {
            //使用异或^运算
            //1. 一个数与本身异或，结果总是为0
            //2. 一个数与0异或，结果总是其自身
            ans = ans ^ nums[i];
        }

        return ans;
    }

    public static void main(String[] args) {
        int[] nums = {4,1,2,1,2};
        System.out.println(singleNumber(nums));   //结果：4
    }

}

算法应用：389.找不同

389. 找不同

package com.test.selfcoding.algorithm;

/**
 * @ClassNAME FindTheDifference
 * @Description TODO
 * @Author Andya
 * @Date 2022/5/21 17:25
 * @Version 1.0
 *
 */
public class FindTheDifference {
    /**
     * 使用异或
     * @param s
     * @param t
     * @return
     */
    public static char findTheDifferenceWithXOR(String s, String t) {
        int ans = 0;
        for (int i = 0; i < s.length(); i++) {
            ans ^= s.charAt(i);
        }
        // 此时ans将s字符串中的所有字符拼接起来了
        for (int j = 0; j < t.length(); j++) {
            ans ^=  t.charAt(j);
        }

        return (char)ans;
    }

    /**
     * 使用位计数法
     * @param s
     * @param t
     * @return
     */
    public static char findTheDifferenceWithCount(String s, String t) {
        // 26个字母大小的数组
        int[] letter = new int[26];

        for (int i = 0; i < s.length(); i++) {
            char sChar = s.charAt(i);
            //对应字符位置的数值+1
            letter[sChar - 'a']++;
        }

        for (int j = 0; j < t.length(); j++) {
            char tChar = t.charAt(j);
            //对应字符位置的数值-1
            letter[tChar - 'a']--;
            //找到负数的则为不同
            if (letter[tChar - 'a'] < 0) {
                return tChar;
            }
        }

        return ' ';
    }

    /**
     * 使用ASCII码计算
     * @param s
     * @param t
     * @return
     */
    public static char findTheDifferenceWithASCII(String s, String t) {
        //将字符串s和t中每个字符的ASCII码的值求和，得到asciiS和asciiT
        int asciiS = 0, asciiT = 0;
        for (int i = 0; i < s.length(); i++) {
            asciiS += s.charAt(i);
        }

        for (int j = 0; j < t.length(); j++) {
            asciiT += t.charAt(j);
        }
        return (char) (asciiT - asciiS);
    }

    public static void main(String[] args) {
        String s = "abcdef";
        String t = "abcdfeg";
        System.out.println(findTheDifferenceWithXOR(s, t));
        System.out.println(findTheDifferenceWithCount(s, t));
        System.out.println(findTheDifferenceWithASCII(s, t)); //结果：g
    }

}

算法应用：寻找2个奇数次的数

package com.test.selfcoding.algorithm;

import java.util.Arrays;

/**
 * @ClassNAME Find2OddNumbers
 * @Description TODO
 * @Author Andya
 * @Date 2022/5/21 21:51
 * @Version 1.0
 */
public class Find2OddNumbers {

    //寻找一个数组中仅有的2个奇数次的数，假设a,b,c,c,d,d，则a和b即为要找的结果
    public static int[] find2OddNumbers(int[] arr) {
        //eor = a ^ b
        int eor = 0;
        for (int cur : arr) {
            eor ^= cur;
        }
        //若res1 = b 则，res2 = eor ^ res1
        //找到二进制最右边的1，取非，加1，再与自身
        // eor =   111010010
        // ~eor =  000101101
        //~eor+1 = 000101110
        //eor & (~eor+1) = 000000010
        int right = eor & (~eor + 1);
        int onlyOne = 0;
        for (int cur : arr) {
            //取一半，此二进制位为0或者为1，即为一半
            if ((cur & right) == 1) {
                onlyOne ^= cur;
            }
        }

        return new int[] {onlyOne, eor ^ onlyOne} ;
    }

    public static void main(String[] args) {
        int[] arr = new int[] {1, 2, 3, 4, 2, 1, 3, 5, 4, 6, 7, 7};
        System.out.println(Arrays.toString(find2OddNumbers(arr))); //结果：[5,6]
    }

}

对数器

package com.test.selfcoding.algorithm;

import java.util.Arrays;

/**
 * @ClassNAME SelectionSort
 * @Description TODO
 * @Author Andya
 * @Date 2022/5/21 11:30
 * @Version 1.0
 */
public class SelectionSort {
    public static void selectionSort(int[] arr) {
        //空或者长度小于等于1，则直接返回，无需排序
        if (arr == null || arr.length < 2) {
            return;
        }

        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            // i ~ n-1上找到最小值下标
            for (int j = i + 1; j < arr.length; j++) {
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            }

            if (minIndex != i) {
                swap(arr, i, minIndex);
            }
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }


    //for test: 对数器 generate random array
    public static int[] generateRandomArray(int maxSize, int maxValue) {
        // Math.random() -> [0,1) 所有的小数，等概率返回一个
        // Math.random() * N -> [0,N) 所有的小数，等概率返回一个
        // (int)(Math.random() * N -> [0,N-1]所有的整数，等概率返回一个

        //长度随机
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];

        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
        }
        return arr;
    }

    // for test: copy array
    public static int[] copyArray(int[] arr) {
        if (arr == null) {
            return null;
        }
        //新建一个数组
        int[] res = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            res[i] = arr[i];
        }
        return res;
    }

    // for test: is equals
    public static boolean isEqual(int[] arr1, int[] arr2) {
        if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
            return false;
        }

        if (arr1 == null && arr2 == null) {
            return true;
        }

        if (arr1.length != arr2.length) {
            return false;
        }

        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }

        return true;
    }

    // for test: sortArray
    public static void sortArray(int[] arr) {
        Arrays.sort(arr);
    }



    public static void main(String[] args) {
//        int[] arr = {1, 5, 3, 7, 8, 4, 2, 1, 2, 6};
//        selectionSort(arr);
//        System.out.println(Arrays.toString(arr));

        int testTime = 600000;
        int maxSize = 100;
        int maxValue = 100;
        boolean succeed = true;
        for (int i = 0; i < testTime; i++) {
            int[] arr1 = generateRandomArray(maxSize, maxValue);
            int[] arr2 = copyArray(arr1);
            selectionSort(arr1);
            sortArray(arr2);
            if (!isEqual(arr1, arr2)) {
                System.out.println(Arrays.toString(arr1));
                System.out.println(Arrays.toString(arr2));
                succeed = true;
                break;
            }
        }

        System.out.println("result: " + (succeed ? "succeeded" : "failed!"));

        int[] arr = generateRandomArray(maxSize, maxValue);
        System.out.println(Arrays.toString(arr));
        selectionSort(arr);
        System.out.println(Arrays.toString(arr));
    }

}
Andya_net
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法设计与分析学习总结
qq_40798278的博客
12-11 1万+
算法设计与分析学习总结 通过对《算法设计与分析》这门课的学习，似乎对算法有了一定的了解，之前对算法并没有太多的接触，只是一些普通的编程。选课的时候，觉得特别有意思，就选了这门课，通过学习各类算法，有了一定的认识。递归法，分治法，蛮力法，回溯法。贪心算法等等，对之后的编都有很大的帮助。 现在，我深刻的明白这门课的对软件工程专业的重要性，程序的编写都离不开它，对培养思维能力也有一定的帮助，还能培养我们...
聚类算法总结
CharlesDavid
12-27 2万+
聚类算法 文章目录聚类算法聚类算法简介认识聚类算法聚类算法的概念聚类算法与分类算法最大的区别聚类算法api初步使用api介绍案例聚类算法实现流程k-means聚类步骤案例练习小结模型评估误差平方和(SSE \The sum of squares due to error)：“肘”方法 (Elbow method)— K值确定轮廓系数法（Silhouette Coefficient）CH系数（Calinski-Harabasz Index）总结算法优化Canopy算法配合初始聚类K-means++二分k-me
算法学习路线总结: 算法工程师的修炼手册
最新发布
码到三十五
07-01 1万+
在算法工程师的学习之路上，经常被问到的问题就是“应该如何系统地学习算法？那，今天，它来了！我将为大家详细解读算法工程师的学习路线，不仅包括基础理论知识，还涵盖实战经验和项目实践。为了更好地帮助大家，我还专门收集整理了配套的视频教程、教材推荐以及刷题网站等资源。
【Machine Learning系列】带你快速学习十大机器学习算法
Java 技术专栏，从入门到精通，熟悉企业级开发
04-19 1万+
机器学习算法的学习是一个长期的过程，需要不断地练习和实践才能够掌握。通过坚持不懈地学习和实践，你才能快速掌握机器学习算法并应用于实际问题中。
常见机器学习算法优缺点总结
周君的个人博客
08-04 6110
常见机器学习算法优缺点总结 1. 回归 回归是一种用于连续型数值变量预测和建模的监督学习算法，使用案例包括房地产价格、股价走势或学生成绩等的预测。 回归任务的特征是具有数值型目标变量的标注数据集。换言之，每一个用以监督算法的观察样本，都有一个数值型真值。 1.1 （正则化）线性回归 线性回归是回归任务最常用的算法。它最简的形式，是用一个连续的超平面来拟合数据集（比如，当你仅有两个变...
算法学习规划
仰望天空，妳我亦是行人.
03-16 1209
算法学习初步规划
机器学习实验报告- KNN算法
m0_64198455的博客
01-21 2247
K最近邻（KNN）算法是一种基本的模式识别和机器学习算法，发展于20世纪60年代。它是一种基于“类的相似性”进行分类的无参数算法，在许多实际应用中取得了良好的效果。在分类问题中，KNN算法将一个测试样本所在区域内训练样本的多数类作为该测试样本的预测类别；在回归问题中，KNN算法利用k个最近邻居的平均值或加权平均值预测连续变量。
深度学习系列资料总结
热门推荐
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
07-17 2万+
说明本系列深度学习资料集合包含机器学习、深度学习等各系列教程，主要以计算机视觉资料为主，包括图像识别、分类、检测、分割等，内容参考Github及网络资源，仅供个人学习。深度学习定义一般是指通过训练多层网络结构对未知数据进行分类或回归深度学习分类有监督学习方法——深度前馈网络、卷积神经网络、循环神经网络等；无监督学习方法——深度信念网、深度玻尔兹曼机，深度自编码器等。手写机器学习笔记github机器学习算法公式推导以及numpy实现github人工智能相关术语link。..................
对排序算法的一些思考和总结
m0_59602613的博客
02-12 1292
一味的好高骛远是不行的，在学习了一些框架之后，我又重新返回了基础知识的学习，今天想讲的就是数据结构中的排序算法。接下来我将以排序的类型进行总结（概括性）。 插入排序类 直接插入排序 将记录插入到一个已经排好序的有序列表中，从而得到一个新的、记录+1的有序列表。 通过赋值方式来取代交换，最优情况(序列本身有序)下时间复杂度能达到O(n)，减少了性能上的损耗，属于稳定排序。 希尔排序 作为直接插入排序的升级，采用跳跃分割策略，以“增量”为间隔的子序列内使用直接插入排序。直到最后的增量值为一。 相应
学习算法之前应该做哪些准备？
IT1124的博客
02-27 1745
先学一些基本的数据结构（如果连树是什么都不知道而是上来就刷题的话，刚开始会花大量的无用功在这些基础概念上面），比如：线性表(顺序表、链表)、特殊的线性表(栈、队列)、树(BST、AVL)、图，以及这些结构的基本性质。 掌握了这些数据结构的基本概念和性质后，开始刷题，LeetCode也好，牛客网也罢，随你心情，老老实实当个小镇做题家（这是个长期的过程，很容易劝退）。 语言方面，JDK 中有大量的类库方法，对一些典型的问题（比如：查找、排序、字符串匹配、最短路径问题……），尽量看看这些方法都是解决这些问题的
python学习项目联系，包含多个算法小练习
01-08
这个压缩包“python-master”显然包含了与Python学习相关的项目和算法练习，是初学者和进阶者提升Python技能的宝贵资源。以下是对这些练习可能涉及的知识点的详细解释： 1. **基础语法**：Python的基础语法包括变量...
Java算法题总结，供自己学习使用
02-20
总的来说，这份"Java算法题总结"资源应该包含了各种类型的题目，旨在通过实战练习提高读者的算法思维和编程技巧。通过不断练习和理解这些算法，不仅可以提升编程技能，还能在面试和实际工作中游刃有余。对于每个算法...
算法和数据结构 JAVA
06-09
“数据结构与算法（学长）”可能是学长的经验分享，包含了他在学习过程中总结的技巧、心得以及一些实用的Java实现代码。这种实践经验往往能提供独特的视角和解决问题的方法，对初学者来说是非常宝贵的资源。 通过...
算法练习，常见算法，面试常用
03-12
"labuladong的算法小抄完整版.pdf"和"（算法小抄）- top101.pdf"这两份文档很可能是关于算法的精炼总结，由知名博主labuladong提供。labuladong以其通俗易懂的讲解方式深受读者喜爱，他的算法小抄通常会涵盖排序、...
java经典算法练习题
11-02
对于初学者来说，掌握Java的基本语法和编程理念是至关重要的，而算法的学习则是提升编程技能的关键。本压缩包包含了三个文档，分别是“JAVA经典算法40题.doc”、“最新JAVA编程题全集_50题及答案.doc”和“50道JAVA...
RPC——RPC协议介绍及原理详解
Andya_net的博客
06-11 2万+
RPC（Remote Procedure Call Protocol） 远程过程调用协议。RPC是一种通过网络从远程计算机程序上请求服务，不需要了解底层网络技术的协议。RPC主要作用就是不同的服务间方法调用就像本地调用一样便捷。序列化：将消息对象转换为二进制流。反序列化：将二进制流转换为消息对象。
Java-重载和重写的区别
Andya_net的博客
08-07 1万+
【重写和重载的区别，是经历面试的时候面的比较多的吧，在学习过程中，整理了一下这两者的区别，希望能够帮助理解这些知识点。重写，意味着原来就有，继承基类的，但是子类重新写了一个；重载，意味着本类有同样的方法，重新载入一个相同的方法名而不同的参数列表】这样理解会不会好记一点~~~
使用switch case语句来显示月份的对应天数
Andya_net的博客
07-28 7900
方法一：控制台输入月份 package com.liaojianya.chapter1; import java.util.Scanner; /** * This program demonstrates thw way of implements * display the number of days according to 12 months. * @author LIA
Java | 使用切面AOP拦截并修改Controller接口请求参数
Andya_net的博客
06-29 5607
在开发过程中，会有一些需求将controller层的一些方法入参进行全量转换，最容易想到的可能是在调用下层service方法时，调用公共的方法进行入参转换，这时带来的唯一问题就是代码不雅观，比较冗余。那还有什么方法可以更优雅的解决这个问题吗？答案是有的：切面。我们实现一个AOP切面程序，对入参中的需转换的参数进行专项转换，而无需在各个controller层的各个方法中进行转换处理。
matlab学习算法
08-29
对于学习算法，Matlab是一个非常强大和...总结来说，学习算法并在Matlab中实现它们需要对算法原理有深入理解，并结合Matlab的语法和工具来实现和验证算法。通过不断练习和实践，可以提高算法的理解和Matlab的应用能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值