实训Day01

今日知识

  • jdk安装和配置
  • java基础补充
  • javaweb安装和配置
  • maven安装和配置
  • 框架简介

jdk安装和配置

  • JAVA_HOME=安装目录

  • PATH=;%JAVA_HOME%/bin;

    目的:cmd窗口可以直接使用bin目录下面的可执行文件

ArrayList

含义

底层采用可变数组的线性列表

体系结构

  • List-接口
    • ArrayList-实现类

特点

  • 元素有序,可以重复

    因为底层采用可变数组

  • 存放的是对象的引用

案例

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
public class ListDemo {
    public static void main(String[] args) {
        User zs = new User();
        zs.setName("ZhanShan");

        List<User> dataList = new ArrayList<>();

        // 添加对象
        dataList.add(zs);

        // 获取指定下标的对象
        System.out.println(dataList.get(0));

        // 存储的是对象的引用
        zs.setName("LiSi");
        System.out.println(dataList.get(0));

        // 判断是否为空
        System.out.println(dataList.isEmpty());

        // 判断是否包含
        System.out.println(dataList.contains(zs));

        // 元素个数
        System.out.println(dataList.size());
    }
}

class User{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name;
    }
}

IO

含义

输入输出

使用场景

  • 游戏分数
  • 数据传输
  • 文件保存
  • 等等

分类

  • 方向

    • 输入流
    • 输出流

  • 传输的单位

    • 字符流
      • 以 Reader || Writer 结尾
    • 字节流
      • 以 Stream 结尾

案例一

输入流

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
69
70
71
72
73
74
75
76
77
78
79
public class InputDemo {
    public static void main(String[] args){
        String filePath = "src/main/java/com/neu/day01/_02IO/input.txt";
        readDataByByte(filePath, 5);
        readDataByChar(filePath, 5);
    }

