【算法与数据结构】Java实现查找与排序

文章目录

  • 第一部分：查找算法
    • 二分查找
    • 插值查找
    • 分块查找
    • 哈希查找
    • 树表查找
  • 第二部分：排序算法
    • 冒泡排序
    • 选择排序
    • 插入排序
    • 快速排序
  • 总结

第一部分：查找算法

二分查找

也叫做折半查找，属于有序查找算法。

前提条件：数组数据必须有序，从小到大，或者从大到小都是可以的。

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

二分
基本思想：用给定值先与中间结点比较。

比较完之后有三种情况：

  • 相等 ：说明找到了
  • 要查找的数据比中间节点小 ： 说明要查找的数字在中间节点左边
  • 要查找的数据比中间节点大： 说明要查找的数字在中间节点右边
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点，尽可能靠近想要查找的元素。
1
修改mid公式即可！

private static int binarySearch2(int[] arr, int num) {
    int min = 0;
    int max = arr.length - 1;

    while (true) {
        if (min > max) {
            return -1;
        }

        int mid = min + (num - arr[min]) / (arr[max] - arr[min]) * (max - min);//这里改公式
        if (num > arr[mid]) {
            min = mid + 1;
        } else if (num < arr[mid]) {
            max = mid - 1;
        } else {
            return mid;
        }
    }
}

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

分块查找

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

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

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

分块查找的过程：

  1. 需要把数据分成N多小块，块与块之间不能有数据重复的交集。
  2. 给每一块创建对象单独存储到数组当中
  3. 查找数据的时候，先在数组查，当前数据属于哪一块
  4. 再到这一块中顺序查找
public class 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;//结束索引
	
	//省略 构造 属性 等 JavaBean
}

哈希查找

树表查找

第二部分：排序算法

冒泡排序

Bubble Sort：

数值之间 两两比较 找到最大的数 放到最后
第二轮开始以此类推 ：从0-倒数第二 再开始比较 （即不再管最后一个数[依次找得到最大数]）

    private static void bubbleSort() {
        Random random = new Random();
        int[] arr = new int[10000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(1000);
        }

        long start = System.currentTimeMillis();

        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]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

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

总结步骤：

  1. 相邻的元素两两比较，大的放右边，小的放左边
  2. 第一轮比较完毕之后，最大值就已经确定，第二轮可以少循环一次，后面以此类推
  3. 如果数组中有n个数据，总共我们只要执行n-1轮的代码就可以
