JAVA基础知识一（java简介，基础语法）

一、 Java简介

1.Java语言简介

从1991年开始研发，Java语言之父(詹姆斯.高斯林)，Green项目小组，C++，oak(橡树)。

1995年，想要将oak语言正式对外发布，java(咖啡杯)，1996年正式发布--JDK。

公司：SUN公司，Oracle公司收购。

JDK 是一款软件，作用：用来编译和执行java语言所编写的程序。

2.发展史

\1. 1996年，jdk1.0。 jdk5.0:泛型、可变参数、枚举...。

JDK8.0: Lambda表达式/函数式接口/StreamAPI...

目前最新版本：JDK16.0。

\2. 在jdk1.2版本时，将java语言根据不同的需求，划分了三大平台。

javase(j2se): 标准版，桌面应用程序。

javaee(j2ee): 企业版，做web项目，简单理解：做网站

javame(j2me): 微型版，做移动端项目--淘汰了，Android和iOS。

\3. Java语言特点

a.编译性 ：我们编写好的代码，必须先编译，编译后会有新的文件产生(字节码文件或类文件)，最终执行的编译后的文件。

我们编写的自己可以看懂的代码编译为字节码文件，字节码文件是计算机能看懂的，然后JVM执行这些字节码文件。

b.面向对象：编程思想，解决问题的思路。找对象，调用其功能。封装对象。

Java语言的特性，万物皆是对象。把需求不自己亲自解决，而是交给对象解决。对象是我们提前设计好的能有一定功能的代

码，当我们需要的时候直接调用对象实现其功能。比如：洗衣服的面向过程的理解就是，每次洗衣服都拿盆放水放洗衣液自己

洗完拧干晾衣服，每次洗衣服都是这个重复的工作。面向对象的思想就是，我把这些重复的工作设计到一个全自动洗衣机里，

或者买一个全自动洗衣机，我每次洗衣服的时候只需要把衣服放进洗衣机打开开关就行。自己设计洗衣机就是自己设计代

码块，买洗衣机就是拿别人设计好的-可以实现该功能的代码，我们直接复制过来。

c.跨平台 ：java相较于其他语言火的原因之一。

d.动态性 ：执行过程中，可以选择要运行的内容或对内容进行修改。

e.开源 ：开放源代码、免费的

\4. 跨平台

跨：跨越； 平台：操作系统。

指的就是编译后的类文件可以在不同的操作系统平台上运行。

原因：在不同的操作系统平台上，安装了对应系统版本的jvm(虚拟机)。

jvm: 一台假的计算机，是一个软件。

不同的操作系统上的jvm，可以营造相同的环境，能识别类文件。

总结：一次编译，处处运行。

3.配置环境变量

方法一、

1.计算机--右键--属性--高级系统设置--环境变量--系统变量--Path

2.Path = E:\Java\jdk1.8.0_131\bin; ....

注意：在Path值的原来基础上做添加，使用分号与其他内容做分隔

千万不要将Path原理的值删除。

方法二、

将jdk的安装目录，使用一个变量名来表示。

JAVA_HOME= E:\Java\jdk1.8.0_131

Path = %JAVA_HOME%\bin;......

这对百分号的作用就是用来获取某个变量名所对应的值。

jvm：java virtual machine, java虚拟机，看成是容器，装载类文件，执行类文件。

jre: java runtime environment，java运行时环境，包含：jvm + 核心类库

jdk：java development kit，java开发工具包，包含：开发工具+jre。

关系： jdk包含jre，jre包含jvm。

安装：jdk，满足我们的需求。

JAVA_HOME : jdk 路径

Path : 需要把jdk的bin目录路径，添加到path变量

Jdk 开发工具

Jre 核心类库

Jvm

4.编辑器

只要能用来编写纯文本数据，都可以用来作为编写代码的软件。

1.普通记事本软件

没有颜色区分、没有快捷键、没有自动缩进和换行等.

电脑系统自带的记事本软件。

2.超级记事本

有颜色区分、可以设置快捷键、有缩进和换行、有高亮提示等。

Editplus、 notepad++...

3.集成开发工具

有颜色区分、可以设置快捷键、自动补全代码的快捷键，有缩进和换行、有高亮提示等。

