同系列文章导读：【JavaSE】文章导读

所有文章均在本博客首发，其他平台同步更新

如有问题，欢迎指正（评论区留言即可）

发表评论时请填写正确邮箱，以便于接收通知【推荐QQ邮箱】

集合基础

对象数组

// 需求：将(张三,23)(李四,24)(王五,25)封装为3个学生对象并存入数组，随后遍历数组，将学生信息输出
// 新建一个Student类
public class Student{
  private String name;
  private String age;
  public Student(){}
  public Student(String name, String age){
      this.name = name;
      this.age = age;
  }
  public String getName(){
      return name;
  }
  public void setName(String name){
      this.name = name;
  }
  public String getAge(){
      return age;
  }
  public void setAge(String age){
      this.age = age;
  }
}

//---------------------------下面为一个新的class文件----------------------------------------------

public class Test{
  public static void main(String[] args){
      Student[] arr = new Student[3];
      Student stu1 = new Student("张三","23");
      Student stu2 = new Student("李四","24");
      Student stu3 = new Student("王五","25");
      arr[0] = stu1;
      arr[1] = stu2;
      arr[2] = stu3;
      for(int i = 0; i < arr.length; i++){
          System.out.println("姓名：" + arr[i].getName() + " 年龄：" + arr[i].getAge());
      }
  }
}

集合和数组的特点对比

  • 集合类的特点：提供一种存储空间可变的存储类型，存储的数据容量可以发生改变

  • 集合和数组的区别：

    共同点：都是存储数据的容器

    不同点：数组的容量是固定的，集合的容量是可变的

    如果存储的数据，长度经常发生改变，推荐使用集合

ArrayList集合

构造方法：ArrayList() 构造一个初始容量为10的空列表

成员方法

  • boolean add(E e) 将指定的元素添加到此列表的尾部
  • void add(int index, E element) 将指定的元素插入此列表中的指定位置

如果没有进行数据类型的限制，可以添加任何数据类型的数据

如果要进行限制，格式为：ArrayList<数据类型> list = new ArrayList<数据类型>();

JDK7版本以后，可写为：ArrayList<数据类型> list = new ArrayList<>();

\<E>：是一种特殊的数据类型，泛型。<>里面只能写引用数据类型，int、double等基本数据类型不行

  • public boolen remove(Object) 删除指定的元素，返回是否删除成功,只能删除第一个匹配到的元素
  • public E remove(int index) 删除指定索引处的元素，返回被删除的元素
  • public E set(int index, E element) 修改指定索引处的元素，返回被修改的元素
  • public E get(int index) 返回指定索引处的元素
  • public int size() 返回集合中的元素的个数

案例

// 需求：创建一个存储字符串的集合，存储3个字符串元素，使用程序实现在控制台遍历该集合

import java.util.ArrayList;
public class Test{
    public static void main(String[] args){
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        for(int i = 0; i < list.size(); i++){
            System.out.println(list.get(i));
        }
    }
}
// 需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

// 新建一个Student类
public class Student{
    // 成员变量
    private String name;
    private int age;
    // 构造方法
    public Student(){}
    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }
    //成员方法
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
}

//---------------------------下面为一个新的class文件----------------------------------------------

import java.util.ArrayList;
public class Test{
    public static void main(String[] args){
        ArrayList<Student> list = new ArrayList<>();
        Student stu1 = new Student("张三",23);
        Student stu2 = new Student("李四",24);
        Student stu3 = new Student("王五",25);
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        for(int i = 0; i < list.size(); i++){
            System.out.println("姓名：" + list.get(i).getName() + " 年龄：" + list(i).getAge());
        }
    }
}
// 需求：创建一个存储String的集合，内部存储（test,张三,李四,test,test）字符串，删除所有的test字符串，将删除后的集合元素打印到控制台

import java.util.ArrayList;
public class Test{
    public static void main(String[] args){
        ArrayList list = new ArrayList();
        list.add("test");
        list.add("张三");
        list.add("李四");
        list.add("test");
        list.add("test");
        for(int i = 0; i < list.size(); i++){
            if("test".equals(list.get(i))){        // 变量和常量调用方法，尽量常量去调用，减少不必要的错误
                list.remove(i);
                i--;
            }
        }
        System.out.println(list);
    }
}
// 需求：定义一个方法，方法接收一个集合对象（泛型为Student），方法内部将年龄低于18的学生对象找出并存入新集合对象，方法返回新集合
// 新建student类步骤省略

