一. java基本语法
1.关键字
(1)被Java语言赋予特定含义的单词

(2)特点：全部小写

(3)注意：goto和const作为保留字存在

2.标识符
(1)给类、接口、方法、变量等起名字的字符序列

(2)组成规则：

a.英语大小写字母

b.数字

c.$和_

(3)注意：

a.不能一数字开头

b.不能是java中的而关键字

c.区分大小写

(4)常见的命名规则(要见命知意)

a.包 全部小写

单个包：小写，如：wxhl

多个包：全部小写，中间用.隔开，如：com.wxhl.day18

b.类或者接口

一个单词：首字母大写

多个单词：每个单词首字母大写

c.方法或者变量

一个单词：首字母小写

多个单词：第一个单词全部小写，后面单词首字母大写

d.常量

一个单词：全部大写

多个单词：全部大写，用_隔开

3.注释
(1)对程序解释说明的文字

(2)分类：

a.单行注释  //

b.多行注释  /*注释的内容*/

c.文档注释  /**注释的内容*/

(3)作用：

a.解释说明程序，提高代码的可读性

b。可以帮助我们调试程序

4.常量
(1)在程序执行的过程中，其值不发生改变的量

(2)分类：

a.字面值常量

字符串常量   "HelloWorld"

整数常量    123

小数常量    1.23

字符常量    'char'

布尔常量    true

空常量 null

b.自定义常量

(3)Java中整数常量有四种表现形式

a.二进制   由0,1组成，以0b开头

b.八进制   由0,1,...,7组成，以0开头

c.十进制   由0,1,...,9组成，默认的是十进制

d.十六进制  由0,1,...,9,a,...,f(不区分大小写)组成，以0x开头

5.变量
(1)在程序的执行过程中，其值在某个范围内可以发生改变的量

(2)变量的定义格式：

a.数据类型 变量名 = 初始化值;

b.数据类型 变量名;

变量名 = 初始化值;

6.数据类型
(1)在Java中，针对每种数据都提供了对应的数据类型

(2)分类：

a.基本数据类型    4类8种

整型  byte    short   int(默认)   long

浮点型 float   double(默认)

字符型 char

布尔型 boolean

注意：长整数后面要加l或者L，单精度的浮点数要加F或者f

b.引用数据类型

类，接口，数组等

(3)数据类型转换

a.boolean不能进行转换

b.默认的转换

数值范围从小到大：

byte short char --->int--->long--->float--->double

byte short char之间不能相互转换

c.强制转换

从大到小转换

会丢失精度

格式：

目标数据类型 变量名 = (目标数据类型)被转换的数据

(4)数据运算

a.字符型参与运算：其实是按照ASCII里面的值进行运算

'0' 48

'a' 97

'A' 65

b.字符串运算，+起连接符的作用，连接两个字符串

7.运算符
(1)算术运算符+ - * / % ++ --

a.+可以做加法运算，也表示正号，也可以连接字符串

b.%取余

c.++自加 --自减

单独使用时放在前后作用一样，都是数字本身+1或者-1

参与操作时：

放在操作数前面，先自增或自减，再参与操作

放在操作数后面，先进行操作，后自增或自减

(2)赋值运算符    = += -= *= /= %=

a.=是赋值运算符，可以对变量进行赋值

b.扩展赋值运算符隐含了自动强制转换，如：

short a = 1;

a = a + 1; //是有问题的

short a = 1;

a += 1; //隐含自动强制转换

(3)比较运算符 == != < <= > >=

a.不管运算符两端是什么，结果都为boolean类型

(4)逻辑运算符& | ^ ! && ||

a.逻辑运算符用于连接boolean类型的式子

b.结论：

&   有false则false

|   有true则true

^   相同false，不同true

!   true为false，false为true

&&  作用与&一样，有短路功能，左边为false，则右边不执行

||  作用与|一样，有短路功能，左边为true，则右边不执行

(5)位运算符

^的特殊用法：一个数据对另一个数据位亦或两次，该数不变

<< >> 左移和右移

