有梦想的鲨鱼 发布于

Java

Java，JVM，JRE的关系以及主要结构

1
2
3
// 三者是包含的关系
// Java = JRE + 开发工具集（javac.exe,java.exe,javadoc.exe）
// JRE = JVM + Java核心内库

为什么需要设置环境变量

1
2
3
4
/*
方便在任何路径下运行Java
配置：JAVA_HOME=%JAVA_HOME
*/

Java基础

关键字

数据类型

数值型

整数型

​ byte (1字节=8bit,-128-127)

​ short

​ int

​ long (变量必须以l或者L结尾)

浮点型

​ Float(4字节，单精度，一位小数点，表示范围比long还大)，(定义时，变量需要以f或者F结尾)

​ double(8字节，双精度，两位小数点，通常我们使用double)

​ 如果要进行四舍五入，可以对浮点数加上0.5再强制转型：

字符型

字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
和`char`类型不同，字符串类型`String`是引用类型，我们用双引号`"..."`表示字符串。一个字符串可以存储0个到任意个字符
  从Java 13开始，字符串可以用"""..."""表示多行字符串（Text Blocks）了。举个例子：
	public class Main {
    public static void main(String[] args) {
        String s = """
                   SELECT * FROM
                     users
                   WHERE id > 100
                   ORDER BY name DESC
                   """;
        System.out.println(s);
    }
}

字符串不可变

1
2
3
4
5
6
7
8
9
10
11
// 字符串是不可变类型
// String属于引用数据类型
public class Main {
    public static void main(String[] args) {
        String s = "hello";
        String t = s;
        s = "world";
        System.out.println(t); // t是"hello"还是"world"?
    }
}
// 结果为hello，因为s = "world"只是改变了s的指向。并没有改变原始的值

字符

char

字符类型char是基本数据类型，它是character的缩写。一个char保存一个Unicode字符：

布尔型

​ boolean(true false)

类

​ class

接口

​ interface

数组

​ array

运算符

负数的反码是对原码按位取反，只是最高位确定为1

二进制补码：

正数的补码反码原码都是本身

负数的补码是其反码+1

优先级

1
2
3
4
5
6
关系运算符的优先级从高到低依次是：
!
>，>=，<，<=
==，!=
&&
||

三元运算

1
2
3
4
5
6
7
注意到三元运算b ? x : y会首先计算b，如果b为true，则只计算x，否则，只计算y。此外，x和y的类型必须相同，因为返回值不是boolean，而是x和y之一。
  public static void main(String[] args) {
        int age = 7;
        boolean isPrimaryStudent = age <=12 && age>=6;
        System.out.println(isPrimaryStudent ? "Yes" : "No");

    }

根据一元二次方程ax^2+bx+c=0a**x2+b**x+c=0的求根公式：

1
2
3
4
5
6
7
8
9
public class intyunsuan {
    public static void main(String[] args) {
        double a = 1.0;
        double b = 3.0;
        double c = -4.0;
        System.out.println((-b + Math.sqrt(b * b - 4 * a * c))/2*a);
        System.out.println((-b - Math.sqrt(b * b - 4 * a * c))/2*a);
    }
}

流程控制

要判断引用类型的变量内容是否相等，必须使用equals()方法：

if-else if-else

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
if (条件判断){
  // code
} else if (条件判断){
  // code
} else{
  // code 
}
public class Main {
    public static void main(String[] args) {
        int n = 70;
        if (n >= 90) {
            System.out.println("优秀");
        } else if (n >= 60) {
            System.out.println("及格了");
        } else {
            System.out.println("挂科了");
        }
        System.out.println("END");
    }
}

Switch

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
switch (条件判断) {
  case 1:
    // code
  case 2:
    // code
  default:
    //code
}

public class Main {
    public static void main(String[] args) {
        int option = 99;
        switch (option) {
        case 1:
            System.out.println("Selected 1");
            break;
        case 2:
            System.out.println("Selected 2");
            break;
        case 3:
            System.out.println("Selected 3");
            break;
        default:
            System.out.println("Not selected");
            break;
        }
    }
}

石头剪刀布

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.util.Scanner;