eclipse：免费的，下载后解压就可以使用。 javase javaee

MyEclipse: 收费的， javaee项目

Idea: 收费的，安装.

二、 基础语法

1.注释

1. 单行注释： //

//这是一条单行注释

public int i;

2. 多行注释： /和* 相结合

/** The first Thinking in Java example program.

* Lists system information on current machine.

* @author Bruce Eckel

* @author http://www.BruceEckel.com

* @version 1.0

*/

注意： 多行注释不能嵌套使用

2.关键字

是被Java语言赋予特殊含义，具有专门用途的单词，比如class，int，double均为Java已经预设好的;

组成关键字的字母全部小写 ,注意String不是关键字;

goto与const是Java中的保留字，即没有赋予特殊含义却仍被Java占用的单词;

3.标识符

凡是让我们自己起名字，这些名字就是标识符

类名、变量名、方法名、常量名、包名、接口名、枚举类名。

就是给类,接口,方法,变量等起名字时使用的字符序列,组成规则只能包含下面的内容,不能有其它内容:

l 英文大小写字母

l 数字字符

l $和_

1.注意事项

l 数字不能开头

l 不可以使用关键字

l 严格区分大小写，不限制长度

l 起名时，尽量见名知意

2.标识符常见的命名规则

l 包名：多单词组成时所有字母均小写，使用.连接.比如：aaa.bbb.ccc

l 类名&接口名&枚举类名：大驼峰式。比如：AaaBbbCcc

l 变量名&方法名：小驼峰式。比如：aaaBbbCcc

l 常量名：多单词组成是所有字母均大写，使用_连接。比如：AAA_BBB_CCC

4.数据类型

1. 基本数据类型

基本数据类型是Java语言中内置的类型，分别是整数类型、小数类型、字符类型、布尔类型。

l 整数(byte、short、int、long)，默认的整数类型是int类型，long类型需添加"L"后缀。

l 小数(float、double)、字符类型(char)，默认的浮点类型是double类型。在Java中所有没有后缀以及使用“D”后缀（小写也可以，但建议使用大写）的小数都是double类型；float类型常量必须添加“F”后缀

l 字符类型（char）

l 布尔类型(boolean)

整数：

byte 1字节 8位 -128~127

short 2字节 16位 -2^15~2^15-1

int 4**字节** 32**位** -2^31~2^31-1 默认类型

long 8字节 64位 -2^63 ~ 2^63-1

浮点：

float 4字节

double 8**字节** 默认类型

字符：

char 2个字节 0~65535

布尔：

boolean true/false

大小排序

byte < short = char < int < long < float < double

一个汉字字符在UTF-8 编码表中占3个字节。

一个汉字字符在GBK 编码表中占2个字节。

2. 引用数据类型

引用数据类型是强大的数据类型，它是基于基本数据类型创建的。JavaSE中提供了一个超级类库，类库中包含了近万种引用数据类型。比如： 数组、类、接口、枚举

注意： 字符串类型不是基本类型，属于引用型类类型

3. 数据类型间 的转换

自动转换：（小变大）

这个动作是自动完成的，不需要手动写代码。

小类型 会自动提升类型，与操作中的大类型一致，提升后进行计算。

有浮点类型出现，最终结果是浮点类型

byte / short /char-->int --->long--->float--->double

boolean类型不能转成数字，因此不能做转换。

强制转换：（ 大类型 转换成 小类型 ）

这个动作是显示完成的，需要手动写代码。

格式： (要转换的类型)数据

Float x = （float）10 ；

强转后，数据的精确程度可能会降低，因此使用时要慎重。

5.常量

常量就是不变的数据量, 在程序执行的过程中其值不可以发生改变

常量分类

数值型：

整数： 1,2,3， -1，-2...

浮点： 1.2， -1.3...

字符串型：使用双引号来表示的数据

内容不限，是什么都可以，个数也不限，最少0。 “” “())__” “abcd”....

字符型：使用单引号来表示的数据

内容是什么不限制，但是个数有要求，必须是1个。 ‘ ’ ‘1’ ‘中’ ‘a’

布尔类型： true 和false

空 ： null

6.变量

1.概念

字面角度： 可以改变的数据