(6)三目运算符

格式：

比较表达式?表达式1(true):表达式2(false)

8.流程控制
(1)顺序结构

Java程序都是按照从上到下的顺序执行的

(2)选择结构

a.按照不同的选择，执行不同的代码

b.if语句

格式1：

if(逻辑判断){

表达式

}

先进行逻辑判断,如果为true则执行表达式,false不执行

格式2：

if(逻辑判断){

表达式1

}else{

表达式2

}

先进行判断，如果为true则执行表达式1，false执行表达式2

格式3:

if(逻辑判断1){

表达式1

}else if(逻辑判断2){

表达式2

}else{

表达式3

}

中间else if可以写很多

注意：

if和else后面的大括号可以不写，

但是只有最近的一条进行判断，其他的正常执行

c.switch语句

格式：

switch(表达式){

case 值1:

语句1;

break;

case 值2:

语句2;

break;

...

default:

语句n;

break;

}

说明：

表达式可以是byte short int char

default 放在哪个都可以，都是最后执行

(3)循环结构

a. for循环

格式：

for(初始化语句;判断条件语句;控制条件语句){

循环体语句;

}

说明：判断语句为true则执行循环体，直到为false为止

b. while循环

格式:

while(判断条件语句){

循环体语句;

}

说明：与for循环类似，两者可以相互转换

c.do...while循环

格式：

do{

循环体语句;

}while(判断条件语句);

说明:与while循环差别在于，while先判断，再执行，

do...while先执行一次语句，再判断

d. 注意：

使用循环时应该注意控制判断条件语句，否则容易造成死循环

简单的死循环有两种:

while(true){    for(;;){

... ...

}   }

(4)控制跳转语句 break continue    return

a. break

用在循环和switch中，作用是：

跳出本层循环

利用标签跳出多层循环

b. continue

用在循环中,作用:

结束本次循环，继续下一循环

c. return

用在方法中，结束方法的同时返回一个值

9.数组
(1)定义

存储同一种数据类型的多个元素的容器

(2)特点

数组中的每一个元素都有对应的下标，从0开始，到数组最大长度-1结束

(3)定义格式

数据类型[] 数组名;

数据类型 数组名[];

(4)数组的初始化

a.静态初始化

在定义数组时给出值，长度按给出的元素个数决定

例：int[] array = new int[]{1,2,3,4,5};

等价于int[] array = {1,2,3,4,5};

b.动态初始化

定义时给出数组长度，系统给默认值

例：int[] array = new int[5];

关于默认值：

整型默认的是：0

浮点型默认的是：0.0

boolean默认的是：false

字符型默认的是：

引用数据类型默认的是：null

(5)数组的遍历

public static void main(String[] args){

int[] array = new int[]{1,2,3,4,5};

for(int i = 0; i < array.length; i++){

System.out.println(array[i]);

}

}

(6)数组的排序

a.冒泡排序法

原理：两两相比，大的数向后移，直到最大的数移到最右端，

依次比较，直到最后排序完成

代码：

int[] arr = new int[]{2,5,7,4,9,1};

for(int j = 0; j < arr.length-1; j ++){

for(int i = 0; i < arr.length-1-j; i ++){

if(arr[i]>arr[i+1]){

int temp = arr[i];

arr[i] = arr[i+1];

arr[i+1] = temp;

}

}

}

b.选择排序

原理：将第一个元素(0索引)与其他元素比较，大的回到原位置，最后0索引为最小值

依次类推，直到所有元素排序完成

代码：

int[] arr = new int[]{2,5,7,4,9,1};

for(int j = 0; j < arr.length-1; j ++){

for(int i = j+1; i < arr.length; i ++){

if(arr[j]>arr[i]){

int temp = arr[j];

arr[j] = arr[i];

arr[i] = temp;

}

}

}

(7)二维数组

a.可以看成是一维数组的数组

b.格式

数据类型[][] 数组名 = new 数据类型[m][n];

10.包装数据类型
(1)为了让基本数据类型进行更好的操作，Java为每种基本类型提供了对应的包装类

