Java零基础教程专栏——数组

已于 2023-02-24 17:06:50 修改
阅读量752 收藏
点赞数
分类专栏： Java零基础学习 文章标签： java 数据结构 算法
于 2023-02-11 22:36:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46703995/article/details/128989937
版权

目录

数组

数组就是用来存储一批同种类型数据的容器。

20, 10, 80, 60, 90
int[] arr = {20, 10, 80, 60, 90};
//位置        0   1   2   3   4

数组的位置是从0开始的；

数组的初始化

  • 分为静态初始化，动态初始化、

静态初始化数组

​ 通俗的讲：定义数组的时候直接给数组赋值。

​ 静态初始化数组的格式：

// 完整格式
数据类型[] double[] scores = new double[]{89.9, 99.5, 59.5, 88.0};
int[] arr = new int[]{12, 24, 36}
  数组名 = new 数据类型[]{元素1，元素2 ，元素3… };


// 简化格式
数据类型[] 数组名 = { 元素1，元素2 ，元素3，… };
int[] arr = {12, 24, 36};

注意：数组变量名中存储的是数组在内存中的地址，数组是引用类型。

数组的访问

取值

格式：数组名称[索引]

赋值

格式：数组名称[索引] = 数据

int[] arr = {12, 24, 36};
//位置        0   1    2 

// 取值： 数组名称[索引]
System.out.println(arr[0]);//12
System.out.println(arr[1]);//24
System.out.println(arr[2]);//36
// 赋值：数组名称[索引] = 数据;
arr[2] = 100;
System.out.println(arr[2]); // 100


// 访问数组的长度 数组名称.length
        System.out.println(arr.length);

在这里插入图片描述

数组的动态初始化

数组的动态初始化格式：

数据类型[] 数组名 = new 数据类型[长度];

int[] arr = {12, 24, 36};
//位置        0   1    2 

//数据类型[]  数组名 = new 数据类型[长度];
int[] arr = new int[3];


// 后赋值
arr[0] = 10;
System.out.println(arr[0]); // 10

元素默认值规则：

数据类型明细默认值
基本类型byte、short、char、int、long 0
float、double 0.0
booleanfalse
引用类型类、接口、数组、Stringnull
数据类型明细默认值
基本类型byte、short、char、int、long0
float、double0.0
booleanfalse
引用类型类、接口、数组、Stringnull
// 1、整型数组的元素默认值都是0
        int[] arr = new int[10];
        System.out.println(arr[0]);
        System.out.println(arr[9]);

        // 2、字符数组的元素默认值是多少呢？ 0
        char[] chars = new char[100];
        System.out.println((int)chars[0]);
        System.out.println((int)chars[99]);

        // 3、浮点型数组的元素默认值是0.0
        double[] scores = new double[90];
        System.out.println(scores[0]);
        System.out.println(scores[89]);

        // 4、布尔类型的数组
        boolean[] booleans = new boolean[100];
        System.out.println(booleans[0]);
        System.out.println(booleans[99]);

        // 5、引用类型的数组
        String[] names = new String[90];
        System.out.println(names[0]);
        System.out.println(names[89]);

在这里插入图片描述

注意：

  • 动态初始化：只指定数组长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务场景。
  • 静态初始化：开始就存入元素值，适合一开始就能确定元素值的业务场景。
  • 两种格式的写法是独立的，不可以混用。

数组的遍历

代码：

int[] ages = {20, 30, 40, 50};
for (int i = 0; i < ages.length; i++) {
    System.out.println(ages[i]);
}

数组遍历-求和

需求：某部门5名员工的销售额分别是：20、16、36、3、100，请计算出他们部门的总销售额。

分析

  1. 把这5个数据存储在数组中

    int[] money = {16, 16, 36, 3, 100};

  2. 遍历数组中的每个数据，然后在外面定义求和变量把他们累加起来。

    int sum = 0;
for (int i = 0; i < money.length; i++) {
    // i = 0 1 2 3 4
    sum += money[i];
}

冒泡排序

1、定义一个数组，存储一些数据啊

