集合框架

集合

(1)java是一种面向对象语言，如果我们要针对多个对象进行操作，就必须对多个对象进行存储。

   而对多个元素进行存储，前面我们学习过数组，数组的弊端，长度固定。这样，数组将不能

   满足变化的要求。所以，java就提供了集合供我们使用。

(2)集合的特点：

A:长度可以发生改变

B:只能存储对象

C:可以存储多种类型对象(一般存储的还是同一种)

(3)集合和数组的区别

A:长度问题

数组固定

集合可变

B:存储元素问题

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

集合只能是引用类型。

C:是否同一类型

数组元素类型一致。

集合元素类型可以不一致。

(4)集合体现的由来

集合是存储多个元素的容器，但是，由于数据结构不同，java就提供了多种集合类。

而这多种集合类有共性的功能，所以，通过不断的向上抽取，最终形成了集合体系

结构。

 

数据结构：数据存储的方式。

 

Collection

|--List

|--ArrayList

|--Vector

|--LinkedList

|--Set

|--HashSet

|--TreeSet

(5)如何学习和使用一个继承体系呢?

学习顶层：因为顶层定义的是共性内容。

使用底层：因为底层才是具体的实现。

 

2：Collection的功能

(1)Collection的功能

A:添加功能

boolean add(Object obj):添加一个元素

boolean addAll(Collection c):添加一个集合

B:删除功能

void clear():删除集合里的所有内容

boolean remove(Object obj):删除集合里的指定元素

boolean removeAll(Collection c):删除指定集合

C:判断功能

boolean isEmpty():判断集合是否为空

boolean contains(Object obj):判断集合内是否包含指定元素

boolean containsAll(Collection c):判断集合是否包含另一个集合的全部内容

D:遍历功能

Iterator iterator():迭代器，用于对集合内对象的遍历

E:长度功能

int size():集合内对象的个数

F:交集功能

boolean retainAll(Collection c):判断两个集合是否有相同的元素

G:转换功能

Object[] toArray():把集合转换成对象数组

(2)迭代器的使用

A:使用步骤

a:通过集合对象获取迭代器对象。

b:通过迭代器对象判断。

c:通过迭代器对象获取。

B:迭代器原理

由于多种集合的数据结构不同，所以存储方式不同，所以，取出方式也不同。

这个时候，我们就把判断和获取功能定义在了一个接口中，将来，遍历哪种

集合的时候，只要该集合内部实现这个接口即可。

C:迭代器源码

public interface Iterator

{

public abstract boolean hasNext();

public abstract Object next();

}

 

public interface Collection

{

public abstract Iterator iterator();

}

 

public interface List extends Collection

{

...

}

public class ArrayList implements List

{

public Iterator iterator()

{

return new Itr();

}

 

private class Itr implements Iterator

{

public boolean hasNext(){...}

public Object next(){...}

}

}

(3)集合的常见使用步骤：

A:创建集合对象

B:创建元素对象

C:把元素添加到集合中

D:遍历集合

a:通过集合对象获取迭代器对象。

b:通过迭代器对象判断。

c:通过迭代器对象获取。

(4)Collection存储字符串和自定义对象并遍历。

A:存储字符串

Collection c = new ArrayList();

 

c.add("hello");

c.add("world");

c.add("java");

 

Iterator it = c.iterator();

while(it.hasNext())

{

String s = (String)it.next();

System.out.println(s);

}

 

 

B:存储自定义对象

//创建集合

Collection c= new ArrayList();

//创建对象name  age

Student  s1= new Student("HHH",12);

Student  s2= new Student("HHH",13);

 

//把对象添加到集合中

c.add(s1);

c.add(s2);

//增强For遍历

for(Student s:c)

{

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

}

 

3：List的特有功能

(1)List的特有功能

A:添加功能

void add(int index,Object obj):在指定位置  添加指定元素

B:删除功能

Object remove(int index):删除元素并把删除的元素返回

C:修改功能

Object set(int index,Object obj):把指定位置的元素修改为指定的元素。返回修改前的值。

D:获取功能

Object get(int index):获取指定索引的对象

int indexOf(Object obj):返回此列表中指定元素第一次出现的索引。不包含则返回-1；

