黑马程序员_Collection集合

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ---------

1：集合
(1)java是一种面向对象语言，如果我们要针对多个对象进行操作，就必须对多个对象进行存储。
   而对多个元素进行存储，前面我们学习过数组，数组的弊端，长度固定。这样，数组将不能
   满足变化的要求。所以，java就提供了集合供我们使用。
(2)集合的特点：
1、长度可以发生改变
2、只能存储对象
3、可以存储多种类型对象(一般存储的还是同一种)
(3)集合和数组的区别
1、长度问题
数组固定
集合可变
2、存储元素问题
数组可以是基本类型，也可以是引用类型。
集合只能是引用类型。
3、是否同一类型
数组元素类型一致。
集合元素类型可以不一致。
(4)集合体系的由来
集合是存储多个元素的容器，但是，由于数据结构不同，java就提供了多种集合类。
而这多种集合类有共性的功能，所以，通过不断的向上抽取，最终形成了集合体系
结构。

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

程序 = 算法 + 数据结构

Collection
|--List
|--ArrayList
|--Vector
|--LinkedList
|--Set
|--HashSet
|--TreeSet
(5)如何学习和使用一个继承体系呢?
学习顶层：因为顶层定义的是共性内容。
使用底层：因为底层才是具体的实现。

2：Collection的功能(掌握)
(1)Collection的功能
1、添加功能(掌握)
boolean add(Object obj):向集合中添加一个元素。
boolean addAll(Collection c):向集合中添加一个集合的元素。
2、删除功能(掌握)
void clear():删除集合中所有的元素。
boolean remove(Object obj):删除集合中指定的元素。
boolean removeAll(Collection c):删除集合中指定的集合元素。
3、判断功能(掌握)
boolean isEmpty():判断集合是否为空。
boolean contains(Object obj):判断集合是否包含指定的元素。
boolean containsAll(Collection c):判断集合是否包含指定的集合中的元素。
4、遍历功能(掌握)
Iterator iterator():迭代器。
hasNext（）:判断是否还有元素
next():获取下一个元素
5、长度功能(掌握)
int size():获得集合的元素个数。
6、交集功能
boolean retainAll(Collection c):判断集合中是否有相同的元素。
7、转换功能
Object[] toArray():把集合变成数组。
(2)迭代器的使用
1、使用步骤
1、通过集合对象获取迭代器对象。
2、通过迭代器对象判断。
3、通过迭代器对象获取。
2、迭代器原理
由于多种集合的数据结构不同，所以存储方式不同，所以，取出方式也不同。
这个时候，我们就把判断和获取功能定义在了一个接口中，将来，遍历哪种
集合的时候，只要该集合内部实现这个接口即可。
3、迭代器源码
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)集合的常见使用步骤：
1、创建集合对象
2、创建元素对象
3、把元素添加到集合中
4、遍历集合
1、通过集合对象获取迭代器对象。
2、通过迭代器对象判断。
3、通过迭代器对象获取。
(4)Collection存储字符串和自定义对象并遍历。
a、存储字符串
Collection c = new ArrayList();

