java配置+J_IDEA配置+git配置+maven配置+基本语句

輕栀

已于 2023-12-21 08:40:37 修改

阅读量941

点赞数 20

文章标签： linux 运维服务器

于 2023-12-18 11:37:59 首次发布

本文链接：https://blog.csdn.net/mnwl12_0/article/details/135058581

版权

当前目录文件夹dir

进入文件夹cd

返回上一级cd..

创建文件夹：mkdir

文件名删除文件夹：rd 文件夹名，

目录不为空不能直接删

rd /s 带子文件夹一起删

清屏cls

切换d盘才能进入

下载git地址：

Git - Downloading Package (git-scm.com)

1、下载完成后，直接点击安装包安装，即可。

2、开始安装，然后下一步

3、可以在此处自定义地址，然后下一步

3、选择组件全选

此处默认即可，但我选择了一个新功能。

4、选择Git默认的编辑器

此处选择默认即可，有特殊爱好亦可更换。

5、选择执行git init命令时创建的分支名

第一个选项是使用 master 作为分支名，第二个选项自定义分支名。此处默认即可。

6、设置环境变量PATH 添加到环境变量

配置一是 “仅从 Git Bash 使用 Git” 。这是最安全的选择，因为您的 PATH 根本不会被修改。您只能使用 Git Bash 的 Git 命令行工具。但这将不能通过第三方软件调用 Git 。

配置二是 “从命令行以及第三方软件启用 Git” 。该选项被认为是安全的，因为它仅向 PATH 添加了一些最小的 Unix 命令解析器，以避免使用时造成系统环境混乱。您将能够从 Git Bash ，命令提示符和 Windows PowerShell 以及在 PATH 中寻找 Git 或是在任何第三方软件中使用 Git 。这也是推荐的选项。

配置三是 “从命令提示符使用 Git 和可选的 Unix 命令” 。警告：这将覆盖 Windows 命令，如：find 和 sort。你只有在了解其含义后才使用此选项。

一般默认即可

7、选择SSH连接工具

选项一是使用内置的 SSH 工具
选项二是使用自定义的 SSH 工具

如果没有特殊习惯，默认即可。

8、选择在加密连接时使用的证书

选项一是服务器证书将使用 ca-bundle.crt 文件进行验证。这也是默认的选项。

选项二是“使用本地 Windows 安全通道库”。服务器将使用 Windows 证书验证，此选项还允许您使用公司的内部根 CA 证书，例如使用 Active Directory Domain Services.

一般默认即可

9、配置行尾符号转换

选项一是“查看时使用 Windows 风格的行尾，保存时使用 Unix 风格的行尾”。查看文本文件时，Git 会将 LF 转换为 CRLF 。保存文本文件时， CRLF 将转换为 LF 。对于跨平台项目十分有用，这里是 Windows 上的推荐设置（core.autocrlf设置为true）

选项二是“查看时按原样展示，保存时使用 Unix 样式的行尾”。查看文本文件时，Git 不会执行任何转换。保存文本文件时，CRLF 将转换为 LF 。对于跨平台项目比较有用，这是 Unix 上的建议设置（core.autocrlf设置为input）

选项三是“查看时按原样展示，保存时按原样保存”。当查看或保存文本文件时，Git 不会执行任何转换。不建议跨平台项目选择此选项（core.autocrlf设置为false）。

一般默认即可。

后面的全部选默认配置即可

三、配置

在桌面点击右键——>git bash here

#配置用户名
git config --global user.name "test"

#配置邮箱
git config --global user.email  abc@163.com

# 查看所有账户
$ git config --global --list

# 生成ssh文件夹（生成ssh秘钥）（敲击三次回车键）# 文件目录-C:\Users\用户名.ssh；
$ ssh-keygen -t rsa

如果看不到.ssh文件夹，查看文件夹属性，勾选显示隐藏文件夹

4. git如何创建本地版本库

版本库又名仓库，可以简单的理解成一个目录，这个目录里面的所有文件都可以被Git管理起来，每个文件的删除和修改Git都能追踪，以便任何时候都可以追踪历史，或者在将来某个时刻可以将其还原。由于git是分布式版本管理工具，所以git在不需要联网的情况下也具有完整的版本管理能力。

使用open Git Bash Here建立

在文件夹内右键

