java基础

ava基础知识

JDK = jre + java开发工具

jre = jvm + 核心类库

环境变量的作用是为了 进行全局使用java 和javac命令

​ 先配置javahome : 指向jdk 安装的主目录

​ path ： 指向 jdk 中的bin 文件的目录 如： %javahome%\bin

java编写步骤

​ 编写伪码 >>编写java的源代码 >> javac 编译,得到对应的.class 文件 >> java运行，本质就是把 .class文件 加载到jvm 运行

java初学易犯错误

1.编译运行 时 找不到文件

2. 主类名字和文件名不一致 >>修改一致就行
3. 缺少；
4. 拼写错误 >>写代码时，不要乱写

java代码规范简介

​

1.类，方法的注释要以javadoc的方式来写
2.非java DOc的注释，往往是给代码的维护者看的，着重告述读者为什么这样写
3.使用tab操作，实现缩进，默认整体享有移动到时候shift+tab整体向做移动
4.运算符和 = 两边习惯保持一个空格
5.源代码使用utf-8编码（jbk：因为doc中有中文所以防止乱码使用jbk）
6.行宽度不要小于80字符
7.代码编写的次行风格和行尾风格

javadoc命令

dos的基本原理以及基本命令

​ 相对路径 从当前目录开始定位，形成的路径

​ 绝对路径 从顶级目录开始定位，形成的路径

​ md + src 文件名字: 创建文件 src:创建文件的位置

​ rd + src 文件名字: 删除文件

​ dir + 文件 ： 查看当前目录有什么

​ cd :切换到其他盘符 如 ： cd … cd / cd /D + 盘符

​ cls :清屏

​ tree 目录: 以树的形式展开一个盘符，文件夹的内容

​ exit : 退出DOS

​ md : 创建目录

​ rd ： 删除目录

​ cope : 拷贝文件

​ del : 删除文件

​ echo :输入内容 到文件

​ move 剪切

java的变量

变量是程序的基本组成单位

变量的三要素： 类型 变量名称 值

变量的使用 ： 声明变量 赋值变量 使用变量

局部变量 ： 生命周期与方法一致 且存在于栈中

new 的变量 ： 存在于 堆中

switch分支结构

基本语法：

switch(表达式){
    case 常量1:
        语句块
        break;
    case 常量2:
        语句块
        break;
    default: //匹配不到就会默认执行
        语句块
       	break;
        
}

跳转控制语句

**break **

可以在 for while do-while switch 中使用

特殊使用： break lable1 ： 退出指定的标签 如果没有使用标签，那么就是默认直接退出当前循环体

使用方式：

public static void main(String[] args){
    
    lable1: //标签
    for(int j = 0;j<4 ;j++){
        lable2:
        for(int i = 0;i<10 ; i++){
            if(i==2){
                break lable2;//break +标签
            }
            System.out.println("i = "+ i);
        }
    }
}

countinue语句

可以在 for while do-while switch 中使用

和break相同，countinue 也可以使用标签 lable 进行跳过某个循环，但不会结束循环

用于结束本次循环，继续执行上次循环

public static void main(String[] args){
    
    for(int j = 0;j<4 ;j++){
            if(j == 2){
            	countinue; //不会跳出循环，但是会结束该次循环
            }
            System.out.println("i = "+ i);
        }
}

return

跳出所在的方法，可携带返回值

public static void main(String[] args){
    
    for(int j = 0;j<4 ;j++){
            if(j == 2){
            	return; //用在方法中是，跳出方法，用在main中是结束程序
            }
            System.out.println("i = "+ i);
        }
}

数组（引用类型）

存放多个同一类型的数据

特点： 地址连续 查找快，删除慢，存储的数据相同 属于引用类型 数组中的类型可以是基本数据类型，也可以是引用数据类型

数组的定义

数据类型 数组名[ ] = new 数据类型[大小]

数组的引用方式：

使用索引下标进行访问 使用地址值加1 进行访问

动态初始化

先声明数组   ： 数据类型 数组名[ ]  或者 数据类型[ ]  数组名

​ 在创建数组 ： 数组名 = new 数据类型[ 大小]

//方式一   默认数组中的值是0
int[] num = new int[5];
//动态初始化  先声明数组  在创建数组

//方式二 静态初始化
int[] num = {1,5,9,6};
//方式三 动态初始化
 int num[];//声明数组 目前 num还有存储空间，还是一个空值
num = new int[8];//分配了内存空间 因为是new出来的，放在堆中
//数组长度的访问
num.length
    

数组赋值机制

基本数据赋值，这个值就是具体的数据，不相互影响；数组在默认情况是引用传递，付的值是地址。

