总结

1.1                知识点总结

l  数据类型转换

n  数据类型范围从小到大排序（byte < char < short < int < long < float < double），布尔类型Boolean不能参与类型转换；

n  自动类型转换，范围小的数据类型向范围大的数据类型转换时使用；

n  强制类型转换，范围大的数据类型向范围小的数据类型转换时使用。

l  算数运算符

n  用来完成算数运算（如加减乘除计算等）

n  ++，--运算符的使用

u  ++，--前置（如++a），当参与运算时，变量a的值先自增1，然后用自增后的新值再参与运算；

u  ++，--后置（如a++），当参与运算时，变量a先使用原有值参与运算符，变量a的值再自增1。

l  赋值运算符

n  用来完成数据的赋值（如 int a = 100;）

n  +=,-,*=,/=这样的赋值运算符包含了一个强制转换的操作，会将左右两边运算后的结果，强制类型转换后赋值给左边

int n = 10;

byte by = 20;

by += n; // 运算完毕后，by的值为byte类型30， 相当于代码 by = (byte)(by + n);

l  比较运算符

n  用来比较数据的大小（如 3>4），比较运算符也称为条件运算符。

n  比较后的结果为布尔类型Boolean的值

n  “==”两个等号代表比较是否相等，“=”一个等号代表赋值。

l  逻辑运算符

n  逻辑与& 和逻辑短路与&&：代表着并且的意思，左右两边都要条件成立，结果才为true；

n  逻辑或| 和逻辑短路或||：代表着或者的意思，左边两边有一个条件成立，结果就为true；

n  逻辑非!：代表着相反的意思，原先是false，结果就为true；原先是ture，结果就为false；

n  逻辑异或^： 左右两边条件结果相同，结果就为false，左右两边条件结果不同，结果就为true；

l  三元运算符

n  根据判断条件运算结果，执行不同的表达式值；条件为true，执行表达式1，否则，执行表达式2。

第2章     总结

2.1      知识点总结

l  选择结构 if

n  方式1:

格式：

if(条件表达式) {

语句体;

}

执行流程：

如果条件表达式值为true, 执行语句体

如果条件表达式值为false,不执行语句体

n  方式2：

格式:

if(条件表达式) {

语句体1;

} else {

语句体2;

}

执行流程：

如果条件表达式值为true, 执行语句体1

如果条件表达式值为fales,执行语句体2

n  方式3：

格式：

if(条件表达式1) {

语句体1;

} else if (条件表达式2) {

语句体2;

} else if (条件表达式n...) {

语句体n...

}

...

else {

语句体n+1;

}

执行流程：

哪一个条件表达式成立，执行对应的语句体，

如果所有的条件表达式都不成立，执行最后else中的语句体

n  注意事项：

1，条件表达式无论是简单还是复杂，结果都是boolean类型的值

2, 如果语句体只有一条语句，大括号可以省略，

如果是多条语句，大括号不能省略，建议什么时候都写上大括号

l  循环语句For

n  格式：

for (初始化表达式;条件表达式; 控制条件表达式) {

语句体;

}

n  执行流程：

1，初始化表达式；

2，条件表达式

如果结果为true, 执行语句体

如果结果为flase, 循环结束

3, 当语句体执行后， 执行控制条件表达式

4，接下来，回到第二步, 直到条件表达式为false 循环结束

l  循环语句 while

n  格式：

初始化表达式;

while (条件表达式) {

语句体;

控制条件表达式;

}

n  执行流程；

1，初始化表达式；

2，条件表达式

如果结果为true, 执行语句体

如果结果为flase, 循环结束

3, 当语句体执行后， 执行控制条件表达式

4，接下来，回到第二步, 直到条件表达式为false 循环结束跳转语句（break、continue）

l  循环语句  do...while

n  格式：

初始化表达式;

do {

语句体;

控制条件表达式;

} while (条件表达式);

n  执行流程:

1，初始化表达式；

2, 执行语句体

3, 执行控制条件表达式

4, 执行条件表达式,

如果结果为true, 继续执行语句体