输入 git init;通过这个命令把目录变成Git可以管理的仓库

即创建成功。此时，Git仓库已经建好，这是一个空仓库，可以发现当前目录下多了一个.git的目录，这个目录是Git来跟踪管理版本库的，千万不要手动修改这个目录里的文件。

5 push代码到Git（添加文件）

1.将需要的文件保存到版本库，则需要将这些文件放到和“.git”同级的目录下，右键配置好的本地文件夹，

进入后会出现更改或新增文件（需要上传文件），然后点击push，如图：

点击push后会弹出框，输入git地址，然后push就可以上传了，如图：

GIt命令大全

git config

配置 Git 的相关参数。

Git 一共有3个配置文件：

1. 仓库级的配置文件：在仓库的 .git/.gitconfig，该配置文件只对所在的仓库有效。
2. 全局配置文件：Mac 系统在 ~/.gitconfig，Windows 系统在 C:\Users\<用户名>\.gitconfig。
3. 系统级的配置文件：在 Git 的安装目录下（Mac 系统下安装目录在 /usr/local/git）的 etc 文件夹中的 gitconfig。

# 查看配置信息
# --local：仓库级，--global：全局级，--system：系统级
$ git config <--local | --global | --system> -l

# 查看当前生效的配置信息
$ git config -l

# 编辑配置文件
# --local：仓库级，--global：全局级，--system：系统级
$ git config <--local | --global | --system> -e

# 添加配置项
# --local：仓库级，--global：全局级，--system：系统级
$ git config <--local | --global | --system> --add <name> <value>

# 获取配置项
$ git config <--local | --global | --system> --get <name>

# 删除配置项
$ git config <--local | --global | --system> --unset <name>

# 配置提交记录中的用户信息
$ git config --global user.name <用户名>
$ git config --global user.email <邮箱地址>

# 更改Git缓存区的大小
# 如果提交的内容较大，默认缓存较小，提交会失败
# 缓存大小单位：B，例如：524288000（500MB）
$ git config --global http.postBuffer <缓存大小>

# 调用 git status/git diff 命令时以高亮或彩色方式显示改动状态
$ git config --global color.ui true

# 配置可以缓存密码，默认缓存时间15分钟
$ git config --global credential.helper cache

# 配置密码的缓存时间
# 缓存时间单位：秒
$ git config --global credential.helper 'cache --timeout=<缓存时间>'

# 配置长期存储密码
$ git config --global credential.helper store



# 默认在当前目录下创建和版本库名相同的文件夹并下载版本到该文件夹下
$ git clone <远程仓库的网址>

# 指定本地仓库的目录
$ git clone <远程仓库的网址> <本地目录>

# -b 指定要克隆的分支，默认是master分支
$ git clone <远程仓库的网址> -b <分支名称> <本地目录>



# 初始化本地仓库，在当前目录下生成 .git 文件夹
$ git init


# 查看本地仓库的状态
$ git status

# 以简短模式查看本地仓库的状态
# 会显示两列，第一列是文件的状态，第二列是对应的文件
# 文件状态：A 新增，M 修改，D 删除，?? 未添加到Git中
$ git status -s


# 列出已经存在的远程仓库
$ git remote

# 列出远程仓库的详细信息，在别名后面列出URL地址
$ git remote -v
$ git remote --verbose

# 添加远程仓库
$ git remote add <远程仓库的别名> <远程仓库的URL地址>

# 修改远程仓库的别名
$ git remote rename <原远程仓库的别名> <新的别名>

# 删除指定名称的远程仓库
$ git remote remove <远程仓库的别名>

# 修改远程仓库的 URL 地址
$ git remote set-url <远程仓库的别名> <新的远程仓库URL地址>


# 列出本地的所有分支，当前所在分支以 "*" 标出
$ git branch

# 列出本地的所有分支并显示最后一次提交，当前所在分支以 "*" 标出
$ git branch -v

# 创建新分支，新的分支基于上一次提交建立
$ git branch <分支名>

# 修改分支名称
# 如果不指定原分支名称则为当前所在分支
$ git branch -m [<原分支名称>] <新的分支名称>
# 强制修改分支名称
$ git branch -M [<原分支名称>] <新的分支名称>

# 删除指定的本地分支
$ git branch -d <分支名称>

