javaee入门基础重要知识

                                              **

javaee入门基础重要知识

**
一.Java概述:
操作系统:pc端: Windows系统, Linux系统 Unix系统 Mac系统 4种
手机端: IOS 安卓 黑莓 鸿蒙 4种
框架: ssm(spring springMvc mybatis) SpringDate SpringCloud Meavn
高级语言: java c c++ python go c# 6种
命令行指令: 切换盘符(盘符 : ) 查看当前内容(dir) 进入文件夹 (cd文件夹名)
删除文件夹(rd 文件夹名称) 删除非空文件夹,会询问(rd/s 文件夹名)
直接删除(rd/s/q文件夹名 )
创建文件夹(mkdir文件夹名) 创建多层文件夹(mkdir 文件夹名\文件夹名)
创建文件(echo 文本内容 >> 文件夹名(带格式))
删除文件(del 文件名)
清空控制台(cls)
.: 代表当前文件自己 …代表当前文件夹上一级 cd\ cd/(代表返回盘符)
java语言特点: 1.开源免费 2.面向对象 3.跨平台性 4.编译性 5.动态性
跨平台性:都为对应平台开发了java虚拟机
java虚拟机(java程序运行容器) === jvm
jdk(开发者工具包) > jre(java运行环境) > jvm(java虚拟机)
注释: // 单行注释（可以嵌套使用） /* */多行注释(不可以嵌套注释)
快捷键: ctrl+ / ctrl+shift+/
关键字: 50个关键字 48个已使用(goto const)
标识符: $ _ ,数字不能开头,不能和关键字重复 (严格区分大小写)
命名规则: 类,枚举,接口 大驼峰命名法 方法, 变量名 小驼峰命名法
常量 全部大写 包名: 公司域名倒写
常量分类: (只是用来研究 值 属于数据类型,数据的四类八种包含常量的四类八种,属于类型中的特
殊类型)
表现形式分类: 1.字面值常量 2.符号常量
数据类型分类: 1.基本数据类型 2.引用数据类型
基本数据类型: 整数常量,小数常量,字符常量,布尔常量
引用数据类型: 字符串常量 空常量
常量的默认类型: 整数 int 小数 double float后需添加 f long后需添加 l
常量优化机制: 一些简单的计算,例如常量与常量之间的计算,计算过程不会等到运行时才做运算,而是在
代码编译器就完成了运行,这种现象称之为常量优化机制
变量: 数据类型 变量名 = 变量值
数据类型: 作用:规定变量所代表的内存空间所占空间的大小==java强类型语言
1.基本数据类型(内置数据类型) 2.引用数据类型
基本数据类型: 整数类型 byte 1 short 2 int 4 long 8
小数类型 (ieee754) float 4 double 8
字符类型 char 2字节
布尔类型 boolean
数据类型转换: 1.隐式转换(小类型数据类型时可以直接向大类型转换)
byte+byte=byte(不存在这种算法,直接提升为 int)
2.显示转换(大类型向小类型转换,在=后面强制定义数据类型)
字符类型: 编码: 从字符到数字的过程 解码:从数字到字符的过程
字符集: ASCII码表 128个字符 GB2312 GBK Unicode2字节
二.运算符
运算符的分类: 1.算数运算符 2.赋值运算符 3.比较运算符 4.逻辑运算符 5.位运算符
6.三目(元)运算符
1.算数运算符 一元运算符 二元运算符 a++ a-- ++a
2.赋值运算符 += %=
3.比较运算符 对比运算符 !=
4.逻辑运算符 & | && || ! ^
5.位运算符 & | ~(按位取反) ^ 移位运算符 >> << >>
6.三元运算符 a > b ? a : b

                               a > b ? a : b > c ? a > b ? a : b : c

