Java入门到入土！(三)_java入门到种地-程序员宅基地

技术标签： JAVA java 零基础 java

文章目录

第五章、流程控制
第六章、方法
第七章、数组

第五章、流程控制

5.1.流程控制的简介

5.1.1. 程序的执行结构

在Java中，程序的执行结构分为三种

顺序结构：代码从上往下，逐行依次执行，是程序执行的默认结构。
分支结构：程序在某一个节点遇到了多种向下执行的可能性，根据条件，选择一个分支继续执行。
循环结构：某一段代码需要被重复执行多次。

5.1.2. 流程控制的介绍

流程控制，就是通过指定的语句，修改程序的执行结构。按照修改的不同的执行结构，流程控制语句可以分为：

分支流程控制语句：
- 将程序，由顺序结构，修改为分支结构
循环流程控制语句：
- 将程序，由顺序结构，修改为循环结构

5.2. 分支流程控制 - if

5.2.1. if 流程图

略

5.2.2. if 基础语法

if(condition){
    
    //代码块1
}else{
    
    //代码块2
}

逻辑: condition是一个boolean类型的变量, 或者一个boolean结果的表达式. 如果condition的值为true, 则代码段1执行, 否则, 代码段2执行

public class JavaSyntax {
    
    public static void main(String[] args) {
    
        int score = 99;
        if (score>=60){
    
            System.out.println("成绩及格！");
        }else {
    
            System.out.println("成绩不及格！");
        }
    }
}

5.2.3. if 语法进阶

if(condition1){
    
    //代码块1
}else if(condition2){
    
    //代码块2
}else{
    
    //代码块3
}

逻辑: 先判断condition1, 如果condition1成立, 执行代码段1; 如果condition1不成立, 再判断condition2, 如果condition2成立, 执行代码段2, 否则执行代码段3

public class JavaSyntax {
    public static void main(String[] args) {
        // 1. 定义一个成绩
        int score = 59;

        // 2. 将成绩划分成不同的等级
        //    < 0 || > 100 : 错误成绩
        //    [0, 60): 不及格
        //    [60, 80): 良
        //    [80, 90): 中
        //    [90, 100]: 优
        if (score < 0 || score > 100) {
            System.out.println("错误成绩");
        }
        else if (score < 60) {
            System.out.println("不及格");
        }
        else if (score < 80) {
            System.out.println("良");
        }
        else if (score < 90) {
            System.out.println("中");
        }
        else {
            System.out.println("优");
        }
    }
}

5.3. 分支流程控制 - switch

5.3.1. switch流程图

在这里插入图片描述

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JuidFe04-1594201665245)(C:\Users\Ba-Ba\Desktop\wps156.jpg)]

5.3.2. switch的基础语法

switch(变量){
    
	case值1：
        //分支语句1
    case值2：
        //分支语句2
     ......
        
    default:
}

程序逻辑：

检测某一个变量的值，从上往下依次与每一个case进行校验、匹配
如果变量的值和某一个case后面的值相同，则执行这个case后的语句
如果变量的值和每一个case都不相同，则执行default后的语句

5.3.3. break

public class Switch1 {
    
    public static void main(String[] args) {
    
        // 1. 定义一个变量, 记录第几个季节
        int season = 1;
        // 2. 根据season的值, 输出不同的季节
        switch (season) {
    
            case 1:
                System.out.println("春天");
            case 2:
                System.out.println("夏天");
            case 3:
                System.out.println("秋天");
            case 4:
                System.out.println("冬天");
            default:
                System.out.println("这是一个适合学习的季节");
        }
    }
}

上述代码中， switch结构捕获变量season的值。变量的值和第一个case是匹配的，应该输出的结果是 “春天”。但实际上的输出结果却是从春天开始的每一个输出。

因为在switch结构中有“穿透性”。

穿透性:

指的是，当switch的变量和某一个case值匹配上之后，将会跳过后续的case或者default的匹配，直接向后穿透。

在这里插入图片描述

为了杜绝穿透，可以使用关键字 break:

