Vstar项目练手——学习笔记

少年没有乌托邦，心向远方自明朗。

 

我决定写一篇博客来记录学习。

项目选自github优质开源项目——微人事，这里是项目地址链接lenve/vhr: 微人事是一个前后端分离的人力资源管理系统，项目采用SpringBoot+Vue开发。 (github.com)

选择这个项目作为练手是由于不管是从项目来看，还是开发文档来看，都比较全面详细。

前后端分离的一般思路：

这里参考这篇博客

java前后端分离开发思路 - 高sir不会跳舞 - 博客园

在学习项目的同时，我也在B站的狂神说JAVA线上网课学习，以下是学习路线：

还是得多花时间敲代码，实践是检验真理的唯一标准。

更新于2022.4.11

不小心关了浏览器，还重启了电脑，只能重新编辑了 T_T

首先右键进入要执行的文件终端

 在终端中输入javac nm.java进行编译

报错了；解决方法添加 -encoding utf-8

 

此时会产生一个.class文件在同级目录下 

 发现错误。

然后执行该文件

出现错误 

解决办法执行cd ..或cd ../退回上一级目录直至src

 这时执行javac com.company.nm

运行成功。

更新于2022.4.21(下次得注意发布了博客再关浏览器) 

关于数组学习的一些总结；

1.数组的四个特点

        1）长度确定。数组一旦被创建，它的大小就是不可以改变的。

        2）其长度必须是相同的类型，不允许出现混合类型。

        3）数组中的元素可以是任何数据类型，包括基本类型和引用类型。

        4）数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象那个的成  员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

2.小结：
 数组是相同数据类型（数据类型可以为任何类型）的有序集合

 数组也是对象。数组元素相当于对象的成员变量

 数组长度是确定的，不可变的。如果越界，则报：ArrayIndexOutofBounds

数组操作

失败的数组反转操作：

package com.company;

public class test02 {
   public static void main(String args[]){
       int[] nums = new int[]{1,2,3,4,5};

       //数组反转
       for(int i=0; i<nums.length ;i++){
           nums[nums.length-i-1] = nums[i];

       }
       for(int i=0; i<nums.length;i++) {
           System.out.print(nums[i]);
       }
   }
}

显然是错误的

正确的数组反转：

package com.company;

public class test02 {
   public static void main(String args[]){
       int[] nums = new int[]{1,2,3,4,5};

       //数组反转
       int[] revers = reverse(nums);
       for (int i=0;i<nums.length;i++){
           System.out.print(" "+revers[i]);
       }
   }
   //反转数组
    public static int[] reverse(int[] arrays){
       //新建了一个新的数组
       int[] result = new int[arrays.length];
        //反转操作
        for(int i = 0,j=result.length-1; i < arrays.length; i++,j--){
            result[i] = arrays[j];
        }
        return result;
        }
}

 成功反转

冒泡排序学习，直接上代码

package com.company;
import java.util.Arrays;
public class test03 {
    public static void main(String args[]){
            int[] a = {1,2,3,4,11,5,14};
            System.out.println("排列前的数组顺序"+Arrays.toString(a));
            sort(a);
            System.out.println("排列后的数组顺序"+Arrays.toString(a));

    }

    //冒泡排序
    //1.比较数组中，两个相邻的元素，如果第一个数比第二个大，就交换位置
    //2、每一个比较，都会产生出一个最大，或者最小的数字
    //3.下一轮则可以少一次排序
    //4.依次循环，直到结束！
    public static int[] sort(int[] array){
        //临时变量
        int temp=0;
        //外层循环，判断我们这个要走多少次
        for(int i = 0;i<array.length-1; i++){
            //内层循环，比较判断两个数，如果第一个数比第二个数大则交换位置
            for( int j=0;j<array.length-1; j++){
                if(array[j]>array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        return array;
    }
}

冒泡排序的时间复杂度为O(n2)

这里可以优化，省略掉一些不必要的已经排好的数

package com.company;
import java.util.Arrays;
public class test03 {
    public static void main(String args[]){
            int[] a = {1,2,3,4,11,5,14};
            System.out.println("排列前的数组顺序"+Arrays.toString(a));
            sort(a);
            System.out.println("排列后的数组顺序"+Arrays.toString(a));

    }

    //冒泡排序
    //1.比较数组中，两个相邻的元素，如果第一个数比第二个大，就交换位置
    //2、每一个比较，都会产生出一个最大，或者最小的数字
    //3.下一轮则可以少一次排序
    //4.依次循环，直到结束！
    public static int[] sort(int[] array){
        //临时变量
        int temp=0;
        //外层循环，判断我们这个要走多少次
        for(int i = 0;i<array.length-1; i++){
            boolean flag = false;//通过flag标识位减少没有意义的比较
            //内层循环，比较判断两个数，如果第一个数比第二个数大则交换位置
            for( int j=0;j<array.length-1; j++){
                if(array[j]<array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if(flag==false){
                break;
            }
        }
        return array;
    }
}

 还可以用其他的方法优化。

稀疏数组的学习：

        1）当一个数组中大部分元素为0，或者为同一值得数组时，可以使用稀疏矩阵来保存该数组。

        2）稀疏数组的处理方式是：

                1.记录数组一共有几行几列，有多少个不同值

                2.把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

左边是原始数组，右边是稀疏矩阵；

解读：第一行的意思是有6行7列的数组，其中有8个有效值，后面的的行表示坐标位置及其值。

稀疏矩阵的两种输出格式

package com.company;

public class test04 {
    public static void main(String args[]){
        int[][] array1=new int[11][11];
        array1[1][1]=1;
        array1[2][2]=2;
        System.out.print("输出原始的数组");
        System.out.print("\n");
        for( int[] ints :array1){
            for(int anInt : ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //转换为稀疏矩阵
        //获取有效值的个数
        int sum = 0;
        for (int i=0;i<11;i++){
            for(int j = 0;j<11;j++){
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.print("有效值个数"+sum+"\n");

        //创建一个稀疏矩阵的数组
        int[][] array2 = new int[sum+1][3];

        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //循环遍历数组中的元素，找出非零项
        int count=0;
        for(int i=0;i<array1.length;i++){
            for(int j=0;j<array1[i].length;j++){
                if(array1[i][j]!=0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                 }
            }
        }
        System.out.println("稀疏矩阵");
        for(int i=0;i<array2.length;i++){
            System.out.println(array2[i][0]+"\t"+
                    array2[i][1]+"\t"+
                    array2[i][2]+"\t");
        }
    }
}

更新于2022.4.23

  （更新中...）