如果结果为false, 循环结束

l  跳转控制语句

break; 跳出循环

continue; 结束本次循环

l  Scanner类

n  获取键盘录入的数据，对获取数据的具体操作进行了封装，只需要调用方法，即可得到键盘录入的数据。

n  常用的方法

public int nextInt()：获取键盘录入的数据，返回int类型值

public String next()：获取键盘录入的数据，返回String类型值

l  Random类：随机数类，用来产生多种类型的随机数

n  方法：

public int nextInt(int n) 返回一个，在 0（包括）和指定值（不包括）之间int随机数

第3章     总结

3.1      知识点总结

l  数组

n  它是一个用来存储同一个数据类型多个元素的一个容器（数组长度是固定的，数组中存储的元素的数据类型要求一致）

n  格式：

格式1：

数据类型[] 数组名 = new 数据类型[数组长度];

格式2:

数据类型[] 数组名 = new 数据类型[]{元素值1,元素值2,..};

格式3：

数据类型[] 数组名 = {元素值1,元素值2,..};

n  数组操作的常见问题：

NullPointerException: 空指针异常

ArrayIndexOutOfBoundsException: 数组越界异常

l  二维数组：

n  它是一个包含多个一维数组的数组

n  特点：二维数组中的每个元素都是一个一维数组

n  格式：

格式1：

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

m: 代表二维数组中一维数组的个数

n: 代表每个一维数组中元素的个数

格式2：

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

m: 代表二维数组中一维数组的个数

每一个一维数组通过赋值来确定数组长度

格式3：

数据类型[][] 数组名 = {{元素值1，元素值2,..},{元素值1，元素值2,..},..};

第4章     总结

4.1      知识点总结

l  方法

n  格式：

修饰符 返回值类型 方法名(参数类型 参数名1, 参数类型 参数名2, ...) {

方法体;

return 返回值;

}

n  方法使用的注意事项：

1，方法不调用，自己不执行

2，方法中不能定义方法， 但是，方法中可以调用方法

3, 方法定义的位置在类中，其他方法的外面

4, 如果方法没有明确的返回值类型，使用‘空‘类型， void表示

5，void只能在方法返回值类型位置使用，不能作为 普通的数据类型使用

6, 如果方法返回值类型为void类型，可以省略 return ;

n  方法调用方式：

有明确返回值类型的方法调用方式：

1，单独调用

2，输出调用

3，赋值调用

没有明确返回值类型的方法调用方式：

1，  单独调用

n  方法重载：

方法重载，在同一个类中，出现了多个同名的方法，他们的参数列表不同 (参数列表的个数不同，参数列表的数据类型不同，参数列表的顺序不同)。

方法重载特点：

与方法的返回值类型无关，与方法的参数名无关，只看方法名与参数列表；

方法重载，是通过JVM来完成同名方法的调用的，通过参数列表来决定调用的是哪一个方法。

第5章     总结

5.1      知识点总结

l  引用数据类型（类）

n  类的类型为两种：

u  第一种，Java为我们提供好的类，如Scanner类，Scanner类等，这些已存在的类中包含了很多的方法与属性，可供我们使用。

u  第二种，我们自己创建的类，按照类的定义标准，可以在类中包含多个方法与属性，来供我们使用。

n  创建类的格式

public class 类名 {

//可以定义属性

//也可以定义方法

}

n  使用类的格式：

类名 变量名 = new 类名();

n  使用类中的属性与方法格式

使用属性： 变量名.属性

使用方法： 变量名.方法()

l  ArrayList集合

n  它属于引用数据类型（类）。我们可以看作一个长度可变的数组。

n  创建集合的方式

ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();

n  集合中的常用方法

u  boolean add（Object obj）

u  Object get（int index）

u  int size（）

u  boolean add（int index,  Object obj）

u  Object set（int index, Object obj）

u  Object remve（int index）

u  void clear（）

第6章     总结

6.1      知识点总结

l  类与对象

n  类，用于描述多个对象的共同特征，它是对象的模板。

n  对象，用于描述现实中的个体，它是类的实例。