这一段程序， season的值，和case1匹配。因此会输出“春天”，然后向下穿透，输出“夏天”。此时，遇到了关键字 break。将会结束穿透，直接结束switch结构。

因此，此时的输出结果是: 春天夏天

5.4. 循环流程控制 - for

5.4.1. for循环流程图

略

5.4.2. for循环基础语法

for(循环初始部分；循环条件；循环迭代部分){
    
    循环体
}

执行逻辑：

循环开始后，先执行循环初始部分，这一部分的代码只会执行一次。在初始部分，常常用于定义循环控制变量。
循环初始部分结束后，判断循环条件。
如果循环条件成立，执行循环体。
循环体执行结束后，执行循环迭代部分。这里常常用于对循环控制变量进行修改。
循环迭代部分执行结束，再回到第二步，判断循环条件。
如果循环条件成立，继续执行循环体。如果循环条件不成立，循环结束。

5.4.3. 特殊语法

循环体中的代码如果只有一句，大括号可以省略。但是从语法角度出发，可以省略，实际写程序的时候，出于规范，一般不省略。

public class For1 {
      
    public static void main(String[] args) {
      
        // 基础案例: 输出数字 1~100
        // for (int number = 1; number <= 100; number++) {
      
        //     System.out.println(number);
        // }

        // 基础案例: 输出[1,100]范围内的奇数
        // for (int num = 1; num <= 100; num++) {
      
        //     if (num % 2 != 0) {
      
        //         System.out.println(num);
        //     }
        // }
        // for (int num = 1; num <= 100; num += 2) {
      
        //     System.out.println(num);
        // }

        // 基础案例: 计算 1+2+3+4+...+100 = ?
        // 思路:
        // 定义一个变量, 用来记录累加的结果
        // 再将所有的数字依次累加到这个和里面
        int sum = 0;
        for (int n = 1; n <= 100; n++) {
      
            sum += n;
        }
        System.out.println(sum);
    }
}

for循环小括号中的每一部分都可以省略不写，但是分号不能省略。
```
 for (int n = 1; n <= 100; n++) 
        System.out.println(n);
```

5.5. 循环流程控制 - while

5.5.1. while循环基础语法

while(循环条件){
    
    //循环体
}

程序逻辑：

如果循环条件条件成立，循环体循环执行。直到循环条件不成立。

5.5.2. 示例代码

public class JavaSyntax {
    
    public static void main(String[] args) {
    
        int n = 1;
        while (n < 100) {
    
            System.out.println(n);
        }
    }
}

5.5.3. do-while循环

do-while循环基本与while循环是一致的，只是在执行逻辑上稍微有点区别:

public class JavaSyntax {
    
    public static void main(String[] args) {
    
        int n = 1;
        do {
    
            System.out.println(n);
        } while (n < 100);
    }
}

执行逻辑:

先执行循环体，再判断循环条件是否成立。
如果循环条件成立，继续执行循环体。
如果循环条件不成立，结束循环。

5.6. 两个关键字

5.6.1. break

break用在循环中，表示无论循环条件是否成立，立即结束循环。

public class JavaSyntax {
    
    public static void main(String[] args) {
    
        for (int i = 0; i < 10; i++) {
    
            if (i == 5) {
    
                break;
            }
            System.out.println(i);
        }
    }
}

上述代码中，如果i的值为5，结束循环。所以，程序输出结果是

0

1

2

3

4

5.6.2. continue

continue用在循环中，表示立即停止本次循环，开始下次循环。

public class JavaSyntax {
    
    public static void main(String[] args) {
    
        for (int i = 0; i < 10; i++) {
    
            if (i == 6) {
    
                continue;
            }
            System.out.println(i);
        }
    }
}

当i的值是5的时候，停止当次的循环，立即进入下次循环。所以，程序输出的结果是

0

1

2

3

4

6

7

8

9

5.7. 循环标签

循环的实际使用中，有些情况下，需要使用到嵌套循环。在嵌套循环中，如果内层循环写了break或者continue，此时只能作用于内层的循环。

public class Loop {
    