byte    Byte

short   Short

int Integer

long    Long

float   Float

double  Double

char    Character

boolean Boolean

(2)String和int的转换

a. String--->int

Integer.parseInt("100");

b. int--->String

String.vallueOf(100);

注意：

String类型的字符串必须是数字

二. 面向对象
1.面向对象
a.定义

面向对象是基于面向过程的编程思想

b.面向对象的特点

是一种更符合我们思考习惯的思想

把复杂的事情简单化

c.类与对象

类是指抽象的概念，对象是实际存在的东西

例如：说车，会想到很多，具体不到那一辆车，这是类的概念

说你家的小轿车，会直接定位到你家的那辆车，这是对象的概念

d.类的定义与使用

定义

属性：即成员变量    在类中，方法外，格式与普通变量相同

行为：即成员方法    格式  下面细说

使用

创建对象的格式

类名 对象名 = new 类名();

使用成员变量和方法

对象名.成员变量

对象名.方法()

2.方法

(1)定义

完成特定功能的代码块

(2)格式

修饰符 返回值类型 方法名(参数列表){

方法体;

return 返回值;

}

(3)注意

返回值类型是方法调用完之后返回的值的类型

参数列表包括参数类型和参数名，是形参

(4)方法的调用

a.单独调用，有返回值的使用此方法没意义

b.输出调用，不需要对返回值进行下一步操作

c.赋值调用，可以输出，可以进行操作,无返回值类型的方法不能这么用

(5)注意事项

a.方法不调用时不执行

b.方法之间是平级关系，不能嵌套

c.方法定义时，参数之间用,隔开

d.调用方法时，不能传递数据类型

e.如果方法有明确的返回值类型，最后必须使用return

3.成员变量和局部变量

(1)在类中的位置不同

成员变量：类中方法外

局部变量：方法定义中

(2)在内存中位置不同

成员变量：在堆中

局部变量：在栈中

(3)生命周期不同

成员变量：随着对象的创建而存在，随着对象的消失而消失

局部变量：随着方法的调用而存在，调用完毕就消失

(4)初始化值不同

成员变量：有默认值

局部变量：没有默认值，必须定义，赋值，然后才能使用

4.匿名对象

(1)定义

没有名字的对象

(2)应用

a.调用方法，仅仅只调用一次的时候

b.可以作为实际参数传递

5.this关键字

(1)代表当前类的引用对象

哪个对象调用方法，该方法内部的this就代表那个对象

(2)应用场景

解决了局部变量隐藏成员变量的的问题

6.构造方法

(1)定义

在类中与类同名，且没有返回值类型的方法，也叫构造器

(2)作用

用于对对象的数据进行初始化

(3)格式

a.方法名与类名相同

b.没有返回值类型

c.没有返回值

(4)注意事项

a.如果没有写构造方法，系统将提供一个默认的无参构造方法

b.如果我们给出了有参的构造方法，系统默认的无参构造方法将消失

如果用无参构造方法，必须手动给出一个无参的构造方法

(5)给成员变量赋值

构造方法内调用set方法

调用带参构造方法

7.参数传递

(1)基本数据类型传递

a.基本数据类型参数传递时传递的是这个值的拷贝值

b.参数传递时会在栈内存中另外开辟一个空间，存放拷贝的值

c.调用方法时，无论怎么变，变的是另外空间的值

d.原来的值是不会变的

(2)引用数据类型传递

a.引用数据类型在传递参数时，传递的是堆内存中的地址值

b.两个对象同时指向一个内存地址

c.无论哪一个变化堆中的值，其他对象的内容都会变

(3)注意

String虽然是引用数据类型，但是其参数传递方式与基本数据类型相同

8.package和import

(1)package  文件夹

a.作用

区分同名的类

对类进行分类管理

b.格式

package 包名  中间用.隔开，一级代表一个文件夹

创建类时系统自动导入包的路径，不用手写

c.注意

package必须放在第一句

在一个java文件中，只能有一个package

(2)import   导包

a.原理