引深含义：在内存中，开辟空间，存储数据，存储的数据可以改变

java语言是一个强类型语言，开辟的空间有大小限制，根据空间类型，即java中的数据类型。

2.格式

变量的声明(定义)：

数据类型 变量名；

存储数据：

变量名 = 数据;

合并一行：

数据类型 变量名 = 数据;

例如：

int 整数类型

int a = 123; //定义变量并存储数据

a = 125; //对存储的数据的改变

3.注意事项

1.变量没有定义过即不存在，不能直接使用

2.变量定义过，但是没有存储数据，也不能直接使用（只针对局部变量，因为局部变量储存在栈中，没有默认值，而成员变量储存在堆中，有默认值）

3.在一对大括号中，不能出现同名的变量

7.进制转换、原码、反码、补码

1.进制

二进制： 0 和1 ，逢2进1 0b（0B）开头 ：0b010101

八进制： 0-7， 逢8进1 0开头 ： 0123

十进制： 0-9， 逢10进1 正常数字： 123

十六进制：0-9和a-f 逢16进1 以0x(0X)开头，数字以0-9及A-F组成：0x12c

二进制转成其他进制：

二转十进制 1101 ：从右边开始，每位上的数字乘以2的N次幂，n从0开始，逐位+1，最终相加之和为十进制数。 1 1 0 1 ，12^0 +02^1 +12^2 +12^3 = 1+0 + 4+ 8 = 13

二转八进制 1101： 从右边开始，每三位为一位，不够位数用0补位。

二转十六进制 1101

从右边开始，每四位为一位，不够位数用0补位。

其他进制转二进制：

十转二进制： 13

除以2 取余数的过程，直至商为0停止

八转二进制： 15

每位数字与2进行取余过程，直至商为0，共三位。

不足三位用0补位，这些二进制数合在一起即是整个二进制数

1 ==== 001 5 === 101

001101 有效位： 1101

十六转二进制： D

每位数字与2进行取余过程，直至商为0，共四位。

不足四位用0补位，这些二进制数合在一起即是整个二进制数

13 === 1101

十进制转其他进制，其他进制转十进制(扩展)。

3. 原码、反码、补码

都是使用二进制数进行计算的。

无符号表示 (+正数)，有符号表示(+ -)

最高位是一个符号位，0 正数 1负数

正数 ： 原码 、 反码、 补码都一致

6 00000110

负数 ：

-6 10000110 11111001 11111010

反码： 最高位保留，其他位取反

补码： 反码+1

在java中，进行计算都是将数据转成其补码后在进行计算的。

bit ： 位 (比特) 代表的是一个二进制数位 要么是0 要么是1，最小存储单元

byte： 字节 是由8个bit组成，最小的计量单位

1k = 1024b

1m = 1024k

1G = 1024m

1T = 1024G

8.运算符

算术运算符：

一元：+正号 -负号 ++自增 --自减

自增 自减： 单独使用时 a++ 和++a 没有区别 都是 a = a+1

在与其他运算接和使用时a++和 ++a 有区别

a++ > 10 先判断a>10 ,在进行运算 +1

++a > 10 先进行运算+1 ,再用+1后的结果判断 > 10

二元：+ - * / %取余数 +字符串连接符

赋值运算符：

= ：将右边的结果存储到左边，有赋值动作的任何情况下都可以使用。

+= -= *= /= %=

A += 5 ; 效果是 A = A +5 ;

当A 和 5 的数据类型一样时。两个效果是一样的

如果A 和 5 的数据类型不一样时，涉及到精度问题。

byte b = 1 ;

b = b + 1;

byte = byte + int 会报错

b += 1 这种写法会自动转换数据类型

比较运算符：

计算后的结果是：boolean类型，即true或false结果

> >= < <=

==: 比较左右两边是否相等

!=: 比较左右两边是否不等

注意：一个等号是赋值， 两个等号是比较

逻辑运算符：

作用：就是用来连接比较运算符组成的表达式

计算后结果：boolean类型

&与and ：连接的表达式值都是true，最终结果是true，否则是false。

| 或or ：连接的表达式值都是false，最终结果是false，否则是true。

! 非not：对表达式的结果进行取反，!true=false , !false = true