    public static void main(String[] args) {
    
        for (int i = 0; i < 3; i++) {
    
            for(int j = 0;j<3;j++){
    
                if (j == 2){
    
                    break;
                }
                System.out.println("i="+i+",j="+j);
            }
        }
    }
}

上述代码中，当内层循环j的值为2的时候，结束内层循环。所以，程序的输出结果是

i = 0, j = 0

i = 0, j = 1

i = 1, j = 0

i = 1, j = 1

i = 2, j = 0

i = 2, j = 1

如果在内层循环中，需要使用break或者continue关键字作用于外层的循环，需要配合循环标签使用。

循环标签是一个标识符，常写成全大写。在循环的前面直接写标签，添加一个冒号即可。

public class Loop {
    
    public static void main(String[] args) {
    
        loop:for (int i = 0; i < 3; i++) {
    
            for(int j = 0;j<3;j++){
    
                if (j == 2){
    
                    break loop;
                }
                System.out.println("i="+i+",j="+j);
            }
        }
    }
}

上述代码中， break OUTER; 使得break关键字作用于指定的循环。此时，程序的输出结果是

i = 0, j = 0

i = 0, j = 1

第六章、方法

6.1.方法的简介

6.1.1. 方法的概念

在程序中，有些情况下，有些代码是需要被多次执行的。如果需要在每次使用到这些逻辑的时候，都去写代码实现，此时代码将会非常的冗余，不利于维护。

此时，我们可以将这些需要被多次执行的逻辑单独包装起来，在需要的时候直接调用即可。

方法，就是为了实现这个需求而存在的。

方法，其实就是一个实现特定功能的代码段，方法中的逻辑可以被重复使用。

6.1.2. 为什么要使用方法

可以使用方法，将需要多次执行的逻辑封装起来，哪里需要，哪里直接调用即可。

降低了代码的冗余，提高了代码的复用性与维护性。

6.2. 方法的定义与调用

6.2.1. 方法的定义

[访问权限修饰符][其他修饰符]返回值类型 方法名字([参数列表]){
    
    方法体
}

访问权限修饰符：定义了方法的访问权限。
其他的修饰符：定义了方法的其他的修饰。
返回值类型：定义了方法返回的值的类型。
方法名字：遵循小驼峰命名法的标识符。
方法体：需要封装起来的，可以被重复执行的代码段。

6.2.2. 第一个方法

//这个方法中，封装了一个九九乘法表
//哪里需要乘法表，哪里调用即可
public static void diaplay(){
    
    for (int line = 1;line<=9;line++){
    
        for (int colume = 1;colume<=9;colume++){
    
            System.out.println(colume+"x"+line+"="+colume*line+"\t");
        }
    }
}

6.2.3. 方法的调用

方法写完后，其中的逻辑并不会立即执行。如果想让程序中的逻辑执行，需要调用方法。

调用方法，直接使用方法的名字即可。

public class Test {
    
    public static void main(String[] args) {
    
        //方法的调用
        diaplay();
    }
    //这个方法中，封装了一个九九乘法表
    //哪里需要乘法表，哪里调用即可
    public static void diaplay(){
    
        for (int line = 1;line<=9;line++){
    
            for (int colume = 1;colume<=9;colume++){
    
                System.out.println(colume+"x"+line+"="+colume*line+"\t");
            }
        }
    }
}

6.3. 方法的参数

6.3.1. 参数的概念

多数情况下，方法与调用者之间需要进行数据的交互。调用者必须提供必要的数据，才能使用方法完成相应的功能。

例如:

ATM取款机，封装了取钱的功能。用户在使用ATM取款的时候，需要插入银行卡。此时，就是使用者与功能集的数据交互。

自动贩卖机，封装了贩卖的功能。用户在使用自动贩卖机的时候，需要选择购买的物品。此时，也是使用者与功能集的数据交互。

调用方法的时候，需要将一些数据传入到方法中，实现调用方与方法的数据交互。这个被传入到方法中的数据，被称为是参数。

6.3.2. 参数的定义

参数定义在方法的小括号中，与变量的定义类似，使用 [ 数据类型标识符 ] 的方式定义。