public class intyunsuan {
    public static void main(String[] args) {
        System.out.println("玩家输入: ");
        Scanner scan = new Scanner(System.in);
        String player = scan.nextLine();
        int cmrandom = (int) Math.floor(Math.random()*3);
        System.out.printf("PC的选择是：%s\n",cmrandom == 1?"石头":cmrandom == 2? "剪刀":"布");
        switch (player){
            case "石头":
                System.out.println(cmrandom == 1?"平局":cmrandom == 2?"胜利":"失败");
                break;
            case "剪刀":
                System.out.println(cmrandom == 1?"失败":cmrandom == 2?"平局":"胜利");
                break;
            case "布":
                System.out.println(cmrandom == 1?"胜利":cmrandom == 2?"失败":"平局");
                break;
            default:
                System.out.println("请输入剪刀石头布");
                break;
        }

    }
}

while循环

1
// 循环语句就是让计算机根据条件做循环计算，在条件满足时继续循环，条件不满足时退出循环。

计算1到100的和

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class intyunsuan {
    public static void main(String[] args) {
        int i =100;
        int sum = ((1+i)*i)/2;
        System.out.println(sum);
    }
}

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

do while

1
2
3
4
5
6
7
8
9
public static void main(String[] args){
        int sum = 0;
        int n = 1;
        do {
            sum = sum+n;
            n++;
        }while (n <=100);
        System.out.println(sum);
    }

for循环

1
2
3
4
5
6
7
8
9
10
11
12
13
for (初始条件，循环条件检测，循环后更新计数器){
  // code
}

public class forloop {
    public static void main(String[] args){
        int sum = 0;
        for (int i = 1;i<=100;i++){
            sum = sum+i;
        }
        System.out.println(sum);
    }
}

for each(变量n直接拿到ns数组的元素，而不是索引。)

1
2
3
4
5
6
public static void main(String[] args){
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int n : ns) {
            System.out.println(n);
        }
    }

For (;;)

1
死循环

求圆周率

1
2
3
4
5
6
7
8
9
10
11
12
13
public class forloop {
    public static void main(String[] args) {
        double pi = 1;
        boolean flag = false;
        for (double i = 3;i<1000000;i+=2){
            System.out.println(flag);
            pi =flag?(pi+(1/i)):(pi-(1/i));
            flag = !flag;
            System.out.println(flag);
            System.out.println(pi*4);
        }
    }
}

九九乘法表

1
2
3
4
5
6
7
8
9
10
public class forloop {
public static void main(String[] args){
        for (int i = 1; i <= 9; i++) {
            for (int j=1;j<=i;j++){
                System.out.printf("%d * %d = %d\t",j,i,j*i);
            }
            System.out.println(" ");
        }
    }
}

100以内的完数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class forloop {
public static void main(String[] args) {
        int factor = 0;
        for (int i = 1; i <= 1000; i++) {
            for (int j = 1; j <= i/2; j++) {
                if (i % j == 0) {
                    factor += j;
                }
            }
            if (i == factor){
                System.out.println(i);
            }
            factor = 0;
        }
    }
}

数组

数组的特点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 数组是有序的排列
// 数组的内存地址是一个连续的的空间
// 数组长度确认后，无法修改长度
// 数组是引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型

// 数组的分类
  // 按照维数：二维数组，多维数组等
	// 按照数组元素的类型：基本数据类型元素的数组，引用数据类型元素的数组

// 静态初始化：数组的初始化和数组元素的赋值操作同时进行
// int[] ids;
// ids = new int[]{1,2,3,4,5}
// int[] ids ={1,2,3,4,5};
// 动态初始化：数组的初始化和数组元素的赋值操作分开进行
// String[] names = new String[5];
// 或者可以这样写 int ns[] = new int[5]

遍历数组(变量i拿到是一个索引)

1
2
3
4
5
6
public static void main(String[] args){
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int i =0;i<ns.length;i++){
            System.out.println(ns[i]);
        }
    }

排序算法

数据结构

手机号码