# 强制删除指定的本地分支
$ git branch -D <分支名称>


# 切换到已存在的指定分支
$ git checkout <分支名称>

# 创建并切换到指定的分支，保留所有的提交记录
# 等同于 "git branch" 和 "git checkout" 两个命令合并
$ git checkout -b <分支名称>

# 创建并切换到指定的分支，删除所有的提交记录
$ git checkout --orphan <分支名称>

# 替换掉本地的改动，新增的文件和已经添加到暂存区的内容不受影响
$ git checkout <文件路径>


# 把已经提交的记录合并到当前分支
$ git cherry-pick <commit ID>


# 把指定的文件添加到暂存区中
$ git add <文件路径>

# 添加所有修改、已删除的文件到暂存区中
$ git add -u [<文件路径>]
$ git add --update [<文件路径>]

# 添加所有修改、已删除、新增的文件到暂存区中，省略 <文件路径> 即为当前目录
$ git add -A [<文件路径>]
$ git add --all [<文件路径>]

# 查看所有修改、已删除但没有提交的文件，进入一个子命令系统
$ git add -i [<文件路径>]
$ git add --interactive [<文件路径>]


# 把暂存区中的文件提交到本地仓库，调用文本编辑器输入该次提交的描述信息
$ git commit

# 把暂存区中的文件提交到本地仓库中并添加描述信息
$ git commit -m "<提交的描述信息>"

# 把所有修改、已删除的文件提交到本地仓库中
# 不包括未被版本库跟踪的文件，等同于先调用了 "git add -u"
$ git commit -a -m "<提交的描述信息>"

# 修改上次提交的描述信息
$ git commit --amend


# 将远程仓库所有分支的最新版本全部取回到本地
$ git fetch <远程仓库的别名>

# 将远程仓库指定分支的最新版本取回到本地
$ git fetch <远程主机名> <分支名>


# 把指定的分支合并到当前所在的分支下
$ git merge <分支名称>


# 比较当前文件和暂存区中文件的差异，显示没有暂存起来的更改
$ git diff

# 比较暂存区中的文件和上次提交时的差异
$ git diff --cached
$ git diff --staged

# 比较当前文件和上次提交时的差异
$ git diff HEAD

# 查看从指定的版本之后改动的内容
$ git diff <commit ID>

# 比较两个分支之间的差异
$ git diff <分支名称> <分支名称>

# 查看两个分支分开后各自的改动内容
$ git diff <分支名称>...<分支名称>


# 从远程仓库获取最新版本。
$ git pull


# 把本地仓库的分支推送到远程仓库的指定分支
$ git push <远程仓库的别名> <本地分支名>:<远程分支名>

# 删除指定的远程仓库的分支
$ git push <远程仓库的别名> :<远程分支名>
$ git push <远程仓库的别名> --delete <远程分支名>


# 打印所有的提交记录
$ git log

# 打印从第一次提交到指定的提交的记录
$ git log <commit ID>

# 打印指定数量的最新提交的记录
$ git log -<指定的数量>


# 重置暂存区，但文件不受影响
# 相当于将用 "git add" 命令更新到暂存区的内容撤出暂存区，可以指定文件
# 没有指定 commit ID 则默认为当前 HEAD
$ git reset [<文件路径>]
$ git reset --mixed [<文件路径>]

# 将 HEAD 的指向改变，撤销到指定的提交记录，文件未修改
$ git reset <commit ID>
$ git reset --mixed <commit ID>

# 将 HEAD 的指向改变，撤销到指定的提交记录，文件未修改
# 相当于调用 "git reset --mixed" 命令后又做了一次 "git add"
$ git reset --soft <commit ID>

# 将 HEAD 的指向改变，撤销到指定的提交记录，文件也修改了
$ git reset --hard <commit ID>


# 生成一个新的提交来撤销某次提交
$ git revert <commit ID>


# 打印所有的标签
$ git tag

# 添加轻量标签，指向提交对象的引用，可以指定之前的提交记录
$ git tag <标签名称> [<commit ID>]

# 添加带有描述信息的附注标签，可以指定之前的提交记录
$ git tag -a <标签名称> -m <标签描述信息> [<commit ID>]

# 切换到指定的标签
$ git checkout <标签名称>

# 查看标签的信息
$ git show <标签名称>