三.分支结构
程序流程控制的分类: 顺序结构 分支结构 循环结构
分支机构: if 语句 switch语句
if语句和switch语句的区别: 1. if语句相对灵活,switch语句可以被if语句代替
2.if语句适合做连续性判断,switch适合做离散性匹配
3.switch效率比if语句效率高,if语句每次都需进行判断
if语句 : 1. if…
if( 判断 ){ 语句体 ;}
2.if…else…
if( 判断 ){ 输出 ;}else{ 输出 ;}
3.if…else if…else if_else的级联语句
if( ){ 输出 ;}else if( ){ 输出 ;}else if( ){ 输出 ;}else{ 输出 ;}
switch语句: swith 开关 case 情况 break 退出 default 默认
switch(表达式) {
case 常量1:
语句体1;
break;
case 常量2:
语句体2;
break;
default:
语句体n+1;
break;}
1.表达式:jdk1.5之前支持(byte short char int) jdk1.5(枚举类型) jdk1.7(String)
2.case后只能跟常量,每段语句体后必须跟break(否则无法结束)
3.可以做穿透效果
四.循环
循环结构: for循环(加强版foreach) while循环 do…while循环
for循环: 1. for( ; ; ){ ;}
2.循环嵌套(外层循环控制行数,内层循环控制列数)
while循环: 循环变量初始化
while(范围){循环体;自增量;}
do…while循环: 循环变量初始化
do {循环体,循环变量}while(循环条件);
死循环: for(,){循环体} while(ture){循环体} do{循环体}while(ture);
跳转语句: break 结束 continue 继续 return结束方法 exit(0)结束虚拟机
三种循环语句区别:相同点: 都可以做循环结构
不同点: do…while:循环条件是否成立都走一遍循环体(直到循环)
for,while条件不成立不走(当型循环)
for 知道循环次数,while循环条件判断停止
for循环停止循环变量不能使用,while循环结束循环变量还可以使用
(循环初始化在上面)
方法: 1.不能嵌套定义,可以嵌套调用
方法好处:1.提高代码的复用性
2.简化程序设计难度,提高程序开发效率
3.有利于程序维护
4.提高代码的封装性
方法调用的三种形式: 直接调用 赋值调用 打印调用
方法的重载(overload): 定义:在同一个类中,多个方法之间存在,方法名相同,参数列表不同与返回值类
型无关的多个方法之间的关系称之为方法重载.
好处:没有方法重载时,相同逻辑的方法需要定义不同的方法名,有重载后相同逻
辑的方法可以定义一个方法名
方法 调用