    public static void readDataByByte(String path, int span) {
        // 字节输入流
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream(path);
            byte[] cache = new byte[span];
            // 缓冲区
            StringBuilder stringBuilder = new StringBuilder();
            int len = -1;
            // 读取到文件字节的长度
            while ((len = inputStream.read(cache)) != -1) {
                // 当读取长度不为-1，即仍有字节可以读取时
                System.out.println(len);
                // 输出长度
                String temp = new String(cache, 0, len);
                System.out.println(temp);
                // 输出读到的字节
                stringBuilder.append(temp);
                // 拼接字节
            }
            System.out.println(stringBuilder);
            // 输出全部字节
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                // 如果不为空，则注销资源
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void readDataByChar(String path, int span) {
        Reader reader = null;
        // 字符输入流
        try {
            reader = new FileReader(path);
            char[] cache = new char[span];
            // 缓冲区
            StringBuilder stringBuilder = new StringBuilder();
            // 用于拼接所有字符
            int len = -1;
            while ((len = reader.read(cache)) != -1) {
                // 读取长度不为-1，即仍有字符可以读取时
                System.out.println(len);
                // 输出长度
                String temp = new String(cache, 0, len);
                System.out.println(temp);
                // 输出读到的字符
                stringBuilder.append(temp);
                // 拼接字符
            }
            System.out.println(stringBuilder);
            // 输出全部字符
        } catch (IOException e){
            e.printStackTrace();
        } finally {
            if (reader != null) {
                // 如果不为空，则注销资源
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

案例二

输出流

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
public class OutputDemo {
    // 字节输出流
    public static void main(String[] args) {
        String content = "print(\"Hello World\")";
        // 要输出的内容
        String path = "src/main/java/com/neu/day01/_02IO/output.txt";

        writeDataByByte(path, content);
        writeDataByChar(path, content);
    }

    public static void writeDataByByte(String path, String content) {
        OutputStream outputStream = null;
        try {
            outputStream = new FileOutputStream(path);
            outputStream.write(content.getBytes());
            // 写入内容
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (outputStream != null) {
                // 如果对象不为空，则释放资源
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void writeDataByChar(String path, String content) {
        Writer wirter = null;
        try {
            wirter = new FileWriter(path);
            wirter.write(content);
            // 写入内容
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (wirter != null) {
                // 如果对象不为空，则释放资源
                try {
                    wirter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

File

含义

  • jdk提供的类
  • file对象代表一个文件或文件夹

案例一

File入门

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
public class FileDemo {
    public static void main(String[] args) {
        File file = new File("src/main/java/com/neu/day01/_02IO/Dir");
        dfs(file, 0, ".txt");
    }

    public static void dfs(File dir, int i, String post) {
        File[] children = dir.listFiles();
        // 获取子文件
        if (children != null) {
            // 如果不为空
            for (File child : children) {
                // 遍历子文件
                if (child.isFile() && !child.getName().endsWith(post)) continue;
                // 筛选特殊文件
                String head = "    ";
                // 前缀
                System.out.println(head.repeat(i) + child.getName());
                // 输出文件名
                if (child.isDirectory()) {
                    // 如果是目录，继续递归
                    dfs(child, i+1, post);
                }
            }
        }
    }
}

缓冲流

示意图

缓冲流图

案例

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
69
70
71
72
73
74
75
76
public class BufferDemo {
    /*
        缓冲流
            - 含义: 内部有缓冲区，读取数据从缓冲区中读取，写出数据先写到缓冲区
            - 刷新的时机
                - 缓冲区满
                - flush
                - close
     */
    public static void main(String[] args) {
        String path = "src/main/java/com/neu/day01/_02IO/buffer.txt";
        writerDataByCharToBuffer(path, "hello world");
        readDataByCharFromBuffer(path);
    }


    public static void readDataByCharFromBuffer(String path) {
        Reader reader = null;
        // 字节输入流
        BufferedReader bufferedReader = null;
        // 字节输入缓冲流
        try {
            reader = new FileReader(path);
            bufferedReader = new BufferedReader(reader);
            String s = "";
            // 存储每一行的字节
            StringBuilder stringBuilder = new StringBuilder();
            // 全部字节
            while ((s = bufferedReader.readLine()) != null) {
                // 当仍有一行字节能读取时，用s存储该行字节
                stringBuilder.append(s);
                // 拼接一行字节
            }
            System.out.println(stringBuilder);
            // 输出全部字节
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bufferedReader != null) {
                // 如果对象不为空，则释放资源
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    public static void writerDataByCharToBuffer(String path, String content){
        Writer writer = null;
        // 字符输出流
        BufferedWriter bufferedWriter = null;
        // 字符输出缓冲流
        try {
            writer = new FileWriter(path);
            bufferedWriter = new BufferedWriter(writer);
            // 将 writer 封装入 bufferedWriter 中
            bufferedWriter.write( content);
            // 写入缓冲区
        } catch (IOException e){
            e.printStackTrace();
        } finally {
            if (bufferedWriter != null) {
                // 对象不为空，则释放资源
                try {
                    bufferedWriter.close();
                    // close 内调用了 flush
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

代码统计

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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
public class codeLineCount {
    public static void main(String[] args) {
        File dir = new File("src");
        // 统计项目该目录下所有JAVA文件的非空代码行数
        ArrayList<String> result = new ArrayList<String>();
        // 目录树
        int count = dfs(result, dir, 0, ".java");
        // 递归得到目录树和目录下所有JAVA文件的非空代码行数
        for (int i=result.size()-1; i>=0; i--) {
            System.out.println(result.get(i));
            // 输出目录树
        }
        System.out.println("该目录下的Java文件代码总行数为: " + count);
        System.out.println("详细情况为上面的文件目录树");
        // 输出结果
    }


    // 计算一个文件中的为空代码行数
    public static int Count(File file) {
        String path = file.getPath();
        // 获取文件路径
        int count = 0;
        // 非空代码行数计数
        Reader reader = null;
        // 字符输入流
        BufferedReader bufferedReader = null;
        // 字符输入缓存流
        try {
            reader = new FileReader(path);
            bufferedReader = new BufferedReader(reader);
            // 根据文件路径获取加载代码文件
            String temp = "";
            // 临时存储每行代码的内容
            while ((temp = bufferedReader.readLine()) != null) {
                // 仍能读取一行，则继续读取
                if (!"".equals(temp.trim())) count += 1;
                // 如果该行代码内容非空，则计数+1
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bufferedReader != null) {
                // 如果对象不为空，则释放资源
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return count;
        // 返回计数结果
    }


    // 深度遍历递归目录下指定后缀的文件并计数对于非空代码行数
    public static int dfs(ArrayList<String> result, File dir, int i, String suffix) {
        int count = 0;
        // 该目录下的指定后缀文件非空代码行数的总和
        String head = "    ";
        // 打印目录树所使用的前缀
        File[] children = dir.listFiles();
        // 获取目录下的文件列表
        if (children == null) {
            // 如果该目录没有子文件
            result.add("0");
            result.add(dir.getName());
            // 则该目录下的指定后缀文件的非空代码数量为0
            return 0;
        }
        for (File child : children) {
            // 遍历所有子文件
            if (child.isFile()) {
                // 如果该子文件为文件类型
                if (child.getName().endsWith(suffix)) {
                    // 且该子文件后缀为指定后缀
                    int temp = Count(child);
                    // 对其非空代码行数进行计数
                    result.add(head.repeat(i+1) + temp);
                    result.add(head.repeat(i+1) + child.getName());
                    // 添加其文件名和对应非空代码行数
                    count += temp;
                    // 更新目录下的非空代码行数
                }
            } else {
                int temp = dfs(result, child, i+1, suffix);
                // 否则该子文件为目录类型
                // 继续往下递归
                count += temp;
                // 更新目录下的非空代码行数
            }
        }
        result.add(head.repeat(i) + count);
        result.add(head.repeat(i) + dir.getName());
        // 添加该目录的文件名及其下所有文件的非空代码行数
        return count;
        // 返回结果
    }
}

网络编程

服务端

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
public class Server {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        try {
            serverSocket = new ServerSocket(8080);
            System.out.println("等待客户端连接");
            socket = serverSocket.accept(); // 阻塞的
            // 等待客户端连接获取 socket

            System.out.println("有客户端连接");
            // 提示有客户端连接

            InputStream inputStream = socket.getInputStream();
            // 获取字节输入流
            byte[] cache = new byte[1024];
            // 缓冲区
            int len = -1;
            StringBuilder requestData = new StringBuilder();
            // 存储请求数据
            while ((len = inputStream.read(cache)) != -1) {
                // 当流仍有未读的字节
                requestData.append(new String(cache, 0, len));
                // 拼接请求数据
            }
            System.out.println("请求数据为: " + requestData);

            OutputStream outputStream = socket.getOutputStream();
            // 获取 socket 输出流，将应答结果通过该流传给客户端
            outputStream.write(requestData.toString().getBytes());
            // 将请求数据当作应答数据返回给客户端
            socket.shutdownOutput();
            // 关闭socket输出流
            // 告知客户端应答数据传输结束
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (serverSocket != null) {
                // 如果对象不为空，则释放资源
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

客户端

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
public class Client {
    public static void main(String[] args) {
        // localhost = 127.0.0.1 = 本地IP
        Socket socket = null;
        try {
            socket = new Socket("localhost", 8080);
            // 新建一个 socket 对象

            String requestData = "hello world";
            // 请求数据
            OutputStream outputStream = socket.getOutputStream();
            // 获得 socket 输出流
            outputStream.write(requestData.getBytes());
            // 向 socket 输出流写进请求数据
            socket.shutdownOutput();

            InputStream inputStream = socket.getInputStream();
            // 获得 socket 输入流
            int len = -1;
            byte[] cache = new byte[1024];
            // 缓冲区
            StringBuilder responseData = new StringBuilder();
            // 存储应答数据
            while ((len=inputStream.read(cache)) != -1) {
                // 当有字节流仍未被读取
                responseData.append(new String(cache, 0, len));
                // 拼接应答数据
            }
            System.out.println("应答数据为: " + responseData);
            // 输出应答数据

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                // 如果对象不为空，则释放资源
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Tomcat安装和配置

Tomcat下载

点击链接进入官网下载最新的版本即可（7、8、9、10）
官网链接

Tomcat安装

将下载好的压缩包解压至特定路径后，配置环境

  1. 配置：
    CATALINA_BASE = tomcat文件夹的路径（bin目录的前一级）
    CATALINA_HOME = tomcat文件夹的路径（bin目录的前一级）
    CATALINA_TMPDIR = tomcat文件夹下temp文件夹的路径（与bin目录同级）

    注意事项：需要配置好JAVA_HOME

  2. 添加Path系统变量：
    %CATALINA_HOME%\bin
  3. tomcat启动测试：
    startup

maven安装和配置

Maven介绍

Maven是一个跨平台的项目管理工具。作为Apache组织的一个颇为成功的开源项目，其主要服务于基于Java平台的项目创建，依赖管理和项目信息管理。maven是Apache的顶级项目，解释为“专家，内行”，它是一个项目管理的工具，maven自身是纯java开发的，可以使用maven对java项目进行构建、依赖管理。

Maven作用

  • 依赖管理
    • 依赖指的就是是 我们项目中需要使用的第三方Jar包, 一个大一点的工程往往需要几十上百个Jar包,按照我们之前的方式,每使用一种Jar,就需要导入到工程中,还要解决各种Jar冲突的问题。
    • Maven可以对Jar包进行统一的管理,包括快速引入Jar包,以及对使用的 Jar包进行统一的版本控制。
  • 一键构建项目
    • 之前我们创建项目,需要确定项目的目录结构,比如src 存放Java源码, resources存放配置文件,还要配置环境比如JDK的版本等等,如果有多个项目 那么就需要每次自己搞一套配置,十分麻烦。
    • Maven为我们提供了一个标准化的Java项目结构,我们可以通过Maven快速创建一个标准的Java项目。

Maven下载

在官网中找到最新的链接下载即可

官网链接
阿里云镜像

Maven安装

解压下载的压缩包到没有中文和空格的路径后，配置环境变量

  1. 配置：
    MAVEN_HOME = maven文件夹的路径（bin目录的前一级）
  2. 添加Path系统变量：
    %MAVEN_HOME%\bin
  3. maven版本测试：
    mvn-v

框架简介

TODO

编程 > 实训
实训Day01
http://yjh-2860674406.github.io/2023/07/06/编程/实训/Day01/
Author
Ye JinHua
Posted on
July 6, 2023
Licensed under