ListIterator listIterator():列表迭代器。

(2)List的遍历方式

A:Iterator迭代器

B:ListIterator迭代器

C:普通for

(3)ListIterator迭代器

A:是Iterator的子接口。

B:有自己的特有功能，可以逆向遍历数据，但是需要先正向遍历。一般不用。

(4)面试题：并发修改异常

A:并发修改异常的产生原因

用迭代器遍历集合，用集合去操作集合。

B:解决方案：

a:使用集合操作。

b:使用列表迭代器操作。

(5)List集合存储字符串和自定义对象并遍历。

A:存储字符串

 

B:存储自定义对象

 

1：BigDecimal

因为double类型的数据在参与运行的时候，有精度不明确的情况。

 

2：常见的数据结构

(1)数据结构+算法+UML+设计模式

(2)栈,队列,数组,链表

栈：先进后出

队列：先进先出

数组：查询快，增删慢

链表：查询慢，增删快

(3)面试前：百度下常见的数据结构的优缺点。

 

3：List的三个儿子

(1)List的三个儿子特点：

List

|--ArrayList

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

线程不安全，效率高

|--Vector

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

线程安全，效率低

|--LinkedList

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

线程不安全，效率高

(2)到底使用谁?根据需求看

是否要安全：

是：Vector

否：ArrayList,LinkedList

查询多：ArrayList

增删多：LinkedList

 

如果你什么都不知道，用ArrayList。

(3)ArrayList(存储字符串和自定义对象)

(4)Vector(存储字符串和自定义对象)

有自己的特殊功能。

但是不用，被新功能给替代了。

(5)LinkedList(存储字符串和自定义对象)

有自己的特殊功能。可以很方便的操作头和尾。

(6)案例：

A:ArrayList存储字符串并去除重复值

B:ArrayList存储自定义对象并去除重复值

需求：我们认为同姓名和同年龄的人即为同一个人。

C:用LinkedList模拟栈数据结构

 

4：泛型

(1)泛型是一种把明确类型的工作放在了创建对象或者调用方法时候才去明确的特殊的类型。

(2)格式：

<数据类型>

(3)好处：

A:解决了黄色警告线问题

B:把运行期间的转换异常给提前到了编译期间

C:优化了程序设计，不需要做强制类型转换了

(4)泛型的前世今生

A:泛型类

B:泛型方法

C:泛型接口

(5)泛型的使用：

看API中的类或者接口,其后是否跟有<>,如果有，就是泛型的应用。

一般在集合中用。

 

5：增强for循环

(1)格式：

for(数组或者Collection集合的元素类型 变量 : 数组或者Collection集合的对象)

{

直接使用变量即可。

}

(2)好处：

方便了数组和Collection集合的遍历。

(3)注意：

A:增强for是用来替代迭代器的。

B:不要在用增强for遍历集合的时候，用集合对集合本身进行修改。

 

1：Set

(1)Set的特点：

元素无序,唯一。

注意：这里的顺序是指存储和取出顺序。

 

2：HashSet

(1)HashSet：不保证元素的迭代顺序。并且，不保证该顺序恒久不变。

(2)怎么保证的呢?

HashSet底层数据结构是哈希表。

它依赖两个方法：hashCode()和equals()

顺序：

首先，判断hashCode()值是否相同。

相同：

继续走equals()方法，根据其返回值：

true：说明元素重复，不添加到集合。

false：说明元素不重复，添加到集合。

不同：直接添加到集合。

(3)怎么重写hashCode()和equals()方法呢?

hashCode():

把对象的所有成员变量值相加即可。

如果是基本类型，就加值。如果是引用类型，就加哈希值。

equals():

A:this==obj

B:!(obj instanceof Student)

C:所有成员变量的值比较。基本类型用==,引用类型用equals()。

 

如果不会，自动生成。

(4)案例：

HashSet存储字符串并遍历

HashSet存储自定义对象并遍历

针对自定义对象：

需求：如果对象的成员都相同，我们就认为是同一个元素。

 

3：TreeSet

(1)TreeSet：根据构造方法的不用，选择使用自然排序或者比较器排序。

            按照实际的需求，可以对元素进行排序。并且保证唯一。

(2)怎么保证的呢?