import java.util.ArrayList;
public static void main(String[] args){
    Student stu1 = new Student("张三",23);
    Student stu2 = new Student("李四",16);
    Student stu3 = new Student("王五",22);
    Student stu4 = new Student("赵六",13);
    Student stu5 = new Student("马七",18);
    ArrayList<Student> list = new ArrayList<>();
    list.add(stu1);
    list.add(stu2);
    list.add(stu3);
    list.add(stu4);
    list.add(stu5);
    ArrayList<Student> newList = getList(list);
    for(int i = 0; i < newList.size(); i++){
        System.out.println("姓名：" + newList.get(i).getName() + " 年龄：" + newList.get(i).getAge());
    }
}
public static ArrayList<Student> getList(ArrayList<Student> list){
    ArrayList<Student> newList = new ArrayList<>();
    for(int i = 0; i < list.size(); i++){
        if(list.get(i).getAge() < 18){
            newList.add(list.get(i));
        }
    }
    return newList;
}

学生管理系统

实现思路

  1. 定义学生类
public class Student{
    // 成员变量
    private int sid;                //学号
    private String name;            //姓名
    private int age;                //年龄
    private String birthday;        //生日
    // 构造方法
    public Student(){}
    public Student(int sid, String name, int age, String birthday){
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }
   // 成员方法
    public void setSid(int sid){
        this.sid = sid;
    }
    public int getSid(){
        return sid;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public void setBirthday(String birthday){
        this.birthday = birthday;
    }
    public String getBirthday(){
        return birthday;
    }
}
  1. 主界面代码编写
import java.util.Scanner;
import java.util.ArrayList;

public class studentManager {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArrayList<Student> list = new ArrayList<>();    // 创建一个容器
        // 搭建主界面菜单
        lo:            //添加一个标号，配合break完成退出操作
        while (true) {
            System.out.println("-------欢迎来到学生信息管理系统-------");
            System.out.println("1.添加学生");
            System.out.println("2.删除学生");
            System.out.println("3.修改学生");
            System.out.println("4.查看学生");
            System.out.println("5.退出");
            System.out.println("---------------------------------");
            System.out.print("请输入您的选择：");
            int choice = sc.nextInt();
            switch (choice) {
                case 1:
                    addStudent(list);
                    break;
                case 2:
                    delStudent(list);
                    break;
                case 3:
                    System.out.println("修改");
                    break;
                case 4:
                    queryStudent(list);
                    break;
                case 5:
                    System.out.println("您已退出，感谢您的使用");
                    break lo;
                default:
                    System.out.println("您的输入有误，请重新输入");
                    break;
            }
        }
    }
}
  1. 添加学生的代码编写
// addStudent
public static void addStudent(ArrayList<Student> list){
    Scanner sc = new Scanner(System.in);
    int sid;        // 写在while外面，方便整个addSt
    while(true){
        System.out.print("请输入学号：");
           sid = sc.nextInt();
        int index = getIndex(list, sid);
        if(index == -1){
            break;
        }else{
            System.out.println("该学号已存在，请重新输入");
        }
    }
    System.out.print("请输入姓名：");
    String name = sc.next();
    System.out.print("请输入年龄：");
    int age = sc.nextInt();
    System.out.print("请输入生日：");
    String birthday = sc.next();
    Student stu = new Student(sid, name, age, birthday);
    list.add(stu);
    System.out.println("恭喜您，添加成功！");
}
  1. 查看学生的代码编写
// queryStudent
public static void queryStudent(ArrayList<Student> list){
    if(list.size() == 0){
        System.out.println("当前无数据，请添加数据后重试");
    }
    else{
        System.out.println("学号\t\t\t姓名\t\t年龄\t\t生日");
        for(int i = 0; i < list.size(); i++){
            Student stu = list.get(i);
            System.out.println(stu.getSid() + "\t\t\t" + stu.getName() + "\t\t" + stu.getAge() + "\t\t" + stu.getBirthday());
        }
    }
}
  1. 删除/修改学生学号不存在问题
// 定义一个方法(getIndex)，用于从集合中查找【学号】在【集合】中出现的索引位置
public static int getIndex(ArrayList<Student> list, int sid){
    int index = -1;        //假设传入的学号不存在
    for(int i = 0; i < list.size(); i++){
        Student stu = list.get(i);
        int id = stu.getSid();
        if(id == sid){
            index = i;
        }
    }
    return index;
}
  1. 删除学生的代码编写