# 删除指定的标签
$ git tag -d <标签名称>

# 将指定的标签提交到远程仓库
$ git push <远程仓库的别名> <标签名称>

# 将本地所有的标签全部提交到远程仓库
$ git push <远程仓库的别名> –tags



# 重命名指定的文件或者文件夹
$ git mv <源文件/文件夹> <目标文件/文件夹>


# 移除跟踪指定的文件，并从本地仓库的文件夹中删除
$ git rm <文件路径>

# 移除跟踪指定的文件夹，并从本地仓库的文件夹中删除
$ git rm -r <文件夹路径>

# 移除跟踪指定的文件，在本地仓库的文件夹中保留该文件
$ git rm --cached


# 使用 pull 命令，添加 -p 参数
$ git pull -p

# 等同于下面的命令
$ git fetch -p
$ git fetch --prune origin

java IDEA编译器：

下载 IntelliJ IDEA – 领先的 Java 和 Kotlin IDE (jetbrains.com)

配置中文：

配置git仓库和编译器：

把数仓克隆到本地：

java安装配置

java下载：Download Java for Windows

傻瓜式安装即可：

在路径中配置环境变量：

windows+r输入：sysdm.cpl找到环境变量，在系统变量中新建环境变量：

变量名：JAVA_HOME
变量值：jdk 的安装目录 ，可以点击游览目录选择
在path中添加：

%JAVA_HOME%\bin

检查是否配置好：命令行中输入java 或者java -version

maven配置：

下载地址：Maven – Download Apache Maven

下载Binary zip archive版本，下载完后解压缩到你想要的指定位置，如

C:\Users\用户名称\Downloads，

配置环境变量：

按照上述方法进入到环境变量，在系统变量中新建环境变量MAVEN_HOME，赋值C:\Users\用户名称\Downloads\apache-maven-3.8.8-bin,

编辑环境变量Path，追加%MAVEN_HOME%bin;

添加好后，maven已经完成了安装，我们可以通过DOS命令mvn -v 检查一下我们是否安装成功

上述就显示安装成功了。

----------------配置本地仓库---------------------------

1.在apache-maven-3.8.8-bin同级目录下新建maven-repository文件夹，该目录用作maven的本地库。

2. 打开C:\Users\用户名称\Downloads\apache-maven-3.8.8-bin\confsettings.xml文件，settings文件

查找下面这行代码,下面的是我改过后的：

localRepository节点默认是被注释掉的，需要把它移到注释之外，然后将localRepository节点的值改为我们在之前创建的目录：maven-repository

用浏览器打开该网页就知道是被注释掉的。

localRepository节点用于配置本地仓库，本地仓库其实起到了一个缓存的作用，它的默认地址是 C:Users用户名.m2。

当我们从maven中获取jar包的时候，maven首先会在本地仓库中查找，如果本地仓库有则返回；如果没有则从远程仓库中获取包，并在本地库中保存。

此外，我们在maven项目中运行mvn install，项目将会自动打包并安装到本地仓库中。

运行一下DOS命令

mvn help:system

结果如下：

如果前面的配置成功，那么maven-repository目录中会出现一些文件。

注：如果之前没安装Maven,只是在Eclipse上用了Maven插件，如果不想重新下载架包可以直接把C:UsersAdministrator.m2 epository中的内容全都复制或者剪贴到本地仓库maven-repository目录下。到此就配置好了。

基本语句：

文件名后缀必须是.java

类名后面没有()

String大写首字母

静态方法main后面有括号，有两个参数

public修饰的类型名必须和文件名一致

一个源文件就只有一个public 类class

System大写首字母且println

大括号成对出现，每行代码都要有分号

public class Main{
    public static void main(String[] args){
        System.out.println("hello_world");
    }
}

/*
多行注释
*/
        
/**
文档注释
*/
//单行注释

生成文档注释：javadoc 子目录文件夹名(d doc) -encoding utf-8 文件名.java

java特点：面向对象，跨平台性，简单性，先编译再解释

变量是计算机内存中的一块存储空间，是存储数据的基本单元，本质是数值的地址

要说明变量类型(决定内存大小)——变量名——值

声明：数据类型变量名;

赋值：变量=值;

输出：System.out.println(变量)