//定义了一个打印若干分隔符的方法，数量由参数count定义
public static void diaplay(int count) {
    
    for (int i = 0; i < count; i++) {
    
        System.out.println("-");
    }
    System.out.println();
}

定义参数的注意事项：

参数定义在方法的参数列表中，使用 [ 数据类型标识符 ] 的形式定义。
如果需要定义多个参数，多个参数之间以逗号分隔。
参数在定义的时候，不允许赋初始值。
即便多个参数的类型都是相同的，每一个参数也必须显式的定义类型。

6.3.3. 有参方法的调用

在调用有参方法的时候，必须给每一个参数进行赋值。直接将这些值写入到小括号里面即可。

public class Test {
    
    public static void main(String[] args) {
    
        //方法的调用
        diaplay(5);
    }

    //定义了一个打印若干分隔符的方法，数量由参数count定义
    public static void diaplay(int count) {
    
        for (int i = 0; i < count; i++) {
    
            System.out.println("-");
        }
        System.out.println();
    }
}

6.3.4. 几个概念

形参:
- 定义在方法的参数列表中，这样的参数只是一个形式。在方法中并不知道这个参数的值是什么，只有在调用的时候才知道具体的值是多少。
- 这样的参数被称为形式参数，简称形参
实参:
- 定义在方法调用时候的小括号中。这个参数是形参实际的值。
- 这样的参数被称为实际参数，简称实参
传参:
- 在调用方法的时候，实参给形参进行赋值。这个过程被称为传参

6.4. 方法的返回值

6.4.1. 返回值的概念

在进行方法调用的时候，有些情况下是需要有逻辑执行结果的。

例如

ATM取款机，用户在取完钱之后，一定是要能够得到实际的钱的。此时就是调用功能集得到的结果。

6.4.2. 返回值的定义

在前面定义方法的时候，返回值类型部分，写的是void。

void: 表示无，没有返回值。表示这个方法没有执行结果。

static int add(int a, int b){
    
    return a+b;
}

注意事项

如果一个方法的返回值类型不是void，则方法在执行结束之前，必须要有return关键字返回一个结果。

6.4.3. return关键字

表示方法的执行结果。

return关键字后面跟上方法的执行结果，这个值的类型，必须和方法定义中的返回值类型一致。
```
static int add(int a, int b){
      
    return a+b; //将a+b的运算结果，作为整个方法的执行结果。
}
```
表示结束方法的执行

在一个返回值类型为void的方法中，也可以使用return关键字。此时， return后面什么都不要写。

return写在方法中，表示结束方法的结束。
```
static int add(int a, int b){
      
    return a+b;
  //return执行后，后面的所有代码都不执行。
    //方法结束。
}
```

6.5. 方法的重载

6.5.1. 重载的概念

在一个类的方法中，如果多个方法满足如下条件，则他们之间的关系就是重载

方法名相同
参数不同
- 参数不同，体现在参数的数量不同或者参数的类型不同。

注意： 方法的重载，与返回值没有关系！

6.5.2. 重载方法的定义

public class Test {
    
    public static void calculate() {
    
    }

    public static void calculate(int a) {
    
    }

    public static void calculate(int a, int b) {
    
    }

    public static String calculate(String x, String y) {
    
        return x + y;
    }
}

6.5.3. 重载方法的调用

调用重载方法的时候，使用实参区分调用不同的方法。

public class Test {
    
    public static void calculate() {
    
    }

    public static void calculate(int a) {
    
    }

    public static void calculate(int a, int b) {
    
    }

    public static String calculate(String x, String y) {
    
        return x + y;
    }
    
    public static void main(String[] args) {
    
        calculate();//无参方法调用
        calculate(3);//一个参数方法调用
        calculate(3, 4);//两个整型参数方法调用
        calculate("a", "b");//两个字符串型参数方法调用
    }
}

第七章、数组

7.1. 数组的概念

7.1.1. 一个案例