2、定义一个循环控制比较的轮数

核心代码

 if(arr[j] > arr[j+1]) {
     int temp = arr[j+1];
     arr[j+1] = arr[j];
     arr[j] = temp;
  }

代码：

 public static void main(String[] args) {
        // 1、定义一个数组，存储一些数据啊
        int[] arr = {5, 2, 3, 1};
        //           0  1  2  3

        // 2、定义一个循环控制比较的轮数
        for (int i = 0; i < arr.length - 1; i++) {
            // i == 0  比较的次数 3  j = 0 1 2
            // i == 1  比较的次数 2  j = 0 1
            // i == 2  比较的次数 1  j = 0
            // 3、定义一个循环控制每轮比较的次数，占位
            for (int j = 0; j < arr.length - i - 1; j++) {
                // 判断j当前位置的元素值 是否 大于后一个位置 若较大 则交换
                if(arr[j] > arr[j+1]) {
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        // 遍历数组内容输出
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }

数组的逆序交换

 /*
    把一个数组的元素逆序交换，
    int[] a = { 5, 11, 15, 24, 36, 47, 59, 66 };
      交换元素后
    int[] b = { 66 ,59 ,47 ,36 ,24,15 ,11 ,5 };
     */
    public static void main(String[] args) {
        int[] a = {5, 11, 15, 24, 36, 47, 59, 66};
        int[] b = new int[8];
        for (int i = 0; i < 8; i++) {
            b[i] = a[a.length - 1 - i];
        }
        System.out.println(Arrays.toString(b));
    }

练习题

题目1（训练）

请创建一个长度为6的整数数组，并为数组中的元素赋值。遍历数组，打印所有元素，元素之间用空格隔开。比如：

数组为：{1,2,3,4,5}
打印结果：1 2 3 4 5

训练提示

1、数组中的元素有索引，开始索引和结束索引分别是什么？使用循环语句，依次通过索引获取元素即可遍历数组。

2、在打印数组元素时，是以空格分隔，并且不换行，该怎样输出？

解题方案

for循环遍历数组

操作步骤

1、定义int数组，使用静态初始化方式为元素赋值。

2、使用for循环对数组进行遍历，循环索引从0开始，到数组的长度-1结束。

3、逐个打印数组元素，打印元素不换行，在输出元素的后面拼接空格。

参考答案

public class Demo1 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {11,22,33,44,55};
        //2.对数组遍历
        for (int i = 0; i < arr.length; i++) {
            //3.打印每一个元素
            System.out.print(arr[i] + " ");
        }
    }
}

题目2（训练）

现有一个小数数组{12.9, 53.54, 75.0, 99.1, 3.14}。请编写代码，找出数组中的最小值并打印。

训练提示

1、数组的元素是小数，需要定义小数类型数组。

2、找最值需要先定义一个参考值，然后依次拿每个值与参考值比较即可。

解题方案

将数组的第一个值作为参考值，遍历数组，依次比较，记录更小值。

操作步骤

1、定义double类型数组并存入元素。

2、定义double类型变量min代表最小值，初始化为数组第一个值。

3、遍历数组，用每个元素依次和变量min对比。

4、如果发现有元素小于min，则把该元素赋值给min。

5、遍历结束之后min记录的就是最小值，打印结果。

参考答案

public class Demo2 {
    public static void main(String[] args) {
        //1.定义数组
        double[] arr = {12.9,53.54,75.0,99.1,3.14};
        //2.定义变量代表最小值
        double min = arr[0];
        //3.对数组遍历
        for (int i = 1; i < arr.length; i++) {
            //4.判断
            if(arr[i] < min){
                min = arr[i];
            }
        }
        //4.打印最小值
        System.out.println("最小值是" + min);
    }
}

题目3 (训练）

创建一个长度为6的整数数组。请编写代码，随机生成六个0（包含）-100（不包含）之间的整数存放到数组中，然后计算出数组中所有元素的和并打印。

训练提示

1、数组有6个元素，那么就要生成6次随机数。

2、要求所有元素的和，首先需要定义变量来存储求和结果，然后再获取所有元素，依次累加就可以了。

解题方案

定义求和变量，遍历数组，累加元素值。

操作步骤

1、定义长度为6的int数组。

2、创建随机数Random类对象。

3、遍历数组，在循环中生成随机数并给数组元素赋值。

4、定义求和变量，初始化值为0。

5、遍历数组，获取每一个元素，累加。

6、遍历结束，打印结果。

参考答案

public class Demo3 {
    public static void main(String[] args) throws IOException {
        //1.创建随机数对象
        Random r = new Random();
        //2.定义长度为6的数组
        int[] arr = new int[6];
        //3.循环给数组赋值
        for (int i = 0; i < arr.length; i++) {
            int num = r.nextInt(100);
            arr[i] = num;
        }
        //4.定义求和变量
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        //5.打印结果
        System.out.println("和是" + sum);
    }
}

题目4(训练)

现有一个整数数组，数组中的每个元素都是[0-9]之间的数字，从数组的最大索引位置开始到最小索引位置，依次表示整数的个位、十位、百位。。。依次类推。请编写程序计算，这个数组所表示的整数值。例如：

数组：{2, 1, 3, 5, 4}
表示的整数为：21354 // 注：是整数类型的两万一千三百五十四，不是字符串拼起来的。

训练提示

1、首先肯定要获取数组的每一个元素，需要遍历。

2、根据题目分析，个位元素本身就可以表示值，十位是元素乘以10来表示值，百位就是元素乘以100来表示值。。。它们之间有什么规律呢？从左至右，每一位所表示的值是下一位的十倍。根据此规律，怎样编写算法实现呢？

解题方案

遍历数组，与求和的思路相似，但算法不同，累加时需要将高位*10再累加。

操作步骤

1、定义int类型数组，使用静态初始化，将数字存入数组。

2、定义变量num用来存储最终的数值。

3、对数组进行遍历，遍历开始索引是0，结束索引是arr.length-1。

4、在循环中，把num的值乘10再加上元素的值，赋值给num变量。

5、循环上面的步骤，num的值即为所求，打印结果。

参考答案

public class Demo4 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {1, 3, 5, 7, 9};
        //2.定义变量存储最终的整数
        int num = 0;
        //3.对数组进行遍历
        for (int i = 0; i < arr.length; i++) {
            //4.计算，高位乘以10再加上当前位的值
            num = num * 10 + arr[i];
        }
        //5.打印结果
        System.out.println(num);
    }
}