//这种的基本数值赋值就是 值的传递，值的拷贝，n1 ,n2 没有绝对的联系
int n1 = 10;
int n2 = n1;
//相当于把 arr1的地址给了arr2 ，他们的值会相互影响
int[] arr1 = {1,2,3};
int[] arr2 = arr1;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pbOVeyIC-1647764326171)(C:\Users\hasee\AppData\Roaming\Typora\typora-user-images\image-20220315164105795.png)]

数组的拷贝，需要值拷贝 ,代码如下

int[] arr1 = {1,2,3};
int[] arr2 = new int[arr1.length];
for(int i = 0 ; i <arr2.length ; i++){
    arr2[i] = arr1[i];
}

反转思路一 :

i <arr2.length/2 控制次数

arr2[i] = arr1[length-i-1];交换核心

int[] arr1 = {1,2,3};
int temp = 0;
int[] arr2 = new int[arr1.length];
for(int i = 0 ; i <arr1.length/2 ; i++){ 
        temp = arr1[length-i-1];
    	arr1[length-i-1] = arr1[i];
    	rr1[i] = temp;
}

思路二：

创建一个新的数组进行逆序遍历

数组扩容

实现动态的给数组添加元素

int[] arr1 = {1,2,3};
int[] arr2 = new int[arr1.length+1];
//便利原数组，然后赋值给新的扩容的数组，再将新数组的地址赋给原来的数组名。

多维数组

二维数组

从形式上来看是 int[] [] arr

也可以理解为 一维数组中的元素又是一个一维数组

以 行，列 来进行定义二维数组中的两个下表。两个下标都是从0 开始

//静态初始化
int[][] arr = {{1,0,2,3,1,2,5},{0,0,0,0},{2,2,2}};

//便利二维数组
for(int i = 0;i < arr.length; i++){//外围确定二维数组中有几个一维数组
    for(int j = 0 ; j < arr[i].length; j++){//便利一维数组的中的元素
        System.out.println(arr[i][j]);
    }
}

动态初始化

语法 ： 类型[] []  数组名 = new 类型   [大小][大小]
    int[] arr[] //也是二维数组

内存存在形式：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yDAAVNBO-1647764326173)(C:\Users\hasee\AppData\Roaming\Typora\typora-user-images\image-20220315180215037.png)]

动态初始化 2

先声明数组   ： 数据类型 数组名[ ] [] 或者 数据类型[ ] [ ]  数组名

​ 在创建数组 ： 数组名 = new 数据类型[ 大小] [ 大小]

在java中允许 二维数组中的每一个数组的元素可以不同 ，增加灵活性。

如： 
int[][] arr = {{1,2,3,4},
				{2,3,6,4,5},
				{5,6,7,8,9,0}};

//一下动态创建二维数组，表示的是一个有三个一维数组，但是每一个一维数组还没有分配数据空间
int[][] arr = new int[3][];
for(int i = 0 ; i<arr.length ; i++){
    arr[i] = new int[i+1];//在这里进行给每个数组创建空间
}

杨辉三角
$$1111211331$$

先想思想>>代码
1.第n行有第n个元素
2.每一行的第一个元素和最后一个元素都是1
3.从第三行开始，对于不是第一个元素的值，等于上一行对应列的值加上 上一行次列的值

    int[][] arr = new int[n][];
for(int i = 0 ; i<arr.length; i++){
    //对每一行元素进行开辟数据空间
    arr[i] = new int[i+1];
    for(int j = 0 ; j< arr[i].length ; j++){
        if(j==0 || j == arr[i].length-1){
            arr[i][j]=1;
        }else{
            arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
        }
    }
}
//便利
for(int i = 0 ; i<arr.length; i++){
    for(int j = 0 ; j< arr[i].length ; j++){
      System.out.print( arr[i][j]+"\t");
    }
    System.out.println();

排序

内部排序

​ 将需要及逆行处理的数据加载到内部存储器中进行排序，包括（交换式排序法，选择式排序和插入式排序法）；

外部排序

​ 数据量很大，无法全部加载到内存中，需要借助外部存储进行排序（合并排序法和直接排序法）。

基本排序方式

冒泡排序

通过对待排序的序列从后向前（从下表大的元素开始），以此比较两个相邻元素的值，若发现逆序就让值比较大的元素逐渐从前向后移。

特点：

1.如果有 N 个数，则要进行 N - 1 轮排序；

2.在第 i 轮排序中，要进行 N-i 次两两比较

3.可以从前往后排序，也可从后往前排序

从小到大：

int[] arr = new arr[6];
int temp = 0;
for(int i = 0 ;i<arr.length-1 ;i++){//进行arr.length-1次外部循环
    for(int j = 0 ; j<arr.length-i-1 ; j++){//每一轮都会进行 arr.length-i-1 次比较
        if(arr[j] > arr[j + 1]){
            temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
    
}

查找

java中的常见查找有两种，是循序查找 和二分查找