如何存储100名学生的成绩
- 办法：使用变量存储，重复声明100个double类型的变量即可。
- 缺点：麻烦，重复操作过多。
如何让100名学生成绩全部+1
- 办法：100个变量重复相同操作，直到全部完毕。
- 缺点：无法进行统一的操作。

7.1.2. 数组是什么

数组，是一个数据容器。可以存储若干个相兼容的数据类型的数据。

在上述案例中，存储100名学生的成绩，可以用数组来完成。将这100个成绩存入一个数组中。此时对这些数据进行统一操作的时候，直接遍历数组即可完成。

7.1.3. 数组的特点

数组中可以存储基本数据类型的数据，也可以存储引用数据类型的数据。
数组的长度是不可变的。一个数组一旦实例化完成，长度不能改变。

7.2. 数组的声明

7.2.1. 声明数组

double[] arrar1;
int[] array2;
String[] array3

7.2.2. 数组的实例化

实例化数组：其实就是在内存中开辟空间，用来存储数据。

public class Test {
    
    public static void main(String[] args) {
    
        // 实例化了一个数组， 可以存储5个数据
        // 此时数组中的元素就是默认的5个0
         int[] array1 = new int[5];
        // 实例化了一个数组， 默认存储的是 1, 2, 3, 4, 5
        // 此时数组的长度， 由这些存储的数据的数量可以推算出来为5
        int[] array2 = new int[] {
     1, 2, 3, 4, 5 };
        // 实例化了一个数组， 默认存储的是 1， 2， 3， 4， 5
        // 相比较于第二种写法， 省略掉了 new int[]
         int[] array3 = {
     1, 2, 3, 4, 5 };
    }
}

7.2.3. 数组引用

数组的实例化的时候，需要使用到关键字new

数组，其实是在堆上开辟的连续的空间。例如 new int[5]，就是在堆上开辟5个连续的4字节空间。

然后，将堆上的内存地址，给栈上的引用进行赋值。

在这里插入图片描述

7.3. 数组的下标

7.3.1. 下标的概念

下标，就是数组中的元素在数组中存储的位置索引。

注意：数组的下标是从0开始的，即数组中的元素下标范围是 [0, 数组.length - 1)

7.3.2. 访问数组元素

访问数组中的元素，需要使用下标访问。

public class Test {
    
    public static void main(String[] args) {
    
        //实例化一个数组
         int[] array = {
     1, 2, 3, 4, 5 };
         //访问数组中的元素
         array[2] = 300;//将数组中的第2个元素修改为300
        System.out.println(array[2]);//此时输出的是300
    }
}

7.3.3. 注意事项

在访问数组中的元素的时候，注意下标的问题！

如果使用错误的下标访问数组中的元素，将会出现 ArrayIndexOutOfBoundsException 异常！

public class Test {
    
    public static void main(String[] args) {
    
        //实例化一个数组
         int[] array = {
     1, 2, 3, 4, 5 };
         //访问数组中的元素
         array[10] = 300;//访问数组中下标为10的元素，此时数组的最大下标为4,会出现异常
    }
}

7.4. 数组的遍历

数组遍历：其实就是按照数组中元素存储的顺序，依次获取到数组中的每一个元素。

7.4.1. 下标遍历

思路：循环依次获取数组中的每一个下标，再使用下标访问数组中的元素

public class Test {
    
    public static void main(String[] args) {
    
        //实例化一个数组
        int[] array = {
    1, 2, 3, 4, 5};
        //使用下标遍历数组
        for (int i = 0; i < array.length; i++) {
    
            System.out.println(array[i]);
        }
    }
}

7.4.2. 增强for循环

思路：依次使用数组中的每一个元素，给迭代变量进行赋值。

public class Test {
    
    public static void main(String[] args) {
    
        //实例化一个数组
        int[] array = {
    1, 2, 3, 4, 5};
        //使用下标遍历数组
        for (int ele : array) {
    
            System.out.println(ele);
        }
    }
}

7.4.3. 两种方式的对比