1
2
3
4
5
6
7
8
9
10
11
12
public class trainone {
    public static void main(String[] args){
        int[] arr = new int[]{8,2,1,0,3};
        int[] indexx = new int[]{2,0,3,2,4,0,1,3,2,3,3};
        String tel= "";
        for (int i = 0;i<indexx.length;i++){
            System.out.println(arr[indexx[i]]);
            tel += arr[indexx[i]];
        }
        System.out.println(tel);
    }
}

学生成绩小练习

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/*
Student 0score is 20,grade is D
Student 1score is 40,grade is D
Student 2score is 20,grade is D
Student 3score is 30,grade is D
Student 4score is 70,grade is C
Student 5score is 80,grade is B
*/
public class trainone {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入学生个数:");
        int totalStudent = scanner.nextInt();

        int[] studentArray = new int[totalStudent];
        int maxScore = 0;
        System.out.println("请输入" + totalStudent + "个学生成绩: ");
        for (int i = 0; i < studentArray.length; i++) {
            studentArray[i] = scanner.nextInt();
            if (maxScore < studentArray[i]) {
                maxScore = studentArray[i];
            }
        }

        char level;
        for (int i = 0; i < studentArray.length; i++) {
            if (maxScore - studentArray[i] <= 10) {
                level = 'A';
            } else if (maxScore - studentArray[i] <= 20) {
                level = 'B';
            } else if (maxScore - studentArray[i] <= 30) {
                level = 'C';
            } else {
                level = 'D';
            }
            System.out.println("Student " + i + " score is " + studentArray[i] + ",grade is " + level);
        }
    }
}


二维数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
// 1 二维数组的声明与初始化
public class trainone {
    public static void main(String[] args) {
        // 一维数组动态初始化
        int[] ns = new int[5];
        // 静态初始化
        int[][] arr1 = new int[][]{{123,123},{456,456}};
        // 动态初始化
        String[][] arr2 = new  String[3][2];
        // 动态初始化2
        String[][] arr3 = new  String[3][];

        // 另一种正确写法
        int[] arr4[] = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
        int arr5[][] ={{123,123},{321,321}};
    }
}
// 2 如何调用数组的指定位置的元素
public class trainone {
    public static void main(String[] args) {
        // 一维数组动态初始化
        int[] ns = new int[5];
        // 静态初始化
        int[][] arr1 = new int[][]{{123,123},{456,456}};
        String[][] arr2 = new String[3][2];
        // 调用数组的指定位置的元素
        System.out.println(arr1[0][1]);
        System.out.println(arr2[1][1]);
    }
}
// 3 获取数组的长度
public class trainone {
    public static void main(String[] args) {
        // 一维数组动态初始化
        int[] ns = new int[5];
        // 静态初始化
        int[][] arr1 = new int[][]{{123,123},{456,456}};

        // 调用数组的指定位置的元素
        System.out.println(arr1.length); // 2

    }
}
// 4 如何便利数组
public class trainone {
    public static void main(String[] args) {
        // 一维数组动态初始化
        int[] ns = new int[5];
        // 静态初始化
        int[][] arr1 = new int[][]{{123,123},{456,456}};

        // 遍历二维数组
        for (int i = 0; i < arr1.length;i++){
            for (int j = 0; j <arr1.length;j++){
                System.out.println(arr1[i][j]);
            }
        }

    }
}
// 5 数组元素的初始化默认值
	// 针对初始化方式一：int[][] arr1 = new int[4][3];
			// 外层元素的初始化值为 地址值
			// 内存元素的初始化值为 与一维数组情况相同(随数组类型，int类型的为0)
	// 针对初始化方式二：int[][] arr4 = new int[4][];
			// 外层元素的初始化值为 null
			// 内层元素的初始化值为 这个时候会报一个空指针的错误
// 6 数组的内存解析

面向对象

类/对象

类的结构

三大特性

接口

设计模式

应用程序开发

JDBC

集合

IO/NIO

类库

多线程

异常处理

反射

网络

Small Shark

Small Shark

鲨鱼也会有划水的一天

13
0
6
NOTICE

flex-block主题部分重构，详情查看https://github.com/miiiku/flex-block

CATEGORYS
TAGS
CDN Route53 SSM Tag VPN s3