java入门~第十四天 数组常见操作以及Arrays类

最新推荐文章于 2024-07-12 15:51:39 发布
最新推荐文章于 2024-07-12 15:51:39 发布
阅读量122 收藏
点赞数
分类专栏： 基数 冒泡 文章标签： java 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41924998/article/details/107731448
版权

1.数组常见操作

1.01数组高级冒泡排序

1.数组排序：把数组中的无序的元素，通过交换移动等方式，使数组中的元素，成为一个有序序列。

2.冒泡排序原理:
相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。

原理图：在这里插入图片描述

3.分析以及代码实现：

规律：数组中有5个元素，比较了4轮。

第一轮：比较了4次。

第二轮：比较了3次。

第三轮：比较了2次。

第四轮：比较了1次。

public class MyTest {
    public static void main(String[] args) {
        int[] arr={24, 69, 80, 57, 13};
        //因为arr[i+1],所以arr.length-1，要不然会越界。
        for (int i = 0; i < arr.length-1; i++) {
            if(arr[i]>arr[i+1]){
                int  t=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
        for (int i = 0; i < arr.length-1-1; i++) {
            if(arr[i]>arr[i+1]){
                int  t=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
        for (int i = 0; i < arr.length-1-1-1; i++) {
            if(arr[i]>arr[i+1]){
                int  t=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
        for (int i = 0; i < arr.length-1-1-1-1; i++) {
            if(arr[i]>arr[i+1]){
                int  t=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

public class MyTest {
    public static void main(String[] args) {
        int[] arr={24, 69, 80, 57, 13};
        bubbleSort(arr);//抽取方法
        //因为arr[i+1],所以arr.length-1，要不然会越界。
       /* for (int j = 0; j<arr.length-1 ; j++) {
            for (int i = 0; i< arr.length-1-j; i++) {
                if(arr[i]>arr[i+1]){
                    int  t=arr[i];
                    arr[i]=arr[i+1];
                    arr[i+1]=t;
                }
        }
            System.out.println(Arrays.toString(arr));
*/
    }
    private static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            if(arr[i]>arr[i+1]){
                int  t=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
        for (int i = 0; i < arr.length-1-1; i++) {
            if(arr[i]>arr[i+1]){
                int  t=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
        for (int i = 0; i < arr.length-1-1-1; i++) {
            if(arr[i]>arr[i+1]){
                int  t=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
        for (int i = 0; i < arr.length-1-1-1-1; i++) {
            if(arr[i]>arr[i+1]){
                int  t=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}
//[24, 69, 57, 13, 80]
//[24, 57, 13, 69, 80]
//[24, 13, 57, 69, 80]
//[13, 24, 57, 69, 80]

1.02选择排序法

1.选择排序原理：

​ 每次拿一个元素，跟后面剩余的元素，挨个比较，小的往前放，经过一轮比较后，最小的元素就会出现在最前面。

2.选择排序原理图：
在这里插入图片描述

3.分析以及代码实现：

选择排序的特点：

A:从0索引开始依次和后面的元素进行比较，小的往前放，第一次排序完毕以后，最小值出现在了最小索引处。

B：第一次比较的时候是从0索引开始比较了4次；

​ 第二次比较的时候是从1索引开始比较了3次；

​ 第三次比较的时候是从2索引开始比较了2次；

​ 第四次比较的时候是从3索引开始比较了1次；

C：总共比较了4次；

public class MyTest {
    public static void main(String[] args) {
        int[] arr={24, 69, 80, 57, 13};
        int  index=0;
        for (int i = 1; i <arr.length ; i++) {
            if(arr[index]>arr[i]){
              int   t=arr[index];
                    arr[index]=arr[i];
                    arr[i]= t;
            }
        }
        System.out.println(Arrays.toString(arr));
        index=1;
        for (int i = 1+1; i <arr.length ; i++) {
            if(arr[index]>arr[i]){
                int   t=arr[index];
                arr[index]=arr[i];
                arr[i]= t;
            }
        }
        System.out.println(Arrays.toString(arr));
        index=2;
        for (int i = 1+1+1; i <arr.length ; i++) {
            if(arr[index]>arr[i]){
                int   t=arr[index];
                arr[index]=arr[i];
                arr[i]= t;
            }
        }
        System.out.println(Arrays.toString(arr));
        index=3;
        for (int i = 1+1+1+1; i <arr.length ; i++) {
            if(arr[index]>arr[i]){
                int   t=arr[index];
                arr[index]=arr[i];
                arr[i]=t;
            }
        }
        System.out.println(Arrays.toString(arr));

    }

}

public class MyTest {
    public static void main(String[] args) {
        int[] arr={24, 69, 80, 57, 13};
        int  index=0;
        choicePaixu(arr, index); //抽取方法
        /*for (index = 0; index <arr.length-1 ; index++) {
            for (int i = 1+index; i <arr.length ; i++) {
                if(arr[index]>arr[i]){
                    int   t=arr[index];
                    arr[index]=arr[i];
                    arr[i]= t;
                }
            }

        }
        System.out.println(Arrays.toString(arr));*/
    }
    private static void choicePaixu(int[] arr, int index) {
        for (int i = 1; i <arr.length ; i++) {
            if(arr[index]>arr[i]){
              int   t=arr[index];
                    arr[index]=arr[i];
                    arr[i]= t;
            }
        }
        System.out.println(Arrays.toString(arr));
        index=1;
        for (int i = 1+1; i <arr.length ; i++) {
            if(arr[index]>arr[i]){
                int   t=arr[index];
                arr[index]=arr[i];
                arr[i]= t;
            }
        }
        System.out.println(Arrays.toString(arr));
        index=2;
        for (int i = 1+1+1; i <arr.length ; i++) {
            if(arr[index]>arr[i]){
                int   t=arr[index];
                arr[index]=arr[i];
                arr[i]= t;
            }
        }
        System.out.println(Arrays.toString(arr));
        index=3;
        for (int i = 1+1+1+1; i <arr.length ; i++) {
            if(arr[index]>arr[i]){
                int   t=arr[index];
                arr[index]=arr[i];
                arr[i]=t;
            }
        }
        System.out.println(Arrays.toString(arr));
    }

}

1.03插入排序

直接插入排序：从第二个元素，每次拿一个后面元素插入之前的有序列中，使之仍保持有序

1.算法思路:直接插入排序,是一种最简单的排序方法.他的基本操作是将一个记录插入到一个长度为m 的有序表中,使之仍保持有序,从而得到一个新的长度为m+1的有序列表.假设有一组元素{k1,k2…,kn},排序开始就认为k1是一个有序序列,让k2插入上述表长为1的有序序列,使之成为一个表长为2的有序序列,然后让k3插入上述表长为2的有序序列,使之成为一个表长为3的有序序列,以此类推,最后让kn插入表长为n-1的有序序列,得到一个表长为n的有序序列。

•例如:

•49,38,65,97,76,13,27 原始数据

•[49],38,65,97,76,13,27 从1索引开始插入

•[38,49], ,65,97,76,13,27

•[38,49,65] 97,76,13,27

•[38,49,65,97] 76,13,27

•[38,49,65,76,97]13,27

•[13,27,38,49,65,76,97],27

•[13,27,38,49,65,76,97]

2.代码实现：

for while语句：

public static void main(String[] args) {
    int[] arr={9,1,2,4,3,5,7,6,8,11,10,13,12};
    //外层循环定义比较的轮次,也就是得几轮才能排序完
    for (int i = 0; i < arr.length; i++) {
        int j=i;
        while(j>0&&arr[j]<arr[j-1]){//如果当前元素比前一个元素小交换位置
            int t=arr[j];
            arr[j]=arr[j-1];
            arr[j-1]=t;
            j--;; //往前递减让当前元素继续和上一个元素比较
        }
    }
    System.out.println(Arrays.toString(arr));
    //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

for for if语句：

public static void main(String[] args) {
    int[] arr={9,1,2,4,3,5,7,6,8,11,10,13,12};
    //外层循环定义比较的轮次,也就是得几轮才能排序完
    for (int i = 0; i < arr.length; i++) {
        for (int j = i; j >0 ; j--) {
            if(arr[j]<arr[j-1]){
                int t=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=t;
            }
        }
    }
    System.out.println(Arrays.toString(arr));

}

1.04希尔排序

1.希尔排序原理：

​ 希尔排序又称为缩小增量排序。是对插入排序的优化。也可以将插入排序认为增量为1的希尔排序。

​ 基本思想：先将原表按增量ht分组，每个子文件按照直接插入排序。同样，用下一个增量

ht/2将文件再分为子文件，在直接插入法排序。直到ht=1时整个文件排好序。

​ 关键：选择合适的增量。可以通过三重循环来实现。

2.原理图：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.代码实现：

public static void main(String[] args) {
    int[] arr={46,55,13,42,17,94,5,70};
    //先把上节课讲的直接插入排序方法抽取出来
    shellSort(arr);
}

private static void shellSort(int[] arr) {
    //先复制一下之前插入排序的代码：
    for (int i = 0; i < arr.length; i++) {
        for (int j = i; j >0 ; j--) {
            if(arr[j]<arr[j-1]){
                *//*int t=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=t;*//*
                swapVlue(arr,i, j);
            }
        }
    }
    System.out.println(Arrays.toString(arr));
}
//将交换值的方法如下
private static void swapVlue(int[] arr,int i,int j){
    int t=arr[j];
    arr[j]=arr[j-1];
    arr[j-1]=t;
} //[5, 13, 17, 42, 46, 55, 70, 94]

 public static void main(String[] args) {
        int[] arr = {46, 55, 13, 42, 17, 94, 5, 70};
        //先把上节课讲的直接插入排序方法抽取出来
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
     //[5, 13, 17, 42, 46, 55, 70, 94]
    }

    private static void shellSort(int[] arr) {
        //定义一个增量
        int h = 4;
        for (int i = h; i < arr.length; i++) {
            for (int j = i; j > h - 1; j -= h) {
                if (arr[j] < arr[j - h]) {
                    int t = arr[j];
                    arr[j] = arr[j - h];
                    arr[j - h] = t;
                }
            }
        }
        //第二轮
        h = 2;
        for (int i = h; i < arr.length; i++) {
            for (int j = i; j > h - 1; j -= h) {
                if (arr[j] < arr[j - h]) {
                    int t = arr[j];
                    arr[j] = arr[j - h];
                    arr[j - h] = t;
                }
            }
        }
        h=1;
        for (int i = h; i < arr.length; i++) {
            for (int j = i; j > h - 1; j -= h) {
                if (arr[j] < arr[j - h]) {
                    int t = arr[j];
                    arr[j] = arr[j - h];
                    arr[j - h] = t;
                }
            }
        }

    }
}

优化上面代码：

public static void main(String[] args) {
    int[] arr = {46, 55, 13, 42, 17, 94, 5, 70};
    //先把上节课讲的直接插入排序方法抽取出来
    shellSort(arr);
    System.out.println(Arrays.toString(arr));
}

private static void shellSort(int[] arr) {
    for (int h = 4; h >0 ; h/=2) {
        for (int i = h; i < arr.length; i++) {
            for (int j = i; j > h - 1; j -= h) {
                if (arr[j] < arr[j - h]) {
                    int t = arr[j];
                    arr[j] = arr[j - h];
                    arr[j - h] = t;
                }
            }
        }
    }
}

1.05快速排序法

1.分治法：比大小，再分区

从数组中取出一个数，作为基准数。

分区：将比这个数大或等于的数全放到他的右边，小于他的数全放到他的左边。

再对左右区间重复第二步，直到各区间只有一个数。

实现思路： 挖坑填数
将基准数挖出形成第一个坑。
由后向前找比他小的数，找到后挖出此数填到前一个坑中。
由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
再重复执行2，3两步骤。
2.代码实现：

public class QuickSrotUtils {
    private QuickSrotUtils() {
    }

    public static void quickSrot(int[] arr, int start, int end) {
        //递归调用左右两区
        if (start < end) {
            //获取分左右两区的那个位置索引
            int index = getIndex(arr, start, end);
            //对左区递归
            quickSrot(arr, start, index - 1);
            //对右区递归
            quickSrot(arr, index + 1, end);
        }
    }

    //挖坑填数：
  /*  1.将基准数挖出形成第一个坑。
    2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
    3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
    4.再重复执行2，3两步骤。*/

    private static int getIndex(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        //1.定义基准数
        int x = arr[i];
        //重复2 3  步
        while (i < j) {
            //2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
            while (i < j && arr[j] >= x) {
                j--;
            }
            if (i < j) {
                arr[i] = arr[j];
                i++;//顺便让i增一下
            }
            //3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
            while (i < j && arr[i] < x) {
                i++;
            }
            if (i < j) {
                arr[j] = arr[i];
                //顺便让j减一下
                j--;
            }
        }
        //把基准数，填到最后一个坑中
        arr[i] = x;
        return i;
    }
}

public class MyTest {
    public static void main(String[] args) {
        int[] arr={20,20,6,8,9,1,2,3,4,90,100,3,0,-1,-2,6,9};
        QuickSrotUtils.quickSrot(arr,0,arr.length-1);

        System.out.println(Arrays.toString(arr));
    }
}

1.06二分法

1.原理：

二分查找：前提数组元素必须有序
二分查找的思想：每一次都查中间的那个元素，比较大小就能减少一半的元素。

2.原理图：

在这里插入图片描述

3.代码实现：

一般查找：

public class MyTest {
    public static void main(String[] args) {
        //查找该元素在数组中第一次出现的索引
        //基本查找：从头开始挨个往找。
        int[] arr = {10, 20, 30, 10, 50, 30, 90};
        int index = getIndex(arr, 10);
        System.out.println(index);

    }

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

二分查找：

public class MyTest2 {
    public static void main(String[] args) {
        //查找该元素在数组中第一次出现的索引
        //基本查找：从头开始挨个往找。
        int[] arr = {10, 20, 30, 40, 50, 60, 90};
        //int index = getIndex(arr, 90);
        //二分查找的前提：数组元素有序。
        int index = getIndex2(arr, 40);
        System.out.println(index);

    }

    //二分查找
    private static int getIndex2(int[] arr, int ele) {
        //定义最小索引和最大索引
        int minIndex = 0;
        int maxIndex = arr.length - 1;
        int centerIndex = (minIndex + maxIndex) / 2;
        while (minIndex <= maxIndex) {
            if (ele == arr[centerIndex]) {
                return centerIndex;
            } else if (ele < arr[centerIndex]) {
                maxIndex = centerIndex - 1;
            } else if (ele > arr[centerIndex]) {
                minIndex = centerIndex + 1;
            }
            //记得再次计算中间索引
            centerIndex = (minIndex + maxIndex) / 2;
        }
        return -1;
    }

2.Arrays

2.1Arrays类概述

​ 针对数组进行操作的工具类。提供了排序，查找等功能

2.成员方法
public static String toString(int[] a)

public class MyTest {
    public static void main(String[] args) {
        //Java给我们提供了一个工具类，可以方便的对数组进行操作。
        int[] arr={10,20,30};//[10,20,30]
        //toString(arr);把数组中的元素，转换成一个漂亮字符串。
        String s = Arrays.toString(arr);
        System.out.println(s);
    }
}

​ public static void sort(int[] a)

​ public static int binarySearch(int[] a,int key)

public static void main(String[] args) {
    int[] arr = {20, 20, 6, 8, 9, 1, 2, 3, 4, 90, 100, 3, 0, -1, -2, 6, 9};

    Arrays.sort(arr);

    System.out.println(Arrays.toString(arr));
    //[-2, -1, 0, 1, 2, 3, 3, 4, 6, 6, 8, 9, 9, 20, 20, 90, 100]
    //二分查找:数组元素必须有序
    int index = Arrays.binarySearch(arr, 100);
    System.out.println(index);//16

​ static boolean equals(int[] a, int[] a2) 比较两个数组中的元素，是否一样

public static void main(String[] args) {
    int[] arr = {20, 20, 6, 8};
    int[] arr2 = {20, 20, 6, 8};

    //比较两个数组中的元素是否一样。

    boolean b = Arrays.equals(arr, arr2);
    System.out.println(b);

}

​ static int[] copyOf(int[] original, int newLength) 复制旧数组中的元素到一个新的数组

中，新的数组长度是newLength 从0开始复制旧数组

​ static int[] copyOfRange(int[] original, int from, int to) 复制旧数组中的指定范围间的几个元素到新数组中。

public static void main(String[] args) {
  /*  static int[] copyOf ( int[] original, int newLength)复制旧数组中的元素到一个新的数组中，新的数组长度是newLength 从0开始复制旧数组
    static int[] copyOfRange ( int[] original, int from, int to)复制旧数组中的指定范围间的几个元素到新数组中*/

    int[] arr = {20, 20, 6, 8,20,30,50,60};

    int[] ints = Arrays.copyOf(arr, 3);

    System.out.println(Arrays.toString(ints));
    //3 起始索引，6 终止索引 含头不含尾
    int[] ints1 = Arrays.copyOfRange(arr, 3, 6);
    System.out.println(Arrays.toString(ints1));

}
囍阿宁
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
java arraylist min_如何在ArrayList中找到最小值以及索引号？ （Java）
weixin_33601966的博客
02-16 2563
如何在ArrayList中找到最小值以及索引号？ (Java)我需要在Java的arraylist中获取最小值的索引值。 我的arraylist包含多个浮点数，我正在尝试一种获取最小浮点数的索引号的方法，以便可以在代码的其他地方使用该索引号。 我是一个初学者，所以请不要讨厌我。 谢谢！user2130496 asked 2020-01-17T11:06:44Z6个解决方案93 votes您可以使用...
java 数组取数_Java入门篇（四）——数组
weixin_30456153的博客
02-20 3424
上篇在foreach中有引入一个数组的概念，数组是最为常见的一种数据结构，是相同类型的、用一个标识符封装到一起的基本类型数据序列或对象序列。数组是具有相同数据类型的一组数据的集合，根据维数不同可以分为一维数组、二维数组和多维数组。大家可以将一维看作直线，二维看作平面、三维看成立体空间。一、一维数组1.创建一维数组数组作为对象允许使用new关键字进行内存分配。在使用数组之前，必须首先定义数组变量所...
入门JAVA第五天 方法与数组
qq_57167753的博客
02-03 221
方法定义的格式：# 方法定义 返回值-名字-参数(这三个一个不能少的)# 完全定义：访问修饰符 [static / final ] 返回值 方法名(小驼峰) (参数...) {}# 一般方法普通方法非静态方法修饰符 返回值类型 方法名称参数列表) {方法体语句;return语句;静态方法修饰符static返回值类型 方法名称参数列表) {方法体语句;return语句;特殊方法（格式不可修改） ：//主函数 主方法 程序执行入口方法定义详解：1。
java入门~第十五天 基本数据类型包装类，各种常用类.以及正则表达式md
weixin_41924998的博客
08-06 498
1.基本数据类型包装类 1.01基本类型包装类的概述 需求: a:将100转换成二进制 , 八进制 , 十六进制 b:判断一个数是否在int的范围内 if(25252525>=Integer.MIN_VALUE&& 25252525<=Integer.MAX_VALUE){ System.out.println("在int范围内"); } 1.为什么会有基本类型包装类: 为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型.
Java数组高级算法与Arrays类常见操作小结【排序、查找】
08-26
Java数组高级算法与Arrays类常见操作小结【排序、查找】 Java数组高级算法与Arrays类常见操作小结是Java数组高级...通过本文的学习，我们可以熟悉Java数组高级算法的常见排序算法和查找算法，以及Arrays类的常见操作。
Java多维数组和Arrays类方法总结详解
08-19
java.util.Arrays类提供了许多静态方法来操作数组，下面我们将介绍一些常用的方法： 1. asList()方法：返回一个受指定数组支持的固定大小的列表。 List stooges = Arrays.asList("Larry", "Moe", "Curly"); @...
java数组及arrays类对数组的操作实例
08-29
Arrays 类是 Java 提供的一个工具类，用于操作数组。该类提供了多种方法来操作数组，包括排序、查找、复制、比较等。 在本文中，我们将通过一个实例来展示 Java 数组及 Arrays 类对数组的操作。首先，我们创建了一...
JAVA基于Arrays.sort()实现数组升序和降序
08-19
在 Java 中，排序数组是非常常见的操作之一，而 Java 提供了多种方式来实现数组的排序，其中一种常用的方法是使用 Arrays.sort() 方法。今天，我们将详细介绍如何使用 Arrays.sort() 方法来实现数组的升序和降序排序...
面试题涵盖Java数组常见操作和用法
06-14
总的来说，理解并熟练掌握Java数组的声明、创建、初始化、访问、遍历以及相关操作，是Java编程基础的重要组成部分，也是面试中常见的考点。通过这些知识点的学习，你将能够更有效地利用数组解决实际编程问题。
配置Java开发环境
Broken_x的博客
07-10 1443
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
最新发布
baina666的博客
07-12 310
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 416
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
java Object 转 Integer
servepeople的博客
07-09 1407
在 Java 中，可以通过多种方法将一个Object转换为Integer。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2282
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java占位符替换五种方式
weixin_61478518的博客
07-08 532
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
elk部署springboot
Chihirozy的博客
07-11 194
elk部署springboot。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 3278
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
springboot中抽离日志
qq_24223159的博客
07-08 394
【代码】springboot中抽离日志。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值