如果需要在遍历的同时，获取到数组中的元素下标，需要使用下标遍历法。
如果需要在遍历的同时，修改数组中的元素，需要使用下标遍历法。
如果仅仅是想要获取数组中的每一个元素，不需要下标，也不需要修改数组中的元素，使用增强for循环。因为这种方式，遍历的效率比下标遍历法高。

7.5. 数组的排序

排序，即排列顺序，将数组中的元素按照一定的大小关系进行重新排列。

在Java中，常见的排序有:

选择排序：固定值与其他值依次比较大小，互换位置。
冒泡排序：相邻的两个数值比较大小，互换位置。
JDK排序：java.util.Arrays.sort(数组); // JDK提供默认的升序排序

…

有兴趣的可自行百度。

7.6. 可变长参数

7.6.1. 概念

可以接收多个类型相同的实参，个数不限，使用方式与数组相同。

在调用方法的时候，实参的数量可以写任意多个。

7.6.2. 语法

数据类型…形参名（必须放到形参列表的最后位，且只能有一个）

ststic void show(int...parameters){
    
	//方法体
}

7.6.3. 使用

public class Test {
    
    public static void main(String[] args) {
    
        // int[] array = { 1, 2, 3 };
        // showArray(array);

        // 如果一个方法的参数，使用 ... 来定义，可以将这个数组中的元素，直接写到实参列表中
        // 注意事项:
        // 1. 在形参列表中，可变长度的参数，必须在形参列表的最后位
        // 2. 一个形参列表中，只能存在一个...修饰的可变长度参数
        showArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
    }

    public static void showArray(int a, int... array) {
    
        for (int i : array) {
    
            System.out.println(i + ",");
        }
    }
}

7.7. 二维数组

7.7.1. 概念

二维数组，其实就是数组中嵌套数组。

二维数组中的每一个元素都是一个小的数组。

理论上来讲, 还可以有三维数组、四维数组，但是常用的其实就是二维数组。

7.7.2. 定义与使用

public class Array {
    
    public static void main(String[] args) {
    
        // 1. 实例化一个二维数组
        // 第一个中括号中的3: 二维数组中包含了三个一维数组
        // 第二个中括号中的5: 二维数组中的每一个一维数组长度为5 
        int[][] array = new int[3][5];
        // 使用双下标访问数组中的元素
        array[0][3] = 10;

        // 这里得到的，是二维数组的长度，3 
        System.out.println(array.length);
        // 2. 实例化一个二维数组
        // 第一个中括号中的3: 二维数组中包含了三个一维数组
        //  第二个中括号中什么都没有，代表现在二维数组中的三个元素是 null 
        int[][] array2 = new int[3][];
        array2[0] = new int[]{
    1, 2, 3};

        // 3. 通过初始值实例化一个二维数组
        int[][] array3 = {
    {
    1, 2, 3}, {
    1, 2, 3, 4, 5}, {
    2, 3, 4}};
    }
}

7.8. Arrays工具类

7.8.1. 常用方法

方法	描述
copyOf(int[] array, int newLength)	从原数组中拷贝指定数量的元素，到一个新的数组中，并返回这个新的数组
copyOfRange(int[] array, int from, int to)	从原数组中拷贝指定范围 [from, to) 的元素，到一个新的数组中，并返回这个新的数组
equals(int[] array1, int[] array2)	判断两个数组是否相同
fill(int[] array, int element)	使用指定的数据，填充数组
sort(int[] array)	对数组进行排序（升序）
binarySearch(int[] array, int element)	使用二分查找法，到数组中查询指定的元素出现的下标
toString(int[] array)	将数组中的元素拼接成字符串返回

本文链接：https://blog.csdn.net/weixin_42947670/article/details/107211526

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

while循环&CPU占用率高问题深入分析与解决方案_main函数使用while(1)循环cpu占用99-程序员宅基地