如果多次使用同一包下的类，需要导包

b.格式

import 包名...类名;

三. 面向对象高级特性一

1.封装

(1)定义

把类中不想让外部调用的属性隐藏起来，并提供公有的访问方法

(2)好处

a.提高代码的复用性

b.提高代码的安全性

(3)关键字  private

a.可以修饰成员变量和成员方法

b.被private修饰的成员，只能在本类中使用

(4)格式

private 数据类型 变量名;

提供set和get方法，用来给属性赋值和访问属性

2.继承

(1)定义

把多个类中相同的成员提取出来定义到一个独立的类中，然后让多个类和

该类产生一个关系，这个类就具备了这些内容，这就叫做继承

(2)格式

a.用关键字extends连接两个类

b.例：    class 子类名 extends   父类名{}

(3)继承的好处

a.提高了代码的复用性

b.便于后期维护

c.让类与类产生一个关系，多态的前提

(4)继承的弊端

a.提高了类的耦合性，如果一个类改变，会影响其他和该类有关系的类

b.打破了封装性

(5)继承的特点

a.java中类只支持单继承

b.java中可以多层继承

(6)继承的注意事项

a.子类不能继承父类的私有成员

b.子列不能继承父类的构造方法，但可以通过super访问

c.继承使用时应慎重考虑

(7)继承中的成员关系

a.成员变量

子类和父类中有同名的属性时，子类方法访问的顺序是

首先在子类的方法中找，没有的话进行下一步

然后在子类的成员中找，没有的话进行下一步

最后在父类的成员中找，没有的话就报错

b.构造方法

子类的构造方法默认会访问父类的无参构造方法

父类中如果没有无参构造器，则通过super去访问带参构造器

c.成员方法

子类和父类中有同名方法时，子类访问方法的顺序

现在子类中找，如果没有就去父类中找，父类没有就报错

其实这也是方法的重写

3.多态

(1)定义

同一个对象在不同时刻体现出来的不同状态

(2)多态的前提

a.有继承或者实现关系时

b.有方法重写

c.有父类或者父接口引用指向子类对象

(3)思考题，有争议

重载是多态吗？

(4)多态中成员的访问

a.属性

编译看左，运行看左

b.构造器

子类的构造都会默认访问父类构造

c.成员方法

编译看左边，运行看右边

d.静态方法

编译看左边，运行看左边

(5)多态的好处

a.便于后期代码维护

b.提高代码的扩展性

(6)注意

父类不能使用子类的特有功能

子可以当父用，父不可以当子使用

(7)多态中的转型

a.向上转型  通过父类引用指向子类对象

b.向下转型  通过子类引用指向父类对象，需要强制转型

4.方法重写和重载

(1)方法重载

a.在同一个类中，方法名相同，参数列表不同，与返回值无关

b.参数列表不同：

参数个数

参数数据类型

c.应用：不同类型的参数可以使用同一个方法

d.扩展    可变个数的形参

public void sum(int...num){}

必须是同一类型，个数不确定才能使用

(2)方法的重写

a.在有继承关系的类中，子类出现和父类方法声明一样的方法

b.方法名相同，返回值类型相同，权限修饰符可以增大

c.应用：当子类需要父类的功能，而功能主体子类有自己特有的内容时，

可以重写父类中的方法，达到既有父类功能，又有自己特定的内容

d.注意：

父类中私有方法不能被重写

子类重写父类方法时，访问权限不能降低，最好不变

父类静态方法，子类也必须通过静态方法进行重写

子类重写父类方法是，最好保持声明一模一样

5.访问控制(权限修饰符)

(1)权限修饰符    Y可以使用  N不可以使用

本类  同一包下    不同包下子类  不同包下无关类

private   Y N     N   N

default(不写)   Y Y     N   N

protected     Y Y     Y   N

public    Y Y     Y   Y

(2)注意

a.这四种修饰符只能出现一次，不能使用两种修饰同一方法或属性

b.对于方法的重写或重写时，只能扩大修饰符范围，不能减小

6.super关键字

(1)定义