//String s = "hello";
//c.add(s);
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();
                            Student s1=new Student("张三",24);          
                            c.add("s1");
                     
                            Iterator it=c.iterator();
                            while(it.hasNext()）
                              {
                                String s=(String)it.next();
                                System.out.println(s);
                              }

3：List的特有功能


(1)List的特有功能
1、添加功能
void add(int index,Object obj):
2、删除功能
Object remove(int index):
3、修改功能
Object set(int index,Object obj):
4、获取功能
Object get(int index):
int indexOf(Object obj):
ListIterator listIterator():
(2)List的遍历方式
1、Iterator迭代器
2、ListIterator迭代器
3、普通for+get()
(3)ListIterator迭代器
是Iterator的子接口。

(4)面试题：并发修改异常
1、并发修改异常的产生原因
用迭代器遍历集合，用集合去操作集合。
2、解决方案：
1、使用集合操作。
2、使用列表迭代器操作。
(5)List集合存储字符串和自定义对象并遍历。(
1、存储字符串

2、存储自定义对象

(6)List特点：
1. 有序(存储和取出的顺序一致)
2. 可以重复
3. 可以通过索引值操作对应位置的元素
常见的数据结构：
数据结构：组织数据的方式，也就是，存储数据的方式。
栈，队列，链表，数组，树，图，堆。
栈：先进后出。  为什么呢？  入口和出口都是同一个。
队列：先进先出。（去超市买东西，最后结账排队）   入口和出口不是同一个。
数组：
概念：存储多个同一种类型元素的容器。
特点：每一元素都有编号。
优缺点：
优点：查询快。
缺点：增删慢。
int[] arr = {1,2,3,4,5,6,7};
链表：
概念；把一些结点通过链子连接起来的数据结构。
什么是结点：
其实就是由地址域（指针）和数值域组成的。
优缺点：
优点：增删快。
缺点：查询慢。
面试题：List三个“儿子”的特点？
ArrayList：
底层数据结构是数组，查询快，增删慢。线程不安全，效率高。
Vector：
底层数据结构是数组，查询快，增删慢。线程安全，效率低。
这个集合，一般不用。
LinkedList：
底层数据结构是链表。增删快，查询慢。线程不安全，效率高。
思考题：我们使用List的那个儿子呢？
看需求。
1、我要查询快。
这个时候肯定要使用底层结构是数组的集合。
A：我要线程安全的。
Vector。
B：我要效率高的。
ArrayList。
2、我要增删快。
LinkedList。
如果你不知道要使用那个集合，就用ArrayList。
使用ArrayList集合存储自定义对象（学生类），然后去重。
我们假设：姓名和年龄一致的就是重复元素。
思路：
1、我得有集合，创建两个集合，A，B。
2、创建元素对象。
3、把元素对象添加到集合A中。（集合A中是有元素的，而集合B中是没有的）
4、遍历集合A中的所有的元素。
判断集合B中是否有（遍历到的当前元素，集合A），如果没有，就把当前元素，添加到集合B中。
如果有，不添加。 
判断的时候，出了问题。怎么解决的？？？
因为集合的contains方法是依赖于Object类的equals方法的，而Object类的equals方式，默认比较的是地址值。
所以，我们应该在学生类中重写Object类的equals方法。
4.Vector的特有功能：JDK1.0版本以前的。
添加：
void  addElement(Object obj);  添加元素
获取：
Object  elementAt(int index); 根据给定索引获取指定元素
Enumeration  elements();  相当于现在的Iterator（hasNext():判断集合中是否还有元素   next()：获取集合中某个元素）。
类Enumeration里边也有两个方法；
hasMoreElements();   就相当于hasNext() 
nextElement();       就相当于next();
JDK版本升级考虑因素：
1、安全。
2、效率。
3、简化书写。

5.LinkedList：
添加：
void addFirst();
void addLast();
获取：
Object getFirst();
Object getLast();
删除：
Object removeFirst();
Object removeLast();

请用LinkedList集合来模拟栈的数据结构。
意思就是我们有一个LinkedList集合可以使用（只能使用他），但是需要再定义一个栈集合。
而我们定义的这个栈集合（来模拟栈的数据结构的集合）需要对外提供添加，获取两个方法。
栈：先进后出。
存储顺序： a,b,c
取的顺序： c,b,a
思路：
1、我们需要自定义一个栈集合，里边有一个LinkedList数据类型的成员变量。
2、在栈集合中，对外提供添加，获取的功能。
其实就是调用LinkedList集合的添加，获取功能。
添加功能：
而我们知道，栈的数据结构是先进后出的。所以我们要保证添加的元素永远在第一位。
所以，添加功能调用的是LinkedList集合的addFirst()方法。
获取功能：
我们要使用LinkedList集合的get方法，通过索引来依次获取所有元素。但是我们现在没办法知道集合的长度，
所以，我们自定义的栈集合还应该有一个获取集合长度的方法。

6.泛型：
概念：任意的类型。是一种把明确数据类型的功能放在创建对象或者调用方法的时候的特殊的类型。（泛指某一种任意的类型）
ArrayList<Student>  list = new ArrayList<String>();
格式： <数据类型>
作用：
1、可以解决eclipse中的黄色警告线问题。
2、解决类型转换问题。
怎么解决类型转换问题呢？
模仿数组，告诉咱们，在存储对象的对象的时候，只能存储我指定的数据类型。
好处：
1、可以解决eclipse中的黄色警告线问题。
2、把运行期间的类型转换问题提到了编译期间。
3、优化程序设计。
在哪使用：
一般在集合中使用。
看API。如果一个或者接口后边跟的有<>，那我们在使用这个类或者接口的时候，就必须明确数据类型。
泛型接口：
泛型类：
泛型方法：


增强for：
格式：
for(数组或者Collection集合的数据类型 变量名 : 数组或者Collection集合对象)
{
基本操作。。。。
}
作用：简化数组或者Collection集合中的变量。
注意事项：
增强for其实就是来替代迭代器的。所以，我们在使用增强for的时候，不能使用集合对象对集合进行操作。
否则回报一个异常，并发修改异常。 ConcurrentModificationException。
刚才我们用ArrayList存储自定义元素Student对象,用的是Iterator遍历的,现在把刚才的代码拿出来,用增强for循环从新遍历一下。

泛型类：
需求：在不使用方法重载的情况下，实现同一个方法，输出不同数据类型的对象。
解决方案：用泛型类来做。
class Tool<SS>
{
void show(SS s)
{
System.out.println(s);
}
}
在main函数中的代码：
Tool<引用类型>  t = new Tool<和前一个尖括号内的类型必须一致>();
注意事项：泛型类型必须是引用类型。


泛型方法：
我们在实现上边那个需求的时候，发现我们为了输出不同数据类型的对象，所以在类上定义了泛型。
那么，我们如果能在调用方法的时候才告诉它我要输出什么类型的数据，该有多好呢？
所以，我们改进了一下，把泛型加在了方法上。
思考题：
下面这个方法是非静态方法。那，如果有static，能用泛型吗？ 能用的话，泛型加在哪？
public <SS> void show(SS s)
{
System.out.println(s);
}
泛型接口：
如果一个接口后边有“泛型”，那我们在写该接口的实现类的时候，也必须要加泛型。
interface Inter<SS>
{
}
class InterImpl<SS> implments Inter<SS>
{
}


7.Set集合的特点
元素无序,唯一。
注意：这里的顺序是指存储和取出顺序

HashSet是如何保证元素唯一性的?写代码体现。
1)HashSet：不保证元素的迭代顺序。并且，不保证该顺序恒久不变。
(2)怎么保证的呢?
HashSet底层数据结构是哈希表。
它依赖两个方法：hashCode()和equals()
顺序：
首先，判断hashCode()值是否相同。
相同：
继续走equals()方法，根据其返回值：
true：说明元素重复，不添加到集合。
false：说明元素不重复，添加到集合。
不同：直接添加到集合。


3:TreeSet是如何保证元素唯一性的?把代码看一遍。有问题记录下来。

4:工具类的使用?

5:请分析List和Set，自己总结什么时候使用哪种集合。

6:不同的数据结构特点是什么，需要注意什么?
ArrayXxx:
LinkedXxx:
HashXxx:
TreeXxx:

7.定义一个TreeSet对象，存储自定义对象Student。
按照姓名长度的大小决定存储的顺序，从长到短排序，如果长度一样，年龄小的在前面



----------- android培训、java培训、java学习型技术博客、期待与您交流！ ---------