排序：底层结构是二叉树。按照树节点进行存储和取出。

两种实现：

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

TreeSet的无参构造，要求对象所属的类实现Comparable接口。

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

TreeSet的带参构造，要求构造方法接收一个实现了Comparator接口的对象。

唯一：根据返回值是否为0。

注意：

如果同时有两种方案，以谁为主呢?以比较器为主。

(3)案例：

TreeSet存储字符串并遍历

TreeSet存储Integer并遍历

TreeSet存储自定义对象并遍历

 

4：Collection体现的集合总结

Collection

|--List

|--ArrayList

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

线程不安全，效率高。

|--LinkedList

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

线程不安全，效率高。

|--Vector

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

线程安全，效率低。

|--Set 唯一

|--HashSet

底层数据结构是哈希表。

如何保证元素唯一性呢?

依赖两个方法。hashCode()和equals()。

以后都自动生成。

|--TreeSet

底层数据结构是二叉树。

如何保证元素唯一性呢?如何保证元素排序呢?

根据返回值是否是0，判断元素是否重复。

排序有两种方案：

元素具备比较性 实现Comparable接口

集合具备比较性 实现Comparator接口

 

5：在集合中的数据结构问题

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

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

HashXxx:底层数据结构是哈希表。跟两个有关。hashCode()和equals()

TreeXxx:底层数据结构是二叉树。两种排序方式。Comparable接口和Comparator接口

 

6：什么时候，使用哪种Collection集合。

元素唯一吗?

唯一：

Set

需要排序吗?

需要：TreeSet

不需要：HashSet

 

不知道，用HashSet。

不唯一：

List

需要安全码?

需要：Vector

不需要：ArrayList和LinkedList

查询多：ArrayList

增删多；LinkedList

不知道，用ArrayList。

 

7：Collections

(1)Collections是针对Collection集合操作的工具类。

(2)面试题：

Collection和Collections的区别?

(3)功能：

排序

查找

反转

最值

随机置换

(4)模拟斗地主发牌

 

1:Map

(1)Map是一个键值对形式的集合。它的元素都是有键和值组成。

(2)Map和Collection的区别?(面试题)

A:Map 是由键值对组成的集合,Map的键是唯一的,值可以重复。

B:Collection 是有单列数据组成的集合,它的儿子List是可以重复的，Set是唯一的。

(3)HashMap和Hashtable的区别?(面试题)

HashMap:线程不安全，效率高。允许null键和值。

Hashtable:线程安全，效率低。不允许null键和值。

(4)Map的功能：

A:添加功能 V put(K key, V value) 

  当key在集合中不存在时，添加元素；当key在集合存在时，替换

 

B:判断功能 boolean containsKey(Object key):判断指定的键是否在集合中

boolean containsValue(Object value):判断指定的值是否在集合中

boolean isEmpty()判断集合是否为空

C:删除功能

void clear():清空所有键值对数据

V remove(Object key):根据指定的键删除键值对

D:获取功能

Object get(Object key):根据键获取值

Set <K> keySet():获取所有键的集合

Collection<V> values():获取所有值的集合

E:长度功能

(5)Map的两种遍历方式(思路补齐)

A:丈夫找妻子

Set<String> set=hm.keySet();

for(String s:set)

{

String str=s.get(s);

System.out.println(str);

}

 

B:根据结婚证找丈夫和妻子

 

2:HashMap

(1)HashMap存储字符串并遍历

键：String

值：String

(2)HashMap存储自定义对象并遍历

键：String

值：Student

(3)HashMap存储自定义对象并遍历

键：Student

值：String

需求：如果对象的成员变量值都相同，我们则认为是同一个对象。

 

3:TreeMap

(1)TreeMap存储字符串并遍历

键：String

值：String

(2)TreeMap存储自定义对象并遍历

键：String

值：Student

(3)TreeMap存储自定义对象并遍历

键：Student

值：String

需求：如果对象的成员变量值都相同，我们则认为是同一个对象。

      同时，我们还要按照年龄排序。

 

4:案例

(1)统计字符串中每个字符出现的次数。通过断点看代码执行流程。

(2)HashMap嵌套HashMap的使用。

(3)HashMap嵌套ArrayList的使用。