java基知识:
1、java数据类型:
dos的使用快捷键:
盘符的切换 | 符盘名: |
---|---|
看查当前文件 | dir |
看查文件夹命令 | cd 文件名 |
出退文件夹命令 | cd… |
退出到硬盘的根路径 | cd\ |
清屏 | cls |
退出dos | exit |
-
基本数据类型:整数、浮点数、字符、布尔
-
引用数据类型 :类、数组、接口
关键字 | 内存占用 | 取值范围 |
---|---|---|
byte | 1 | -128~127 |
short | 2 | -32768~32767 |
int(默认) | 4 | |
long | 8 | |
float | 4 | |
double(默认) | 8 | |
char | 2 | 0-65535 |
boolean | 1 | true、flase |
-
long类型:建议数据 后面添加L表示
-
float类型:建议数据后面添加F表示
使用变量的注意事项:
- 1、如果创建多个变量,变量不能重复的
- 2、对于float和long类型的变量,值后面加上字母后缀
- 3、数据类型赋值不能超出数据类型的范围你
- 4、没有进行赋值的变量不能使用
- 5、变量一定要先创建,再使用
- 6、注意作用域:就是大括号( { } )的范围
2、数据类型转换:
当数据类型不一致时,就会发生数据类型转换
-
自动转换(隐式):
特点:代码不需要进行特殊处理,自动完成
规则:数据范围从小到大
byte short char——int——long——float——double
-
强制转换(显式):
规则:数据范围冲大到小
格式:数据类型 变量名 = (数据类型)被转换的数据
int num = (float)100L;
数据类型转换的注意事项: 1、浮点数转整数会造成数据精度丢失、其他数据类型可能会造成数据溢出
2、byte、short、char这三种类型都可以发生数学运算,例如"+"j
-
char ch = 'A'; System.out.println(ch+1); //66,因为计算机是采用二进制的,所以A的值是65,
3、byte、short、char这三种类型在运算的时候,都会被首先提升为int类型,然后在计算
4、boolean不能发生任何数据类型转换
注意事项:
1、对于byte、short、char三种类型来说,如果右侧赋值的数值没有超过范围,那么java编译器将会自动隐含的补上(byte)、(short)、(char)强转,如果超过了,编译器就不报错
2、在给变量赋值的时候,如果右侧的表达式全部都是常量,没有任何变量,那么编译器将会直接将若干个常量表达式计算得到结果
short result = 5+8; sout(result); //13 这样称为【编译器的常量优化】,但是一旦表达式有变量参与,就不能进行这样的优化 short a = 5; System.out.println(5+a+8); //这样编译器会报错 中间有变量,不能使用常量优化
-
ASCII
字符 | 数值 |
---|---|
0 | 48 |
9 | 57 |
A | 65 |
Z | 90 |
a | 97 |
z | 122 |
3、运算符:
3.1、算数运算符
加 | + |
---|---|
减 | - |
乘 | * |
除 | / |
取余 | % |
自增、自减 | ++ 、– |
对于一个整数的表达式来说,除法用的是整除,整数除以整数,结果是整数不保留余数
- 自增和自减:
- 1、如果是【前++】,那么变量【立刻马上+1】,然后拿着结果再使用【先加后用】
- 2、如果是【++后】,那么首相使用变量原来的值,【然后在让变量+1】【先用后加】
3.2、赋值运算符
= | 等于 |
---|---|
+= | 加等于 a+=1 a=a+1 |
-= | 减等于 a-=1 a= a-1 |
*= | 乘等于 |
/= | 除等于 |
%= | 取余等于 |
- 赋值运算符就是:将右边的值赋值给左边的变量
- 常量不能进行赋值
3.3、比较运算符
== | 比较两边的值,如果相等为true,否则为false |
---|---|
> | 如果大于为true,否则为false |
< | 如果小于为true,否则为false |
>= | 如果大于等于为true,否则为false |
<= | 如果小于等于为true,否则为false |
!= | 如果不想等为true,否则为false |
比较运算符是两个数据之间进行比较的运算,运算结果是boolean值:true或者false
3.4、逻辑运算符
&&(逻辑与) | 两边是true,则是true,一边是false,就是false |
---|---|
||(逻辑或) | 两边是false,则是false,一边是true,则是true |
!(逻辑非) | !true就是false, !false就是true |
逻辑运算符:就是用来连接两个boolean类型结果的运算符,运行结果是true或者false
3.5、三元运算符
-
三元运算符的格式:
- 数据类型 变量名 = 布尔表达式? 结果1:结果2
三元运算符计算方式:
boolean表达式的结果是true,三元运算符整体结果为结果1,赋值给变量
boolean表达式的结果是false,三元运算符整体结果为结果2,赋值给变量
public static void main(String[] args){ int i = (1==2 ? 100:200); sout(1) ; //200 int j = (2<=4 ? 500:600); sout(j) ; //500 }
4、方法入门
4.1概述:
概述:就是将一个功能抽取出来,把代码单独定义在大括号内,形成一个单独的功能。当需要这个功能时,就可以去调用,这样即实现了代码的复用性,也解决了代码冗余的现象。
4.2方法的定义:
定义格式:
修饰符 返回值类型 方法名(参数列表){
代码……
return
}
public statci void method(){
sout("这是一个方法");
}
4.3方法的调用:
方法定义完毕后,方法不会自己运行,必须被调用才能被执行,我们在主方法main中调用我们自己定义好的方法,在主方法中,直接写要调用方法的名字就可以调用了
格式:方法名称();
public static void main(String[] args){
method() //这样就是调用方法
}
4.4方法定义的注意事项:
- 1、方法必须定义在类中方法外
- 2、方法不能定义在另一个方法里面
5、JShell的使用
-
dos窗口输入JShell,可以直接编写代码,不需要写类和方法,可以直接编译运行,回车即可
-
退出:/exit
-
JShell只适合片段代码的测试,建议代码写下方法中
6、流程控制:
6.1:概述:
概述:在一个程序执行过程中,各条语句的执行顺序对程序的结果是有直接影响到的,也就是说,程序的流程对运行结果有直接影响所以我们必须清楚每条语句的执行流程,而且很多时候需要通过控制语句的执行来实现我们要完成的功能;
6.2、顺序结构:
顺序结构:根据编写的程序,从上到下的执行;
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-heEJyfpp-1597327597938)(…/typora_picture/01-%E9%A1%BA%E5%BA%8F%E7%BB%93%E6%9E%84%E7%9A%84%E6%B5%81%E7%A8%8B%E5%9B%BE.png)]
6.3、判断语句:
1、if
if关系表达式{
语句体
}
public statci void main(String[] args){
int a = 10;
int b = 20;
if(a==b){
System.out.println("a=b");
}
System.out.println("结束");
}
-
首先判断关系表达式,看其结果是true还是false
-
如果是true,就执行语句体
-
如果 false,就不执行语句体
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SgdghokI-1597327597940)(…/typora_picture/02-%E5%8D%95if%E8%AF%AD%E5%8F%A5%E7%9A%84%E6%B5%81%E7%A8%8B%E5%9B%BE.png)]
2、if…else
if(关系表达式){
语句体1;
}else{
语句体2
}
public static void main(String[] args){
int a = 1;
if(a % 2 == 0){
System.out.println("a是偶数");
}else{
System.out.println("a是奇数");
}
}
执行流程:
- 首先盘算关系表达式看其结果是true还是false
- 如果是true,就执行语句体1
- 如果是false,就执行语句体2
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6TbuCs6x-1597327597942)(…/typora_picture/03-%E6%A0%87%E5%87%86if-else%E8%AF%AD%E5%8F%A5%E7%9A%84%E6%B5%81%E7%A8%8B%E5%9B%BE.png)]
3、if…else if…else
if(判断条件1){
执行语句1;
}else if(判断条件2){
执行语句2
}
……
}else if(判断条件n){
执行语句n;
}else{
执行语句n+1
}
public static void main(String[] args){
int score = 100; //score分数
if(score < 0 || score>100){
sout("你的成绩有误!");
} else if(score >= 90 && score <= 100){
sout("优秀");
}else if(score >= 80 && score < 90 ){
sout("好");
}else if(score >= 70 && score < 80 ){
sout("良");
}else if(score >= 60 && score < 70 ){
sout("及格");
}else{
sout("不及格");
}
}
//使用三元运算符取两个数中的最大值
public static void main(String [] args){
int a = 10;
int b = 20;
int max ; //定义变量存储最大值
if(a>b){
max = a;
} else{
max = b;
}
max = a > b ? a : b;
sout(max);
}
执行流程:
-
首先判断关系表达式1,看其结果是true,还是false
-
如果是true,就执行语句体1
-
如果是false就继续判断关系表达式2,看其结果是true还是false
-
如果是true ,就执行语句体2
-
如果是false,就继续判断表达式……,看其结果是true还是false
-
……
-
如果没有任何关系表达式为true,就执行语句体n+1
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rWQh5Tmy-1597327597945)(…/typora_picture/04-%E6%89%A9%E5%B1%95if-else%E8%AF%AD%E5%8F%A5%E7%9A%84%E6%B5%81%E7%A8%8B%E5%9B%BE.png)]
6.4、选择语句:
switch (表达式){
case 常量值1;
语句体1;
break;
case 常量值2;
语句体2;
break;
……
}
public statci void main(String[] args){
//根据输入的数字判断星期
Scanner sc = new Scanner(System.in);
int weekend = sc.nextInt();
System.out.println("请输入数字(1-7) : ");
switch(weekend){
case 1:
sout("星期一");
break;
case 2 :
sout("星期二");
break;
case 3 :
sout("星期三");
break;
case 4:
sout("星期四");
break;
case 5 :
sout("星期五");
break;
case 6 :
sout("星期六");
break;
case 7 :
sout("星期日");
break;
default :
System.out.println("你输入的数字有误");
}
}
执行流程:
-
首先计算出表达式的值
-
其次和case依次比较,一旦有相对应的值,就会执行想对应的额语句,在执行过程中,遇到break就会结束
-
最后,如果所有的case都和表达式的值不匹配,就会执行default语句部分,盘后程序结束
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k2uJSEM9-1597327597946)(…/typora_picture/switch%E8%AF%AD%E5%8F%A5%E6%B5%81%E7%A8%8B%E5%9B%BE.png)]
case穿透:
public static void main(String[] args){
int i = 5;
switch(i){
case 0:
System.out.println("执行case 0") ;
break;
case 5;
System.out.println("执行 case 5 ");
break;
case 10 ;
System.out.pritnln("执行case 10");
break; //这个break可以省略
default :
System.out.println("执行default");
}
}
在switch语句中,如果case后面不写break,就会出现穿透现象也就是不会判断下一个case的值,直接向后运行,直到遇到break,或者整体switch结束
综上所述,执行【case 5】,后面如果没有break,程序就会一直往下执行,不会判断case,直到遇到break或者运行完switch整体
6.4、循环语句:
1、for循环:
for循环的结构:
for(初始化表达式; 布尔表达式; 步进语句;){
循环体
}
//输出100次 helloworld
public static void main(String args[]){
for(int x = 1; x <= 100 ; x++){
System.out.println("helloworld" + i); //+i可以查到次数
}
}
//判断1-100之间的偶数和:
public static void main(String[] args){
int sum = 0;
for(int i = 1; i<= 100; i++){
if( i % 2 == 0){
sum+=1;
}
}
sout(sum);
}
执行流程:
-
执行顺序:1-2-3-4,——2-3-4——2-3-4……2不满足为止
-
1、负责完成循环的变量的初始化;
-
2、负责判断时候满足循环条件,不满足就跳出循环
-
3、执行具体的语句
-
4、循环后、循环条件所涉及变量的情况
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RpvcCV6i-1597327597947)(…/typora_picture/05-for%E5%BE%AA%E7%8E%AF%E7%9A%84%E6%B5%81%E7%A8%8B%E5%9B%BE.png)]
2、while循环:
while循环的格式:
初始化表达式1
while(布尔表达式2){
循环体3;
步进表达式4;
}
//输出10次helloworld
public static void main(String [] args){
int i = 1; //定义初始化变量
while(i<=10){
System.out.println("helloworld");
i++; //步进表达式
}
}
//计算1-100之间的和
public static void main(String [] args){
int sum = 0; //定义一个累计变量
int x = 1; //定义一个初始化表达式
while(i<=100){
sum+=1; //步进语句
}
System.out.println(sum)
}
执行流程:
-
执行顺序:1-2-3-4——2-3-4——2-3-4——2 不满足为止
-
1、负责完成循环的初始化
-
2、负责判断时候满足循环条件,不满足则跳出循环
-
3、执行具体的语句
-
4、循环后,置换变量的变化情况
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sipvpxc5-1597327597948)(…/typora_picture/06-while%E5%BE%AA%E7%8E%AF%E7%9A%84%E6%B5%81%E7%A8%8B%E5%9B%BE.png)]
3、do…while循环:
do…while循环格式:
初始化表达式1:
do{
循环体3
步进表达式4
}while(布尔表达式2);
//输出10次helloworld
public static void main(String [] args){
int x = 10;
do{
System.out.println("hellowprld");
x++;
}while(x<=10;);
}
do…while循环的特点:无条件执行一次循环体,即是循环条件是false,也会执行一次循环体,这样的循环具有一定的风险性;
执行流程:
-
执行顺序:1-3-4——2-3-4——2-3-4…2,不满足为止
-
1、负责完成村换变量的初始化
-
2、负责判断是否满足条件,不满足则跳出循环
-
3、具体执行的语句
-
4、循环后,循环变量的情况
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-09UaJcNv-1597327597949)(…/typora_picture/do%E2%80%A6while%E5%BE%AA%E7%8E%AF%E7%9A%84%E6%B5%81%E7%A8%8B%E5%9B%BE.png)]
6.5、循环语句的区别:
1、如果条件判断从来没有满足过,那么for和while将会被执行0次,但是do…while循环至少会执行一次
2、已知循环次数的时候用for,循环次数为止的时候推荐使用while循环
3、控制条件语句所控制的那个变量,在for循环结束后,就不能再被访问,而while循环结束还可以继续使用,如果想继续使用,就用while,如果不想使用就用for,因为for循环结束后,该变量就从内存中消失,能够提内存的使用效率(for循环的变量定义在小括号中,只能循环内部使用,while循环和do…while循环的初始化语句在循环外,所以出来循环还可以使用)
6.6、跳出语句(break、continue)
break:
-
使用场景:终止switch或者循环
-
1、在选择结构switch语句中
-
2、循环语句中
-
3、离开使用场景是没有意义的;
public static void mainn(String []args){ for(int x = 1; x<=10;x++){ //需求:数据两次helloworld就停止 if(x==2){ break; } System.out.println("helloworld"); } }
continue:
使用场景:结束本次循环,继续下一次循环
public static void main(String [] args){
for(int i = 1; i<=10; i++){
if(i==4){
continue;
}
System.out.println("helloworld"+"---"+i);
}
}
//跳过了4
/*
helloworld---1
helloworld---2
helloworld---4
helloworld---5
helloworld---6
helloworld---7
helloworld---8
helloworld---9
helloworld---10
*/
6.6、死循环:
1、死循环:
就是循环逇条件永远是true,死循环的永不结束的循环,例如:while(true){}。在后期开发中,出现死循环的场景例如:我们需要的读取用户数据的数据,但是用户输入了多少个数据我们并不知道,只能用死循环,单用具不想输入的数据了,就可以结束死循环,结束死循环的方法就需要使用到跳出语句了
2、嵌套循环:
嵌套循环:是指一个循环的循环体是另外一个循环,比如for循环里面嵌套一个for循环,总共循环的次数 = 外循环次数 + 内循环次数
for(初始化表达式;循环条件;步进表达式;){
for(初始化表达式;循环条件;步进表达式;){
执行语句
}
}
//打印输出5*8的矩形
public statci void main(String[] args){
//5行8列
for(int x = 0; x < 5 ; x++){
for(int y = 0; y<8;y++){
System.out.print("*");
}
System.out.println();
}
}
//九九乘法表
for (int x = 1; x <= 9; x++) { //x是列,y是行
for (int y = 1; y <= x; y++) {
System.out.print(y + "*" + x + "=" + y * x + "\t");
}
System.out.println();
}
/*
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
*/
7、idea快捷键
快捷键 | 功能 |
---|---|
alt+enter | 导包,自动补全代码 |
ctrl+y | 删除光标所在行 |
ctrl+d | 复制光标所在行,插入光标位置下面 |
ctrl +alt+L | 格式化代码 |
ctrl+/ | 单行注释 |
ctrl+shift+/ | 选中代码注释,多行注释,再按就取消注释 |
alt+ins(F12) | 自动生成代码toString,get,set |
alt+shift+上下箭头 | 移动当前行代码 |
tab | 代码右移 |
shift+tab | 代码左移 |
shift+alt+↑ | 代码上移 |
shift+alt+↓ | 代码下移 |
alt+7 | 类的大纲视图 |
ctrl+shift+alt+s | 查看项目属性 |
ctrl+alt+t | idea中try—cath |
ctrl+shift+alt+u | idea查看机场关系 |
shirt+enter | idea光标移动到下一行 |
debug快捷键:
-
**Show Execution Point (Alt + F10):**如果你的光标在其它行或其它页面,点击这个按钮可跳转到当前代码执行的行。
-
**Step Over (F8):**步过,一行一行地往下走,如果这一行上有方法不会进入方法。
-
**Step Into (F7):**步入,如果当前行有方法,可以进入方法内部,一般用于进入自定义方法内,不会进入官方类库的方法。
-
**Force Step Into (Alt + Shift + F7):**强制步入,能进入任何方法,查看底层源码的时候可以用这个进入官方类库的方法。
-
**Step Out (Shift + F8):**步出,从步入的方法内退出到方法调用处,此时方法已执行完毕,只是还没有完成赋值。
-
**Drop Frame (默认无):**回退断点,后面章节详细说明。
-
**Run to Cursor (Alt + F9):**运行到光标处,你可以将光标定位到你需要查看的那一行,然后使用这个功能,代码会运行至光标行,而不需要打断点。
-
**Evaluate Expression (Alt + F8):**计算表达式
for循环的简单使用:
20.fori —— for (int i = 0; i < 20; i++)
8、方法:
package cn.itcast.day04.demo02;
/**
* 方法其实就是若干语句的功能集合
* 方法:(好比一个工厂)
* 参数:进入方法的参数
* 返回值类型:从方法出来的数据
*
* 定义方法的完整格式:
* 修饰符 返回值类型 方法名称(参数类型 参数名称,……){
* 方法体
* return
* }
*
* 修饰符 public static
* 返回值类型:方法最终产生的数据结果的是什么类型
* 方法名称:方法的名字,规则和变量一样,小驼峰
* 参数类型:进入方法的数据是什么类型
* 参数名称:进入方法对应的变量名称
*
* 注意参数如果有多个,使用逗号隔开
* 方法体:方法要做的事情
* return :两个作用:
* 1、停止当前方法,
* 2、将后面的返回值还给屌用处
*
* 返回值:就是方法执行后最终产生的数据结果
*
* return后面的返回值类型必须和方法名称前面的返回值类型保持一致
*
* //定义一个两个int类型的数值相加,
* 返回值类型:int
* 方法名称:sum
* 参数列表:int a ,int b
*
*
* 方法的三种调用格式:
* 1、单独调用:(方法名称(参数))
* 2、打印调用 (System.out.println(sum(10,20)))
* 3、赋值调用
*
* */
public class Demo02Method {
public static void main(String[] args) {
//单独调用
sum(10,20);
//打印调用:
System.out.println(sum(10,20));
//赋值调用
int number = sum(10,20); //30
number+=100; //30+100
System.out.println("number = " + number);
}
private static int sum(int a, int b) {
System.out.println("方法执行了!");
int result= a+b;
return result;
}
}
package cn.itcast.day04.demo02;
/**
* 方法有参数:
* 小括号当中有内容,当有个方法需要一些数据条件才能完成任务,就会有参数,
* 例如两个数相加,鄙俗知道两个数字是多少
* 方法没有参数:
* 小括号当中留空,一个方法不需要任何数据条件,自己能够独立完成任务,就是无参数
* 例如:定义方法,打印固定10次的helloworld
*
*
*
* */
public class Demo03MethodParam {
public static void main(String[] args) {
method1(10,29);
method2();
}
public static void method1(int a ,int b ){
//两个数字相乘,做乘法,必须知道两个数字的是多少,否则无法计算
//有参数
int result= a*b;
System.out.println("result = " + result);
}
public static void method2(){
for (int i = 0; i < 10; i++) {
System.out.println("HelloWorld");
}
}
}
使用方法的注意事项:
- 1、方法定义在类中,但不能定义在 方法中,不能嵌套使用
- 2、方法定义的顺序没有要求
- 3、方法定义了不会马上执行,需要调用,
- 4、如果方法有返回值,就必须写上return
- 5、return后面的额返回值类型,必须和方法的返回值类型相对应
- 6、对于一个void没有返回值的方法,不能写return后的的返回值,只能写return,没有返回值的return只是结束党发的执行
- 7、对方法的最后一行的return,可以省略不写
- 8、一个方法有很多的return语句,但是必须保证同时只会有一个被执行
public static void Method(){
System.out.println("ccc");
System.out.println("qqq");
return //可以省略
}
public static void method(){
return 10; //错误的
//因为方法没有返回值
}
public statici int method(){
return 10;
}
1、重载:
* 重载:
* 对于功能类似的方法来说,因为参数列表不同,却需要记住这么多的方法名称,太麻烦,
*
* 为了解决这个问题,java就提供了方法的重载(OverLoad)
* 方法的重载:多个方法的名称一样,但是参数列表不同
*
* 优点:只需要记住唯一的一个方法名称,简便
*
* 注意事项:
* 1、参数的个数不同,
* 2、参数的类型不同
* 3、参数的顺序不同
*
* 方法重载与下列因素无关:
* 1、与参数的名称无关
* 2、与方法的返回值类型无关
public class DemoMethodOverLoad {
public static void main(String[] args) {
// System.out.println(sumTwo(10,20));
// System.out.println(sumThree(10,20,30));
// System.out.println(sumFour(10,20,30,40));
System.out.println(sum(10,30));
System.out.println(sum(10,20,30,30));
System.out.println(sum(1.1,1.9));
}
两个数相加
// public static int sumTwo(int a, int b) {
return a + b;
}
//三个数相加
public static int sumThree(int a, int b, int c) {
return a + b + c;
}
//四个数相加:
public static int sumFour(int a, int b, int c, int d) {
return a + b + c + d;
//两个数相加
public static int sum(int a, int b) {
return a + b;
}
//三个数相加
public static int sum(int a, int b, int c) {
return a + b + c;
}
//四个数相加:
public static int sum(int a, int b, int c, int d) {
return a + b + c + d;
}
public static int sum(double a,double b){
return (int)(a+b);
}
}
9、数组:
1、数组概念:
概念:数组就是存储数据长度固定的容器,保证多个数据的数据类型要一致
2、数组的定义:
两种常见的初始化:
- 动态初始化:(指定长度)
- 静态初始化:(指定内容)
方式1:动态初始化:(指定长度)
格式:数据存储的数据类型[ ] 数组名字 = new 数组存储的数据类型[长度];
int [] arr = new int[100]; //存储100个int类型的数据
String [] arr = new String[5] //存储5个String的字符串
方式2:静态初始化:(指定内容)
格式:数据类型[ ] 数组名 = new 数据类型[ ] {元素1、元素2、元素3……};
int [] arr = new int[]{1,2,3,4,5……}
方式3:静态初始化:(指定内容)(优化)
格式:数据类型[ ] 数组名= {元素1,元素2、元素3……};
int [] arr = {1,2,3,4,5};
注意:
* 注意事项:
1、数组有定长特性,长度一旦指定,不可以更改
* 2、静态初始化没有指定长度,但是仍然会自动推算得到长度
* 3、静态初始化标准格式可以拆分为两个步骤:
* int[] arr;
* arr = new int[] {1,2,3,4,5};
* 4、静态初始化一旦使用省略格式,就不能拆分两个步骤
使用建议:
如果不确定数组当中的具体内容,就用动态初始化(指定长度),否则,已经确定了具体的内容就使用静态初始化(指定内容)
3、数组的访问:
索引:
-
每一个存储到数组的元素,都会自动编号,称为数组索引(index),可以通过数组的索引访问到数组的元素
-
数组名[索引]
-
注意:索引元素从0开始,一直到【数组的长度-1】为止
数据长度的属性:
每一个数组都有长度,而且是固定的,java中赋予了数组的一个属性,可以获取到数组的长度,,语句为(数组名.length),属性length的执行结果就是数组的长度,int类型的结果,由此可以推出数组的最大索引值为(数组名.length-1)
public static void main(String [] args){
int [] arr = int [] {1,2,3,4,5,5}
System.out.println(arr.length) //输出数组的长度
}
使用动态初始化数组的时候,那么其中的元素将会拥有一个默认值,规则如下:
- 如果是整数类型:默认是0
- 如果是浮点类型:默认是0.0
- 如果是字符乐行:默认是’\u0000’
静态初始化其实也有默认值的过程,只不过系统自动马上将默认值替换为大括号当中具体的数值
int[] arr = new int[3];
System.out.println(arr); //[I@1c53fd30
System.out.ptinyln(arr[0]); //0
System.out.println(arr[1]); //0
//赋值
arr[1] = 123;
sout(arr[1]) //123
4、java内存的划分:
1、栈(Stack)
存放的都是方法中的局部变量,【方法的运行一定在栈中】
- 局部变量:方法的参数,或者是{} 内部的变量
- 作用域:一旦超出作用域,就会从栈内存中消失
2、堆(Heap):
【凡是new出来的东西,都在堆内存中】,堆内存里面的东西都有一个地址值:16进制,堆内存中的数据都有默认值,规则:
- 如果是整数: 默认是0
- 如果是浮点数:默认是0.0
- 如果是字符 默认是’\u0000’
- 如果boolean 默认是false
- 如果 引用类型 默认是null
3、方法区(Method Area):
存储class相关的信息,包含方法 的信息
4、本地方法栈(Native Method Stack):
与操作系统相关
5、寄存器(PC Register)
与cpu相关
5、索引越界:ArrayIndexOutOfBoundsException
原因:索引编号写错了,索引从0开始,长度是:数组名.length
解决:写上正确的索引编号
6、空指针异常:NullPointerException
- 数组必须进行new初始化才能使用元素,没过只是赋值一个null,没有进行new的创建,就会发生空指针异常
- 原因:没有new
- 解决:补上new
7、获取数组长度:
格式:数组名.length
public static void main(String[] args){
int [] arr = new int[3];
System.out.println(arr.length); //3
int [] array = {1,2,3,4,5};
Sysstem.out.println(array.length); //5
}
8、数组的遍历:
public static void main(String[] args){
int [] arr = {1,2,3,4,5};
for(int x= 0; x<arr.length; x++){
System.out.println(arr[x]); //1 2 3 4 5
}
}
9、数组元素的反转:
数组的反转:对称位置的元素交换,1,2,3,4,5反转为1,5,4,3,2,1
实现思想:数组的元素互换位置
package Demo01;
public class Demo06ArrayReverse {
public static void main(String[] args) {
int [] array = {10,20,30,40,50};
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
System.out.println("===============");
/**
* 初始化语句:int min= 0, max = array.length
* 条件判断:min<max
* 步进表达式:min++,max--
* */
for (int min = 0, max = array.length - 1; min < max; min++, max--) {
int temp = array[min];
array[min] = array[max];
array[max] = temp;
}
//反转后遍历
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
//3
int [] array = {1,2,3,4,5};
Sysstem.out.println(array.length); //5
}
### 8、数组的遍历:
```java
public static void main(String[] args){
int [] arr = {1,2,3,4,5};
for(int x= 0; x<arr.length; x++){
System.out.println(arr[x]); //1 2 3 4 5
}
}
9、数组元素的反转:
数组的反转:对称位置的元素交换,1,2,3,4,5反转为1,5,4,3,2,1
实现思想:数组的元素互换位置
package Demo01;
public class Demo06ArrayReverse {
public static void main(String[] args) {
int [] array = {10,20,30,40,50};
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
System.out.println("===============");
/**
* 初始化语句:int min= 0, max = array.length
* 条件判断:min<max
* 步进表达式:min++,max--
* */
for (int min = 0, max = array.length - 1; min < max; min++, max--) {
int temp = array[min];
array[min] = array[max];
array[max] = temp;
}
//反转后遍历
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}