public class BubbleDemo {
    public static void main(String[] args) {
        /*
            冒泡排序：
            核心思想：
            1，相邻的元素两两比较，大的放右边，小的放左边。
            2，第一轮比较完毕之后，最大值就已经确定，第二轮可以少循环一次，后面以此类推。
            3，如果数组中有n个数据，总共我们只要执行n-1轮的代码就可以。
        */
        
        //1.定义数组
        int[] arr = {2, 4, 5, 3, 1};

        //2.利用冒泡排序将数组中的数据变成 1 2 3 4 5

        //外循环：表示我要执行多少轮。 如果有n个数据，那么执行n - 1 轮
        for (int i = 0; i < arr.length - 1; i++) {
            //内循环：每一轮中我如何比较数据并找到当前的最大值
            //-1：为了防止索引越界
            //-i：提高效率，每一轮执行的次数应该比上一轮少一次。
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //i 依次表示数组中的每一个索引：0 1 2 3 4
                if(arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        printArr(arr);
    }

    private static void printArr(int[] arr) {
        //3.遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

选择排序

找到最小的数 排在最前面
第一轮： 0索引位置的数 与后面的数依次比较 找到最小的互换位置
第二轮： 1索引位置的数 与… 以此循环
注意内循环 是从1 开始 所以 arr.length不减1

//for (int i = 0; i < arr.length - 1; i++) {
//    if (arr[0] > arr[i + 1]) {
//        int temp = arr[0];
//        arr[0] = arr[i + 1];
//        arr[i + 1] = temp;
//    }
//}
//
//for (int i = 1; i < arr.length - 1; i++) {
//    if (arr[1] > arr[i + 1]) {
//        int temp = arr[1];
//        arr[1] = arr[i + 1];
//        arr[i + 1] = temp;
//    }
//}

// 关于为什么 (j = 1 +i) :
//① i = 0 -> j=  1 ~ 5
//② i = 1 -> j = 2 ~ 5
//...
for (int i = 0; i < arr.length - 1; i++) {
    for (int j = 1 + i; j < arr.length; j++) {
        if (arr[i] > arr[j]) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
}

    private static void selectionSort() {
        int[] arr = {2, 4, 5, 3, 1};

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

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

总结步骤：

  1. 从0索引开始，跟后面的元素一一比较
  2. 小的放前面，大的放后面
  3. 第一次循环结束后，最小的数据已经确定
  4. 第二次循环从1索引开始以此类推
  5. 第三轮循环从2索引开始以此类推
  6. 第四轮循环从3索引开始以此类推。
public class SelectionDemo {
    public static void main(String[] args) {
        /*
            选择排序：
                1，从0索引开始，跟后面的元素一一比较。
                2，小的放前面，大的放后面。
                3，第一次循环结束后，最小的数据已经确定。
                4，第二次循环从1索引开始以此类推。

         */
        //1.定义数组
        int[] arr = {2, 4, 5, 3, 1};

        //2.利用选择排序让数组变成 1 2 3 4 5
       /* //第一轮：
        //从0索引开始，跟后面的元素一一比较。
        for (int i = 0 + 1; i < arr.length; i++) {
            //拿着0索引跟后面的数据进行比较
            if(arr[0] > arr[i]){
                int temp = arr[0];
                arr[0] = arr[i];
                arr[i] = temp;
            }
        }*/

        //最终代码：
        //外循环：几轮
        //i:表示这一轮中，我拿着哪个索引上的数据跟后面的数据进行比较并交换
        for (int i = 0; i < arr.length -1; i++) {
            //内循环：每一轮我要干什么事情？
            //拿着i跟i后面的数据进行比较交换
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        printArr(arr);
    }
    private static void printArr(int[] arr) {
        //3.遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

插入排序

  1. 首先分为 有序的部分 无序的部分 数据

  2. 无序的部分第一个数 依次 与有序的数据 倒序进行对比 ， 然后将无序的部分插入到有序的适当位置

  3. 依次循环 每个无序的第一个数 与有序的倒序 对比 加入到有序的部分 中

  4. 其实就是 跟它的前一个数对比 交换位置

int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};

//1.找到无序的部分
int startIndex = -1;
for (int i = 0; i < arr.length; i++) {
    if (arr[i] > arr[i + 1]) {
        startIndex = i + 1;
        break;
    }
}

//2.遍历无序 (可以用while 或者 for) 用while 比较清晰
for (int i = startIndex; i < arr.length; i++) {
    //int j = i;
    //
    //while (j > 0 && arr[j] < arr[j - 1]) {
    //    int temp = arr[j];
    //    arr[j] = arr[j - 1];
    //    arr[j - 1] = temp;
    //    j--;
    //}

    for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
        int temp = arr[j];
        arr[j] = arr[j - 1];
        arr[j - 1] = temp;
    }
}

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

   private static void insertionSorting() {
        int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};

        //1.找到无序的部分的索引头
        int index = findOrderPart(arr);
        for (int i = index; i < arr.length; i++) {
            for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
            }
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    private static int findOrderPart(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > arr[i + 1]) {
                return i + 1;
            }
        }
        return -1;
    }

public class InsertDemo {
    public static void main(String[] args) {
        /*
            插入排序：
                将0索引的元素到N索引的元素看做是有序的，把N+1索引的元素到最后一个当成是无序的。
                遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如遇到相同数据，插在后面。
                N的范围：0~最大索引

        */
        int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};

        //1.找到无序的哪一组数组是从哪个索引开始的。  2
        int startIndex = -1;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > arr[i + 1]){
                startIndex = i + 1;
                break;
            }
        }

        //2.遍历从startIndex开始到最后一个元素，依次得到无序的哪一组数据中的每一个元素
        for (int i = startIndex; i < arr.length; i++) {
            //问题：如何把遍历到的数据，插入到前面有序的这一组当中

            //记录当前要插入数据的索引
            int j = i;

            while(j > 0 && arr[j] < arr[j - 1]){
                //交换位置
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
                j--;
            }

        }
        printArr(arr);
    }

    private static void printArr(int[] arr) {
        //3.遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

}

快速排序

  1. 定义两个索引：从前往后 寻找 比基准数大的 // 从后往前 寻找 比基准数小的 --> 找到两个索引交换位置
  2. 直到 两个索引交汇在同一个数值索引位置上 为止
  3. 之后 这个交汇位置的值 与 基准数 进行交换
  4. 以上为一轮交换逻辑。
  5. 循环使用递归方法进行排序， 以基准数为分界线，分为两部分，两次递归 重复排序
    213
    private static void quickSort(int[] arr, int i, int j) {
        int start = i;
        int end = j;

        if (start > end) {
            return;
        }

        int baseNum = arr[i];

        while (start != end) {
            while (true) {
                if (start >= end || arr[end] < baseNum) {
                    break;
                }
                end--;
            }

            while (true) {
                if (start >= end || arr[start] > baseNum) {
                    break;
                }
                start++;
            }

            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }

        int temp = arr[i];
        arr[i] = arr[start];
        arr[start] = temp;

        quickSort(arr, i, start - 1);
        quickSort(arr, start + 1, j);
    }

总结步骤：

  1. 从数列中挑出一个元素，一般都是左边第一个数字，称为 “基准数”;
  2. 创建两个指针，一个从前往后走，一个从后往前走。
  3. 先执行后面的指针，找出第一个比基准数小的数字
  4. 再执行前面的指针，找出第一个比基准数大的数字
  5. 交换两个指针指向的数字
  6. 直到两个指针相遇
  7. 将基准数跟指针指向位置的数字交换位置，称之为：基准数归位。
  8. 第一轮结束之后，基准数左边的数字都是比基准数小的，基准数右边的数字都是比基准数大的。
  9. 把基准数左边看做一个序列，把基准数右边看做一个序列，按照刚刚的规则递归排序
public class QuickSortDemo {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
      /*
        快速排序：
            第一轮：以0索引的数字为基准数，确定基准数在数组中正确的位置。
            比基准数小的全部在左边，比基准数大的全部在右边。
            后面以此类推。
      */

        int[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 10, 8};

        //int[] arr = new int[1000000];

       /* Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = r.nextInt();
        }*/

        long start = System.currentTimeMillis();
        quickSort(arr, 0, arr.length - 1);
        long end = System.currentTimeMillis();

        System.out.println(end - start);//149

        System.out.println(Arrays.toString(arr));
        //课堂练习：
        //我们可以利用相同的办法去测试一下，选择排序，冒泡排序以及插入排序运行的效率
        //得到一个结论：快速排序真的非常快。

       /* for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }*/

    }

    /*
     *   参数一：我们要排序的数组
     *   参数二：要排序数组的起始索引
     *   参数三：要排序数组的结束索引
     * */
    public static void quickSort(int[] arr, int i, int j) {
        //定义两个变量记录要查找的范围
        int start = i;
        int end = j;

        if(start > end){
            //递归的出口
            return;
        }

        //记录基准数
        int baseNumber = arr[i];
        //利用循环找到要交换的数字
        while(start != end){
            //利用end，从后往前开始找，找比基准数小的数字
            //int[] arr = {1, 6, 2, 7, 9, 3, 4, 5, 10, 8};
            while(true){
                if(end <= start || arr[end] < baseNumber){
                    break;
                }
                end--;
            }
            System.out.println(end);
            //利用start，从前往后找，找比基准数大的数字
            while(true){
                if(end <= start || arr[start] > baseNumber){
                    break;
                }
                start++;
            }
            
            //把end和start指向的元素进行交换
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }

        //当start和end指向了同一个元素的时候，那么上面的循环就会结束
        //表示已经找到了基准数在数组中应存入的位置
        //基准数归位
        //就是拿着这个范围中的第一个数字，跟start指向的元素进行交换
        int temp = arr[i];
        arr[i] = arr[start];
        arr[start] = temp;

        //确定6左边的范围，重复刚刚所做的事情
        quickSort(arr,i,start - 1);
        //确定6右边的范围，重复刚刚所做的事情
        quickSort(arr,start + 1,j);

    }
}

总结

2.1

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

教你用五步让千年的兵马俑跳上现代的科目三？

教你用五步让千年的兵马俑跳上现代的科目三？

以下是一张我上月去西安拍的兵马俑照片&#xff1a; 使用通义千问&#xff0c;5步就能它舞动起来&#xff0c;跳上现在流行的“科目三”舞蹈。 千年兵马俑跳上科目三 全民舞王 第1步 打开通义千问App&#xff0c;我使用的是华为手机&#xff0c;苹果版的没试&#xff1b; 在…
阅读更多...
西米支付：到底什么是NFT（数字藏品支付通道）（NFT支付通道）

西米支付：到底什么是NFT（数字藏品支付通道）（NFT支付通道）

NFT到底指的是什么呢&#xff1f; 数字藏品的实际意义在于它们打破了传统艺术品的物质形态束缚。数字藏品可以通过虚拟现实和区块链技术进行创作、展示和交易。它们不仅可以满足人们对艺术品的审美需求&#xff0c;还可以成为一种投资和资产保值增值的方式。数字藏品的实际意义…
阅读更多...
128基于matlab的粒子群优化算法寻找多元函数的最大值

128基于matlab的粒子群优化算法寻找多元函数的最大值

基于matlab的粒子群优化算法寻找多元函数的最大值&#xff0c;可定义多元函数&#xff0c;变量区间范围&#xff0c;输出最大值条件下的变量值。程序已调通&#xff0c;可直接运行。 128matlab多元函数极值 (xiaohongshu.com)
阅读更多...
小程序基础学习（缓存）

小程序基础学习（缓存）

目录 设置用户信息缓存(同步): wx.setStorageSync(key,value) ​编辑 获取用户信息缓存(同步): wx.getStorageSync(key) 删除用户信息缓存(同步): wx.removeStorageSync(key) 清空用户信息缓存(同步): wx.clearStorageSync() 设置用户信息缓存加密信息(异步): wx.setStorage(…
阅读更多...
flink 1.18 sql gateway /sql gateway jdbc

flink 1.18 sql gateway /sql gateway jdbc

一 sql gateway 注意 之所以直接启动gateway 能知道yarn session 主要还是隐藏的配置文件&#xff0c;但是配置文件可以被覆盖&#xff0c;多个session 保留最新的applicationid 1 安装flink &#xff08;略&#xff09; 2 启动sql-gatway(sql-gateway 通过官网介绍只能运行…
阅读更多...
16位单片机单片机S1C17153

16位单片机单片机S1C17153

16位单片机单片机 .16KB ROM / 2KB内存 * S1C17653对于程序开发很有用。 .产生具有内置振荡器的操作时钟。 - OSC3B振荡器电路&#xff1a;2MHz/1MHz/500kHz&#xff08;类型&#xff09;内部振荡器电路 -OSC1无振荡器电路&#xff1a;32.768 kHz&#xff08;类型&#xf…
阅读更多...
css3过渡与动画

css3过渡与动画

css3过渡与动画 前言过渡过渡的基本使用 transition兼容性transition属性基本使用哪些属性可以参与过渡all过渡的四个小属性 过渡的缓动效果常用缓动参数贝塞尔曲线 过渡效果实战 动画动画的定义和调用动画的执行次数 动画效果实战 案例&#xff1a;发光的灯泡案例&#xff1a;…
阅读更多...
磁盘raid1降级后，mdxxx rota发生变化

磁盘raid1降级后，mdxxx rota发生变化

背景 虚拟机系统盘vda后端使用宿主机ssd盘lvm组raid1，虚拟机内部查看vda磁盘类型（rota=1）：机械硬盘，vda后端raid1降级导致磁盘类型降级：rota 0---->1，vda磁盘类型显示不正确，应该是ssd类型（rota=0）； 分析 1.基础 1.1 linux磁盘类型 Rota表示磁盘类型：（1）0，表…
阅读更多...
设计模式—行为型模式之中介者模式

设计模式—行为型模式之中介者模式

设计模式—行为型模式之中介者模式 中介者模式(Mediator Pattern)&#xff1a;用一个中介对象来封装一系列的对象交互&#xff0c;中介者使各对象不需要显式地相互引用&#xff0c;减少对象间混乱的依赖关系&#xff0c;从而使其耦合松散&#xff0c;而且可以独立地改变它们之…
阅读更多...
基于SSM的交流论坛设计与实现

基于SSM的交流论坛设计与实现

末尾获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;SSM 前端&#xff1a;Vue、HTML 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xff1a;IDEA / Eclipse 是否Maven项目&#xff1a;是…
阅读更多...
What is `@Repository` does?

What is `@Repository` does?

Repository 是Spring注解&#xff0c;标识数据访问层组件&#xff08;DAO, Data Access Object&#xff09; 当一个类被标记为 Repository 时&#xff1a; 1、组件扫描与自动代理&#xff1a; Spring通过组件扫描&#xff08;Component Scan&#xff09;机制发现带有 Reposit…
阅读更多...
基于FPGAWS2812B的贪吃蛇方案设计(含源码)

基于FPGAWS2812B的贪吃蛇方案设计(含源码)

第1章 基于FPGA&WS2812B的贪吃蛇方案设计 1.2 贪吃蛇游戏系统的功能需求分析 为了更好的实现我们的贪吃蛇游戏系统&#xff0c;我们需要对项目进行功能分析&#xff0c;利于我们对整个系统的分析、架构。 首先&#xff0c;对于整个游戏系统&#xff0c;我们需要界面来引…
阅读更多...
ChatGPT Plus 经验分享：是否值得花钱升级？

ChatGPT Plus 经验分享：是否值得花钱升级？

ChatGPT Plus 经验分享&#xff1a;是否值得花钱升级&#xff1f; 五星上将麦克阿瑟曾经说过&#xff1a;“在有钱与没钱面前&#xff0c;我选择了or” ChatGPT 的每月订阅方案- ChatGPT Plus 已经推出一段时间了&#xff0c;目前的费用是$20 USD / 月(约TWD 610 / 月)。 Open…
阅读更多...
STM32--7针0.96寸OLED屏幕显示（4线SPI）

STM32--7针0.96寸OLED屏幕显示（4线SPI）

本文介绍基于STM32F103C8T60.96寸OLED&#xff08;7针&#xff09;的显示&#xff08;完整程序代码见文末链接&#xff09; 一、简介 OLED&#xff0c;即有机发光二极管&#xff08; Organic Light Emitting Diode&#xff09;。 OLED 由于同时具备自发光&#xff0c;不需背光…
阅读更多...
C程序技能：彩色输出

C程序技能：彩色输出

在终端上输出的字体总是单色&#xff0c;但在一些场景彩色输出更能满足需求&#xff0c;在Linux环境中&#xff0c;可以使用终端控制字符来设置输出字符的颜色&#xff0c;在部分版本的Windows系统中也可以使用。本文参考一些文献简要介绍一下在Windows下彩色输出的方法。 1. …
阅读更多...
3D PDF查看器HOOPS Publish助力Smartscape拓展日本AEC市场！

3D PDF查看器HOOPS Publish助力Smartscape拓展日本AEC市场！

​ 公司&#xff1a;Smartscape Co., Ltd. 行业&#xff1a;建筑、工程和施工(AEC) 软件&#xff1a;适用于AEC行业的3D PDF工具 软件开发工具包&#xff1a;Hoops Publish HOOPS_3D软件开发工具_HOOPS中文网慧都科技是HOOPS全套产品中国地区指定授权经销商&#xff0c;提供3D…
阅读更多...
使用@Slf4j后引入log，idea标红

使用@Slf4j后引入log，idea标红

引入Slf4j注解 idea标红Cannot resolve symbol ‘log’ 引入Lombok插件 如果在Marketplace查不到时&#xff0c;不妨关闭菜单再打开试下
阅读更多...
微信小程序canvas画布图片保存到相册官方授权、自定义授权、保存

微信小程序canvas画布图片保存到相册官方授权、自定义授权、保存

关键步骤介绍 wx.getSetting可以获取授权信息。 wx.authorize首次授权时会打开弹框让用户授权&#xff0c;若用户已选择同意或拒绝&#xff0c;后续不会再显示授权弹框。 如果授权信息显示未进行相册授权&#xff0c;则打开自定义弹框&#xff08;show_auth: true&#xff0…
阅读更多...
【前端框架】Vue3合集

【前端框架】Vue3合集

一、Vue3初识 1、create-vue create-vue是Vue官方新的脚手架工具&#xff0c;底层切换到了 vite &#xff08;下一代前端工具链&#xff09;&#xff0c;为开发提供极速响应 前置条件&#xff1a;16.0或更高版本的Node.js 安装并执行 create-vue npm init vuelatest2、项目…
阅读更多...
前端如何压缩图片在进行上传给后端

前端如何压缩图片在进行上传给后端

前端压缩图片我目前能想到的就是 通过canvas 改变图片的 画质去改变图片的大小。 解决方案如下&#xff1a; 1、首先获取图片的全部内容&#xff0c;然后转化为base64让他可以在页面上展示。 2、当我们获取到base64的图片的时候我们就可以获取图片的大小尺寸。 3、我们把这个图…
阅读更多...
最新文章

Copyright @ 2022~2023