题目5（训练）

定义一个数组来存储10个学生的成绩，例如：{72, 89, 65, 87, 91, 82, 71, 93, 76, 68}。计算并输出学生的平均成绩。

训练提示

1、要操作数组的每一个元素，需要遍历。

2、怎样求平均数？其实只要求和之后也就知道了平均数。

解题方案

使用数组的遍历操作完成。

操作步骤

  1. 定义保存学生成绩的数组arr。
  2. 定义变量sum用来存储和。
  3. 对数组进行遍历，求和。
  4. 和除以元素个数得到平均数。
  5. 打印结果。

参考答案

public class Demo5 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {72,89,65,87,91,82,71,93,76,68};
        //2.定义变量存储累加和
        double sum = 0;
        //3.遍历数组
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        //4.通过和求出平均数
        double avg = sum / arr.length;
        //5.打印平均数
        System.out.println("平均值是" + avg);
    }
}

题目6（训练）

有一个数组，其中有十个元素从小到大依次排列 {12,14,23,45,66,68,70,77,90,91}。再通过键盘录入一个整数数字。要求：把数字放入数组序列中，生成一个新的数组，并且数组的元素依旧是从小到大排列的。执行效果如下：

请输入一个整数数字：
50
生成的新数组是：12 14 23 45 50 66 68 70 77 90

训练提示

  1. 数组的长度是不能改变的，所以增加一个元素需要定义一个新数组。
  2. 数组元素是从小到大排列的，如何找到新元素存放的位置？

解题方案

​ 使用数组的遍历，用元素依次和数字作比较，找到正确的存放位置。