n  类的定义：使用关键字class来定义java中的类

u  格式：

class 类名 {

//属性

数据类型 变量名;

…

//方法

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

…

}

n  创建对象：

u  格式：

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

l  封装（private关键字）

n  封装，把对象的属性与方法的实现细节隐藏，仅对外提供一些公共的访问方式

n  封装的体现：

u  变量:使用 private 修饰，这就是变量的封装

u  方法:也是一种封装，封装了多条代码

u  类： 也是一种封装，封装了多个方法

n  private关键字，私有的意思

u  它可以用来修饰类中的成员(成员变量，成员方法)

u  private的特点：

l  private修饰的成员只能在当前类中访问，其他类中无法直接访问

l  this关键字

n  this关键字，本类对象的引用

u  this是在方法中使用的，哪个对象调用了该方法，那么，this就代表调用该方法的对象引用

u  this什么时候存在的？当创建对象的时候，this存在的

u  this的作用：用来区别同名的成员变量与局部变量（this.成员变量）

public void setName(String name) {

this.name = name;

}

第7章  总结

7.1      知识点总结

l  继承：是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有

l  继承的好处：可继承的属性和方法。

n

提高了代表的可维护性

提高了代码的复用性

让类与类之间产生了继承关系

n  继承的弊端：

类与类之间的耦合度过高

n  继承特点：

java中类只能够单继承，不能多继承，可以多层继承

class Yy extends Object {}

class Fu extends Yy{}

class Zi extends Fu {}

所有的类都直接或者间接的继承了 Object类，Object类称为祖宗类

n  继承的注意事项：

1，使用关键字 extends 让类与类之间 产生继承关系

2, 父类私有的成员，子类不能继承，因为根本看不到

3，不能为了继承某个功能而随意进行继承操作， 必须要符合 is a 的关系

苹果 is a 水果

男人 is a 人

狗   is a 人 ， 这种情况就不能继承了

n  继承中的成员变量关系：

不同名的变量：

子类直接继承使用

同名的变量：

默认访问的是子类自己的成员变量, 想访问父类中的同名变量，请使用 super.成员变量;

n  继承中的成员方法关系：

不同名的方法：

子类直接继承使用

同名的方法：

默认访问的是子类自己的成员方法，想访问父类中的同名方法，请使用 super.成员方法();

n  super:用来表示当前对象中包含的父类对象空间的引用

调用父类的成员变量：

super.成员变量;

调用方法的成员方法:

super.成员方法();

n  方法重写(override)：指 在子父类中，出现了方法声明相同的情况，也叫做方法覆盖，方法复写

u  方法重写的注意事项：

1， 子类的方法声明要与父类相同

2, 子类要重写方法的方法，方法的权限修饰符不能比父类的更低

n  3, 父类私有的方法，子类不能够进行方法重写

n  方法重载(overload)：指 在同一个类中，多个方法名称相同，它们的参数列表不同(个数不同，数据类型不同)

l  抽象

n  抽象方法： 方法只有声明部分，没有方法体

n  抽象类： 包含抽象方法的类，一定是抽象类

使用 abstract 修饰的类，是抽象类

n  抽象类的特点：

1，抽象类与抽象方法都必须使用 abstract来修饰

2，抽象类不能直接创建对象

3，抽象类中可以有抽象方法，也可以没有抽象方法

4，抽象类的子类

a，实现了抽象方法的具体类

b，抽象类

n  抽象类面试题：

1，抽象类中是否可以没有抽象方法？如果可以，那么，该类还定义成抽象类有意义吗？为什么？

可以没有抽象方法，有意义，不会让其他人直接创建该类对象

第8章  总结

8.1      知识点总结

l  接口：理解为是一个特殊的抽象类，但它不是类，是一个接口

n  接口的特点：

1，定义一个接口用interface关键字

interface Inter{}

2，一个类实现一个接口，实现implements关键字

class Demo implements Inter{}

3, 接口不能直接创建对象

通过多态的方式，由子类来创建对象，接口多态

n  接口中的成员特点：

成员变量：