super代表父类存储空间的标识，即父类引用，可以操作父类的成员

(2)应用场景

有继承关系的子类中，引用父类对象，使用super关键字

(3)this与super的使用

a.调用成员变量

this.成员变量   调用本类的成员变量

super.成员变量  调用父类的成员变量

b.调用构造方法

this(...)   调用本类的构造方法

super(...)  调用父类的构造方法

c.调用成员方法

this.成员方法   调用本类的成员方法

super.成员方法  调用父类的成员方法

7.object类

(1)定义

Object是类层次结构的根类，所有的类都直接或间接继承自Object

(2)Object的构造方法只有一个，是无参的构造方法

(3)常见方法

a. toString()

返回对象的字符串表示，默认是类的路径+@+哈希码十六进制值

使用时要重写toString方法，否则没意义

b. equals()

两个对象进行比较，用此方法前要重写hashCode()方法

c.clone()

可以实现对象的克隆，包括成员变量的数据复制

(4)==与equals()区别

a.==

基本数据类型：比较的是值是否相等

引用数据类型：比较的是地址值是否相同

b.equals

只能比较引用数据类型，比较的是两个内容是否相等，

默认情况下比较的是两者的hashCode值是否相等

8.常见的修饰符

(1)分类：

权限修饰符：private,default(默认，不写),protected,public

状态修饰符：static,final

抽象修饰符：abstract

(2)常见的类及其组成的修饰

类：

default,public,final,abstract

属性：

private，默认，protected,public,static,final

构造方法：

private,default,protected,public

成员方法：

private,default,protected,public,static,final,abstract

四. 面向对象高级特性二

1.static关键字

(1)含义

静态的意思，可以修饰成员变量和成员方法

(2)特点

a.随着类的加载而加载

b.优先于对象存在

c.类的所有对象都可以调用，方法：类名.静态方法或变量

d.静态内容在静态区

(3)静态变量与成员变量的区别

a.所属不同

静态变量：属于类，类变量

成员变量：属于对象，对象变量，实例变量

b.内存位置不同

静态变量：静态区

成员变量：堆内存

c.生命周期不同

静态变量：随着类的加载而加载，随着类的结束而消失

成员变量：随着对象的创建而创建，随着对象的消失而消失

d.调用方法不同

静态变量：可以通过对象名调用，也可以通过类名调用

成员变量：只能通过对象名调用

2.内部类

(1)定义

把类定义在两一个类的内部，该类就成为内部类

(2)访问规则

a.内部类可以直接访问外部类的成员，包括私有的

b.外部类要想访问内部类成员，必须创建对象

(3)分类

成员内部类(静态和非静态)

局部内部类

匿名内部类

(4)成员内部类

a.创建对象的方法

静态的成员内部类

外部类名.内部类名 对象名 = new 外部类名.内部类名();

非静态

外部类名.内部类名 对象名 = 外部类名.new 内部类名();

b.小细节

成员内部类中可以使用与外部类相同的变量名

如果内部类的方法中调用外部类属性或方法，需要用外部类名.this.属性名

访问内部类中的属性，需要用this.属性

有同名属性时，变量按就近原则取值

(5)局部内部类

a.在方法体或者语句块内部定义的类

b.局部内部类中的局部变量必须加上final修饰

(6)匿名内部列

a.是局部内部类的简化形式

b.格式

new 类名或接口(){

重写方法;

};

c.注意

匿名内部类可以继承一个类或实现一个接口

3.代码块

(1)定义

用{}括起来的代码

(2)分类

非静态代码块

对类的数据和属性进行初始化，每次实例化对象就执行一次

静态代码块

对类的数据和属性进行初始化，仅仅执行一次

(3)执行顺序

静态代码块 > 非静态代码块 > 构造方法

4.final关键字

(1)定义

是最终的意思，可以修饰类，属性，方法

(2)特点

a.final修饰的类不能被继承

b.final修饰的方法不能被重写

c.final修饰的属性，是一个常量，定义时必须赋值

(3)扩展

a.局部变量