1. 无参数无返回值(输出在方法中) 直接调用 名字()
   2.有参数无返回值(输出在方法中) 直接调用 名字(数据,数据)
   3.无参数有返回值 赋值调用 打印调用
   类型 变量 = 名字(实际参数) System.out.prinln(变量名) / System.out.prinln(名字(实际参数))
   4.有参数有返回值 赋值调用 打印调用 直接调用(无意义)
   类型 变量 = 名字(实际参数)System.out.prinln( 变量名)/ System.out.prinln(名字(实际参数))
   五.数组(最值,查找,翻转,遍历)
   数组:用来存储一组相同数据类型数据的一个容器
   定义数组格式: 元素数据类型[]数组名 = new 元素数据类型[数组元素个数]
   特点:一旦指定大小,大小就不可以在变化了
   数组初始化的分类: 动态初始化 静态初始化
   动态初始化: 元素数据类型[] 数组名 = new 元素数据类型[元素的个数];
   1.所有元素都需要按下标一个个赋值,
   2.数组每个元素都有默认值(默认值都是0;小数数组0.0;字符数组’a’;布尔数组false;
   静态初始化: 元素数据类型[] 数组名 = new 元素数据类型[]{元素值得罗列};
   简化:元素数据类型[]数组名 = {元素值的罗列};
   1.中括号内不要写元素个数
   2.元素数据类型要一致
   数组异常: 1.数组索引越界异常 2.空指针异常
   遍历:一个一个把数组中的元素访问一遍,称之为遍历(数组遍历 length)
   穷举法:通过数组组名[索引]一个一个通过写代码的方法,手动访问.
   二维数组:
   二维数组:数组的每个元素都是一个一维数组
   定义格式:元素数据类型[][] 数组名 = new 元素数据类型[一维数组个数][每个一维数组长度];
   遍历:双层for循环
   二维数组的访问:1.直接打印二维数组名: 打印的是二维数组的地址
   2.二维数组名.length: 获取管理小数组的个数
   3. 二维数组名[索引]: 代表获取指定索引的小数组
   4. 二维数组名[索引1][索引2]: 获取指定位置小数组中指定位置的元素
   例: int[][] arr2 = new int[3][]; 创建一个二维数组, 数组中有三个元素, 每个元素都是一个一维数组,但是每个小数组元素的个数不知道. 就是只是要管理三个小数组, 三个小数指向那个,有几个元素都不知道.第一个中括号长度必须给, 第二个中括号中长度可以不给.
   jvm(软件)内存分析: 1.栈内存 2.堆内存 3.方法区 4.本地方法区 5.程序计数器
   1. 栈内存[常用]: 用于执行方法, 每个方法执行时都会进栈, 每个方法在栈内存空间有个名
   称: 栈帧. 方法执行就叫做”进栈”, 方法执行完”出栈”; 管理方法方式: 先进后出变量定义
   在方法中, 所以变量也在栈内存存储.
   2. 堆内存[常用]: 用于存储数组, 对象等引用数据类型数据. 堆内存中存储都是引用类型
   数据, 这些数据都可以new关键字创建.
   3. 方法区[常用]: 用来存储字节码文件形成的对象及常量. 静态的内容也在方法区.
   4. 本地方法区: 用于存储java底层需要依赖的C预言的内容.
   5. 程序计数器: 用于控制程序执行流程的, 也就用于控制程序应该执行哪行代码.
   引用类型变量:如果一个变量中存储的不是数据本身,而是一个数据地址,我们就管这种变量叫做引用类
   型变量

六.面向对象
面向对象:是编程中使用的一种编程思想,编程思路.
面向过程是面向对象的基础,面向对象是基于面向过程的.
面向对象的三大特征: 封装 继承 多态
类:具有相同特征(属性)和行为事物的抽象
(类型,具有相同特征和行为事物的抽象,是一个抽象的结果.是一个概念)
类在java中是一种数据类型,属于引用数据类型,是一个复杂的数据类型,类名就是类型名
抽象:抽象对象中,相同的或者相似的内容出来,形成一个概念性的内容.
特征:就是属性,对类中特征的描述,一般都是名字或形容词,
属性是一个类的成员变量,方法中定义的变量叫做局部变量
行为:对类中功能的一种描述,一般都是动词或者动宾结构的单词,
行为是类的成员方法
局部变量和成员方法
成员变量访问: 给对象的成员变量赋值: 对象.成员变量 = 变量值;
取出对象成员变量的值: 对象.成员变量
成员方法访问: 对象.成员方法名(); 表示调用对象中某个成员方法.
.的含义: 就是调用和访问的意思
成员变量: 直接定义在类大括号的变量,就是成员变量;
局部变量: 定义在方法中大括号或者参数列表位置的变量,就是局部变量
成员变量和局部变量的不同点: 定义位置不同 储存位置不同 生命周期不同 初始状态不同
成员变量初始值: 引用类型成员变量:null 整数成员变量:0 小数成员变量:0.0 字符成员变量: a
布尔成员变量:false
方法的形式参数:方法的形式参数可以是基本数据类型,也可以是引用数据类型(数组,类,接口,枚举)
匿名对象
匿名对象:没有名字的对象 new 类名()
1. 如果某个对象创建之后, 只使用该对象调用一次该对象某个方法, 以后就没再使用该对象,
此时使用匿名对象, 就比带有名字对象代码要简化. 调用方法格式: new 类名().方法名();
2. 匿名对象可以当做方法的实参传递, 一个方法参数是引用类型, 可以直接传递一个匿名对象
进去. 到方法内部就有名字, 形参名就是对象的名字; 方法名(new 类名()
3. 匿名对象当做方法的返回值, 一个方法返回值是引用类型, 可以直接在return关键后跟一个
匿名对象. 调用方法之后, 返回值可以定义一个有名字的对象接受. return new();
4. 匿名对象可以访问成员变量, 但是这样是没有意义的, 因为匿名对象没有名字,只能被使用一
次. 如果使用匿名对象操作成员变量, 后面是无法取出的.
封装
封装:隐藏事物的属性和实现细节,不让外界直接看见,对外定义公开访问方式;
封装的好处:1.隐藏事物的实现细节 2.提高安全性 3.提高代码的复用性
封装的原则:隐藏事物的实现细节 对外提供公开访问方
set get方法
public void set成员变量名首字母大写(参数类型 参数名){成员变量名 = 参数名;}
public 返回值数据类型 get+成员首字母大写(){return 成员变量;}
变量访问:
变量访问原则是就近原则
构造方法在对象创建之前进行赋值,set在创建对象后进行复制,
用this对成员变量进行定义赋值,外部类对对象进行指定赋值
构造方法 构造函数,构造器 constructor
构造方法作用: 用于对成员变量进行赋值
构造方法不能自己调用自己, 也不能间接的自己调用自己;
修饰符 方法名(参数列表){方法体} //方法名 = 类名
构造方法没有返回值,可以写return,一般不写
一个对象,构造方法只能调用一次
对象不能调用构造方法,由jvm自动直接调用
在方法体用this对成员变量进行定义赋值,另一个类用对象进行指定赋值
系统自动添加空参构造方法,建议一定要进行手动添加空参
构造方法在对象创建之前进行赋值,set在创建对象后进行复制
同一个类中可以定义多个构造方法,构造方法之间是方法重载的关系
构造方法和setter方法比较
1.都可以为私有方法赋值,为外界提供了公开的访问方法
2.构造方法,由jvm调用,方法内部给成员变量赋值,只能执行一次
3.setter,在对象创建完进行赋值,可以多次调用
三种赋值执行顺序: 默认初始化 > 显示初始化 > 构造方法初始化
静态
静态变量特点:
1.随着类的加载而加载,早于对象创建
2.在方法区开辟出静态方法区
3.静态变量可以被所有的对象共享,(在类中修改静态变量后,调用都进行改变)
4.静态对象的访问
可以用对象访问也可以用类访问,建议使用类访问(对象访问和类访相互对应)
类名访问: 类名.静态变量名 (取值) 类名.静态变量名 = 值; (赋值)

静态变量和非静态变量的区别:
概念上: 非静态属于对象,静态属于类变量
内存空间上:非静态对象储存在堆内存,静态储存在方法区中静态区
存活时间:非静态和对象的生命周期一样,静态和类生命周期一样
访问方式:非静态可以通过对象访问,静态可以通过对象和类访问

静态方法特点:(静态不能访问非静态,非静态可以访问静态)
可以用对象访问也可以用类访问,建议使用类访问(对象访问和类访相互对应)
静态方法不能访问非静态方法
静态方法不能调用非静态方法
静态方法不能使用this关键字

工具类,帮助文档,Arrays工具类
工具类中都是静态方法,无构造方法
private修饰空参构造,方法私有化
Array 操作数组工具类,方法

1. 自己写了ArrayTool工具类, 其实jdk提供有专门用来操作数组的工具,就是Arrays
2. 使用之前要导包: import java.util.Arrays;
3. Arrays中的常用方法:
   1.sort(int[] arr): 对整型属性进行升序操作
   2.binarySearch(int[] arr, int key): 返回执行数据key,在数组arr中下标,
   注意: 使用前提是arr一定是一个升序的数组.
   3.equals(int[] arr1, int [] arr2): 用来判断两个数组arr1和arr2 对应位置所有元素是否相等.如果相等返回true,否则false
   4.fill(int[] arr, int val): 将数组arr中所有元素都填充为val;
   5.toString(int[] arr): 讲数组转为字符串,并返回.

代码块,继承,final
代码块:使用大括号括起来的一段代码,根据出现的位置不同,有不同的名称,根据是否有修饰符有不同的
作用和不同的执行时机
分类:局部代码块 构造代码块 静态代码块 同步代码块
局部代码块:方法中大括号括起来的一段代码
作用:限制局部变量的生命周期,局部代码块中声明的变量只能在局部代码块中使用
注意事项:1.在方法中定义的变量在局部代码块中不能重复定义
2.局部代码块可以使用方法中定义的变量,在代码块中修改后,出代码块不会恢复
构造代码块:在类后到括号中,直接写在类体中的使用大括号括起来一段代码
作用:给成员变量赋值,如果执行多个相同操作的构造方法,可以把相同的操作提取到构造代
码块中,这样就只需要执行一份就够了,可以简化代码
注意事项:在构造代方法执行前执行,构造方法执行一次,构造代码块就会先执行一次
静态代码块:static{执行内容},可以在类后大括号,也可以在类体中
作用:用于给静态变量赋值. 用于执行一个类一生只执行一次的代码
注意事项:随着类的加载而加载,静态代码块只执行一次,早于所有对象
继承
父子:被继承的类 子类:用于继承的类 派生类
继承的目的:为了让类和类之间产生一种父子类关系.(扩展 增加)
好处: 1.提高了代码的复用性, 2.提高了代码的可维护性(减少代码量,减轻设计难度),
3.多态的前提
弊端: 1.提高了类之间的耦合性(事物与事物的之间的依赖关系,互相影响程度)
注意事项:1.父类中的私有成员变量子类不能直接访问(set get方法)
2.父类中的私有方法子类不能直接访问 (父类中调用),子类在进行调用
继承中成员变量的关系:
1.子类可以直接访问父类的成员变量(除私有变量)和子类的成员变量
2.相同名字的变量就近访问原则
继承中成员方法的关系:
1.方法名相同 ===重写(父类提供的方法无法满足子类)
2.完全重写,全部都按父类的方法进重写
3.不完全重写,super进行调用,在进行重写子类方法
继承中构造方法的关系:
1.父类的构造方法不能被继承(子类通过super语句对成员变量进行赋值)
2.子类中先完成父类成员变量的初始化,在初始化子类独有的成员变量
3.子类构造方法中没有调用父类的构造方法系统会自动在子类添加空参构造
4. 构造方法不能递归调用
this:表示当前应用对象的引用 this 子父类(方法变量)
super:表示本类对象父类部分数据的引用 super 父类 super不能打印(只代表调用过程)
1.只能出现在子类构造方法的第一行,不能在子类的其他方法中出现
2.不能同时出现在构造方法中,
3.this()表示访问本类构造方法,super 父类构造方法
重写 在子父类中 参数列表相同 与返回值类型有关(相同)
重载 在一个类中 参数列表不相同 与返 回值类型无关
而且重写可以通过@Override校验, 子类重写权限不能比原来小
java的继承特点
支持单继承,不支持多继承,支持多层继承
final:修饰的父类不能被继承,变量不能改变;修饰方法不能被重写
多态
多态:事物的多种形态
好处:提供代码的扩展性
分类:对象的多态和类型的多态
对象的多态:同一个对象,可以具有不同名称,可以使用不同类型指向它
类型的多态:同一类型,可以有不同子类类型,有不同的实现
实现的前提:1.继承 2.父类类型的引用指向子类对象 3.方法的重写
成员访问特点:编译看左,运行看左
成员方法访问的特点:不重写:编译看左,运行看左
重写:编译看左,运行看右
静态访问的特点:只能类有关系, 和对象没有关系, 无论指向那个对象走的都是类的实现
不论方法还是变量,编译看左,运行看左
向上向下转型:多态就是向上转型, 父类类型 父类引用 = new 子类类型();
有向上转型才能有向下转型 子类类型 子类引用 = (子类类型)父类引用;
本质:向上缩小访问权限,向下回复对象的访问权限
抽象
抽象类
概念:能储存抽象方法的类
抽象类格式: abstract class 类名{ 类体; }
注意事项: 1.用来定义抽象方法
2.子类继承后必须重写所有的抽象方法
3.抽象类中可以定义成员变量,可以定义构造方法,
4.不能创建对象,可以包含实现的方法,
5.不能实例化,不能和private一起修饰
子类: 1.普通类,要实现父类所有的抽象方法
2.抽象类,可以实现,可以不实现
3.可以实例化
抽象方法
抽象方法:只包含方法的声明部分,没有方法的实现部分,这种方法就是抽象方法.
方法格式: 权限修饰符 abstract 返回值类型 方法名(参数列表);
注意事项: 1.修饰符必须包含 abstract
接口(抽象方法)
接口的好处: 1.扩展一个事物的功能
2.达到高内聚低耦合的目的
3.方便后期维护
4.在程序中可以做到规则(抽象方法)和实现者(实现类)相分类
接口格式: interface 接口名{ 抽象方法 }
注意事项: 1.不可实例化,都是抽象方法,不能定义带有方法体的方法
2.不能定义成员变量,系统默认添加 public static final 修饰
3.成员变量都是静态常量
4.不能定义构造方法
接口的实现: class 类名 implements 接口名{ 重写接口中所有的抽象方法 }
注意事项: 1.普通类,全部实现, 抽象类,实现接口后,可以部分实现抽象方法
2.可以实现多态
3.实现类访问自己父类的构造方法.
类与接口的关系:实现的关系(implements),
类可以单实现和多实现接口(类和类只能单继承),没有多层实现(类和类可以多层继承)
类与接口的区别:都可以做顶层父类,
一个子类可以继承自一个父类, 一个类也可以实现某个接口(继承自这个接口了)
接口和接口的关系:可以单继承,多继承和多层继承
内部类
内部类:定义在内部的类就是内部类
内部类分类: 成员内部类(类后大括号中) 局部内部类(方法后大括号中)
成员内部类:普通成员内部类 内部类可以访问外部类(私有可以) 外部类不能直接访问(创建对象访问)
外部类以外(创建对象) 外部类.内部类 内部类对象名 = new 外部类名().new 内部类名()
私有成员内部类 可以访问外部类所有内容 外部不能直接访问(创建内部类对象进行调用)
外部类以外不能访问私有成员内部类
静态成员内部类 不能访问外部类非静态内容(静态不能访问非静态) 外部不能直接访问
(创建内部类对象)
外部类以外(创建对象) 外部类名.静态内部类名 对象名 = new 外部类名.静态内部类名();
根据名字分类: 有名字内部类 匿名内部类
局部内部类: 内部类可以使用方法中局部变量 方法不能直接使用局部内部类内容(创建内部类对象)
外部类以外 调用方法才能使用局部内部类
匿名内部类: 使用条件:继承自某个类
实现某个接口
匿名内部类格式: new 父类名 (){ 重写父类中抽象方法};
new 接口名(){重写接口中抽象方法};
匿名内部类的本质:快速的为一个类提供一个子类对象,或者为一个接口提供一个实现类对象;
匿名内部类的命名规则: 有名字的内部类命名规则 类名 =[外部类名$内部类]匿名内部类命名规则A类名$n, n从1开始,逐次增大
包:1.pageage 包的声明
2.在不同的包下可以采用全类名的方式和导包的方式进行访问
3.全部小写 公司域名倒写 本质就是文件夹
4.同一个包下不能有相同的类
权限修饰符:
修饰符 本类中 本包其他类中 本包子类中 其他包中其他类 其他包中子类
默认(啥都不写) 能 能 能 不能 不能
public(公共的,公开的) 能 能 能 能 能
protected(被保护的) 能 能 能 不能 能
private(私有的) 能 不能 不能 不能 不能
默认的只有本包中能直接访问;
public那都能直接使用;
protected其他包中无关类之外,在哪都能直接访问;
private只有自己类中能直接访问,其他都不能.

十一. Object Scanner String
API:应用程序编程接口
使用API:调用时需要传入什么数据,调用完返回什么数据
类库:类的储存仓库 API分类打包成jar文件,jar打包整理形成类库
工具类:没有构造方法,都是静态方法
Object
Object:类层次结构的根类
构造方法:Object() 生成一个Object对象
成员方法:getClass() 返回当前运行时类,返回class类型数据
常用方法getName()
hashCode() 作用:根据对象生成一个整数(哈希值)
方法特点1.同一对象多次调用hashCode方法时,必须一致的返回相同的
整数
2.使用equals方法判断相等的两个对象,调用hashCode方法必
须生成相同的整数结果
3.equals方法不相等,调用hashCode尽量返回不相同的整数(提
高hashCode性能)
4.hashCode会根据不同的对象生成不同的整数
toString() 作用: 返回当前对象字符串描述
注意事项:1.子类继承Object后重写toString方法,
2.打印对象内容不需要调用toString方法(系统自动打印toString结果)
3.重写(快捷键)(类名 属性名 = 属性值,属性名 = 属性值)
4.不怎么使用toString方法,除了重写,打印系统自动打印toString
equals() 作用: 用来判断两个对象是否相等的方法
方法特点:1.自反性 2.对称性 3.传递性 4.一致性 5.x.equals(null) false
== 和 equals区别
相同点:都用来比较两个数据是否相等
不同点: 1. == 可以比较任意类型,比较地址(equals只能比较引用对象)
2.== 是个运算符, equals是个方法
3.== 基本数据类型比较数值,引用类型比较地址
equals 引用类型重写前比较地址,重写后比较地址.类型和属性
finalize() 执行时机:当一个对象死之前由虚拟机自动调用的方法
Scanner(util)
Scanner:扫描器,根据规则把数据解析为基本数据类型或者字符串类型(按分割符解析:\n和空格)
构造方法:Scanner(inputStream is)根据键盘录入创建一个扫描器对象
Scanner(String source) 根据字符串创建一个扫描器对象
Scanner(File f)根据文件对象创建一个扫描器对象
对象方法:基本数据类型扫描方法 [ 没有nextChar()方法,当做String类型使用] (以空格为分隔)
nextByte(), nextShort(), nextInt(), nextLong(), nextFloat(), nextDouble(), nextBoolean()
字符串数据扫描方法
字符串next()以空格为分隔, nextLine() 读取整行以换行符为分隔
注意事项:1.int以下计算时自动转化为int接受的数据,
2.nextFloat():录入不需要加f或者F的后缀, 录入不是java代码.
3.整型类型都是以空格为分隔
Scanner两种换行符输入时的解决办法
1.调用两次nextLine.
2.创建两个Scanner对象
3.所有数据都用nextLine()方法接收,返回String类型,进行转换
String(lang)
注意事项: 1.所有的字符串对象是不可变的
2.所有的字符串都是常量(底层final修饰的char数组)
3.操作String类型原字符串不变,返回一个新的字符串
构造方法:1.String() === " " 不等于null
2.String(byte[]arr) byte数组转化为字符串了类型
3.String(byte[]arr,int offset,int length) 从某处开始转化几个为字符串
4.String(char[]arr) 将char数组转化为字符串类型
5.String(char[]arr,int offset,int count) 从某处开始转化几个为字符串
String判断: 返回的都是boolean类型的
1.equals(Object obj) 判断字符串相等
2.equalsIgnoreCase(String anotherString)忽略大小写判断两个字符串是否相等
3.startsWith(String prefix) 判断字符串是否是指定开始
4.endsWith(String suffix) 判断字符串是否是制定结尾
5.contains(String s)判断字符串是否包含指定字符串
6.isEmpty()判断字符串是否为空
7.String(String original(在常量池))在堆区
获取的相关方法: length()返回字符串的长度
1.charAt(int index)返回指定索引下标字符
2.subString(int beginIndex)获取字符从某个位置开始
3.subStrng(int beginIndex,int endIndex)获取指定字符从某处到某处 含头不含尾
4.contcat(String s)末尾处拼接
5.indexOf
(隐式转换 int) indexOf(int ch)返回指定字符在字符串中第一次出现的位置
indexOf(int ch,int fromIndex)从指定该字符第一次出现的位置,然后开
始索引
indexOf(String s)返回指定字符串第一次出现的位置
indexOf(String s,int fromIndex)指定字符串第一次出现的位置,然 后开始索
引该字符串
lastIndexOf 和 indexOf相反是从后向前找,第一次出现的位置
String类型的转换:1.byte[] getByte()把字符串转换为byte数组
2.char[] toCharArray()把字符串转化为char数组
3.toUpperCase()把字符串转换为大写的字符串
4.toLowerCase()把字符串转换为小写的字符串
5.concat(String str)拼接
6.valueOf家族 其他类型转化为字符串,静态方法,用String类名调用

其他方法:replace(String oldStr,string newStr)替换
               trim()去掉头部和尾部的空白                            

StringBuilder 包装类和正则
StringBuilder(改变原来的字符串)储存字符
StringBuilder:可变的字符序列,字符缓冲区(默认大小16个),单个线程使用较多
添加方法:append自动转换为字符串添加在StringBuilder末尾
insert 插入字符串末尾,不能越界(capacity)
删除方法:delete(int start,int end)指定删除范围含头不含尾
deleteCharAt(int index)制定下标删除字符
修改方法:replace(int start, int end,String str)替换含头不含尾
reverse()将原来的字符串翻转
构造方法:1.StringBuilder()转化类型 初始容量16个字节
2.StringBuilder(int capacity)创建一个StringBuilder对象并指定容量
3.StringBuilder(String str)String转StringBuilder
4.capacity()获取容量 扩容:n*2+2
5.length()获取长度
StringBuilder作为参数时
StringBuilder作为方法参数时,方法内部new对象,类里new对象不变
String和StringBuilder的区别:1.String不可变的字符串(StringBuilder可变字符串)
2.String长度不可变(StringBuilde可变)
String拼接和Builder拼接的区别:1.String(contcat())需要每次都新建,
2.StringBuilder(append)自带缓冲区,原数组改变
String和Builder的互转:1.String转StringBuilder StringBuilder(String str)和StringBuilder()
2.StringBuilder转String toString和String(StringBuilder sb)空参构造
StringBuffer StringBuilder的区别:1.出现的版本不同(jdk1.0和jdk1.5)
2.线程安全不同
3.效率不同
数字到字母叫解码,字母到数字叫编码=字节数组转成字符串叫做解码
基本数据包装类型
基本数据类型=包装类型(首字母大写)=>char=character
Integer类
int =====>Integer
构造方法:1.Integer(int i) 基本数据类型转化为对象包装类型
2.Integer(String str) String类型(只能是整数数据)转化为数据对象包装类型
成员方法:byteValue(),shortVlaue(), intValue(), longValue(), floatValue(),doubleValue()
Integer类型转化为各自的基本数据类型
Integer静态方法:1.paserInt(String str)将字符串以10进制的数据转化为int类型进行返回
2.paserInt(String str, int radix)指定进制转化为int数据返回
3.toBinaryString(int i)转化为2进制字符串表示
4.toHexString(int i)转化为16进制字符串表示
5.toOctalString(int i)转化为8进制字符串表示
6.valueOf(int i)把int类型转化为Integer对象
7.valueOf(String str)把String类型转化为Integer对象
8.valueOf(String str, int radix)把字符串类型指定进制转化为Integer类型
System.out.println(i4);
Integer常量属性:MAX_VALUE MIN_VALUE SIZE(int类型所占的比特位数)
TYPE(int类型在方法区生成的Class对象)
String int Integer类型的转换:
Integer转int: intValue() Integer转String toString()和+" "
int转Integer Integer(int i)和valueOf(int i) int转String Integer.toString(int i)和+" "
String转int Integer.parsetInt(String str) String转Integer Integer(String str)和
Integer.valueOf(String str)
自动装箱和自动拆箱(jdk1.5之后)
装箱: 将基本数据类型,封装到对应包装类型的过程就是装箱. 实用构造方法即可
拆箱: 把包装类型中存储数据, 转为对应基本数据类型过程,就是拆箱. ***Value()
自动装箱和自动拆箱:
自动装箱: 可以直接使用基本类型数据赋值给对应包装类型变量.
自动拆箱: 可以直接使用包装类型给基本数据类型的变量赋值