变量名不以数字开头，可以字母、_、货币符号，不与关键词重合，不要与null、true等重合，

变量名不能重复声明

java有两种数据类型：基本数据类型（整数(byte1字节,short2字节,int4字节,long8字节)、小数(float,double)、字符(ASCII码，0-48，A-65，a-97，char2字节，转义字符\t缩进制表位，string,)、布尔(boolean，4字节)）、引用数据类型（String）

float a=4;而不能是float a=4.9; 1字节范围为-128——127

强制类型转换：两者相互兼容或目标类型小于原类型

10000000是128的补码

long l1=2120399292L;//长型

float l1=21.3f;//单精度，不加f默认为double类型

int i =100;byte b=(byte)i;//强转换，长度不够会截断

任何类型与string凭借都会提升会string,一个数为double结果会提升为double

System.out.println("a="+a)

char可以强转换成int型(int)i

可以定义：int a=10,b=2;

运算顺序：println("a+b="+a+b)

结果为102

println("a+b="+(a+b))

结果为12

5/0为异常，5.0/0结果为无穷大，0/0为NA，未定型

++a,先自增在使用该结果，a++，先使用a在自增，--同++

赋值运算符：+=；-=，*=；/=；求和后赋值

关系运算符：<,!=

逻辑运算：与&&，或||，取反!

三元运算符：？:布尔表达式？结果1：结果2

位与：int a=8,b=10;

System.out.println(a>6&&b++==10); 前面为真后面先用b的值再自增，b的值为11

短路与：int a=8,b=10;

System.out.println(a>9&&b++==10); 前面为假后面不进行运算，b的值为10

||也有短路或

优先级：括号优先，算数>关系>赋值

在类之前导入包(类)：

import java.util.Scanner

public class main{

public static void main(String[] args){

Scanner input=new Scanner(System.in);

System.out.println('输入名字:');

String name=input.next();

System.out.println('你输入的是'+name);

}

String name=input.next().charAt(0);//获得单个字符

注意的点：导入包后有；扫描输入为new Scanner，获取输入为nextline或者next；输出不要带逗号输出两个；赋值要先声明int nam在赋值

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {

        Scanner input=new Scanner(System.in);

        System.out.println("输入名字:");

        String name=input.next();
        int nam = (int) name.charAt(0);
        System.out.println("你输入的是"+nam);
        if (nam<2){
            System.out.println("zhoumifg");
        }
        else if(nam<3){
            System.out.println("dedc1");
        }
        else if(nam<3){
            System.out.println("dedc2");
        }
        else if(nam<20){
            System.out.println("dedc3");
        }
        else if(nam<560){
            System.out.println("dedc4");
        }
        else
        {
            System.out.println("dedc5");
        }
    }
}

switch用法：long不可以放在switch里面做判断；case和变量类型要一致

        switch(nam){
            case 2000:
                System.out.println("工商银行");
            default:
                System.out.println("输入有误");
                break;
        }

while循环：

注意while后面不是：，是小写的true

    public static void main(String[] args) {
        int i = 1;
        while (true) {
            i++;
            System.out.println("草鞋");
            System.out.println("抄写第" + i + "次");
            if (i == 100) {
                break;
            }
        }
    }
}

do while是先做再循环：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        int sco;
        do {
            Scanner score = new Scanner(System.in);
            sco = score.nextInt();
//            System.out.println("草鞋");
//            System.out.println("抄写第" + i + "次");
            if (sco == 100) {
                break;
            }
        }while (sco<60);
        System.out.println("第" + sco + "次，跳出循环");
    }
}

for循环对变量要初始化：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        int sco;
        for(int i=0;i<5;i++){
            Scanner score = new Scanner(System.in);
            sco = score.nextInt();
            System.out.println("分数为" + sco);
        }
    }
}

流程循环的控制，break跳出循环，continue跳出本次循环，嵌套循环不要嵌套多余3次，否则需要优化代码

方法：实现特定功能的一段代码，反复使用

定义：形参要声明类型

public static void 方法名称(int 形式参数){
//方法主体
}

调用时称为实参，方法名称(10);

方法放在主方法main后面定义，不允许main方法里面再定义方法，main会直接运行，是程序的入口，普通方法不会直接运行，方法调用直接写方法名称即可：