基本数据类型：值不能发生改变

引用数据类型：地址值不能发生改变，但是值可以变

b.初始化

只能初始化赋值一次

方式：定义时赋值，构造器中赋值

5.抽象类

(1)定义

在定义方法的时候不给出方法体，以便子类继承时各自重写自己特定的功能

用abstract修饰

(2)特点

a.抽象类和抽象方法必须用关键字abstract修饰

b.抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类

c.抽象类不能被实例化

d.抽象类的子类可以是抽象类，父类方法可以不重写

e.抽象类的子类可以是具体类，父类的抽象方法必须全部重写

(3)成员特点

a.成员变量

有变量，有常量

b.构造方法

有构造方法

c.成员方法

有抽象，也可以有非抽象

(4)注意

a.抽象类也是类，它是有构造方法的，用于子类访问父类数据的初始化

b.一个类如果不想让创建对象，可以定义为抽象类

c.abstract冲突的关键字

final   冲突

private 冲突

static  无意义

6.接口

(1)定义

用interface修饰，类似于类，没有class

(2)接口的特点

a.接口用关键字interface修饰

interface 接口名{}

b.接口不能被实例化

c.类实现接口用implements修饰

class 类名 implements 接口名{}

d.接口的实现类可以是抽象类，也可以是具体类

如果是具体类，这个类必须重写接口的抽象方法，此时类可以实例化

e.接口中的方法都是抽象方法，默认修饰符：public abstract

f.接口中的属性必须是常量，默认修饰符：public static final

(3)接口，类之间的关系

a.类与类

继承关系，只能是单继承，可以是多层继承

b.类与接口

实现关系，可以但实现，也可以多实现

还可以继承一个类的同时，实现多个接口

c.接口与接口

继承关系，可以是单继承，也可以是多继承

(4)抽象类与接口的区别

a.抽象类是个类，接口是接口

b.抽象类中可以有非抽象方法，接口中必须是抽象方法

c.抽象类继承时只能被单继承，接口可以多继承，两者都可以多层继承

d.抽象类中属性可以是变量也可以是常量，接口中只能为常量

e.抽象类中定义的类似于共性功能，而接口中定义的类似于特性功能

五.Java常用类

1.String和StringBuffer、StringBuilder

(1)String类

a.定义

多个字符组成的一串数据，可以和字符数组相互转换

b.特点

字符串一旦被赋值，就不能改变

这里指的是字符串的内容不能改变，而不是引用地址不能变

字面值作为字符串对象和通过构造方法创建对象的不同

String s = "hello";与String s = new String("hello");是不同的

c.字符串的功能

判断功能

equals,equalsIgnoreCase,contains

获取功能

length,indexOf,substring

转换功能

getBytes,toCharArray

替换功能

replace

去空格

trim字符串两端的空格

按字典比较

comparaTo

(2)StringBuffer和StringBuilder

a.定义

字符串缓冲区，为了更好的对字符串进行操作

b.常用功能

添加  insert

删除  detele

替换  replace

反转  reverse

截取  indexOf

c.两者区别

StringBuffer    同步的，数据安全，效率低

StringBuilder   不同步，数据不安全，效率高

2.Date类

(1)日期类，可以精确到毫秒

getTime(long time)

time是此时距1970年1月1日0点0分0秒0毫秒的毫秒差

(2)日期类格式化

DateFormat是针对日期进行格式化和对字符串进行解析的类

是抽象类，必须使用子类SimpleDateFormat

自定义日期类格式

SimpleDateFormat("yyyy-MM-dd HH:mm:ss")

日期和字符串的转换

Date--->String  format()

String--->Date  parse()

3.Calendar类

(1)日历类，封装了所有的日历字段，通过统一的方法根据传入不同的日历字段可以获取值

(2)获取对象

Calendar c = Calendar.getInstance();

(3)成员方法

根据日历字段得到对应的值    get()

根据日历字段和一个正负数确定是添加还是减去对应日历字段的值  add()

设置日历对象的年月日  setTime()

4.Math类

