Javace基础
Javaweb 前段技术 数据库技术Servlet
ssm框架:
Spring Springmvc Mybatis 主流三大框架
互联网架构阶段(Java的提升,大数据的基础)
java高级阶段
大数据基础阶段
大数据阶段
离线阶段
实时阶段
Java简介:
JAVA之父:
James Gosling(高司令)詹姆斯.高斯林
Java是一门高级编程语言,1995年由sun公司推
出的。
2009年,sun公司被Oracle(甲骨文)公司收购。
Oak吸收了C++的优点,摒弃了C++的缺点,采用了面向对象、跨平台等新思想
Oak是Java的前身,后改名为JAVA,
JAVA logo:咖啡杯
Oracle 数据库:
优点:稳定性 安全性 查询效率 存储量级相对高
缺点:收费高
MySQL数据库:
优点:免费
Java应用场景:
1、嵌入式
2、安卓开发
Java开发-》安卓开发
安卓开发-》Java开发
3、网站后端开发--Java最重要的阵地 如京东、淘宝
4、大数据、人工智能
Hadoop框架原生语言是Java编写
Java语言的特点:
1、开源:开放源代码
2、面向对象:核心编程思想
3、跨平台
4、简单易学:和C语言相对比简单
5、安全
跨平台:
跨平台又称平台无关性
平台:
操作系统:
Windows
Linux
安卓
Mac系统
不跨平台的问题:
1、人力 时间成本高
2、不方便
概念:
Java语言开发的程序,无需任何修改可以在任意一个平台上正常运行
JAVA原理:
如:
小明(JAVA)出国旅游 城市有韩国、美国、日本(平台),他直接去听不懂当地的语言,当地的也听不懂他说啥,他找一个翻译(JVM),就可以了
总结:
1、Java跨平台的核心是JVM(java虚拟机)。JVM将Java程序转换为当前操作系统可以理解的指定,然后由系统来执行程序,完成Java程序的运行。
2、JVM(JAVA 虚拟机)是JAVA跨平台的核心。将JAVA程序翻译成当前操作系统可以理解的指令,当前操作系统来调用自己的资源执行程序。
注意:
1、不同的平台对应的JVM
2、
2、跨平台的缺点?
相比不跨平台的语言来说 效率有所降低
效率影响不明显
Java环境的安装和配置
JVM JRE JDK
JVM:Java虚拟机 是JAVA跨平台核心
JRE:Java运行时环境 JRE=JVM+核心类库
JDK:Java开发工具包 JDK=KRE+开发工具
安装JDK:
Oracle官网下载
JDK需要下载当前系统的版本
JDK的版本号:
JDK1.0-JDK1.1-JDK1.2----
JDK里程碑的版本 JDK5
提供了很多新特性 自动装箱 自动拆箱 泛型等
JDK6-JDK7
目前市场用JDK8,比较稳定
检查当前环境是否已经安装JDK
win+r快捷键打开命令面板
输入Java -version命令
安装JDK-傻瓜式安装:
修改安装目录-不要安装在C盘 安装路径中不要包含中文 空格 特殊字符
JRE安装弹窗可以不安装
配置环境变量:
用户变量:
只对当前用户生效
系统变量:
对所有用户生效
定义JAVA_HOME环境变量:
变量值 JDK的安装目录 具体到bin的上一级目录
Path:Windows系统变量
%JAVA_HOME%\bin
再次测试是否能执行java -version命令
入门案例
文件重命名快捷键F2
定义类(Java基本单位):
class 类名{}
例如:class HelloWorld {}
{}表示范围
执行程序
编译:
.java文件编译成.class文件(字节码文件)
格式:Javac Java文件名(.java)
例如:Javac HelloWorld.Java
运行:
格式:Java 类名(运行不加后缀)
例如:java HelloWrold
注意:
1、类中
2、
在类中定义main方法
main方法 主函数 程序入口
格式:public static void main(String[] args){}
public(公共的)
输出语句
打印输出语句
格式:System.out.println();
例如:System.out.println("HelloWorld");
注意:
1、一个Java文件中可以定义多个类
2、每个类在编译之后都会产生一个对应的字节码文件,文件名和类名保持,,,(一个文件里面有两个类的话就有两个字节码文件)
3、文件名和类名可以不一致
4、如果类被public修饰,则要求类名必须和文件名保持一致,否则会报错
一个Java文件中只能有一个public修饰的类
5、单词拼写一定要正确 Java严格区分大小写,符号的全半角区分(只能半角)
关键字
概述:
在Java中被赋予特定含义的单词
例如:class - 定义类 public - 权限修饰符(公共的)
Java中有50多个关键字
true false null
main不是方法,String是类型
关键字分为:
访问控制、类方法和变量修饰符、程序控制语句、错误处理、包相关、基本类型、变量引用。
注意:
1、关键字都是小写字母。
2、开发工具eclipse idea对于关键字有特殊的标识。
3、const goto是特殊的关键字,又称为保留字。
标识符
概述:
在Java中给类、方法、变量、接口等起名字的字符序列
组成规则:
1、英文大小写字母
2、数字
3、$ _
注意:
1、标识符不能和关键字冲突
2、数字不能开头也不能单独使用
3、$_有特殊的应用场景 不建议随便使用
组成规范:
建议最受 (不遵守编译运行不会受影响)
1、见名知意
2、驼峰规则
大驼峰:每个单词的首字母都大写
类名(HelloWorld)、接口名、
小驼峰:从第二个单词开始首字母大写
方法名(mian addUser)、变量名(userInfo)
注释
概述:
解释说明
分类:
行注释:
作用于一行内容
格式://注释的内容
块注释:
注释多行内容
格式:/*注释内容*/
文档注释:
提取说明文档
提取文档注释的类必须使用public修饰
文档注释一般用在类上、属性上、方法上
格式:/**注释内容 */
提取说明文档:
javadoc -d 文档生成的目录 文件名
例如:Javadoc -d d:\code\mydoc HelloWorld.java
注意 :
1、注释嵌套使用
行注释可以嵌套使用
块注释和文档注释不可以嵌套注释
2、注释的作用
测试代码可以通过注释在测试完成之后注释掉不影响正式的运行
辅助调试错误
进制(常用十进制,计算机常用二进制)
概述:
计数时进位的机制
分类:
二进制:满二进一
十进制:满十进一
八进制:满八进一
十六进制:满十六进一
进制转换:
二进制<->十进制
十转二:
总结:十进制数除2取余数,直到商为0,将余数倒着组合即为二进制数
二转十:
总结:二进制的每一位上的数字乘以2的相应的幂次并求和,即得到十进制数
幂次:最低位-最右边的位数 最高位-最左边的位数 位数-1 最低位-》最高位 +1
二进制<->八进制(三位二进制可以表示一位八进制数)
二转八:
总结:从最低位开始 三位为一组,如果不够三位左侧补0,将每一组的二进制都转为0-7的数字,从左向右组合即为八进制数
八转二:
总结:将八进制每一位上的数组拆分为三位二进制数,如果不足三位左侧补0,从左向右组合即为二进制数
二进制<->十六进制
二转十六:
十六转二:
计算机中数据的表现形式
计算机中所有数据的运算和储存都是基于二进制来做的
二进制的单位:
bit:二进制 比特位 只能表示 0 或者1
Byte:字节 1Byte=8bit 不考虑正负的情况下:0000 0000->0 1111 1111->255
KB:1KB=1024Byte 2^10=1024
MB:1MB=1024KB
GB:1GB=1024MB
TB:1TB=1024GB
PB:1PB=1024TB
码表(字符集-编码):
字符和整数值进行映射,从而实现字符到二进制的互相转换
ASCII:
只对常用英文字符和符号共128个字符进行了映射
一个字符占用 一个 字节来存储
GB1312,GBK:
兼容ASCII码表
加入了常用的中文汉字字符
GBK中一个字符占用 两个 字节来存储
中国系统默认的码表就是GBK
unicode编码规则:
兼容ASCII码表
几乎涵盖去哪世界的字符
没有指定占用多大的空间来存储字符
UTF-16:
基于unicode实现的码表
一个字符占用 两个 字节来存储
UTF-32:
基于unicode实现的码表
一个字符占用 四个 字节来存储
UTF-8:
基于unicode实现的码表
采用了变长的字节数来存储字符
常用字符一个字节表示
一般字符两个字节表示
不常用字符三个字节表示
一般不用的字符 四个字节表示
其中,一个中文汉字字符占用三个字节
中文乱码问题:
现象:
Java文件中写了中文汉字---码表 UTF-8
cmd窗口中编译Java文件
出现中文乱码编译报错
原因:
编码
字符->二进制
UTF-8:一个中文汉字字符占用三个字节
中---三个字节
解码
二进制->字符
cmd编译Java文件 默认码表 GBK:一个中文汉字字符占用两个字节
总结:
编码和解码的码表不一致
解决方案:
ANSI-系统默认码表
将Java文件的码表修改为了GBK码表
字面值(直接量)
概述:
在Java中可以直接使用的数据值(直接输出的)
分类:
数值型字面值
整数
默认十进制
指定为其他进制:数值前加前缀
二进制:0b10 八进制:010 十六进制:0x10
浮点数-小数
字符型字面值
必须通过一对 单引号 引起来单个字符
例如:'a' 'A' '中' ' '都是字符型字面值
注意:单引号中只能有一个字符,也不能为空
转义字符:
格式:\字符 \t制表符 \r回车 \n换行
例如:'\''
字符串字面值
一对双引号引起来 可以没有字符一个字符 多个字符
字符串中也可以写转义字符
布尔型字面值
布尔表示逻辑判断的结果
true 正确的
false 错误的
true和false都是关键字
注意:
System.out.println(true); 先输出内容之后进行换行
System.out.print(true); 直接输出内容 不换行
System.out.println();--换行
System.out.print();--编译会报错
变量、常量
变量:
概念:类似于数学的未知数的定义
格式一:数据类型 变量名 = 初始化值;
变量名:遵守标识符的组成规则 组成规范(小驼峰)
初始值:直接量
例如:int num = 6;(定义了一个int类型变量,变量名为num,初始值为6)
格式二:数据类型 变量名; 变量名 = 初始化值;
先声明 后赋值
例如:int num; num= 6;
修改变量的值:
变量名 = 新值;
注意:
在目前的程序中,变量名不能重复的 否则编译报错
先定义变量 在使用变量;变量必须初始化之后才能正常使用
常量:
概念:在程序执行过程中 值不能发生改变的量就是常量
格式:
final 数据类型 常量名 = 初始化值;
常量名:要求所有字母全部大写 多个单词之间通过_来分隔
例如:final int PI=3; final int MAX_VALUE = 90;
java数据类型
分类:
基本数据类型
引用数据类型(数组 类 接口等)
八大基本数据类型:
四类八种:
整数(4种)
byte(字节型)、short(短整形)、int(整形)、long(长整形)
最常用的数据类型就是int类型
整数字面值默认是通过int类型来存储;当字面值超出了int类型的范围,编译会报错;如果想要指定整数字面值通过long类型来存储,需要字面值后边加L或者l后缀
浮点型(2种)
float(单精度浮点型)、double(双精度浮点型)
1、最常用的浮点数类型就是double类型
2、浮点数字面值默认是通过double类型存储,如果想要指定浮点数类型字面值通过float类型来存储,需要字面值后边加F或者f后缀
3、float的有效数字的位数7-8位
double的有效数字的位数15-16位
4、浮点数字面值后边也可以加D或者d后缀表示用double类型来存储,一般可以省略不写
5、java支持科学计数法的表达形式 但是默认是double类型
300=3*10^2<->3e2 0.05=5*10^-2<->5e-2 150=1.5*10^2<->1.5e2
字符型(1种)
char(字符型)
char是character单词的缩写
1、char类型的变量可以通过整数直接赋值
整数必须在码表的范围之内
例如:char c = 97;//a
将97转为二进制先进行存储,当
布尔型(1种)
boolean(布尔型)
值为true或者false
字符串型不是基本数据类型,是引用数据类型
数据类型的转换
两种情形:
自动数据类型转换
数值型:从小到大的顺序
byte->short->int->long--->float->double
整型可以自动转为浮点型,默认是在整数加.0
char->int->long->float->double
根据码表将当前字符对应的编号转为int类型的值
强制数据类型转换:
格式:
(要强转的数据类型)数值或者变量
例如:
byte p2 =(byte)p1;
注意:
1、不是所有类型之间都可以进行强转的
2、浮点数转为整数时,直接舍弃小数部分
3、如果大类型的数据值超过了小类型的范围,则强转之后的结果可能会发生变化
例如:int i= 128; byte b = (byte)i; b的值为-128
4、引用数据类型也可以强制转换
运算符
概述:
有特定运算规则的符号
分类:
算数运算符
赋值运算符
关系运算符
逻辑运算符
三目运算符
位运算符
算数运算符:+ - * / % ++ --
+ - *:
+(求和运算) -(求差运算) *(求积运算)
场景使用:
1、输出语句中对字面值直接使用
2、输出语句中对变量进行运算
3、将运算的结果保存在变量
结果的数据类型:
1、结果数据类型和运算元素中大的数据类型保持一致
2、byte short char 类型的变量参与运算时 会自动提升为int类型
面试题:
byte b1 = 3;
byte b2 = 4;
byte sum = b1+b2;
编译会报错
变量的值只有在运行时才能确定 编译时只会进行变量类型的检查
如何改错?
1、强制类型转换
byte sum = (byte)(b1+b2);
2、修改结果的数据类型
int sum = b1+b2;
byte sum1 = 3+4;
编译不会报错
原因:
1、编译期间只检验变量的类型 不确定变量的值
2、编译期间进行优化 对于字面值会在编译期间由虚拟机进行运算 所以以上程序编译之后 byte sum1 = 7;并检查7在不在byte的范围之内,如果超出范围,编译报错。
/:
/(求商运算)
int/int结果必然为int类一商取整 直接舍弃小数部分
除数不能为0:编译没问题 但是运行抛出异常
正浮点数/0:Infinity 无穷大
负浮点数/0:-Infiniti 无穷小
0.0/0:NaN--Not a Number 非数字
%:
%(取余 模余运算)
整除:余数是否为0
奇偶数:对2取余 判断余数是否为0
++ --:
++(自增运算符)
格式:变量++;让变量的值自增1
理解:x++;理解为x=(type)(x+1);
--(自减运算符)
格式:变量--;让变量的值自减1
理解:x--;理解为x=(type)(x-1);
注意:
1、如果++--单独使用 可以放在变量前边 也可以放在变量后边
2、如果++--不是单独使用:
如果变量在前,++在后,先使用变量的值,再让变量的值+1
如果++在前,变量在后,先让变量的值+1,在使用变量的值
3、++--只能作用于变量,不能作用于数据值和常量
赋值运算符:= += -= *= /= %= &= |= . . .
特点:
赋值运算符的优先级是最低的
连等赋值:
从右向左执行的
int b = a = 3 ;
程序第一步先执行a=3;要求变量a必须声明或定义过,否则编译会报错
第二步执行int b = a;
+=:
格式:x+= r;相当于 x = (type)(x+ y);
x:只能是变量,不能是常量 字面值
关系运算符:> < >= <= == !=
特点:运算结果必然为boolean类型
逻辑运算符:& | ! ^ && ||
特点:只能对boolean类型的值做运算
&&(与 且):
true&true=true
true&false=false
false&true=false
false&false=false
总结:
都为true结果为true,有false结果为false
|(或):
true|true=true
true|false=true
false|true=true
false|false=false
总结:
同为false,结果为false;一旦有true,结果就为true
!(非 取反):
!x
x=true !x=false
x=false !x=true
^(异或)
x^y:
x的取值要么为true 要么为false;y同理
true^true=false
true^false=true
false^true=true
false^false=false
总结:
如果相同,结果为false;不同,结果为true;
&&(双与 短路与):
提高程序的执行效率
案例引入:
false&&(1+2+3+…+10000000>738479832)=false
总结:
&&左边为false时,右边不再执行,结果必然为false;
&&左边如果为true,则效果等同于&.
||(双或 短路或)
案例引入:
true||(1+2+3+…+10000000>738479832)=true
总结:
||左边为true时,右边不再执行,结果必然为true;
||左边如果为false,则效果等同于|.
三目运算符(三元表达式):
单目运算符(一元表达式)
例如:++ -- !
双目运算符(二元表达式)
例如:+ - & >
三目运算符的格式:
表达式或值?表达式1或值1:表达式2或值2
执行流程:
1、执行表达式或值
true:表达式1或值1
false:表达式2或值2
要求:表达式或值必须为boolean类型
位运算符:
了解即可 不要求深入
特点:
整数做运算,先将运算的整数转为二进制,对二进制数来做运算。
&(按位与) |(按位或) ~(按位取反) ^(按位异或)
&:(按位与)
x&y 例如: 1&2=0
1--true 0-false
1&1=1 1&0或0&1或0&0=0
|:(按位或)
x|y 例如: 1|2=3
1--true 0-false
1|1或1|0或0|1=1 0|0=0
^:(按位异或)
特点:一个数异或同一个数两次 结果是该数本身
x^y 1^2=
1-true 0-false
1^1=0 0^0=0 1^0=1 0^1=1
~:(按位取反)
~x 例如: ~1=-2
~1=0 ~0=1
~i=-(i+1)
正数:原码=反码=补码
负数:
原码:符号位1 十进制转换出来的二进制
反码:符号位不变,其余位依次取反
补码:反码+1
<<(按位左移) >>(按位右移) >>>(按位无符号右移)
<<:(按位左移)
x<<y 将x的二进制整体左移y位 左侧多出来的直接舍弃 右侧空出来的补0
>>:(按位右移)
x>>y 将x的二进制整体右移y位 右侧多出来的直接舍弃 左侧空出来的补和符号位一致的数字
>>>:(按位无符号右移)
x>>>y 将x的二进制整体右移y位 右侧多出来的直接舍弃 左侧空出来的补0
开发工具
记事本:
无需单独安装
开发效率低
eclipse:
免费 内存占用率比较低
安装配置非常简单 绿色免安装
intellij idea:
智能提示优化
Debug代码调试功能非常完善 非常的
主题界面风格
插件安装非常的方便
收费 占用内存率比较高
idea的使用:
项目 Project
本质上是文件夹
模块 Module
src-代码源码
包 Package
单级包
多级包
规范:
公司的域名的道写形式作为多级包的开头
类
补充知识点
如何定义字符串类型
1、String类 表示字符串类型 引用数据类型
String 变量名 = 初始化值;
例如:String name = “hello”;
+ 字符串拼接符
案例:
"hello"+"world"=>"helloworld"
"hello"+8 => "hello8"
8+"hello" => "8hello"
"hello"+3.5 => "hello3.5"
"hello"+'a' => "helloa"
"hello"+true => "hellotrue"
"hello"+1+2 => "hello"+1->"hello1"+2->"hello12"
1+2+"hello" => 3+"hello"->"3hello"
"hello"+'a'+1 => "helloa1"
1+'a'+"hello" => 98+"hello"->"98hello"
应用场景:
1、案例 求a b的最大值
int max = a>b ? a : b;
System.out.println("最大值为:"+max);
2、案例
int a = 4;
int b = 3;
输出等式:
4+3=7
System.out.println(a+"+"+b+"="+(a+b));//4+3=7
2、Scanner类
作用:
获取用户输入的数据
Scanner使用步骤:
1、导入Scanner所在包
import java.util.Scanner;
位置:类定义的上边
2、创建Scanner类的对象
Scanner sc = new Scanner(System.in);
3、调用sc的方法来获取数据
nextlnt()--获取用户输入的整数
nextDouble()--获取用户输入的浮点数
next()--获取用户输入的字符串
调用方法:
调用方法的格式:
sc.nextInt();--获取用户输入的一个整数
int num = sc.nextInt();
double num1 = sc.nextDouble();
String str = sc.next();
4、关闭Scanner
sc.close();--关闭Scanner
控制结构
概述:
控制程序语句的执行
分类:
顺序结构:
从上到下 从左到右
基本的控制结构
分支结构:
if判断语句
switch case选择语句
循环结构
分支结构:
if判断语句:
判断条件的值必须是boolean类型
格式一:
if(判断语句){当前判断条件为true时要执行的代码块;}
格式二:
if(判断语句){当前判断为true时要执行的代码块;} else{当条件不成立 时要执行的代码块;}
格式三:if (){}else if(){} …………else{}
if(判断语句1){当前判断为true时要执行的代码块;} else if(判断语句2){当判断条件1不成立且判断条件2成立时要执行的代码块;}else if(判断语句3){当判断条件1不成立且判断条件2不成立且判断条件3成立时要执行的代码块;}else{当所有的判断条件均不成立时要执行的代码块;}
if嵌套:
内层的if看作外层if的代码块
案例:
月份案例 先if else判断数据合法性 再if else if else判断季节范围
注意:
1、如果代码块的内容只有一行 可以省略{}
2、变量的作用域问题
变量定义开始到所属的{}的结束
在同一个作用域中变量不能重名
switch case选择语句:
格式:
switch(值或者表达式或变量){case值1:当值和值1匹配时要执行的代码块;case值2:当值和值2匹配时要执行的代码块;…… default:当值和case后所有的值都不匹配时要执行的代码块;}
注意:
switch只支持int(byte chort char)类型、String字符串、枚举的数据匹配
问题:
case穿透
解决方案:break;--break语句--该语句执行直接结束switch case
case穿透在某些场景可以简化代码
if和switch case 的区别:
范围性的比较适用if语句,一对一的匹配则适合用switch case
if应用更广泛一些Switch case在某些某些特定场景下可以进行的简化
循环结构:
while do.while for
循环四要素:
1、初始化条件语句;
2、循环条件语句;
3、改变循环体条件语句;
4、循环体
while:
格式:
初始化条件语句;while(循环条件){循环体;改变循环条件语句;}
执行流程:
1、初始化条件语句;
2、循环条件boolean值
true:循环体;改变循环条件语句;重复步骤2 false:循环结束
do.while:
格式:
初始化条件语句;
do{循环体;改变循环条件的语句;}while(循环条件);
执行流程:
1、初始化条件语句
2、循环体;
3、改变循环条件的语句
4、循环条件
true:重复步骤2
false:结束循环
while和do.while 的区别:
while循环可能一次都执行不到循环体;do while至少循环一次循环体;
注意:
while后边必须以分号结束
for:
格式:
for(初始化条件语句;循环条件;改变循环条件的语句){循环体;}
执行流程:
1、初始化条件
2、循环条件--boolean值
true:循环体;改变循环条件语句;重复步骤2
false:循环结束
三种循环的联系和区别:
1、一般来说 三种循环可以互相转换的
2、while、for和do while的区别
while和for有可能一次都不执行循环体
do while至少执行一次循环体
3、如果不确定循环次数 建议使用while循环
4、while的初始化条件语句中定义的变量再循环结束后还可以正常访问
for循环的初始化条件语句中定义的白能量则只在for内部生效 出了for循环访问不了
死循环:
while(true){}
for(;;){}
循环没有了出口
一般情况下,在编写代码时要考虑死循环的问题;
某些特殊场景可能需要专门去构建死循环的应用。
死循环的体现:
不停的输出相同的内容 不会停止
卡死的假象
循环、判断嵌套:
循环和if语句来嵌套
循环和循环嵌套:
将内层循环看做外层代码
循环跳转语句:
break;
continue;
break continue 关键字
break;--break语句
应用场景:
switch case语句中 结束switch case
循环语句 结束循环
continue;--continue语句
应用场景:
循环语句 跳过本次循环,继续下一次循环
多层循环中:
break; continue;语句对它所属的且离它最近的循环生效
结束方法
return;--return 语句
变量的作用域:
从变量定义开始带它所属的结束
在同结束一个作用域中,变量名不能重复
数组
引用数据类型
概念:
可以存储多个同一种数据类型且数组长度不可变、内容可变的容器
定义数组的格式:
格式一:
数据类型 [] 数组名 = {元素1、元素2、元素3、……};
例如:int[] num = {18,19,20};
注意:
数组的长度等于元素的个数
当确定每个元素的数据值时可以使用该格式
不支持先声明后赋值
格式二:
数组类型[] 数组名 = new 数据类型[数组的长度];
例如:int[] num = new int[10];
注意:
该格式明确指定了数组的长度,但是没有给出具体的元素值
支持先声明后赋值
格式三:
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
注意:
数组的长度等于元素的个数
当确认每个元素的数据值时可以使用该格式
格式一是格式三的简化形式
该格式不能再[]中指定数组的长度否则编译报错
支持先声明后赋值
数组的基本操作:
索引(下标)
范围:0~数组的长度-1
如果超出了范围,则运行会抛出数组下标越界异常 ArrayIndexOutOfBoundsException
1、获取数组的元素值
数组名[下标]
例如:num[0]--获取num数组的第一个元素
2、设置数组的元素值
数组名[下标] = 新值;
例如:num[0] = 19;
3、获取数组元素的长度
数组名.length--int类型的值
例如:num.length
4、遍历数组
三种方式
1、普通循环遍历数组
2、增强for循环
只能用于遍历数组、集合、Map映射等
格式:
for(数据类型 变量名:数组名){循环体}
例如:for(age:ages){System.out.println(age);}
变量的数据类型应该和数组的元素的数据类型保持一致
3、Arrays类来查看
Arrays类是JDK提供的数组操作的工具类
在java.utll包中,导包
Arrays.toString(数组名);--将数组元素拼接成了字符串返回
例如:System.out.println(Arrays.toString(ages));
注意:
增强for循环只适用于数组元素的查询 使用,不可用于数组元素的修改
只适用于查看数组元素的值或者将数组元素转为字符串
总结:
fori 和 foreach的区别:
如果只是查询数组元素或者使用数组元素 foreach更加简单直接
如果需要在遍历中修改或设置数组元素 则只能使用fori循环
数组的应用:
1、求数组所有之和
2、求数组最大值/最小值
3、数组的反转
4、数组的排序
数组的排序:
冒泡排序
核心思想: 默认升序排序
要求用两个相邻的元素比较大小
如果前一个元素大于后一个元素 则交换位置
选择排序
核心思想:默认升序排序
使用一个元素和之后的所有元素一次比较
如果当前元素大于比较元素 则交换位置
插入排序 快速排序 归并排序等
Arrays.sort(数组名):
效率高
int[] nums = {3,1,5,4,6};
5、数组的查找
1、数组的遍历 比较元素是否相等
2、二分查找(折半查找)
数值型 数组必须是有序数组
6、数组的“扩容”、“缩容”
数组一旦创建长度不可变,所以扩容、缩容本质上已经不是同一个数组了,而是一个新的数组对象
JDK提供了两种方式实现扩容:
System.arraycopy(原数组名,起始元素的下标,目标数组的起始下标,要拷贝的元素的个数);
Arrays.copyOf(原数组名,新的长度)
数组的内存:
内存:
当计算机重启或者断电时,内存中所有的数据会丢失
效率高-快
硬盘:
无论是否重启,只要硬盘硬件不损坏,数据就不会丢失
效率低-慢
java的内存:
栈内存 Stack
方法执行在栈中开辟内存空间
局部变量也是在栈中开辟空间
for循环 判断等语句代码块执行完就会释放空间
方法执行完方法的空间也会立刻释放
堆内存 Heap
new创建对象放在堆中
要求堆中的数据必须要有值,如果没有明确给定数据值则使用数据类型对应的默认值
byte short int :0 long:0L float:'/u0000'空字符 boolean:false 引用数据类型:null
堆中对象的空间释放由垃圾回收器完成
当堆中的对象没有任何引用指向时,被垃圾回收器扫描到,则会被回收
对象的回收不由程序员控制,完全是垃圾回收器自己决定
方法区
本地方法栈:
native修饰的方法
寄存器:
程序计数器
数组内存注意:
1、直接输出num数组,输出的是数组的地址值
二维数组
定义的格式:
格式一:
数据类型[][] 数组名 = {{元素11,元素12,……},{元素21,元素22,……},{…………},……};
例如:
int[] ages = {{18,20,19},{17,16,21,23}};
该元素包含两个一维数组。第一个一维数组包含3个元素,第二个一维数组包含4个元素
格式二:
数据类型[][] 数组名 = new 数据类型[一位数组的个数][每个一维数组中元素的个数];
例如:
int[][] ages = new int [2][2]
特点:每个一维数组中元素个数都相同
格式三:
数据类型[][] 数组名 = new 数据类型[一维数组的个数][];
例如:
int[][] ages = new int[2][];
该二维数组包含两个一维数组,每个一位数组的个数不指定。
基本操作:
数组名[下标]
数组名[下标][下标]
数组名.length--获取到二维数组中一维数组的个数
数组名[下标].length--获取到指定一维数组中元素的个数
方法
引出:
每个数组遍历都需要些一个for循环,代码几乎都是重复的,开发效率低;
将for循环遍历数组代码进行复用--java的方法
概念:
将一段代码重复利用
方法的定义:
public static void main (String[] args) {}
权限修饰符 静态修饰符 返回值数据类型 方法名 (参数列表){方法体;return返回值;}
权限修饰符:public 公共的
静态修饰符:方法可以加也可以不加static
返回值类型:如果方法有返回值,则数据类型需要和返回值得数据类型保持一致;如果方法没有返回值,则数据类型声明为void(关键字);
方法名:标识符 小驼峰
参数列表:方法中的一些内容需要由调用方法的人来指定时,可以通过参数来进行数据传递
可以没有参数 可以有一个或者多个参数
方法体:方法的核心功能逻辑代码
return 返回值:方法执行完成之后,需要给调用方法者反馈,则可以通过return加上要返回的数据值。
return只能返回一个数据值
return语句一旦执行 则当前方法就结束了
return;--return语句 直接结束方法
方法的定义位置:
类中方法外
方法定义的前后位置是无关
注意:
方法不调用不执行 什么时候调用什么时候执行
方法的传参:
调用方法时,将实际的数据值赋值给方法的参数的过程
调用方法时,将实参的值赋值给参数
形参:
形式参数 方法定义时给出的参数
实参:
实际参数 调用方法时传参给形参的变量
注意:
如果参数是基本数据类型,则传递的是具体的数据值;对形参的修改不会对实参产生影响;
如果参数是引用数据类型,则传递的是对象堆中的地址值;当形参通过该地址修改堆中的数据时,实参通过同一个地址访问到的就是堆中修改之后的数据值。
方法的重载:
在同一个类中方法名相同参数列表不同-方法重载
参数列表不同:
1、参数个数不同
2、参数数据类型不同
3、参数数据类型的顺序不同
调用方法时如何确定调用哪一个重载之后的方法?
根据实参的数据类型来匹配--最像的 没有最像的 考虑通过数据类型的自动转换 尝试匹配其他的方法
案例:
1、定义方法,实现打印1 2 3 … 10的功能--无参 无返回值
2、定义方法,实现打印1 2 3 … n的功能--有参 无返回值
3、定义方法,实现int数组遍历功能--有参 无返回值
4、定义方法,实现两个int变量求和,将求和结果返回--有两个参数 有返回值
5、定义方法,实现两个double变量求和,将求和结果返回--有两个参数 有返回值
方法调用栈:
每个方法执行都需要在栈内存创建空间--栈帧
栈-数据结构
先进后出 后进先出
队列-数据结构
先进先出 后进后出
注意:
方法调用不能成环 运行会抛出异常
方法递归
方法自己调用自己
案例:
1、定义方法 实现1+2+3+…+n的和
参考代码:
public static int add(int n){if(n==1){return 1;}return add(n-1)+n; }
优点:
思路简洁 明了
缺点:
内存占用较大 甚至如果递归较深的话 可能会出现栈内存溢出错误StackOverflowError
注意:
递归必须向已知的方向递归 必须要有出口
应用场景:
File部分会使用方法递归
break continue return
break;- 作用于循环
结束循环
continue;-作用于循环
跳过本次循环
return;-作用于方法
结束方法
Debug代码调试
Debug:eclipse idea开发工具提供的代码调式模式
Debug讲解的案例:
定义方法 对int数组基于冒泡排序实现数组升序排序
步骤:
打断点:指定程序停止的位置
左侧行数右边点击一下即可 再点以下即取消
以Debug模式来运行程序
注意:
Debug多使用 熟练掌握