^ 异或：连接的表达式结果都相同，结果是false，否则是true。

&&：段落与，只要有一个表达式结果是false，其他不再进行计算，直接判断结果false。

||：短路或，只要有一个表达式结果是true，其他不再进行计算，直接判断结果true。

其他情况与一个符号是相同的。

三元运算符：

需要有三个数据。

是运算符，必然有结果产生，这个运算符只不过是格式稍微复杂些。

格式：

表达式1 ? 表达式2 ：表达式3;

表达式1： 结果是boolean

如果是true，最终执行表达式2

如果是false，最终执行表达式3

优先级 描述 运算符

1 括号 ()、[] 2 正负号 +、- 3 自增自减，非 ++、--、! 4 乘除，取余 *、/、% 5 加减 +、- 6 移位运算 <<、>>、>>> 7 大小关系 >、>=、<、<= 8 相等关系 ==、!= 9 按位与 & 10 按位异或 ^ 11 按位或 | 12 逻辑与 && 13 逻辑或 || 14 条件运算 ?: 15 赋值运算 =、+=、-=、*=、/=、%= 16 位赋值运算 &=、|=、<<=、>>=、>>>=

9.键盘录入

步骤：

1.在class关键字的上边，写一条导包语句，import java.util.Scanner/*;

2.创建扫描器， Scanner 扫描器名 = new Scanner(System.in);

扫描器名实际就是一个变量名

3.通过扫描器，扫描用户录入的数据 (扫描整数),创建整型变量存储扫描到的数据

int 变量名 = 扫描器名.nextInt();

String 变量名 = 扫描器名.next();

4.对扫描到的数据进行想要的操作

5.注意：扫描器创建好后，就可以一直使用，前提是在当前类中，可以多次扫描数据。

不是扫描一个数据就创建一个扫描器。

三、流程控制语句

1.顺序结构：

从上到下，从左到右，依次执行

2.分支结构：

程序执行到某一处，根据条件，选择要执行内容，不满足的就跳过不执行。

特点：写的多，执行的少。

代表语句：

if语句

switch语句

1. if

关键字：if如果 else否则

格式1：

if(条件){

语句1;...

} 语句2

条件就是boolean类型结果的表达式。

如果条件结果是true，就执行大括号里面的语句1，然后继续执行语句外边的语句2；

如果条件结果是false，跳过大括号里面的语句1，继续执行语句外边的语句2。

格式2：

if(条件){

语句块1；...

}else{

语句块2；...

}语句块3

条件就是boolean类型结果的表达式。

如果条件结果是true，执行语句块1，整个语句结束，继续执行语句外边的语句3

如果条件结果是false，执行语句块2，整个语句结束，继续执行语句外边的语句3

三元运算符其实是if-else语句的简写格式，当执行语句能出现具体数值时可以互换。

格式3：

嵌套语句，一个语句中包含了另一个语句。

if(条件1){

if(条件2){

语句体1;...

}语句2

}语句3

条件1，结果是true去执行条件2，结果是true，执行语句体;如果是false，内部if语句结束。结果是false，整个语句结束。

条件1true——判断条件2 ——条件2true——执行语句块1——执行语句块3

条件1true——判断条件2 ——条件2false——执行语句块2——执行语句块3

条件1 false——执行语句块3

格式4：

多重条件判断。

if(条件1){

语句体1;

}else if(条件2){

语句体2;...

}else if(条件3){

语句体3;...

}...else{

语句体n;

}

所有条件表达式结果是boolean类型。条件123…最多只执行一个，执行了前面的后面直接跳过。

条件1结果是true，执行语句体1，整个语句结束，执行语句后边的代码。如果是false，执行条件2，如果是true，执行语句体2，整个语句结束，执行语句后边的代码。如果是false，执行条件3....，依次类型，所有的条件结果是false，执行语句体n。

格式5：

if(条件1){

执行语句1

}

if(条件2){

执行语句2

}

if(条件3){

执行语句4

}

条件1234…逐个判断，哪个结果是true就执行哪个，可以全部执行也可以全部不执行

注意：

1.条件表达式结果是boolean，只有if后边才能出现条件语句

2.语句体中的语句(大括号中)有且只有一条，这对大括号可以省略不写。

3.写语句时，不要乱加分号，分号出现代表结束。

4.= 叫做赋值， == 比较是否相等

2. switch

关键字： switch case break default

switch其实是 if-else if-else 语句的另外一种表现形式，二者间可以互换使用。

格式：

switch(表达式){

case 值1：

语句体1;

break;

case 值2:

语句体2；

break;

...

default:

语句体n;...

break； //可省略

}

先计算表达式，带着结果进入到switch语句中，首先与第一个case后的值进行匹配，如果匹配上执行语句体1，执行break语句，这个switch语句结束，执行后续代码；如果没有匹配上，找第二个case，与其后的执行进行匹配...,所有case后的值都没有匹配上执行语句体n，即default后的内容，这个语句结束。

说明：

1.表达式结果类型：byte short char int String 枚举

2.break; 语句作用：跳出switch语句，结束switch语句的。

3.switch语句的结束标志是：break; 和 }

4.switch语句中的case是没有顺序的，包括default部分

5.default 语句可有可无，最多只能有一个。

进入switch中，首先从上到下依次找case，那个匹配执行哪个，没有找default

5.如果没有写break语句，那么会继续向下执行，遇到语句就执行，直至遇到结束标志才会停止，不会再进行case后的值的匹配，这种现象称为：穿透性。

6.表达式的结果与case后的值类型得一致。

7.case穿透：如果case1 匹配后，执行完语句体1，再没有写case的情况下，循环不会跳出，而是会填过下面的匹配直接执行下面的语句，知道遇见循环标志。

3.对比总结

\1. If 分支结构的判断语句结果只可以是boolean类型

Switch 分支结构的判断语句可以是

基本数据类型：byte, short, char, int

包装数据类型：Byte, Short, Character, Integer

枚举类型：Enum

字符串类型：String（Jdk 7+ 开始支持）

\2. switch 结构 和 if … else if…else if…else 结构思想相同，匹配一个结果后后面就不匹配、不执行

\3. if…else 和 三元运算符思想相同，结果只有两种，而且每次只会有一个结果产生

4. 循环结构：

概念：某些相同或相似的代码想要重复执行多次，可以使用循环语句来简化编写。

要素：

循环体语句 、初始化变量语句、更改初始化变量语句、循环条件

程序执行到某一处，将某些相同或相似的代码重复执行多次。

代表语句：

1. while语句

while语句：

while(条件){

循环体语句;...

}

条件：是一个boolean类型的结果，用于判断是否进行下一次循环的标志

该结果一旦是false，循环立即停止。

特点： 先判断，后执行；

次数： 0 - n

注意： 更改初始化变量语句，千万别丢了

初始化变量定义在循环的外边，因此循环结束后，依然可以对其进行使用。

2. do-while语句

do{

循环体语句;...

}while(条件);

特点：先执行，后判断

次数：1- n

注意：格式中有一个分号，别落下

3. for语句

for(初始化变量 ; 循环条件 ; 更改初始化变量语句){

循环体语句;...

}

流程：

1.初始化变量语句

2.循环条件

3.循环体语句

4.更改初始化变量语句

5.循环条件

6.循环体语句

7.更改初始化变量语句

...

以此类推，直至循环条件为false，循环停止。

与while类似，都是先判断后执行，执行次数：0-n次。

4. 区别

区别：while，将变量定义在循环外；而for，将变量定义在循环上。

现在定义的变量位置：要么在main方法中，要么在语句中或语句上，这样的变量统称

叫做 局部变量。特点：每个变量都有作用域(使用范围),超出作用域不能再使用.

判定作用域： 在哪定义范围就在哪。

比如：在for中定义的，只能在for中使用。

局部变量特点：

1.没有初始值不能直接使用

2.有作用域，超出范围不能使用

3.在一对大括号中不能出现同名变量

无限循环(死循环)：

指的是循环条件值终生为true，不会出现false结果的情况。

while(true){

}

do{

}while(true);

for(;;)

}

现象就是：循环不能停止，想要停止，必须手动加结束标志。

5.嵌套循环

一个循环语句中包含另一个循环语句---嵌套模式。

循环代表语句有三个：for、while、do-while，这三个可以相互嵌套也可以自身嵌套。

以for嵌套为例：

for(){ //时针

for(){ //分针

}

}

6. 跳转语句

从当前语句中跳出来，去执行其他的代码。

以下这两个语句只能在所在的环境中使用，出了环境其他地方不能出现。

break;

switch和循环语句中出现，其他地方不能出现。

作用：跳出当前语句，去执行语句后边的代码，即当前语句结束。目的就是退出当前执行的Switch 或者循环语句，对外层的Switch 或者循环语句没有影响。

continue;:

只能使用在循环语句中，其他地方不能出现。

作用：跳出此次正在进行中的循环，继续下一次循环。

Return：

返回的意思，将产出的数据返回给方法的调用者。返回的是当前的方法。return可以单独写，后面不写返回数据，目的就是中断当前执行的方法。

一旦执行到return，方法立即结束。

四、 方法

1. 基本概念

1. 概念

对应单词：method

概念：在类中，一段具有特定功能的代码段。

2. 格式

格式：

修饰符 返回值类型 方法名(参数列表){

功能语句;...

return 返回值;

}

修饰符： public static

返回值类型： 数据类型(引用、基本)都可以

方法是代表一个功能执行，因此功能执行后，可能会有数据产生，返回值

类型就是用来表示该数据的数据类型。

方法名： 自定义名字，符号标识符的规则和规范即可。

参数列表：变量声明列表。 数据类型 变量名 这种形式可以有多个，中间使用逗号

连接，最后一个没有逗号。作用：用来接收数据。

编写功能时，如果需要外界资源数据辅助完成，此时必须通过参数列表来接

如果不需要，保留小括号，括号中什么都不写。

return 返回值;： 返回值就是一个数据，即功能执行后产出的那个数据。

return：返回的意思，将产出的数据返回给方法的调用者。

一旦执行到return，方法立即结束。

注意：

1.方法要写在类中，方法间都是平级的，没有位置要求

2.方法不调用不执行，没有位置要求看调用顺序，调用顺序决定了方法的执行顺序。

1. 方法中不能定义方法， 但是，方法中可以调用方法（方法内调用方法就是递归）

返回值类型：

1.具体类型

引用类型、基本类型

2.无返回值类型

方法执行完，并没有数据产出，返回值类型位置上要有内容，因此使用关键字

void来占位。

通常是方法执行完，就可以了，不需要有结果。

调用时，直接写：方法名(参数赋值); 不要在写其他。

return；语句通常省略不写，编译器编译时会自动补全该语句，因为方法结束

依赖于return关键字。

好处：

1.提高代码的复用性

因为相同作用的代码只需要写一遍，需要的时候直接调用就可以。

2.体现了一种封装思想--代码

2. 方法重载

overload

概念：在类中，功能相似的方法允许使用相同的方法名来定义，

前提是保证方法的参数列表不同即可，与返回值类型无关。

参数列表不同：

参数个数、参数类型、参数顺序

调用重载方法时，jvm会根据调用时传递的数据的个数及类型自动找到对应方法执行。

重载方法：

println或print 可以输出打印不同类型的数据。

方法重载注意事项

• 重载和参数变量名无关

• 重载和返回值类型无关如void method(int x)与int method(int y)不是方法重载，不能同时存在

• 重载和修饰符无关

• 重载看 方法名 和 参数列表

3. 数组

1. 概念

1.一组数据

2.看成是一个容器，存储多个数据。

2.特点

1.存储的数据是同类型的

2.数组长度固定的，不能改变其大小

3.既可以存储基本类型，也可以存储引用类型

4.有下标(角标、索引)，操作数组中的数据，从0开始的。

5.获取数组元素个数：数组名.length

获取数组元素最大下标值：数组名.length-1

数组中存储的数据，也叫做元素。

3.格式

动态：

元素类型[] 数组名 = new 元素类型[个数];

静态：

元素类型[] 数组名 = new 元素类型[]{e1,e2,e3,.....};

静态简写格式：

元素类型[] 数组名 = {e1,e2,e3,.....};

注意：元素类型[]的中括号可以写在元素类型的后边也可以写在数组名的后边。

4.二维数组

说明：容器中有容器，外层的容器存储的是内层容器的地址。

元素类型[] [] 数组名 = new 元素类型[行数] [列数]; 二维数组的数据个数= 行数*列数

元素类型[] [] 数组名 = {{1,2,3}，{4,5,6} ，{7,8}}；

"

//创建一个二维数组方法一
​
int[] []arr = new int[3][];
arr[0]  = new int[]{2,5,4,9};
arr[1] = new int[]{1,2,3,4};
arr[2] = new int[]{9,5};
​
//创建二维数组方法二
int[][]arr1= new int[2][3];
arr1[0]= new int[]{1,2,3};
arr1[1]= new int[]{4,5,6};
​
//创建二维数组方法三
int[][] arr2 = {{1,2,3}，{4,5,6} ，{7,8}};

"

二维数组的遍历

"

public static void printArray(int[][] arr) {    //arr[i][j]
    for (int i = 0; i < arr.length; i++) {      //外层控制i的循环
        for (int j = 0; j <arr[i].length ; j++) {   //内层控制j的循环
            System.out.print(arr[i][j]+"\t");
        }
        System.out.println();
    }
}

"

5. 数组的应用

1.数组元素遍历(依次打印)

“

public static  void printArray(int []arr){
    for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i]+"\t");
    }
}

”

2.数组元素获取最大值或最小值

“

public static int getMin(int[] arr){
    int min = arr[0]; //默认第一个最小
    for(int i = 1; i < arr.length; i++){
        if(min > arr[i])
            min = arr[i];
    }
    return min;
}

”

3.反转数组元素

“

第一种方法

public static void  reverseArray(int[] arr){ // arr = arr 引用传递
    //交换
    for(int i = 0; i < arr.length/2 ;i++){
         int temp = arr[i];
         arr[i] = arr[arr.length-1-i];
         arr[arr.length-1-i] = temp;
    }
    
}

”

“

第二种方法

public static int[]  reverseArray1(int[] arr){ // arr = arr 引用传递
    //交换
    for(int start =0, end = arr.length-1; start < end; start ++, end--){
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
    }
    
    return arr;
}

”

4.数组元素的查找和排序

“

一维数组查询

public static int findArray(int[] arr,int a){
    for (int i = 0; i <arr.length ; i++) {
        if(arr[i] == a){
            return i;
        }
    }
    return -1;
}

”

“

二维数组查询

public static String findArray(int[][] arr,int a){
    for (int i = 0; i <arr.length ; i++) {
        for (int j = 0; j <arr[i].length ; j++) {
            if(arr[i][j] == a){
                return i+","+j;
            }
        }
​
    }
    return -1+","+-1;
}

”

“

一维数组的排序

public static void sort(int [] arr){
    for (int i = 0; i < arr.length-1; i++) {
        for (int j = 0; j <arr.length-1-i ; j++) {
            if (arr[j]>arr[j+1]){
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

”

6. 数组内存理解

jvm启动，将内存划分5个区域，从而提高效率。

寄存器：控制执行哪行代码

本地方法区：调用底层方法。

与我们有关的： 栈、堆、方法区

栈：所有的方法执行都是在栈中完成的。一旦方法执行完会出栈。

特点：先进后出。

堆：存储容器或对象或实体

只要是通过关键字new创建的都是。

默认值：

整型: 0 float: 0.0f double :0.0 boolean：false char: ‘\u0000’

引用：null

int[] arr = new int[2];

只要在堆中开辟空间，就会为其分配内存地址值。

在该空间中存储默认值，依赖于空间中元素的数据类型。

将内存地址值赋值给arr引用变量，arr指向了堆中的容器。

垃圾：在堆中的容器，如果没有任何引用变量来指向，那么这个容器是垃圾。

容器一旦是垃圾，最终会被垃圾回收器(GC机制)给回收。

引用变量值为null，说明变量和容器间没有关系，这个容器就是垃圾了。

7. 方法传参

基本类型：（包括String）

值传递，仅仅是将数值赋值给方法的参数，在方法内部做的操作，并不影响原来的变量

引用类型：（除了string）

引用传递，将地址值进行传递，一个引用变量对其进行改变，另一个引用看到的是改变后的结果。