文章目录
JavaEE知识总结
前言
Java学习需要的准备工作
1.做笔记
2.多动手实际操作
3.养成写注释的好习惯
4.写程序前，着急写程序远不如先把思路捋清
一、计算机的基础知识（了解即可）
作为一个Java小白，It小白，有必要先从计算机开始了解一波，不需要熟记，但是要有一个印象。
1.什么是计算机
能够处理海量数据，并且能够告诉运转程序的一套电子设备
例如：云计算、多媒体应用
2.计算机的组成
计算机是由软件和硬件组成
因为要向程序员发展，所以先不研究硬件
软件：
系统软件
例如：windows系统、Linux系统、MAC系统
应用软件
客户端软件（QQ....）
3.软件结构的划分
C\S结构：客户端和服务端的交互
特点：需要程序连接服务端才能使用
B\S结构：浏览器和服务端的交互
特点：只需要浏览器即可使用
4.人机交互方式
图像化界面方式
特点:简单、易上手、直观
命令行方式
特点：需要使用指令
二、常见的DOS指令
1.进入DOS命令
1).windows10系统左下方---开始菜单---输入cmd---命令提示符---右键---进入DOS命令
2).windows键+R键---输入cmd---进入DOS命令[推荐使用]
2.常见的DOS命令(熟练使用)
d:
盘符切换:可直接切到想要的盘符.[大写小写均可]
dir:
罗列当前盘符或目录下的所有文件或文件夹的相关信息.
cd:
cd 文件夹名称;可以进入到当前盘符下的指定目录中
也可以进入多级目录.目录之间用\隔开,但是只能是当前盘 符的目录.
cd..
返回上一级目录
cd \
直接退回当前目录的根目录
cls
(clean screen)清除屏幕
md
md 文件夹名称 ---在当前目录下创建新的文件夹
copy con
copy con a.txt(a为文件夹名称,必须带后缀)---回车- --进入编辑模式,编辑完成后---按ctrl+z---回车
del
del 文件名称 ---删除当前目录下的单个文件
del *.文件后缀名称 ---批量删除当前目录下所有指定结 尾的后缀名称
rd
rd 目录名称 ---删除目录(只能删除空目录)
rd /s
rd /s文件夹名称 ---删除带内容的目录
回车以后会询问是否删除
rd /s /q ---暴力删除(不会询问是否删除,不建议使 用)
其他常用的DOS命令
ipconfig
在windows系统下查看我的ip地址(ipv4)
ifconfig
在Linux系统下查看ip地址
ping
ping ip地址 ---查看自己主机和其他机器之间是否 能够通信
三、Java语言的历史
Java之父----詹姆斯高斯林
1995年由Sun公司发布了Java1.0版本
1998年发布java1.1版本
2009年由Oracle甲骨文公司收购Sun公司
2011年由Oracle公司发布Java1.7版本
2014年发布Java1.8版本
2017年发布Java1.9版本
四、Java语言的平台版本
Java有三个平台版本
JavaSE:
针对桌面应用程序的开发
例如:桌面网络聊天室
JavaME:
针对嵌入式提供的一套解决方案
例如:移动端开发
JavaEE:
针对企业级开发的解决方案
针对web程序的开发
五、JDK、JRE、JVM
JDK
Java运行环境
包含JRE+类库+开发工具包
JRE
Java开发环境
包含JVM和解释器
JVM
虚拟机
在虚拟机中模拟不同的操作系统的运行环境
想运行一个已有的java程序,那么只需要安装JRE即可
想要开发一个新的Java环境,那么必须安装JDK
JDK包含于JRE包含于JVM
六、Java语言的特点
Java语言的特点有简单性、解释性、面向对象、高性能、分布式处理、多线程、健壮性、动态、结构中立、安全性、开源、跨平台
其中最重要的两个特点为开源、跨平台
而跨平台是有JVM来实现的,如下图所示:Java虚拟机本身是不具备跨平台的功能的,每个操作下都有不同版本的虚拟机
由此来实现一次编译,到处执行
七、配置Java环境
方法一:配置环境变量
windows--->桌面--->此电脑--->右键--->属性--->高级属性配置--->环境变量
把安装好JDK目录下的bin目录地址添加到path第一行即可
方法一的弊端:一旦发生需要更改目录的情况,改动过程中需要很小心,以防出现误删的情况,一旦出现,就会导致path出错;
这时就需要方法二来进行更稳妥的解决
方法二:配置Java_HOME (Java的家)
新建一个系统变量Java_HOME,变量值为JDK的安装目录
方法二的好处:以后只需要改Java_HOME中的变量值即可,不需要改path
变量值即JDK的安装目录
path环境变量的执行流程
需要在当前路径下找这个文件
如果找到了就进行编译
如果没找到,就在配置的系统变量path中找JDK的bin目录,如果里面没有,那就证明没有找到文件.
classpath:(了解)
临时环境变量
目前使用非常少,早期使用,当前执行某个java文件的时候,优先执行我指定路径下的文件
需要在系统变量---新建变量名:classpath 直接找到这个 xx.class文件
执行流程:是先在当前指定的classpath这个路径地下找对应class字节码文件,
有的话直接运行,没有的话,就出现加载不了主类;
书写第一个HelloWorld
需要JDK里的两个文件
javac.exe
编译指令:将写好的Java文件进行编译
java.exe
运行指令:运行java程序编译以后产生的.class文
class HelloWorld{ //HelloWorld 为类名(建议和文件名称一致)
//程序入口,可以被JVM识别的main方法
public static void main(String[] args){
//输出一句HelloWorld
System.out.println("HelloWorld");
}
}
1.进入DOS控制台
2.使用 cd 切换到HelloWorld.Java所在的目录地址
3.编译HelloWorld.Java文件
javac HelloWorld.Java
此时若没有问题则会产生类名.class文件(HelloWorld.class)
4.运行字节码文件
java HelloWorld
5.显示运行结果: HelloWorld
八、关键字/注释/标识符
关键字
什么是关键字
被Java语言赋予特定含义的单词
在高级记事本或者开发工具idea/eclipse,针对关键字会有特殊颜色标
目前遇到的关键字有class public static void
关键字不需要死记硬背,多应用,自然会得心应手
组成标识符的注意事项
1.数字不能开头
2.Java中严格区分大小写
3.写标识符的时候一定要"见名知意"
4.Java中的关键字不能作为"标识符"
注释
1.单行注释
在//后书写注释,只能写一行
//单行注释
2.多行注释
/*
在行内容加上文字描述
*/
3.文档注释
/**
文档注释:后期可以通过JDK的bin目录有一个javadoc.exe
解析文档注释的
*/
标识符
什么是标识符
标识符是一种给类名,方法名,接口名,变量名,常量等,起名字的一个字符序列
必须"见名知意"
标识符组成的规则:
1. 26个英文字母
2. $符号
3. _下划线
4. 数字字符
给类起名字
遵循"大驼峰命名法"
即:首字母大写,其他单词小写
例如 class Demo
class HelloWorld
给方法和变量名起名字
遵循"小驼峰命名法"
即:如果单个字母则小写,如果多个单词则从第二个单词首字母大写
例如 int num = 20;
int studentAge = 20;
九、常量
常量的定义
常量是指在程序执行过程中,其值不会发生改变的量
常量的分类:
字面值常量
字符串常量
使用双引号("") 例如:"hello"
字符串+任何数据="新的字符串" -->此时的"+"是字符串拼接符号
任何数据+字符串="新的字符串" -->此时的"+"是字符串拼接符号
字符常量
使用单引号('') 例如':a','A','1'
注意:'ab'不行
整数常量
例如:100,88
进制也属于常量
小数常量
例如:1.34/12.56
布尔常量
例如:true/false
空常量
例如:null
自定义常量:(面向对象------final关键字)
十、进制
进制
属于常量的范畴
是数据进位的一种方式
二进制(0b开头) 逢二进一
八进制(0开头) 逢八进一
十进制 逢十进一
十六进制(0X开头) 逢十六进一
进制转换
任意进制转十进制
使用位权展开法
将当前系数乘以基数的权次幂相加的结果---得到十进制数据
系数:就是当前每个位上的数据本身
基数:几进制基数就是几
十进制转任意进制
使用当前数据本身除以基数,取余,直到除到商为止,余数反转!
二进制与十进制之间快速转换-->8421码
1 1 1 1 1 1 1 1 二进制
--------------------------------
128 64 32 16 8 4 2 1 十进制
例如:0B10010转十进制--->对照上表
16+0+0+2+0=18
100转二进制
64+32+0+0+4+0+0=100
0B1100100
二进制转八进制
方法一:先由二进制转十进制
先由十进制转八进制
方法二:(快捷)
二进制数据,从右边往左边,每三个比特位一组数据,然后分别算出十进制
最后从左到右一次排列.即是八进制
十一、原码\反码\补码
计算机底层对数据的计算----使用"补码"进行计算
一个整数有两个部分组成:最高符号位和数值位组成
例如:1000010
符号位 数值位
1 000010
正数的原码,反码,补码相同
负数的反码
在原码的基础上,符号位不变,数值位按位取反(1变0,0变1)
负数的补码
在反码的基础上,符号位不变,数值位+1
十二、变量
变量的定义
在程序运行过程中,其值会发生变化的量
变量的三要素
1.数据类型
2.变量名(使用小驼峰命名法)
3.初始化值:
变量的格式
格式一:
数据类型 变量名 = 初始化值;
格式二:
数据类型 变量名;
变量名 = 初始化值;
变量使用的注意事项
1.按照标识符的组成格规则,使用"小驼峰命名法"
2.语句结束后,一定加上英文的分号(;)
3.变量一样要先赋值,再使用
4.同一个变量名,不能多次被定义
十三、Java中的数据类型(重点)
数据类型分类
基本数据类型
整数类型:(默认int类型)
byte 字节类型 占用1个字节
short 短整类型 占用2个字节
int 默认类型 占用4个字节
long 长整类型 占用8个字节
例如:
byte num01 = 12;
short num02 = 159;
int num03 = 41;
long num04 = 12345698745L;
浮点类型:(默认double类型)
float 单精度类型 占用4个字节
double 双精度类型 占用8个字节
例如:
folat a = 1.45F;
double b = 12.98;
字符类型
char 占用2个字节
例如:
char ch = 'A'; //根据ASCII码表,输出结果为:65
char ch02 = 'a';//根据ASCII码表,输出结果为:97
char ch03 = '0';//根据ASCII码表,输出结果为:48
布尔类型
boolean (true/false) 占用1个字节
例如:
boolean x = true;
引用数据类型
引用类型包括:类,数组,接口等
基本类型使用注意事项
1.定义long类型时,必须后面加上"L"或者"l";
2.定义float类型时,必须后面加上"F"或者"f";
十四、数据类型转换
数据类型转换
当取值范围不同的数据类型进行运算时会发生数据类型转换
byte,short,char不会相互转换,但是分别参与运算时会优先提升为int
数据类型转换分类
隐式转换
默认类型转换
byte,short,char不会相互转换,但是分别参与运算时会优先提升为int
显示转换
强制类型转换
运算时将取值范围较大的数据类型转换成取值范围较小的数据类型时,需要使用强制类型转换
转换格式
目标数据类型 变量名 = (目标数据类型)(初始化值);
boolean不参与任何转换,它只是描述
十五、运算符
运算符分类
算术运算符:
+,-,*,/(默认取整),%(模,取余)
++/--
对当前数据进行之自增1或者自减1
++/--在数据的前面,先自增或者自减,然后再参与运算
++/--在数据的后面,先参与运算,然后再自增或者自减
赋值运算符:
=
将等号右边的数据赋值给等号左边的变量
+=,-=,*=,/=,%=
特点:隐藏了强制类型转换
例如:
short s = 1;
s = s + 1;//不兼容的类型,因为程序在执行s+1时会自动转换为int
s += 1;//可以执行,相当于 s = (short)(s+1);
关系(比较)运算符:
<,>,<=,>=,!=,==
比较运算符的表达式最终的结果都是booolean
注意:==和=的区别,前者被用来比较,后者被用来赋值
逻辑运算符:
逻辑单与----&
特点:有false则false
逻辑单或----|
特点:有true则true
逻辑异或----^
特点:相同则为false,不同则为true
逻辑非 ----!
特点:非true,则为false,非false,则为真
偶数个非是他本身
逻辑双与(短路与)----&&
特点:
相同点:和逻辑单与----&一样有false则false
不同点:具有短路效果,即左边一旦为false,右边便不再执行
逻辑双或(短路或)----||
特点:
相同点:和逻辑单或----|一样有true则true
不同点:机油短路效果,即左边一旦为true,右边便不再执行
位运算符
所有的位运算都是基于二进制的补码来进行计算的
位与 &
有0则0
例如:
3 & 2
00000000 00000000 00000000 00000011 3的补码
00000000 00000000 00000000 00000010 2的补码
=======================================
00000000 00000000 00000000 00000010 结果为:2的补码
将结果得出的补码转换为原码.因此结果为2
位或 |
有1则1
例如:
3 | 2
00000000 00000000 00000000 00000011 3的补码
00000000 00000000 00000000 00000010 2的补码
=======================================
00000000 00000000 00000000 00000011 结果为:3的补码
位异或 ^
相同则为0,不同则为1
一个数据被另一个数据异或两次,其值是它本身
例如:
3 ^ 2
00000000 00000000 00000000 00000011 3的补码
00000000 00000000 00000000 00000010 2的补码
=======================================
00000000 00000000 00000000 00000001 结果为:1的补码
反码 ~
全部按位取反(0变1,1变0);
左位移 <<
将这个数据的补码向左移动,将高位丢弃,右边补0
快速应用:
将<<符号左边的数据乘以2的移动次幂
右位移 >>
将这个数据的补码向右移动,最高位是0则补0,最高位是1则补1
快速应用:
将>>符号左边的数据除以2的移动次幂
无符号右移 >>>
无论最高位是1还是0,在左边始终补0
三元(三目)运算符
格式
(表达式) ? 执行true的结果 : 执行false的结果;
例如:
int a = 12;
int b = 13;
int max = (a > b) ? a : b;
System.out.println(max);//此时max就为a和b之间的最大值;
十六、键盘录入
/*
在写程序的过程中,想让程序更加灵活,使用Scanner类(一个简单的文本扫描器)
操作步骤
1)导包-->import(关键字) java.util.Scanner;
必须在class类的上面
2)创建一个文本扫描器对象(键盘录入对象)
Scanner 对象名 = new Scanner(System.in);
3)提示,并录入类型数据
System.out.println("请您输入数据:");
int(数据类型) 接收的变量名 = 对象名.nextInt();
*/
import java.util.Scanner;
class InputExercise{
//编写一个方法
public static void main(String[] args){
//创建一个文本扫描器
Scanner sc = new Scanner(System.in);
//提示输入
System.out.println("请输入整数");
//定义int接收数据
int a = sc.nextInt();
System.out.println("a的值为:" + a);
}
}
十七、流程控制语句
流程控制语句分类
顺序结构语句
顺序结构语句即是代码由上而下依次执行,依次加载
选择结构语句
选择结构语句—if语句
格式一:
if(条件表达式){
语句;
}
执行流程:
1.若当前条件表达式成立,则执行语句
2.若不成立,则不执行;
应用场景
对单个条件进行判断
格式二:
if(表达式){
语句1;
}else{
语句2;
}
执行流程:
1.判断当前条件表达式是否成立,执行语句1
2.若不成立,则执行语句2;
应用场景
针对两种情况进行判断
格式二的嵌套
if(表达式1){
if(表达式2){
语句1;
}else{
语句2;
}
}else{
if(表达式3){
语句3;
}else{
语句4;
}
}
执行流程:
1.先判断表达式1是否成立,如果成立
2.执行里面的if语句
①判断表达式1是否成立,如果成立,执行语句1
②如果不成立,执行语句2
3.如果第一次判断表达式不成立,则执行else中的if语句
①判断表达式3是否成立,如果成立,执行语句3,
②如果不成立,则执行语句4;
格式三:
if(表达式){
语句1;
}esle if(表达式){
语句2;
}else if(表达式){
语句3;
}
...
...
}else {
语句n
}
执行流程:
1.判断表达式1是否成立,如果成立,则执行语句1;
2.如果不成立,继续判断表达式2是否成立;如果成立,则执行语句2;
...
...
3.如果上面的都不成立,则执行else中的语句n
if语句格式二和三元运算符的区别
if...else不仅可以操作具体的数据值,还可以操作语句System.out.println("提示信息...");
三元运算符只是运算符,只能操作具体的数据值,不能操作语句System.out.println("提示信息...");
选择结构语句—switch语句
格式:
switch(表达式){
case 值1:
语句1;
break;
case 值2:
语句2;
break;
...
...
...
default:
语句n;
break;
}
执行流程:
1.判断表达式的值和case值1是否匹配,
如果匹配成功,执行语句1,break结束
2.如果case值1不匹配,继续和case值2进行计较,如果匹配成功,执行语句2,break结束
...
...
如果上mian的case的值都和switch中的表达式都不匹配,那么就执行default中的语句n,然后程序默认执行到末尾了.break结束;
switch中的表达式可以是什么数据类型
基本的能够使用的数据类型
byte,short,int,char
JDK5以后,可以使用枚举
JDK7以后,可以使用String类型
switch语句的注意事项:
1.case语句后面只能是常量
2.case语句中必须带break
如果不带break;会造成case穿透;即如果case已经匹配,但是没有break;就会继续执行下一个case的语句,直至遇到break或者程序结束.
3.switch结束条件
3.1语句break结束
3.2程序默认结束到末尾
4.default语句可以在switch中的任意一个位置,不影响程序的执行流程
循环结构语句
for循环
格式:
for(初始化语句;条件表达式;控制体语句){
循环体语句;
}
执行流程:
1.初始化语句进行赋值,只执行一次
2.然后判断条件表达式是否成立
如果成立,执行循环语句体语句;然后执行控制体语句
3.继续判断条件表达式是否成立
如果成立,执行循环语句体语句;然后执行控制体语句
...
...
4.执行到条件表达式不成立为止
5.for循环结束
while循环
格式
初始化语句;
while(条件表达式){
循环体语句;
控制体语句;
}
执行流程
1.初始化语句进行赋值
2.判断条件表达式是否成立
如果成立,执行循环体语句,然后执行控制体语句
3.继续判断条件表达式是否成立
...
...
4.直到条件表达式不成立,while循环结束
while循环和for循环的区别
共同点
都能描述循环思想,将重复度高的代码进行优化,解决冗余度问题
不同点
1.格式上的不同
for(初始化语句;条件表达式;控制体语句){
循环体语句;
}
初始化语句;
while(条件表达式){
循环体语句;
控制体语句;
}
2.内存角度:
for循环使用完毕以后,当前的变量会被没存释放掉
while不会,它始终可以访问到这个变量,
因此for循环更节省空间
3.当明确循环次数时一般使用for
当不明确循环次数时,一般使用while;
do…while循环
格式
初始化语句;
do{
循环体语句;
控制体语句;
}while(条件表达式);
执行流程
1.执行初始化语句;
2.执行条件表达式,如果条件表达式不成立,煦暖体至少执行一次
如果条件成立,依次执行循环体语句和控制体语句
do…while和其他循环语句的区别
无论条件表达式成不成立,循环体都至少执行一次;
死循环
应用场景:
当一些条件需要被重复使用时,需要死循环,比如,当客户输入密码时,如果密码错误,需要重复输入,直到输入正确为止;
格式一
for(;;){
//业务操作
}
格式二
while(true){ //经常使用
//恒成立
//业务操作
}
生成一个随机数
//JDK提供的一个数学运算类java.lang.Math(是一个工具类)
//可以针对三角函数,对数,指数等等进行数学运算
//提供的方法为:
public static double random();
格式
int 变量名 = Math.random()[0.0~1.0)//生成一个0.0到1.0的随机数
for循环嵌套
格式
for(初始化语句1;条件表达式1;控制体语句1){
for(初始化语句2;条件表达式2;控制体语句2){
循环体语句2;
}
循环体语句1;
}
执行流程
1.执行初始化语句1
2.判断条件表达式1是否成立;
如果成立,执行初始化语句2;
判断条件表达式2是否成立,
如果成立,执行循环体语句,接着执行控制体语句
直到条件表达式2不成立
3.执行循环体语句1
3.接着判断条件表达式1是否成立;
如果成立,执行初始化语句2;
判断条件表达式2是否成立,
如果成立,执行循环体语句,接着执行控制体语句
直到条件表达式2不成立
...
...
4.直到条件表达式1不成立,循环结束
跳转控制语句
1. break
break:用来结束当前循环
不能单独使用,会报错
使用场景:
1.switch语句中
2.循环结构语句中
for/while都可以使用
2. continue
continue:跳出本次循环
一般都在循环语句中使用;
表示结束当前循环,立即进入下一次循环
3. return
return:返回结果------>在方法中使用
结束方法时使用
当方法具有返回值类型时可以使用return
十八、方法
方法的概念
方法就是使用{}代码块把一些业务代码包裹起来
有返回值方法的定义
方法名：
用{}包裹起来的业务代码块的名字
定义方法：
权限修饰符 static 返回值类型 方法名（参数类型1 变量名1.....）{
完成代码的业务逻辑
return 结果；
}
详细解释：
权限修饰符：现固定使用public :访问权限足够大
目前方法必须带static 目前的写法:public static
返回值类型:
就是数据类型---基本数据类型
方法名:
给{}代码块起名字,见名知意,"小驼峰命名法"
参数列表:
参数类型---数据类型,目前使用基本数据类型
变量名---给当前形式参数起名字,见名知意,"小驼峰命名法"
return 结果:
返回值类型和调用的类型一致
调用方法
赋值调用:推荐使用
两个明确:
1.明确要使用的返回值类型---数据类型
2.明确形式参数类型以及形式参数个数
方法调用的注意事项
1.方法和方法不能进行嵌套,是平级关系
2.定义方法的时候需要两个明确
2.1:明确返回值类型
2.2:明确形式参数类型以及形式参数个数
3.在定义方法时,形式参数必须携带数据类型
4.在实际参数main中实际参数不需要携带数据类型,因为键盘录入时已经定义过了
5.实际参数调用形式参数时,数据类型需要一一对应
无返回值方法的定义
应用场景
需要直接输出在控制台的,并没有具体的返回值类型结果
根据Java语言规定,使用void关键字填充这个格式
定义格式
权限修饰符 静态修饰符 void 方法名(形式参数列表){
//业务逻辑
输出或者类似数组中(数据进行互换:排序)
}
调用方法
输出调用
赋值调用
单独调用:(推荐使用)
十九、数组
什么是数组
数组就数能够储存同一种数据类型的容器
必须是同一种类型的元素
例如:
数组是int类型,那么就不能出现其他数据类型
Java中的内存分配
栈内存
存放局部变量,即在方法定义或者方法声明上的变量
堆内存
存放对象,即new出来的
举例:
new Scanner(System.in);
new arr[3];
方法区
class(字节码文件区域)
static区域:静态相关
字符串常量池
寄存器
和cpu有关
本地方法区
和系统有关
创建对象时内存处理过程
例如:
int[] arr = new[3];
首先,Java中方法区的main方法以压栈的形式进栈,
main方法在栈中开辟一个内存空间
然后,局部变量(int[] arr)开辟一个栈内存空间
接着,在堆内存中创建一个对象new[3],产生堆内存空间
此时对象会生成一个内存地址,把这个内存地址返回给局部变量(int[] arr)
最后,局部变量(int[] arr)指向内存地址,内存地址指向对象new[3];
数组的格式
格式:
1.数组类型[] 数组名称;
2.数据类型 数组名称[];
注意事项:
数组本身就属于引用数据类型
可以放同一种类型元素或者同一类型的引用类型
数组初始化
1.动态初始化的格式
我们只给定数组的长度,数组的元素内容有系统默认初始化!
默认初始化:
默认初始化是系统给定的,根据数组中储存的数据类型来判定
例如:int类型的默认值为0
double类型的默认值是0.0;
格式
数据类型[] 数组名称 = new 数据类型[数组长度];(推荐)
数据类型 数组名称[] = new 数据类型[数组长度];
例如:
int[] arr = new int[3];
解析上面的格式int[] arr:
int:当前数组中储存的元素与int数据类型
[]:表示一维数组
arr:表述当前数组的对象名称
解析上面的格式new int[3];
new:创建对象(在堆内存中)
int[]:表示创建的是int类型到一维数组
3:给定数组长度为3
2.静态初始化
我们给定数组元素的内容,由系统来默认分配长度
格式:
数据类型[] 数组名称 = new 数组类型{元素1,元素2,元素3...};(推荐)
数据类型 数组名称[] = new 数据类型{元素1,元素2,元素3...};
简化格式:(使用更多一些);
数据类型[] 数组名称 = {元素1,元素2,元素3...};
数据类型 数组名称[] = {元素1,元素2,元素3...};
注意事项:
创建数组时,不能即动态初始化,还静态初始化;
例如:
int[] arr = new int[3] {1,2,3};//错误
数组遍历
数组的遍历,即是把数组中的元素一一输出出来;
代码举例
class AyyayDemo{
//编写一个主方法
public static void main(String[] args){
//创建一个静态初始化数组
int[] arr = {12,54,21,87,34};
//直接调用遍历方法即可
printArray(arr);
}
//编写遍历数组的方法
public static void printArray(int[] array){
System.out.println("[");
//i为数组元素下标
//.length为数组的长度;(可以自动获取数组长度);
for(int i = 0; i < array.length; i++){
if(i == array.length-1){
System.out.println(array[i] + "]");
}else{
System.out.print(array[i] + ", ");
}
}
}
}
数组的高级排序_冒泡排序
冒泡排序思想
数组中两两相互比较,将较大的值往后放,第一次比较完后,最大值会出现在最大索引处,依次比较
规律:
两两比较,大的往后放
第一次比较,倒数第0个不需要再次比较
第二次比较,倒数第1个不需要再次比较
第三次比较,倒数第2个不需要再次比较
....
第n次比较,倒数第3个不需要再次比较
代码举例
class ArrayDemo{
//编写一个主方法
public static void main(String[] args){
//创建一个数组,静态初始化
int[] arr = {};
int[] arr = {12,54,21,87,34};
//排序前先遍历一遍数组
printArray(arr);
//调用冒泡排序方法
bubbleSort(arr);
//排序以后再遍历一遍数组
printArray(arr);
}
//定义冒泡排序方法
public static void bubbleSort(int[] array){
//比较次数
for(int x = 0;x < array.length-1;x++){
//里面的元素进行判断比较
for(int y = 0;y < array.length-1-x;y++){
//判断,前面的元素比后面的元素大就互换
if(array[y] > array[y+1]){
//中间变量互换
int temp = array[y];
array[y] = array[y+1];
array[y+1] = temp;
}
}
}
}
//定义遍历方法
public static void printArray(int[] array){
System.out.prinltn("[");
//遍历数组
for(int i = 0;i < length;i++){
if(i == array.length-1){
System.out.println(array[i] + "]");
}else{
System.out.print(array[i] ", ");
}
}
}
}
422
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
