目录
一丶Java开发环境
环境变量配置
Windows系统下配置JDK环境变量
(1)安装JDK,我们可以自定义安装目录
(2)右击此电脑,选择属性
(3)点击高级系统设置,选择环境变量
(4)在系统变量中,设置3项属性,JAVA_HOME PATH CLASSPATH
如果已存在则点击编辑,不存在则点击新建
(5)JAVA_HOME选择JDK安装路径,例如E:\Java\JDK
(6)PATH设置为%JAVA_HOME%/bin;
(7)创建CLASSPATH变量,设置为 .;%JAVA_HOME%/lib;
(8)cmd输入命令javac,java,java -version这几个命令,出现东西,说明环境变量配置成功
二丶标识符、关键字、数据类型
1.注释
注释有三种形式:单行注释,多行注释以及文档注释
单行注释://
多行注释 :/*
文档注释:以/**开始,以*/结束
2.分隔符、代码块
以;作为代码结束语句
{}里面的代码叫代码块
3.标识符
在Java中类名,方法名以及变量名称为标识符
标识符命名要求
(1)必须以字母、数字、_或$组成
(2)不能以数字作为开头
(3)不能使用java的关键字和保留字
驼峰命名:第一个单词的首字母如果是大写则是大驼峰命名法,若是小写,则是小驼峰命名法
4.关键字
Java语言中有一些特殊的用途的词称为关键字,关键字不能用作变量名、方法名、类名、包名和参数。
5.基本数据类型
类型的范围
6.常量、变量
6.1变量
变量是Java程序中的基本存储单元,它的定义主要包括变量名、变量类型和变量的作用域三个部分。
变量的声明: 数据类型 变量名称。例如:int i;
变量的值可以声明时赋值,也可以声明后赋值。
在声明时赋值 int i = 20; 在声明后赋值 i = 20;
全局变量
在类的{}内直接定义的变量,称为全局变量。
全局变量在整个类中都可以使用。
全局变量在创建对象时会自动初始化,并有初始值(默认值)
局部变量
在方法体内部定义的变量,称为成员变量。
成员变量只能在方法体内部使用。
成员变量不会自动初始化,没有默认值,使用之前必须要初始化。
6.2常量
在Java语言中,主要是利用final关键字(在Java类中灵活使用Static关键字)来进行Java常量定义。
一般情况下我们把static与final结合起来声明一个常量,例如:static final int i= 123;
当常量被设定后,一般情况下就不允许再进行更改。
7.类型转换
Java中类型转换分自动类型转换和强制类型转换。
自动类型转换
类型兼容、小类型转换为大类型
byte-->int short--->int int--->long
long--->float float--->double
String--->Object (子类--->父类)
强制类型转换
大类型转换为小类型
int-->byte int--->short long--->int
float--->long double--->float
Object--->String (父类--->子类)
8.方法
package com.xszx;
/**
* @Author 杨 滢
* @CreateDate 2023-03-15 15:30
**/
public class type {
public static void main(String[] args) {
byte b = 15;
short s = 30;
int i = 126;
long l = 222L;
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(l);
}
}
三丶运算符、表达式、选择结构
1.运算符
- 按操作个数分类:
单目运算符:只需一个操作数参与运算。
双目运算符:需要两个操作数参与运算。
三目运算符:需要三个操作数参与运算
- 按运算符功能分类:
算数运算符 :+ - * / % ++ – –
关系运算符:> < >= <= == !=
逻辑运算符: ! && || & |
位运算符 :>> << >>> & | ^ ~
赋值运算符:= += -= *= /=
条件运算符 :? :
其他:instanceof
(1)算术运算符
运算符 | 运 算 |
+ | 加 |
- | 减 |
* | 乘 |
/ | 除 |
% | 取余 |
+= | 加并赋值 |
-= | 减并赋值 |
*= | 乘并赋值 |
/= | 除并赋值 |
%= | 取余并赋值 |
++ | 自增 |
-- | 自减 |
n++ 被使用之后再进行值加1 ++n 值先加1再进行使用
n-- 被使用之后再进行值减1 --n 值先减1再进行使用
(2)关系运算符
关系运算符是两个操作数之间的比较运算
运算符 | 运 算 |
== | 等于 |
!= | 不等于 |
> | 大于 |
< | 小于 |
>= | 大于等于 |
<= | 小于等于 |
关系运算的结果为布尔类型值,如果关系成立为true,否则为false
关系运算符最常用于if语句和各种循环语句中的控制表达式
(3)逻辑运算符
逻辑运算符是对布尔类型操作数进行的与,或,非,异或等运算,运算结果仍然是布尔类型值
运算符 | 运算 | 结果 |
& | 与 | 左右两边都为true,结果为true,否则为false |
| | 或 | 左右两边只要有一个为true,结果为true,否则为false |
^ | 异或 | 左右两边不同,结果为true,否则为false |
! | 非 | 取反 |
&& | 逻辑与 | 左右两边都为true,结果为true,否则为false |
|| | 逻辑或 | 左右两边只要有一个为true,结果为true,否则为false |
(4)位运算符
位运算符是对操作数以二进制为单位进行的操作和运算,位运算数的运算对象只能是整型和字符型,结果为整型
(5)赋值运算符
赋值运算符的次序是从右向左的,即先计算表达式的值,再将表达式的赋值给变量。
(6)条件运算符
表达式为:表达式1?表达式2:表达式3 例如: int m =(a>b)?a:b
运算符按照优先级别的高低排序分别是:自加 / 减运算符、 算术运算符、关系运算符、逻辑运算符、赋值运算符。
2.表达式
- 表达式由操作数与运算符组成
- 操作数可以是常量、变量,也可以是方法
- 运算符就是数学中的运算符号比如+、-、*、/、%等
3.选择结构
单分支if语句
语法格式:
if(条件){
语句
}
注意事项:
- 条件的结果只能是布尔类型的值
双分支if语句
语法格式:
if(条件){
语句1
}else{
语句2
}
注意事项:
else子句不能单独使用,它必须是if语句的一部分,与最近的if语句配对使用
多分支if语句
语法格式:
if(条件1){
语句1
}else if(条件2){
语句2
}else if(条件3){
语句3
}
…
}else{
语句n
}
注意事项:
不论多分支if语句中有多少个条件,只会执行符合条件的一个,如果没有符合条件的,则执行else子句中的语句。
多分支switch语句
语法格式:
switch(表达式){
case 常量 1:
语句;
break;
case 常量 2:
语句;
break;
…
default:
语句;
break;
}
注意事项:
- 如果case后没有break语句,程序将继续向下执行,直到switch语句结束或遇到break语句
- 在同一个switch语句中,两个case常量不允许具有相同的值
- 每个case语句中需要加上break;语句。如果遗漏了break,则会继续进入到下一个case。
-
default语句通常放在末尾,可以放在开始,中间或者末尾位置
四丶控制语句
1.while循环
语法结构:
while(条件){
执行的代码块;
}
注意事项:
条件是boolean类型的
当条件为true时则会重复执行其中的代码块。
如果条件为false的话则会停止运行。
2. do while循环结构
语法结构:
do {
语句块;
}while(条件表达式);
至少执行一次循环
3.while 和do while的区别
do while先执行 后判断 所以它至少执行一次
while先判断条件 再执行 有可能一次也不执行
所有的循环,都可能出现死循环
4.for循环
语法结构:
for(初始化表达式; 条件表达式; 更新表达式){
循环体;
java语句;
java语句;
....
}
循环是可以嵌套的,包括while和do-while循环
5.break和continue
break:结束本层循环
continue:跳过本次循环,执行循环的下一次
五丶数组
1.概念
数组是指一组数据的集合,数组中的每个数据被称作元素。在数组中可以存放任意类型的元素,但同一个数组里存放的元素类型必须一致。
2.数组声明
数据类型[] 数组名;
int[] a; //声明一个int类型的数组,名字为a
或 数据类型 数组名[];
int a[];
3.数组创建及初始化
int[] a; //声明
数组名=new 数组类型[数组长度];
例如:a=new int[5]; //给数组对象开辟一个长度为5的空间
数组创建的三种方式
int[] nums = new int[5]; //初始化为默认值
int[] nums = {1,2,3,4,5}; //初始化为{}中指定的值
int[] nums = new int[] {1,2,3,4,5};//初始化为{}中指定的值
4.数组的操作
-
通过下标访问数组元素
-
通过循环打印输出所有数组元素
-
可以使用属性length获取数组的长度
5.数组排序
- 冒泡排序
-
Arrays.sort()
6.二维数组
初始化:
Int[][] 数组名称 = new int[行数][列数];
例如:Int[][] arr = new int[3][5];
遍历:
先遍历第一维,然后在内层循环遍历第二维
int[][] a = new int[3][5];
for(int i = 0 ; i < a.length ; i++){
for(int j = 0 ; j < a[i].length ; j++){
System.out.println(a[i][j]);
}
}
六丶类和对象
1.基本概念
类:有相同特征的事物的集合
对象:对象是类实例化出来的,对象中含有类的属性
2.类与对象的定义和使用
- 创建类的语法:
class 类名称 {
成员变量/ 实例变量;
成员方法;
}
- 创建对象的语法:
类名称 引用名称 = new 类名称()
Phone p = new Phone();
例如:
public class PhoneTest {
public static void main(String[] args) {
//创建一个实例化对象
Phone p = new Phone();
//通过对象来调用实例变量,成员方法
p.setBrand("小米");
p.setPrice(998);
p.call();
p.sendMessage();
p.playGame();
}
}
3.方法
已经写好的代码块,可能会被重复利用多次,就可以把这段代码抽象成方法
- 创建方法的语法:
public static 方法返回值 方法名称(参数类型 形式参数列表) {
方法体代码;
[return 返回值];
}
- return
(1)return语句用于明确地从一个方法返回。即,return语句导致程序的执行控制转移回到方法的调用者。
(2)如果return之后还有代码也不会执行。
(3)如果方法的返回类型为void,可以使用return跳出函数,但是不能使用return返回数据。
(4)可以返回对象。
4.方法的调用
-
调用相同类中的方法:可以直接调用。(本质上是使用this关键字调用)
-
调用其他类中的方法:对象.方法名
5.构造器(构造方法)
-
构造方法的作用:开辟内存空间、创建实例、初始化属性值
-
构造方法的特点:
(1)方法名与类名相同
(2)不能声明返回类型
(3)不能使用return语句
(4)通常为public
6.方法重载
方法重载是指发生在同一个类中,定义了若干个方法名称相同,参数列表不同的(参数类型、参数个数不同),且与返回值无关的一组方法,叫做方法重载
public class aa{
//两个整型相乘的方法
public static int add(int a, int b) {
return a* b;
}
//两个整型相加的方法
public static int add(int a, int b) {
return a + b ;
}
}
特点:
1、方法名相同
2、形参列表不同:形参的类型/顺序、形参的个数
注意的地方:
1、返回值在区分重载方法时不起作用。修饰符也不起作用
2、当调用重载方法时,Java使用参数的类型和/或数量确定实际调用哪个版本。
七丶面向对象-封装
1.基本概念
封装是面向对象的三大特征之一(封装 继承 多态)
所谓的封装就是把类的属性和方法使用private修饰,不允许类的调用者直接访问,而是通过该类所提供的方法来实现对内部信息的操作和访问
2.private关键字
是一个权限修饰符 ,可以用来修饰成员变量和成员方法.被私有化的成员只能在本类中访问
3.访问控制符
修饰符 | 同类 | 同包 | 子类 | 所有包 |
public | 是 | 是 | 是 | 是 |
protected | 是 | 是 | 是 | |
默认 | 是 | 是 | ||
private | 是 |
4.this关键字
this关键字指向的是当前对象的引用
用法:
- this.属性名称
指的是访问类中的成员变量,用来区分成员变量和局部变量(重名问题)。
- this.方法名称
用来访问本类的成员方法。
- this()
访问本类的构造方法。
()中可以有参数的 如果有参数 就是调用指定的有参构造。
注意事项:
- this() 不能使用在普通方法中 只能写在构造方法中。
- 必须是构造方法中的第一条语句。
5.static关键字
static可以是:
1.变量
如果将一个变量声明为static
,就是静态变量了
2.Java静态方法
如果在任何方法上应用static
关键字,此方法称为静态方法,静态方法属于类,而不属于类的对象,可以直接调用静态方法,而无需创建类的实例,静态方法可以访问静态数据成员,并可以更改静态数据成员的值。
静态方法的限制:
1.静态方法不能直接使用非静态数据成员或调用非静态方法。
2.this和super两个关键字不能在静态上下文中使用。
3.Java静态块
Java中的静态块主要有两个作用:
- 用于初始化静态数据成员。
- 在类加载时在main方法之前执行。
八丶面向对象-继承
1.基本概念
- 继承就是java允许我们用extends关键字,让一个类和另一个类建立起一种父子关系。 提高代码复用性,减少代码冗余,增强类的功能扩展性。 继承的格式 子类 extends父类
-
被继承的类称为父类,继承的类称为子类
2.语法
public class A extends SuperA{
}
3.继承的特点
子类可以继承父类的属性和行为,但是子类不能继承父类的构造器。 Java是单继承模式:一个类只能继承一个直接父类。 Java不支持多继承、但是支持多层继承。 Java中所有的类都是Object类的子类。
4.对象的转型
- 子类对象 赋给 父类引用 自动转换
- 父类引用 赋给 子类引用 需要强转 ,前提:父类引用确实指向了正确的子类对象
5.super关键字
关键字 | 访问成员变量 | 访问成员方法 | 访问构造方法 |
this | this.成员变量 访问本类成员变量 | this.成员方法(…) 访问本类成员方法 | this(…) 访问本类构器 |
super | super.成员变量 访问父类成员变量 | super.成员方法(…) 访问父类成员方法 | super(…) 访问父类构造器 |
6.object类
Object 是 Java 类库中的一个特殊类,也是所有类的父类
- equals()方法
equals方法默认判断的是地址是否相等,等价于 ==,子类中往往重写该方法,用于判断内容是否相等
- tostring()方法
直接打印对象时,默认调用对象的toString()方法
- HashCode()方法
返回该对象的哈希码值
当我们重写equals()方法,判断两个对象相等时,最好也同时重写hascode()方法,让相同对象的哈希码值也相同
7.final
- 如果final修饰变量,变量就是常量,常量不可修改,定义时必须初始化
- 如果final修饰方法,方法就不能被子类重写
-
如果final修饰类,类就不能再被扩展,不能再有子类。Java类库中的String、Math就是final类
-
final修饰的对象引用不可变,内容可变
如果final修饰的常量是基本数据类型,不可以再修改。
如果final修饰的常量是引用类型,不能再将其他对象赋给该引用,但可以使用该引用改变对象内部的属性。
九丶面向对象—多态
1.基本概念
同一个对象,在不同时刻表现出来的不同形态
2.多态的前提
-
要有继承或实现关系
-
要有方法的重写
-
要有父类引用指向子类对象
3.方法重写与方法重载的区别
只有当两个方法的名称和类型签名都相同时才会发生重写。如果不是都相同,那么这两个方法就只是简单的重载关系
重载是在同一个类中,两个方法的方法名相同,参数列表不同(参数类型、顺序、个数),与方法返回值无关
重写发生在父类和子类之间,子类继承父类方法(非构造、final、static修饰的方法)并重写父类方法。
重写规则:
- 重写方法参数列表、返回值类型必须和父类被重写的方法保持一致
- 重写方法的访问权限不能低于父类被重写的方法
4.内部类
概念:把类定义在其他类的内部,这个类被称为内部类
分类:根据其所在位置及形式的不同,分为成员内部类、静态内部类、局部内部类、匿名内部类
成员内部类
class Outer {
// 成员内部类
class Inner {
}
}
访问成员内部类中的方法:
Outer.Inner inner = new Outer().new Inner();
静态内部类
class Outer {
// 静态内部类
static class Inner {
}
}
访问静态内部类中的方法:
Outer.Inner inner = new Outer.new Inner();
方法内部类
class Outer {
// 成员方法
public Object show() {
// 方法内部类
class Inner {
}
}
}
访问静态内部类中的方法:
Outer outer= new Oute();
System.out.println(outer.showr());
匿名内部类
new Object(){
3 void show(){
4 System.out.println("HHHHHH");
5 }
6 }.show();
十丶面向对象—接口
1.基本概念
简单的说,接口就是一种被规范的标准,只要符合这个标准都可以通用
2.接口的格式
public interface 接口名
3.接口中的属性和方法
(1)接口中所有方法默认是公有的抽象方法
隐式地标识为public、abstract,并且接口中的方法也只允许使用这两个修饰符。
注意,在抽象类中必需使用abstract关键字明确指定方法为抽象方法。
(2)在接口中所有变量默认为公有的静态常量
被隐式地标识为public、static、final。这意味着实现接口的类不能修改它们。同时还必须初始化它们。
4.接口的实现
一旦定义了一个接口,一个或多个类就可以实现该接口。为了实现接口,在类定义中需要包含implements子句,然后创建接口定义的方法
public class Aimplements B{
}
注意:
(1)实现接口的类,必须实现接口的所有抽象方法,如果只实现了部分抽象方法,该类必须声明为抽象类
(2)一个类可以实现多个接口,实现的多个接口用,隔开
(3)实现接口的类可以同时继承一个父类,必须是先继承后实现
5.接口的实现
接口可以通过关键字extends继承另一个接口,其语法和类继承相同。如果类实现的接口继承自另外一个接口,则该类必需实现在接口继承链中定义的所有方法
6.抽象方法与抽象类
- 抽象方法
抽象方法是使用abstract修饰的方法。将一个方法声明为抽象方法,如果有继承关系要求子类必须重写该方法
注意:
- 抽象方法没有方法实现,即没有方法体{},只有定义
- 类中如果有抽象方法,该类必须是抽象类,必须使用abstract
- 对于抽象方法,abstract不能与private、static同时使用
- 抽象类
类定义中使用abstract修饰的类为抽象类
注意:
- 从语法上讲,抽象类中可以没有抽象方法,但是没有实际意义
- 有抽象方法的类必须是抽象类
- 抽象类不能new对象
7.抽象类与接口的区别
抽象类 | 接口 | ||
都可以有抽象方法,都不能实例化,但都可以声明,并能引用子类或实现类对象 | |||
相同点 | |||
不同点 | 属性变量 | 可以有变量 | 只能是静态常量,数据成员必须初始化 |
成员方法 | 可以有具体方法,而且具体方法可以调用抽象方法 | 如果有方法,全部是抽象方法 | |
构造方法 | 有构造方法 | 没有构造方法 | |
继承 | 只能单继承 | 可以多重实现接口 | |
扩张性 | 弱 | 强 |
十一丶常用类
1.包装类的分类
Java有八种基本数据类型:byte、short、int、long、float、double、char、boolean
提供了8种对应的包装类:Byte、Short、Integer、Long、Float、Double、Character、Boolean
2.使用原因
一方面出于性能方面的考虑,java为数值使用基本类型,而不是对象。基本类型不是对象层次的组成部分,它们不继承Object。
3.自动装箱与自动拆箱
- 自动装箱
自动装箱就是在需要的时候,基本数据类型会自动被装配成为对应的包装类
创建包装类对象有两种方式:new关键字、valueOf()方法
Integer n = new Integer(3); //基本数据类型转为包装类
Integer integer = Integer.valueOf(8); //基本数据类型转为包装类
int m = n.intValue(); //包装类型转为基本数据类型
- 自动拆箱
自动拆箱就是自动装箱的逆过程,在需要的时候,包装类会被自动转换为对应的基本数据类型
Integer n = 20; //自动装箱
int m = n; //自动拆箱
System.out.println(n);
System.out.println(m);
4.String类
- 基本概念
在Java中字符串属于对象,,Java提供了String类来创建和操作字符串
String 类是不可改变的,所以你一旦创建了 String 对象,那它的值就无法改变了。 如果需要对字符串做很多修改,那么应该选择使用StringBuffer类或StringBuilder类
- 字符串长度
可以使用length() 方法来返回string字符串的长度
- String类的构造方法
String(); //创建不包含内容的字符串对象
String(char[ ] chars) //通过使用平台的默认字符集解码指定的char数组,构造一个新的String
String(byte[ ] bytes) //通过使用平台的默认字符集解码指定的byte数组,构造一个新的String
String(byte[] bytes,int offset,int length)
//通过使用平台的默认字符集解码指定的byte数组,构造一个新的String
还可以直接使用字符串字面创建String对象:String str = “abc”;
- 字符串的比较
String类重写了equals()方法,重写后的方法比较两个字符串对象的内容是否相同。
运算符“==”比较两个String引用是否指向同一个String对象
- 其他比较方法
boolean equalsIgnoreCase(String str) 将此String与另一个String比较,不考虑大小写。
boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始
- 字符串的连接
String str1 = “abc” ;
String str2 = “def”;
String str3 = “hij”;
(1) String str3 = str1 + str2;
(2)str1.concat(str2);
5. StringBuffer和StringBuilder
区别
- StringBuffer类是线程安全的它的方法都有
synchronized
关键字修饰,而StringBuilder则不是,即不保证其对象的同步性,在多线程环境中是不安全的 - StringBuilder在性能上要比StirngBuffer好一些。
StringBuffer类的常用方法
append()
append()方法将各种其他类型数据的字符串表示形式连接到调用StringBuffer对象的末尾该方法有多个重载版本,下面是其中的几个:
StringBuffer append(String str)
StringBuffer append(int num)
insert ()
在指定位置插入参数提供的内容,返回修改后的该StringBuffer对象引用。该方法有多个重载版本,下面是其中的几个:
StringBuffer insert(int index, String str)
StringBuffer insert(int index, char ch)
StringBuffer deleteCharAt(int index)
移除指定位置的字符,返回修改后的该StringBuffer对象引用
StringBuffer reverse()
将字符序列逆序,返回修改后的该StringBuffer对象引用
int length()
获取StringBuffer对象的当前长度
6.Date类
Date类封装了当前日期和时间。位于java.util包
常用方法
public Date() //使用当前日期和时间初始化对象
public Date(long date) //参数date为自从1970年1月1日子时经历的毫秒数
long getTime() //返回从1970年1月1日午夜开始已经流逝毫秒数
void setTime(long time) //将日期和时间设置为time所指定的值,time是是自从1970年1月1日午夜开始已经流逝的毫秒数
String toString() //将调用Date对象转换成字符串并返回结果
SimpleDateFormat类
SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化(日期 -> 文本)、解析(文本 -> 日期)和规范化。
SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
1.字符串转日期 2008-07-10 19:20:00 要把它转成日期,可以用
sf.format(date )
日期转字符串假如把今天的日期转成字符串可用
String str = sdf.format(new Date());
jdk1.8日期类
- Instant:// 时间戳 瞬时时间。
- LocalDate: // 同时含有年月日时分秒的日期时间对象 本地日期,不包含具体时间, 格式 yyyy-MM-dd。
- LocalTime:// 只含有时分秒的时间对象 本地时间,不包含日期. 格式 yyyy-MM-dd HH:mm:ss.SSS 。
-
ZonedDateTime:最完整的日期时间,包含时区和相对UTC或格林威治的时差
-
LocalDateTime: // 同时含有年月日时分秒的日期时间对象
-
十二丶集合
1.基本概念
(1)集合是存储其他对象的特殊对象。可以将集合当做一个容器。
(2)集合的相关接口和类位于java.util包中
(3)集合中的接口和类是一个整体、一个体系
2.集合接口
Collection 允许操作一组对象,它位于集合层次结构的顶部
List 扩展Collection,以处理序列(对象列表)
Set 扩展Collection,以处理组,组中的元素必须唯一
注意:
Set类型的集合(实现Set接口的类)称为集,其特点是组中的元素必须唯一
3.Collection接口
Collection接口是构建集合框架的基础,Collection是泛型接口,其声明如下:
interface Collection<E>,其中,E指定了集合将存储的对象类型
- 集合中只能存储对象,不能存基本类型
- 使用泛型的优点是在编译时可以检查元素的类型,从而更加安全
4.List接口
List接口扩展了Collection,并且声明了存储一连串元素的集合的行为。索引从0开始,通过它们的位置插入或访问元素。列表可以包含重复的元素
声明:interface List<E>
5.Set接口
Set接口定义了组/集/集合(set)。它扩展了Collection接口,并声明了不允许重复元素的集合的行为。如果为集合添加重复的元素,add()方法会返回false
声明:interface Set<E>
6.Arraylist类
ArrayList实现了List接口。本质上是元素为对象引用的长度可变的数组
ArrayList长度取默认值 10
7.LinkedList类
LinkedList类实现了List、Deque以及Queue接口。它提供了(双向)链表数据结构
8.ArrayList与LinkedList的区别
(1)ArrayList是基于数组结构的集合,有容量的概念;LinkedList是基于链表结构的集合,没有容量的概念
(2)对于随机访问(get和set方法),ArrayList优于LinkedList,因为LinkedList要移动指针
(3)对于新增和删除操作(add和remove方法),LinkedList比较占优势,因为ArrayList要移动数据。但是如果只是在末尾追加元素,并且没有超出容量限制,则ArrayList的性能更好。
(4)LinkedList 还实现了Queue接口,该接口比List提供了更多的方法,包括 offer(),peek(),poll()等
9.HashSet
HashSet类实现了Set接口。该类在内部使用哈希表存储元素
哈希法的优点是add()、contains()、remove()以及size()方法的执行时间保持不变,即使是对于比较大的集合也是如此
HashSet默认容量是16
10.Set与List的区别
(1)Set中的元素无序不能重复,List中的有序元素可以重复
(2)List有索引(下标)的概念,Set没有索引的概念
(3)对于Set表示的集合,通常是遍历操作,没有get()和set()方法
11. Vector类
Vector类实现了动态数组,与ArrayList类似,也实现List接口。但有如下区别:
Vector实现同步,线程安全。ArrayList没有实现线程安全
Vector性能比ArrayList低
Vector和ArrayList在更多元素添加进来时会请求更大的空间。Vector每次请求其大小的双倍空间,而ArrayList每次对size增长50%
十三丶集合的遍历
1.Iterable接口
实现了Iterable接口的类是可以遍历的。因为Iterable接口是Collection接口的父接口
Iterable接口只定义了一个方法:
Iterator<T> iterator() //返回迭代器对象
2.Iterator接口
Iterator接口描述了迭代器的行为,所有迭代器类都必须实现该接口,该接口定义了以下方法:
boolean hasNext() 如果迭代还有更多的元素则返回true
T next() 返回下一个元素
void remove() 删除迭代器返回的元素
3.ListIterator接口
只有实现了List接口的集合类才提供了ListIterator迭代器
List接口提供以下两个方法用于获取列表集合的列表迭代器:
ListIterator<E> listIterator() 该迭代器从列表的开头开始
ListIterator<E> listIterator()(int index) 该迭代器从index所指定的位置开始
4.迭代器的使用
为了使用迭代器遍历集合的内容,需要以下步骤:
通过调用集合的Iterator()方法,获取指向集合开头的迭代器
建立一个hasNext()调用循环。只要hasNext()返回true,就循环迭代
在循环中,通过调用next()获取每个元素
5.增强for循环
如果不修改集合的内容,也不以反向获取元素,使用for-each版的for循环遍历集合通常比使用迭代器更方便
6.迭代器与增强的for循环之间的区别
使用迭代器遍历集合时,可以调用Iterator.remove()方法删除集合中元素,使用增强的for循环遍历集合时,不能删除集合中的元素
可以使用增强的for循环遍历数组,但是数组不支持迭代器
使用增强的for循环遍历基本类型的数组时,只能使用数组元素,而不能修改数组元素
7.Collections工具类
Collections类里面包括动态、有序、可变大小的一维数组Vector与ArrayList
十四丶Map集合
1.基本概念
- Map是一个接口,我们不能直接创建对象,可以通过多态的形式创建对象
- Map中一个元素包含两个值(一个key,一个value)
- Map中的元素,key不允许重复,value可以重复
Map实现常用的一般有两种,一是HashMap,另一个是TreeMap
2.Map集合的获取功能
方法名 | 说明 |
get(Object key) | 根据键获取值 |
keySet() | 获取所有键的集合 |
values() | 获取所有值的集合 |
entrySet() | 获取所有键值对对象的集合 |
3.Map遍历演示
//返回此映射中包含的映射关系的 Set 视图
Set<Map.Entry<Integer, String>> entries = hashMap.entrySet();
//遍历输出 hashmap 里面的数据
System.out.println("获取hashmap中所有的数据");
for (Map.Entry str :entries) {
System.out.print(str.getKey()+"\t");
System.out.print(str.getValue());
System.out.println();
}
4.Hashtable与HashMap的区别
- HashMap不是线程安全的,HashTable中的方法是Synchronize的,所以是线程安全。
- HashMap允许空(null)的键和值(key),HashTable则不允许。
- HashMap性能优于Hashtable
十五丶异常Exception
1.异常产生的原因
程序错误分为三种:1.编译错误;2.运行时错误;3.逻辑错误
(1)编译错误是因为程序没有遵循语法规则,编译程序能够自己发现并且提示我们错误的原因和位置
(2)运行时错误是因为程序在执行时,运行环境发现了不能执行的操作
(3)逻辑错误是因为程序没有按照预期的逻辑顺序执行
2.异常的处理
- 抛出异常
借助关键字throw,抛出一个指定的异常对象
- 捕获异常
try{
}catch(…){
}
finally{
}
异常处理过程:
(1)当执行过程中遇到异常时,系统会抛出异常(对象)
(2)catch()块捕获异常并处理
(3)没有被捕获的异常最终都将由默认处理程序进行处理。默认处理程序会显示一个描述异常的字符串,输出异常发生点的跟踪栈,并终止程序
十六丶反射
1.基本概念
反射是在运行时获取类或对象的信息的能力。具体的讲:可以通过类名或对象获取该类的相关信息,例如类的属性和方法、类实现接口或继承父类。甚至可以通过反射在运行过程中实例化对象,动态调用方法
2.Class对象
可以通过以下三种方式获取类的Class对象:
- 类名.class //大部分时候使用这种方式
- 对象.getClass()
- Class.forName(“类的全名”) //参数必须是类的全名
一旦获得了类的Class对象,就可以通过该Class对象获取类的相关信息了
3.使用反射生成并操作对象
获得了类的Class对象后,还可以通过Class对象调用newInstance()方法创建该类的对象。
Class<Student> c1 = Class.forName(“com.yy.day”);
Student s = c1.newInstance(); //这种情况要求Student类提供了无参构造方法
创建对象的另外一种方法:通过Constructor对象