操作步骤

  1. 定义原数组arr，和一个比原数组长度大1的新数组brr。
  2. 通过键盘录入的方式输入变量num的值。
  3. 定义变量index用于记录num存放的索引位置。
  4. 遍历数组，小于或等于num的元素直接存放到原来的位置，大于num的元素往后移动一个位置。
  5. 存放结束之后，中间会空出一个位置,在遍历时用index记录这个位置。把num放在这个索引处。
  6. 最终遍历新数组打印结果。

参考答案

public class Demo6 {
    public static void main(String[] args) {        
		//1.定义长度为10的原数组
        int[] arr = {12,14,23,45,66,68,70,77,90,91};
        //2.定义长度为11的空数组
        int[] brr = new int[11];
        //3.键盘录入数组
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数数字");
        int num = sc.nextInt();
        //4.定义变量代表要插入的位置
        int index = 0;
        //5.循环遍历原数组
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] <= num) {
                //5.1如果元素小于等于要插入的数字，则直接存放
                brr[i] = arr[i];
                //5.2把i后面的位置记录下来
                index = i + 1;
            }else{
                //5.3如果元素大于要插入的数字,则往后一个位置存放
                brr[i+1] = arr[i];
            }
        }
        //6.index存储的就是要插入的位置
        brr[index] = num;
        //7.遍历新数组查看结果
        System.out.print("生成的新数组是：");
        for (int i = 0; i < brr.length; i++) {
            System.out.print(brr[i] + " ");
        }
    }
}

题目7（综合）

小李用自己的钱买了十只股票，年末他看了各只股票的收益分别是10.4%,-3%,-6.2%,1.2%,-6.1%,-19%,-3.8%,0.9%,-4.5%,5.5%。请使用数组相关知识编程，帮他统计赚钱的股票和赔钱的股票分别有多少只？打印效果如下：

赚钱的股票一共有：4只
赔钱的股票一共有：6只

训练提示

  1. 有多只股票，可以使用数组来存储。
  2. 股票收益为小数，所以数组类型应该是小数。
  3. 需要定义两个变量来分别存储统计的个数。

解题方案

  1. 使用数组的遍历，判断每个股票的收益是正值还是负值，分别统计。

操作步骤

  1. 定义小数数组存储十只股票的收益值。
  2. 定义变量count1用于存储赚钱股票的个数，初始值是0。
  3. 定义变量count2用于存储赔钱股票的个数，初始值是0。
  4. 遍历数组判断，如果收益大于0则count1加一，如果收益小于0则count2加一。
  5. 遍历结束后打印两个变量值。

参考答案

public class Demo7 {
    public static void main(String[] args) {
        //1.定义数组
        double[] arr = {10.4,-3,-6.2,1.2,-6.1,-19,-3.8,0.9,-4.5,5.5};
        //2.定义统计赚钱个数的变量
        int count1 = 0;
        //3.定义统计赔钱个数的变量
        int count2 = 0;
        //4.遍历数组
        for (int i = 0; i < arr.length; i++) {
            //4.1判断股票是赔钱还是赚钱
            if(arr[i] > 0){
                count1++;
            }else{
                count2++;
            }
        }
        //5.打印结果
        System.out.println("赚钱的股票共：" + count1 + "只");
        System.out.println("赔钱的股票共：" + count2 + "只");
    }
}

题目8（综合）

定义一个数组其中包含多个数字。用自己的方式最终实现，奇数放在数组的左边，偶数放在数组的右边。（可以创建其他数组，不必须在原数组中改变）

训练提示

  1. 要找奇数和偶数只需要判断对2取余即可。
  2. 找到一个奇数或偶数之后，把它放在哪个索引处？

解题方案

  1. 定义一个新数组。把原数组的奇数放在新数组的左边，把原数组的偶数放在新数组的右边。

  2. 不定义新数组。找到左边的偶数，和右边的奇数互换位置。

    以下以方案1为准