// delStudent
public static void delStudent(ArrayList<Student> list){
    Scanner sc = new Scanner(System.in);
    System.out.print("请输入您要删除的学生学号：");
    int delSid = sc.nextInt();
    int index = getIndex(list, delSid);
    if(index == -1){
        System.out.println("查无信息，请重新输入");
    }else{
        list.remove(index);
        System.out.println("恭喜您，删除成功！");
    }
}
  1. 修改学生的代码编写
// updateStudent
public static void updateStudent(ArrayList<Student> list){
    Scanner sc = new Scanner(System.in);
    System.out.print("请输入您要修改的学生学号：");
    int updateSid = sc.nextInt();
    int index = getIndex(list, updateSid);
    if(index == -1){
        System.out.println("查无信息，请重新输入");
    }else{
        System.out.print("请输入新的学生姓名：");
        String name = sc.next();
        System.out.print("请输入新的学生年龄：");
        int age = sc.nextInt();
        System.out.print("请输入新的学生生日：");
        String birthday = sc.next();
        Student stu = new Student(updateSid, name, age, birthday);
        list.set(index, stu);
        System.out.println("恭喜您，修改成功！");
    }
}

Git

概述及安装

  • 版本控制：无论是代码编写，还是文档编写，我们都会遇到对文档内容反复修改的情况

  • Git和SVN的对比

    • SVN是集中式版本控制系统，版本库是集中放在中央服务器的，而开发人员工作的时候，用的都是自己的电脑，所以首先要从中央服务器下载最新的版本，然后开发，开发完后，需要把自己开发的代码提交到中央服务器
    • Git是在2005年，Liunx创建者为了帮助全球的开发者，维护Linux系统内核的开发，而开发了自己的开源分布式版本控制工具，分为两种类型的仓库，本地仓库和远程仓库

  • Git下载和安装

    官网下载地址：https://git-scm.com/downloads

    Git GUI : Git提供的图形界面工具

    Git Bash：Git提供的命令行工具

    运行Git命令客户端，使用git --version命令，可以查看git版本

  • TortoiseGit安装

基本操作

本地仓库

  • 工作目录：Working Tree ----代码存放的位置
  • 暂存区(Index)：代码提交到仓库之前的临时存储空间
  • 本地历史仓库(Repository)/版本库：存放不同版本的代码，例如：（完成了项目10%的代码、完成了项目20%的代码）

工作目录---->暂存区---->本地历史仓库（版本库）

版本库指.git隐藏文件夹，工作目录是和.git同级的目录，暂存区是.git隐藏文件中的index

Git常用命令

  • git init：初始化，创建git仓库
  • git status：查看git状态（文件是否进行了添加、提交操作）
  • git add 文件名（支持*通配）：添加，将指定文件添加到暂存区

  • git reset 文件名（支持*通配）：将指定文件从暂存区移除（取消git版本跟踪）

    • 也可以通过git reset --hard 唯一标识，指定版本，回退到对应的版本（唯一标识通过log查询）
  • git commit -m '描述信息' [文件名（支持*通配）]：提交，将暂存区文件提交到历史仓库
  • git log：查看日志（git提交的历史日志）

  • 基本操作流程

    1. 创建工作目录，初始化本地git仓库（初始化本地仓库使用不多，更多的是clone远程仓库）
    2. 新建一个test.txt文件（暂不执行添加操作）
    3. 使用status命令，查看状态
    4. 使用add命令添加，并查看状态
    5. 使用commit命令，提交到本地历史仓库
    6. 使用log命令，查看日志
    7. 修改test.txt文件
    8. 添加并提交，查看日志

TortoiseGit操作

可视化操作

Git版本管理

  • 准备工作：

    1. 查看log日志
      git reflog：可以查看所有分支的所有操作记录（包括已经被删除的commit记录的操作）
    2. 增加一次新的修改记录
  • 主要指令
    git reflog
    git reset --hard 版本唯一索引值：将代码切换到指定版本

远程仓库

  • 工作流程
    推送(push)：推送本地仓库内容到远程仓库
    克隆(clone)：将远程仓库中的内容复制到本地仓库
    拉取(pull)：更新远程仓库中新的内容到本地仓库（和克隆有区别）

  • 常用命令

    • git remote [-v]：查看远程仓库（shortname和url）
    • git remote add <shortname> <url>：添加一个新的远程Git仓库，同时指定一个可以引用的简写（一般origin）
    • git clone：从远程仓库克隆

    • git pull <shortname> <url>：从远程仓库拉取

      如果当前本地仓库不是从远程仓库克隆，而是在本地创建后关联的远程仓库，并且仓库中存在文件，此时从远程仓库拉取文件的时候会报错（fatal: refusing to merge unrelated histories）

      解决此问题可以在git pull 命令后加入参数--allow-unrelated-histories

    • git push <shortname> <url>：推送到远程仓库