只能是final 修饰的常量

默认修饰符： public static final

构造方法：

无

成员方法：

只能是抽象方法

默认修饰符: public abstract

n  类与类，类与接口，接口与接口之间的关系

类与类之间：继承关系，单继承，可以是多层继承

类与接口之间: 实现关系，单实现，也可以多实现

接口与接口之间：继承关系，单继承，也可以是多继承

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

l  多态：理解为同一种物质的多种形态

n  多态使用的前提：

1，有继承或者实现关系

2，要方法重写

3，父类引用指向子类对象

n  多态的成员访问特点：

方法的运行看右边，其他都看左边

n  多态的好处：

提高了程序的扩展性

n  多态的弊端：

不能访问子类的特有功能

n  多态的分类

u  类的多态

abstract class Fu {

public abstract void method();

}

class Zi extends Fu {

public void method(){

System.out.println(“重写父类抽象方法”);

}

}

//类的多态使用

Fu fu= new Zi();

u  接口的多态

interface Fu {

public abstract void method();

}

class Zi implements Fu {

public void method(){

System.out.println(“重写接口抽象方法”);

}

}

//接口的多态使用

Fu fu = new Zi();

l  instanceof 关键字

格式： 对象名 instanceof 类名

返回值： true, false

作用： 判断指定的对象 是否为 给定类创建的对象

第9章  总结

9.1      知识点总结

l  this关键字

n  this关键字，本类对象的引用

u  this是在方法中使用的，哪个对象调用了该方法，那么，this就代表调用该方法的对象引用

u  this什么时候存在的？当创建对象的时候，this存在的

u  this的作用：用来区别同名的成员变量与局部变量（this.成员变量）

public void setName(String name) {

this.name = name;

}

l  构造方法： 用来给类的成员进行初始化操作

n  格式：

修饰符 类名 (参数列表) {

...

}

n  构造方法的特点：

u  1, 方法名与类名相同

u  2，没有返回值，也没有返回值类型，连void也没有

n  构造方法什么时候会被调用执行？

只有在创建对象的时候才可以被调用

l  super: 指的是父类的存储空间(理解为父类的引用)

调用父类的成员变量：

super.成员变量;

调用父类的构造方法:

super(参数);

调用方法的成员方法:

super.成员方法();

l  继承中的构造方法注意事项：

1，如果我们手动给出了构造方法，编译器不会在给我们提供默认的空参数构造方法

如果我们没写任何的构造方法，编译器提供给我们一个空参数构造方法

2, 在构造方法中，默认的第一条语句为 super();

它是用来访问父类中的空参数构造方法，进行父类成员的初始化操作

3, 当父类中没有空参数构造方法的时候，怎么办？

a: 通过 super(参数) 访问父类有参数的构造方法

b: 通过 this(参数) 访问本类中其他构造方法

注意:[本类中的其他构造方法已经能够正常访问父类构造方法]

4, super(参数) 与 this(参数) 不能同时在构造方法中存在

第10章    总结

10.1 知识点总结

l  final：关键字，最终的意思

final修饰的类：最终的类，不能被继承

final修饰的变量： 相当于是一个常量, 在编译生产.class文件后，该变量变为常量值

final修饰的方法： 最终的方法，子类不能重写，可以继承过来使用

l  static : 关键字， 静态的意思

可以用来修饰类中的成员(成员变量，成员方法)

注意： 也可以用来修饰成员内部类

n  特点：

被静态所修饰的成员，会被所有的对象所共享

被静态所修饰的成员，可以通过类名直接调用，方便

Person.country = "中国";

Person.method();

n  注意事项：

静态的成员，随着类的加载而加载，优先于对象存在

在静态方法中，没有this关键字