操作步骤

  1. 定义出原数组arr，其中包含多个数字。
  2. 定义新数组brr，和arr的长度一样。
  3. 定义变量left，初始值是0准备从左边放元素，定义变量right，初始值是arr.length-1准备从右边放元素。
  4. 对原数组arr进行遍历。
  5. 如果元素是奇数，则放在新数组brr的左边，left变量加一。
  6. 如果元素是偶数，则放在新数组brr的右边，right变量减一。
  7. 遍历新数组brr打印最终结果。

参考答案

public class Demo8 {
    public static void main(String[] args) {
        //1.定义原数组
        int[] arr = {12,23,34,45,67,78,11,22};
        //2.定义空数组
        int[] brr = new int[arr.length];
        //3.定义变量代表奇数要存放的位置
        int left = 0;
        //4.定义变量代表偶数要存放的位置
        int right = arr.length-1;
        //5.对原数组进行遍历
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] % 2 == 1){
                //5.1如果是奇数就往左边放
                brr[left] = arr[i];
                //5.2存放之后让索引向右移动
                left++;
            }else{
                //5.3如果是偶数就往右边放
                brr[right] = arr[i];
                //5.4存放之后让索引向左移动
                right--;
            }
        }
        //6.打印brr数组
        for (int i = 0; i < brr.length; i++) {
            System.out.print(brr[i] + " ");
        }
    }
}
沐雨风栉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 14万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
C语言基础——专栏索引篇
01-08
前言 ...第二课：指针与数组——————————————————————–《透过表象看本质->指针与数组的关系》 第三课：结构体的内存对齐———————————————————–《内存对齐模式
Java零基础教程专栏——方法
沐雨风栉
02-12 533
方法就是一段普通的代码片段，并且这段代码可以完成某个特定的功能，而且可以被重复的调用/使用。java 中的方法又叫做 method，在方法定义时：返回值类型、形参列表可以按照需求进行填写。格式修饰符 返回值类型 方法名(形参列表) {方法体代码(需要执行的功能代码) return 返回值;修饰符，此项是可选项，不是必须的。返回值类型，此项可以是 java 语言当中任何一种数据类型，包括基本数据类型，也包括所有的引用数据类型，当然，如果一个方法执行结束之后不准备返回任何数据，则返回值类型必须写 void。
【Java基础教程】（八）面向对象篇 · 第二讲：Java 数组全面解析——动态与静态初始化、二维数组、方法参数传递、排序与转置、对象数组、操作API~
Technology changes the world of life
07-09 1095
本文介绍了一些与数组相关的概念和技术。首先，讲解了动态初始化和静态初始化，它们是创建数组的两种方式。然后，探讨了二维数组的概念和用法，以及如何通过索引来访问二维数组的元素。 接下来，探讨了数组作为方法参数的传递方式。在 Java 中，数组是按引用传递的，意味着数组作为参数传递给方法时，实际上传递的是数组的引用地址，可以在方法中修改原始数组。 随后，简单介绍了常见的数组排序算法，主要介绍了冒泡排序，当然还包括选择排序、插入排序、归并排序、快速排序、堆排序等。每种排序算法都有不同的特点和适用场景，根据需求选
【Java基础教程】Java学习路线攻略导图——史诗级别的细粒度归纳 ~
Technology changes the world of life
07-19 1万+
🍺🍺 各位读者朋友大家好！得益于各位朋友的支持和关注，我的专栏《Java基础教程》至今已经更新近半，我们一起探索了Java语言的许多核心概念和重要特性。在过去的文章中，我们一共涉及了入门介绍、程序基础概念、面向对象、包及访问控制权限、异常处理以及特别篇一共六个篇章，详细阐述了Java基础概念、关键字、各类运算、抽象类、接口、包、权限、异常处理等多个主题知识...
java基础知识点
热门推荐
学Java，找哪吒
09-18 2万+
🏆作者简介：哪吒，CSDN2022博客之星Top1、CSDN2021博客之星Top2、多届新星计划导师✌、博客专家💪，专注Java硬核干货分享，立志做到Java赛道全网Top N。🏆本文收录于，，目前已经700+订阅，CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。🏆姐妹篇，，包含面向对象、基本数据类型、数组、继承和多态、泛型、枚举等Java基础知识点。🏆姐妹进阶篇，
java框架学习笔记——SpringMVC
小熊的学习记录
11-18 967
Spring MVC（全称 Spring Web MVC）是 Spring 框架提供的一款基于 MVC 模式的轻量级 Web 开发框架，是 Spring 为表示层（UI）开发提供的一整套完备的解决方案。
【算法与数据结构】JS基础——数组
qq_41003479的博客
12-23 167
今天首先对JavaScript最基础的数组进行介绍，下一篇会介绍栈，感兴趣的赶紧关注我吧~本文学习了JavaScript数组的基本用法，为下篇文章——栈做铺垫，也简单介绍了Typescript的数组，自己在学习的过程中也是学到了一些平时不怎么用的新东西，希望对你也有些帮助，这里是GIS宇宙，我们下期再见。
【熬夜爆肝版】JAVA基础入门专栏——1.JAVA开发入门
weixin_61605998的博客
10-06 328
本专栏的第一篇博文，主要讲解：java开发入门的一些相关的知识点，java概述、JDK、系统环境变量、Java程序运行机制。使用通俗易懂的文字来讲解，图文并茂，不枯燥。
滚雪球学Java(62)：HashSet的底层实现原理解析
**My Coding Family**
11-14 2989
🏆本文收录于「滚雪球学Java」专栏，专业攻坚指数级提升，助你一臂之力，带你早日登顶🚀，欢迎大家关注&&收藏！持续更新中，up！up！up！！
杨桃的Python进阶讲座11——数组array（四）利用数组或矩阵求解线性方程（帮你回忆线性代数）
01-21
本人CSDN博客专栏：https://blog.csdn.net/yty_7 ...应用背景 一群小孩和家长出去旅游，去程坐的是大巴车，小孩票价为3元/人，家长票价为3.2元/人，总票价是118.4元；回程坐的是火车，小孩票价为...（1）数组array解法 i
JAVA基础知识笔记，内容看JAVA学习专栏，压缩包资源较全
03-13
是本人JAVA学习过程中的一些笔记内容，从最基础的JAVA命名规范到面向对象编程再到网络编程，JDBC等高级应用，本笔记建议与B站韩顺平老师的JAVA课程进行配套。
实验2 Java语言基础.doc
05-02
本专栏主要为Java程序设计（基础）实验报告和Java程序设计（进阶）实验报告，基础篇有JAVA环境搭建、Java语言基础、方法和数组、面向对象基础、Java常用类、继承与接口、成员访问控制与异常、JavaFX程序设计、Java...
JavaSE基础语法专栏所有代码
08-24
JavaSE基础语法专栏学习笔记
Linux下网络编程-简易Epll服务器和客户端
weixin_45256307的博客
05-06 418
Linux下网络编程-简易Epll服务器和客户端
一篇文章，系统性聊聊Java注解
架构风清扬
05-06 1053
一篇文章，系统性聊聊Java注解
Java代码基础算法练习-删除有序数组中的重复项-2024.05.07
最新发布
Sakurapaid的博客
05-07 188
给一个有序数组（共10个元素），请在不新建数组的情况下，删除重复出现的元素，使 每个元素只出现一次，最后请输出删除重复元素后数组的新长度和数组元素。要删除有序数组中的重复项，且不使用额外数组，可以采用。
Nacos 配置中心实例分析实践
m0_73557631的博客
05-03 1078
​ 浏览器: http://localhost:5000/nacos/config/ip。先创建e-commerce-nacos-config-client5000 模块。​ 启动e-commerce-nacos-config-client5000。​ 启动Nacos Server。
java 规则引擎专栏
09-23
[Drools]JAVA规则引擎--Drools_quzishen的专栏是一篇介绍Java规则引擎Drools的专栏，它详细介绍了Drools规则引擎的特点和用法。Drools是一个基于Java的开源规则引擎，可以将复杂多变的规则从硬编码中解放出来，以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

沐雨风栉

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

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

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

打赏作者

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

抵扣说明：

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

余额充值