常见远程仓库平台

  • GitHub：
    域名：https://github.com
    介绍：GitHub是全球最大的开源项目托管平台，俗称大型程序员社区化交友网站
    各类好玩有趣的开源项目，只有想不到，没有找不到
  • 码云：
    域名：https://gitee.com
    介绍：码云是全国最大的开源项目托管平台，良心平台，速度快，提供免费私有库
  • 远程仓库平台操作
    情况：
    1.先有本地仓库，远程仓库为空
    2.先有远程仓库，本地仓库为空

  • 情况1
    步骤：

    1. 创建远程仓库

    2. 将项目从本地仓库，推送到远程仓库
      注意：在推送代码之前，需要先配置SSH公钥

      生成SSH公钥步骤：

      1. 设置Git账户
        查看git账户：git config user.name
        查看git邮箱：git config user.email
        设置全局账户名和邮箱：git config --global user.name "账户名"
        git config --global user.email "邮箱"
      2. 生成SSH公钥
        查看是否生成过SSH公钥：cd ~/.ssh
        生成SSH：ssh-keygen -t rsa -C "邮箱" 这里需要敲击三次回车
        查看SSH：cat ~/.ssh/id_rsa.pub
      3. 设置账户公钥（在远程仓库平台设置）
      4. 公钥测试：ssh -T git@gitee.com

    3. 推送到远程平台
      步骤：

      1. 为远程仓库的URL（网址），自定义仓库名称：git remote add 远程名称 远程仓库URL
      2. 推送：git push -u 仓库名称 分支名

  • 情况2：
    步骤：

    1. 将远程仓库的代码，克隆到本地仓库：git clone 仓库地址
    2. 创建新文件，添加并提交到本地仓库
    3. 推送至远程仓库
    4. 项目拉取更新：git pull 远程仓库名 分支名

    • 代码冲突
      请输入图片描述
      <<<<<<<和>>>>>>>>>中间的内容，就是冲突部分

      1. 修改冲突行，保存，即可解决冲突
      2. 重新add冲突文件并commit到本地仓库，重新push到远程

分支管理

分支是Git使用过程中非常重要的概念。使用分支意味着你可以把你的工作从开发主线上分离开来，以免影响开发主线。同一个仓库可以有多个分支，各分支相互独立，互不干扰。

通过git init命令创建仓库时默认会创建一个master分支

  • 分支：由每次提交的代码，串成的一条时间线
  • 特点：两条时间线，并行工作，互不打扰，==多条时间线可以合并==

  • 使用场景：

    1. 周期较长的模块开发
    2. 尝试性的模块开发
  • 使用分支意味着你可以把你的工作从开发主线上分离开来，以免影响开发主线

  • 工作流程

    1. 查看分支：git branch

      • 列出所有远程分支：git branch -r
      • 列出所有本地分支和远程分支：git branch -a
      • 创建新分支：git branch 分支名
      • 删除分支：git branch -d 分支名
    2. 切换分支: git checkout 分支名
    3. 推送至远程仓库分支：git push [shortName] [name]
    4. 合并分支:：git merge 分支名

标签操作

Git中的标签，指的是某个分支某个特定时间点的状态。通过标签，可以很方便的切换到标记时的状态。

比较有代表性的是人们会使用这个功能来标记发布结点（v1.0、v1.2等）

常用命令

  • git tag：列出已有的标签
  • git tag [name]：创建标签（创建标签时就记录当前分支下的版本信息）
  • git push [shortName] [name]：将标签推送至远程仓库
  • git checkout -b [branch] [name]：检出标签（需要新建一个分支branch来指向某个标签）

IDEA集成Git

  • IDEA中配置Git

    1. File ---- Settings
    2. Version Control ---- Git ---- 指定git.exe存放目录
    3. 点击Test测试
  • 版本切换
    Reset Current Branch to Here... 会抛弃原来的提交记录
    Revert Commit 需要进行版本冲突处理，历史记录还保留提交记录

  • 远程仓库操作

    • 本地推送到远程
    • 远程克隆到本地

推荐阅读：【JavaSE】面向对象进阶

END
本文作者： 文章标题：【JavaSE】集合&Git基础
 本文地址：https://www.jiusi.cc/archives/27/
 版权说明：若无注明，本文皆九思のJava之路原创，转载请保留文章出处。
最后修改：2022 年 11 月 12 日
© 允许规范转载
如果觉得我的文章对你有用，请随意赞赏