单引号和双引号区别在于单引号可以是char，双引号是string，不能定义成char si = "#";

print和println区别在于前者不会换行，后者输出一次就换行一次，不要在方法中定义另外一个方法

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        String sco;
        int num = 10;
        char si = '#';
        for(int i=0;i<4;i++){
            Scanner score = new Scanner(System.in);
            sco = score.next();
            System.out.println(sco);
            System.out.println(Signln(num,si));
        }

    }
    public static String Signln(int count, char sign){
        for(int j=1;j<count;j++) {
            System.out.print(sign);
        }
        return ("已完成");
    }
}

方法执行后有些会有返回值，有些无需返回结果，只需要在普通方法里面return value即可，和python类似，但是要加分号。

要注意返回值要和定义的方法类型一致，如方法定义的是String，那么返回值也必须是string，否则报错，且只能返回一次，只能有一个return。除非是if-else语句可以写多个return.

return作用就是结束当前方法，返回到方法调用处；

没有返回值类型void的方法中return；返回空；

一个方法最好只做一件事；

方法调用就是方法名称()即可；方法之间可以相互调用，

递归：解决具有既定规律的问题时，在方法内部自身调用的编程方式，将大问题拆分成小问题或者用循环解决的都可以用递归解决。

public class Main {
    public static void main(String[] args) {
        int num = 5;
        System.out.println(func(num));
        System.out.println(func1(num));
    }
    // 我写的
    public static int func(int num){
        if(num!=1) {
            return num * func(num - 1);
        }else{
            return 1;
        }
        
    }
    // 同事写的
    public static int func1(int num){
        if(num==1) {
            return 1;
        }
        return num * func(num - 1);
    }
}

这就可以看到思维的差异，所以得多学学，知道了吧。

数组：一组连续的存储空间，存储多个相同数据类型的值，一个数据可以存任何值，称之为对象，但一般不这样做。

在主方法中main中定义，，java数组定义int [] a = new int[5];

或者 int [] a = new int[] {1,2,3,4,5}或者 int [] a = {1,2,3,4,5}；不能int [] a;再赋值；

c语言中定义为：int a[] = new int[5];

数组赋值为a[2]=8;访问为a[2];下标从0开始；

int默认值为0；double默认值为0.0;

数组遍历：

public class Main {
    public static void main(String[] args) {
        int num = 5;
        //int [] a = new int[8];
        int [] a={1,2,3,4};
        //正序遍历
        for(int i=1;i<a.length;i++){
            System.out.println(a[i]);
        }
        //倒序遍历
        for(int i=a.length;i>0;i--){
            System.out.println(a[i-1]);
        }
    }
}

下面代码实现了随机生成一个数组，（然后排序），用遍历或者array或者contains方式判断输入数字是否在该数组中：（数组查找）

import java.util.Random;
import  java.util.Scanner;
import java.util.Arrays;
import java.util.HashSet;
public class Main {
    public static void main(String[] args) {
        int nu = 25;
        int a=1;
        int[] array = new int[nu];
        Random random = new Random(1234);//设置随机数种子，每次都相同
        for (int i = 0; i < nu; i++) {
            array[i] = random.nextInt(30); // 生成0到999之间的随机数
        }
        //对数组排序
//        Arrays.sort(array);
        System.out.println("请输入一个数：");
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        for (int i = 0; i < nu; i++){
            if (n==array[i]){
                a=0;
                System.out.println("找到了，索引在"+i);
                break;
            }else if(i==(nu-1)&&(a==1)){
                System.out.println("未找到,-1");
            }
        }
        //要求有序才可以，这里可以定义成一个方法返回下标
        int index = Arrays.binarySearch(array, n);
        if (index >= 0) {
            System.out.println("目标数存在于数组中");
        } else {
            System.out.println("目标数不存在于数组中");
        }
        //可以无序
        HashSet<Integer> set = new HashSet<>();
        for (int num : array) {
            set.add(num);
        }

        if (set.contains(n)) {
            System.out.println("目标数存在于数组中");
        } else {
            System.out.println("目标数不存在于数组中");
        }
    }
}

数组扩容：数组确定后就不可变更，只能创建新数组再复制给新数组。