文章浏览阅读3.8k次，点赞9次，收藏28次。直接上一个工作中碰到的问题，另外一个系统开启多线程调用我这边的接口，然后我这边会开启多线程批量查询第三方接口并且返回给调用方。使用的是两三年前别人遗留下来的方法，放到线上后发现确实是可以正常取到结果，但是一旦调用，CPU占用就直接100%(部署环境是win server服务器)。因此查看了下相关的老代码并使用JProfiler查看发现是在某个while循环的时候有问题。具体项目代码就不贴了，类似于下面这段代码。while(flag) {//your code;}这里的flag._main函数使用while(1)循环cpu占用99

【无标题】jetbrains idea shift f6不生效_idea shift +f6快捷键不生效-程序员宅基地

文章浏览阅读347次。idea shift f6 快捷键无效_idea shift +f6快捷键不生效

node.js学习笔记之Node中的核心模块_node模块中有很多核心模块,以下不属于核心模块,使用时需下载的是-程序员宅基地

文章浏览阅读135次。Ecmacript 中没有DOM 和 BOM核心模块Node为JavaScript提供了很多服务器级别，这些API绝大多数都被包装到了一个具名和核心模块中了，例如文件操作的 fs 核心模块，http服务构建的http 模块 path 路径操作模块 os 操作系统信息模块// 用来获取机器信息的var os = require('os')// 用来操作路径的var path = require('path')// 获取当前机器的 CPU 信息console.log(os.cpus._node模块中有很多核心模块,以下不属于核心模块,使用时需下载的是

数学建模【SPSS 下载-安装、方差分析与回归分析的SPSS实现(软件概述、方差分析、回归分析)】_化工数学模型数据回归软件-程序员宅基地

文章浏览阅读10w+次，点赞435次，收藏3.4k次。SPSS 22 下载安装过程7.6 方差分析与回归分析的SPSS实现7.6.1 SPSS软件概述1 SPSS版本与安装2 SPSS界面3 SPSS特点4 SPSS数据7.6.2 SPSS与方差分析1 单因素方差分析2 双因素方差分析7.6.3 SPSS与回归分析SPSS回归分析过程牙膏价格问题的回归分析_化工数学模型数据回归软件

利用hutool实现邮件发送功能_hutool发送邮件-程序员宅基地

文章浏览阅读7.5k次。如何利用hutool工具包实现邮件发送功能呢？1、首先引入hutool依赖<dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>5.7.19</version></dependency>2、编写邮件发送工具类package com.pc.c..._hutool发送邮件

docker安装elasticsearch，elasticsearch-head，kibana，ik分词器_docker安装kibana连接elasticsearch并且elasticsearch有密码-程序员宅基地

文章浏览阅读867次，点赞2次，收藏2次。docker安装elasticsearch，elasticsearch-head，kibana，ik分词器安装方式基本有两种，一种是pull的方式，一种是Dockerfile的方式，由于pull的方式pull下来后还需配置许多东西且不便于复用，个人比较喜欢使用Dockerfile的方式所有docker支持的镜像基本都在https://hub.docker.com/docker的官网上能找到合..._docker安装kibana连接elasticsearch并且elasticsearch有密码

随便推点

Python 攻克移动开发失败！_beeware-程序员宅基地

文章浏览阅读1.3w次，点赞57次，收藏92次。整理 | 郑丽媛出品 | CSDN（ID：CSDNnews）近年来，随着机器学习的兴起，有一门编程语言逐渐变得火热——Python。得益于其针对机器学习提供了大量开源框架和第三方模块，内置..._beeware

Swift4.0_Timer 的基本使用_swift timer 暂停-程序员宅基地

文章浏览阅读7.9k次。//// ViewController.swift// Day_10_Timer//// Created by dongqiangfei on 2018/10/15.// Copyright 2018年飞飞. All rights reserved.//import UIKitclass ViewController: UIViewController { ..._swift timer 暂停

元素三大等待-程序员宅基地

文章浏览阅读986次，点赞2次，收藏2次。1.硬性等待让当前线程暂停执行，应用场景：代码执行速度太快了，但是UI元素没有立马加载出来，造成两者不同步，这时候就可以让代码等待一下，再去执行找元素的动作线程休眠，强制等待 Thread.sleep(long mills)package com.example.demo;import org.junit.jupiter.api.Test;import org.openqa.selenium.By;import org.openqa.selenium.firefox.Firefox.._元素三大等待