(1)定义

针对数学运算进行操作的类

(2)常用方法

Random产生随机数

int nextInt()返回int范围内的随机数

int nextInt(int n)返回0-n之间的随机数

Round四舍五入

返回的是整型数，double返回的是long，float返回的是int

(3)BigInteger是针对大整数的运算

BigDecimal针对大浮点数据运算，会丢失精度

六.集合

1.Collection集合

(1)数组长度是固定的，不适合做变化需求，所以java就提供了集合

(2)集合与数组的区别

长度区别

数组是固定

集合是可变

内容区别

数组可以是基本类型也可以是引用类型

集合只能是引用类型

元素内容

数组只能存储同一种类型

集合可以存储不同类型

(3)集合的继承体系结构

Collection

|---List

|---ArrayList

|---Vector

|---LinkedList

|---Set

|---HashSet

|---TreeSet

Map

|---HashMap

|---TreeMap

(4)集合的遍历

a.把集合转为数组

b.迭代器

是集合的获取元素的方式

是依赖与集合而存在的

2.List集合

(1)List是Collection的子接口

(2)特点：有序(存储顺序和取出顺序一致)，可重复

(3)常见数据结构

栈   先进后出

队列  先进先出

数组  查询快，增删慢

链表  查询慢，增删快

(4)List子类特点

ArrayList

底层数据结构是数组，查询快，增删慢

线程不安全，效率高

Vector

底层数据结构是数组，查询快，增删慢

线程安全，效率低

LinkedList

底层数据结构是链表，查询慢，增删快

线程不安全，效率高

3.Set集合

(1)Set是Collection的子接口

(2)特点：无序(存储元素的位置不确定，打印时还是有一定规律的)，元素唯一

(3)HashSet

a.底层数据结构是哈希表(元素为链表的数组)

b.哈希表底层依赖两个方法：hashCode()和equals()

执行顺序：

首先比较哈希值是否相同

如果相同：执行equals()方法

返回true:元素重复，不添加

返回false:直接把元素添加到集合

如果不同：直接把元素添加到集合

c.如何保证元素唯一性

由hashCode()和equals()保证

(4)TreeSet集合

a.底层数据结构是红黑树

b.保证元素的排序方式

自然排序(元素具备比较性)

让元素所属的类实现Comparable接口

比较器排序(集合具备比较性)

让集合构造方法接收Comparator的实现类对象

4.Map集合

(1)将键映射到值的对象，一个映射不能包含重复的键，每个键最多只能映射到一个值

(2)Map和Collection的区别：

Map存储的是键值对形式的元素，键唯一，值可以重复

Collection存储的是单独出现的元素，子接口set元素唯一，子接口List元素可重复

(3)Map集合的遍历

a.键找值

获取所有键的集合

遍历键的集合，得到每一个键

根据键到集合中去找值

b.键值对对象找键和值

获取所有键值对对象的集合

遍历键值对对象的集合，获取每一个键值对对象

根据键值对对象去获取键和值

5.Collections工具类

(1)定义

是针对集合进行操作的工具类

(2)Collection与Collections区别

Collection是单列集合的顶层接口，有两个子接口List和Set

Collections是针对集合进行操作的工具类，可以对集合进行排序和查找等

6.增强for循环

(1)格式

for(数据类型 变量名:数组或者集合){

使用该变量即可

}

(2)好处

简化了数组和集合的遍历

(3)弊端

增强for循环的目标不能为null

七.泛型

1.概述

是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型

2.格式

<数据类型>  该数据类型只能是引用类型

3.好处

a.把运行时期的问题提前到了编译时期

b.避免了强制类型转换

c.优化了程序设计，解决了黄色警告问题

4.应用

a.集合中

集合类型<数据类型>

b.泛型类

泛型类  class 类名<数据类型>{}

c.泛型接口

泛型接口  interface 接口名<数据类型>{}

数据类型如不确定，可以使用通用的T表示

d.泛型方法

泛型方法的格式：修饰符  <数据类型> 返回值类型  方法名 (T t){  }