public class Main {
    public static void main(String[] args) {
        int nu = 25;
        int[] array = new int[nu];
        int[] new_array = new int[array.length*3];
        Random random = new Random(1234);//设置随机数种子，每次都相同
        //复制扩容
        for (int i = 0; i < nu; i++) {
            array[i] = random.nextInt(100); // 生成0到999之间的随机数
        }
        for (int i = 0; i < array.length; i++) {
            new_array[i] = array[i];
        }
        //直接用copyof扩容，也可以缩小/2
        new_array = Arrays.copyOf(array,array.length*3);
        System.out.println(Arrays.toString(new_array));
    }
}

数组传参：传参传的是地址，所以在普通方法里面做修改会改变原来数组的值，传参在普通方法里面进行扩容不会影响原来的数组长度，需要return返回才能更改。

import java.util.Random;
import  java.util.Scanner;
import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int nu = 5;
        int[] array1 = new int[nu];
        Random random = new Random(1234);//设置随机数种子，每次都相同
        //复制扩容
        for (int i = 0; i < nu; i++) {
            array1[i] = random.nextInt(10); // 生成0到999之间的随机数
        }
        System.out.println(Arrays.toString(array1));
        add(array1);
        System.out.println(Arrays.toString(array1));
        array1=expand(array1);
        System.out.println(Arrays.toString(array1));
    }
    public static void add(int[] one_array){
        for (int i = 0; i < one_array.length; i++) {
            one_array[i] += 1;
        }
    }
    public static int[] expand(int[] one_array){
        one_array=Arrays.copyOf(one_array,one_array.length*2);
        return one_array;
    }
}

可变参数占最后一个位置，一个方法只能有一个可变参数，其他参数用...替代，具体如下：

public class Main {
    public static void main(String[] args) {
        int a=add(1,2,3,4,5,6);
        System.out.println(a);
    }
    public static int add(int... nums){
        int sum=0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        return sum;
    }
}

数组排序：十种：

//冒泡排序(相邻两个数值比较大小，互换位置，外层循环控制轮数，内层循环n-i次) 选择排序插入排序复杂度：n*n

//快速排序堆排序希尔排序归并排序复杂度： n*logn

//桶排序计数排序基数排序特定数据场景使用

冒泡排序：

public class Main {
    public static void main(String[] args){
        int[] array1={4,56,32,1,47,5,9,15};
        bubble(array1);//不需要赋值给新的数组，在原有数组基础上进行更改的
        System.out.println(Arrays.toString(array1));
    }
    public static void bubble(int[] nums){
        for(int i =0;i<nums.length-1;i++){
            for(int j =0;j<nums.length-1-i;j++){
             if(nums[j]>nums[1+j]){
                 int te=nums[j];
                 nums[j]=nums[j+1];
                 nums[j+1]=te;
             }
            }
        }
    }
}

计数排序：

小记：朋友问我的一个SQL题：找出数据库中连续工作时间最长的人员。（逻辑类似于计数排序）

假设人员工作了就会有对应日期，没工作就没有日期，现在要找出连续工作日最长(即没有间断)的最大连续工作时间段。

逻辑如下：关键是如何判断工作日是连续的，创建交易日历？？

首先先对工作日历进行排序，然后将每一个工作日的日期-1得到新的一列(周一-3即可)，将每一个工作日的上一个工作日与新的一列工作日进行做差datediff，若工作日连续则值为0，否则值为其他，寻找非0的间断点，统计每个间断点区间内0的个数，找到最大的个数即为连续工作时间最长。

具体sql语句自行实现。

import java.util.HashSet;
public class Main {
    public static void main(String[] args){
        int[] array1 = {1,2,3,4,2,2,3,4,2,1,3,4,1,2,2,3};
        //描述数组
        HashSet<Integer> uniqueValues = new HashSet<>();
        for (int num : array1) {
            uniqueValues.add(num);
        }
        int coun = uniqueValues.size();
        //遍历描述数组
        int[] count = new int[coun];
        for(int i=0;i<array1.length;i++){
            count[array1[i]-1]++;
        }
        //还原数组
        int[] new_array1=new int[array1.length];
        int index=0;
        for(int i=0;i<count.length;i++){
            for(int j=0;j<count[i];j++){
                new_array1[index++]=i+1;
            }
        }
        array1=new_array1;
        System.out.println(Arrays.toString(array1));
    }
}

二维数组：

对象：