静态方法中，只能调用静态的成员(静态成员变量，静态成员方法

l  匿名对象：一个没有名字的对象

n  特点：

创建匿名对象直接使用，没有变量名

匿名对象在没有指定其引用变量时，只能使用一次

匿名对象可以作为方法接收的参数、方法返回值使用

l  内部类：在一个类中，定义了一个新类，这个新的类就是内部类

class A {//外部类

class B{// 内部类

}

}

n  特点：

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

l  包的声明与访问

n  类中包的声明格式：

package 包名.包名.包名…;

n  带有包的类，创建对象格式：包名.类名 变量名 = new包名.类名();

com.oracle.Demo d = new com.oracle.Demo();

n  导包的格式：

import 包名.类名;

l  权限修饰符

public : 公共的

protected: 受保护的

private : 私有的

public  protected   默认的   private

在当前类中       Y       Y           Y       Y

同一包中的其他类  Y       Y           Y

不同包中的子类    Y       Y

不同包中的其他类  Y

l  代码块：

局部代码块：定义在方法中的，用来限制变量的作用范围

构造代码块：定义在类中方法外，用来给对象中的成员初始化赋值

静态代码块：定义在类中方法外，用来给类的静态成员初始化赋值

第11章    总结

11.1 知识点总结

l  不同修饰符的使用

n  类，最常使用public修饰

n  成员变量，最常使用private修饰

n  成员方法，最常使用public修饰

l  自定义数据类型的使用

n  类作为方法参数时，说明要向方法中传入该类的对象

n  类作为方法返回值时，说明该方法要返回一个该类的对象。

n  抽象类作为方法参数时，说明要传入一个实现抽象类所有抽象方法的子类对象。

n  抽象类作为方法返回值时，说明需要返回一个实现抽象类所有抽象方法的子类对象。

n  接口作为方法参数时，说明该方法要传入一个接口实现类对象。

n  接口作为方法返回值时，说明该方法需要返回一个接口实现类对象。

第12章    总结

12.1 知识点总结

l  Object: 它是所有类的超类，祖宗类。java中所有的类都直接或间接的继承这个类

n  方法

public String toString() 返回当前对象中的内容, 对于Object类默认操作来说，返回的对象的类型[email protected]+内存地址值

public boolean equals(Object obj) 比较两个对象内容是否相同，对于Object类默认操作来说,比较的是地址值

l  String: 字符串类，字符串是常量；它们的值在创建之后不能更改

n  方法

boolean equals(Object obj) 判断两个字符串中的内容是否相同

boolean equalsIgnoreCase(String str)  判断两个字符串中的内容是否相同, 忽略大小写

boolean contains(String str) 判断该字符串中 是否包含给定的字符串

boolean startsWith(String str) 判断该字符串 是否以给定的字符串开头

boolean endsWith(String str) 判断该字符串 是否以给定的字符串结尾

boolean isEmpty() 判断该字符串的内容是否为空的字符串  ""

int length() 获取该字符串的长度

char charAt(int index) 获取该字符串中指定位置上的字符

String substring(int start) 从指定位置开始，到末尾结束，截取该字符串，返回新字符串

String substring(int start,int end) 从指定位置开始，到指定位置结束，截取该字符串，返回新字符串

int indexOf(int ch ) 获取给定的字符，在该字符串中第一次出现的位置

int indexOf(String str) 获取给定的字符串，在该字符串中第一次出现的位置

int indexOf(int ch,int fromIndex) 从指定位置开始，获取给定的字符，在该字符

byte[] getBytes() 把该字符串 转换成 字节数组

char[] toCharArray() 把该字符串 转换成 字符数组

String replace(char old,char new) 在该字符串中，将给定的旧字符，用新字符替换

String replace(String old,String new) 在该字符串中， 将给定的旧字符串，用新字符串替换

String trim() 去除字符串两端空格，中间的不会去除，返回一个新字符串

String toLowerCase() 把该字符串转换成 小写字符串

String toUpperCase() 把该字符串转换成 大写字符串

int indexOf(String str,int fromIndex) 从指定位置开始，获取给定的字符串，在该字符串中第一次出现的位置

l  StringBuffer/StringBuilder:

n  方法

public StringBuffer append(String str) 在原有字符串缓冲区内容基础上，在末尾追加新数据

public StringBuffer insert(int offset,String str) 在原有字符串缓冲区内容基础上，在指定位置插入新数据

public StringBuffer deleteCharAt(int index) 在原有字符串缓冲区内容基础上，删除指定位置上的字符

public StringBuffer delete(int start,int end) 在原有字符串缓冲区内容基础上，删除指定范围内的多个字符

public StringBuffer replace(int start,int end,String str)在原有字符串缓冲区内容基础上，将指定范围内的多个字符 用给定的字符串替换

public StringBuffer reverse() 将字符串缓冲区的内容 反转  "abc"----"cba"

public String substring(int start) 从指定位置开始，到末尾结束，截取该字符串缓冲区，返回新字符串

public String substring(int start,int end)  从指定位置开始，到指定位置结束，截取该字符串缓冲区，返回新字符串

第13章    总结

13.1 知识点总结

l  正则表达式：用来定义匹配规则，匹配一系列符合某个句法规则的字符串。

正则表达式的匹配规则

请参见1.2 正则表达式的匹配规则

正则表达式的常用方法：

public boolean matches(String regex) //判断字符串是否匹配给定的规则

public String[] split(String regex)     //根据给定正则表达式的匹配规则，拆分此字符串

public String replaceAll(String regex,String replacement)  //将符合规则的字符串内容，全部替换为新字符串

l  Date: 日期/时间类

构造方法：

public Date()// 系统当前日期时间

public Date(long date) 得到一个1970年1月1日 0点这个时间基础上，加上参数date 毫秒值对应的日期时间

方法：

public long getTime() 获取日期所对应的毫秒值

l  DateFormat:是日期/时间格式化子类的抽象类, 使用其子类SimpleDateFormat 实例化

构造方法：

public SimpleDateFormat() 默认的格式化操作

public SimpleDateFormat(String pattern) 按照指定的格式，进行日期格式化

日期和时间模式

y  年

M  年中的月份

d  月份中的天数

H  一天中的小时数（0-23）

m  小时中的分钟数

s  分钟中的秒数

S  毫秒数

方法：

public final String format(Date date) 把日期 格式化成字符串

public Date parse(String source) 把日期字符串 转换成 日期对象

l  Calendar:日历类，可获取日期中指定字段的值

方法：

public static Calendar getInstance() //获取日期对象

public int get(int field)      //获取时间字段值

public void add(int field,int amount)        //指定字段增加某值

public final void set(int field,int value)//设置指定字段的值

public final Date getTime()      //获取该日历对象转成的日期对象

第14章    总结

14.1 知识点总结

l  基本类型包装类

n  8种基本类型对应的包装类

基本类型                   包装类

byte                             Byte

short                           Short

int                                Integer

log                                Long

float                             Float

double                         Double

char                             Character

boolean                      Boolean

n  自动装箱、自动拆箱

u  自动装箱：基本数值转成对象（int à Integer）

u  自动拆箱：对象转成基本数值（Integer à int）

n  常用方法

public int parseInt(String str):把字符串转成基本类型int

public static String toString(int x):把基本类型int转成字符串

public static Integer valueOf(int x):把基本类型i字符串转成Integer对象

public int intValue():以 int类型返回该包装类对象的值

l  System类: 系统属性信息工具类

n  public static long currentTimeMillis()：获取当前系统时间与1970年01月01日00:00点之间的毫秒差值

n  public static void exit(int status)：用来结束正在运行的Java程序。参数传入一个数字即可。通常传入0记为正常状态，其他为异常状态

n  public static void gc()：用来运行JVM中的垃圾回收器，完成内存中垃圾的清除。

n  public static String getProperties()：用来获取指系统属性信息

l  Arrays类：数组操作工具类

n  public static void sort方法，用来对指定数组中的元素进行排序（元素值从小到大进行排序）

n  public static String toString方法，用来返回指定数组元素内容的字符串形式

n  public static void binarySearch方法，在指定数组中，查找给定元素值出现的位置。若没有查询到，返回位置为-插入点-1。要求该数组必须是个有序的数组

l  Math类：数学运算工具类

n  abs方法,结果都为正数

n  ceil方法，结果为比参数值大的最小整数的double值

n  floor方法，结果为比参数值小的最大整数的double值

n  max方法，返回两个参数值中较大的值

n  min方法，返回两个参数值中较小的值

n  pow方法，返回第一个参数的第二个参数次幂的值

n  round方法，返回参数值四舍五入的结果

n  random方法，产生一个大于等于0.0且小于1.0的double小数

第15章           总结

15.1 知识点总结

l  List与Set集合的区别？

List:

它是一个有序的集合(元素存与取的顺序相同)

它可以存储重复的元素

Set:

它是一个无序的集合(元素存与取的顺序可能不同)

它不能存储重复的元素

l  List集合中的特有方法

n  void add(int index, Object element) 将指定的元素，添加到该集合中的指定位置上

n  Object get(int index)返回集合中指定位置的元素。

n  Object remove(int index) 移除列表中指定位置的元素, 返回的是被移除的元素

n  Object set(int index, Object element)用指定元素替换集合中指定位置的元素,返回值的更新前的元素

l  ArrayList:

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

l  LinkedList:

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

l  HashSet:

元素唯一，不能重复

底层结构是 哈希表结构

元素的存与取的顺序不能保证一致

如何保证元素的唯一的？

重写hashCode() 与 equals()方法

l  LinkedHashSet:

元素唯一不能重复

底层结构是 哈希表结构 + 链表结构

元素的存与取的顺序一致

第16章           总结

16.1 知识点总结

l  Map集合:

map集合中的元素都是成对出现，成对存储的

map集合中的元素都是以一对键和值的形式组成存在的，称为键值对，理解为夫妻对

map集合中的键不能重复存储，值可以重复

map集合中的每一个键 对应着一个值

n  方法：

V put(K key, V value)  把指定的键与指定的值添加到Map集合中

V remove(Object key) 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值

Set<Map.Entry<K,V>> entrySet() 获取到Map集合中所有的键值对对象的集合(Set集合)

V get(Object key) 根据指定的键，在Map集合中获取对应的值

Set<K> keySet() 获取Map集合中所有的键，存储到Set集合中

l  Map集合遍历的两种方式

n  方式1：根据键找值的方式

//a, 获取到Map集合中所有的键，返回对应的Set集合

//b, 遍历键的集合，获取到每一个键

//c, 通过键，找到对应的值

//获取到Map集合中所有的键，返回对应的Set集合

Set<String> keys = map.keySet();

//遍历键的集合，获取到每一个键

for (String key : keys) {

//通过键，找到对应的值

Student s = map.get(key);

System.out.println( key + "..." + s.getName() + "..." + s.getAge() );

}

n  方式2：根据键值对对象找键和值的方式

//a, 获取Map集合中所有的键值对元素,返回对应的Set集合

//b, 遍历键值对元素集合，获取到每一个键值对元素对象

//c, 通过键值对元素对象，获取对应的键，和对应的值

//获取Map集合中所有的键值对元素,返回对应的Set集合

Set< Map.Entry<String, Student>> entrySet = map.entrySet();

//遍历键值对元素集合，获取到每一个键值对元素对象

for (Map.Entry<String, Student> entry : entrySet) {

//通过键值对元素对象，获取对应的键，和对应的值

//找键

String key = entry.getKey();

//找值

Student s = entry.getValue();

//打印

System.out.println( key+"..."+s.getName()+"..."+s.getAge() );

}

l  HashMap:

n  特点：

是Map集合的子集合

底层采用哈希表结构

HashMap集合中的key不能重复，通过重写hashCode() 与 equals()方法来保证键的唯一。

不能保证元素存与取的顺序完全一致

l  LinkedHashMap:

n  特点：

是HashMap集合的子集合

底层采用哈希表+链表结构

LinkedHashMap集合中的key不能重复，通过重写hashCode() 与 equals()方法来保证键的唯一。

l  Collections中的方法：

public static <T> void sort(List<T> list) 排序

public static void shuffle(List<?> list) 集合中的元素存储位置随机打乱

原文地址：https://www.cnblogs.com/time-to-despair/p/9951009.html