黑马程序员——Jave集合

------- android培训、java培训、期待与您交流！ ----------

集合体系：
Collection:
A:List
ArrayList
Vector
LinkedList
B:Set
HashSet
LinkedHashSet
TreeSet
Map:
HashMap
Hashtable
TreeMap

1.Collection
(1)集合的由来：
Java语言是面向对象的语言，我们在很多时候，需要对多个对象进行操作。
目前我们可以考虑采用对象数组实现。但是，对象数组的长度是固定的，有
些情况下不符合需求，所以，java就提供了另外一种对象容器：集合。
(2)集合和数组的区别？
A:集合的长度可变，数组的长度固定。
B:集合只能存储引用类型，数组可以存储基本类型，也可以存储引用类型。
C:集合可以存储多种数据类型，数组只能存储一种数据类型。
(3)集合体系的由来：
由于数据结构不同，java提供了多种集合类供我们使用。
而这么多种集合类有共性的内容，通过不断地向上抽取，最终形成了集合的集成体系。
(4)Collection的功能概述
A.添加功能
add(Object obj)
B.删除功能
remove(Object obj)
C.判断功能
contains(Object obj)
D.长度功能
size()
E.迭代器
Iterator iterator()
(5)Iterator的原理和步骤
A.原理
不同的数据结构不同，所以，他们的取出方式只有他们自己最清楚。
B.使用步骤
a.通过集合对象获取迭代器对象
b.通过迭代器对象的hasNext()判断是否有元素
c.通过迭代器对象的next()获取元素
(6)集合的使用步骤
A.创建集合对象
B.创建元素对象
C.把元素添加到集合
D.遍历集合
案例：
A:Collection存储字符串并遍历
public static void main(String[] args){
//创建集合对象
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存储自定义对象并遍历
public static void main(String[] args){
//创建集合对象
Collection c = new ArrayList();
//创建学生对象
Student s1 = new Student("盖伦", 20);
Student s2 = new Student("赵信", 18);
Student s3 = new Student("嘉文", 22);
//把学生对象添加到集合
c.add(s1);
c.add(s2);
c.add(s3);
//遍历集合
Iterator it = c.iterator ();
while(it.hasNext()){
Student s = (Student)it.next();
System.out.println(s.getName()+"---"+s.getAge);
}
}
class Student{...}

2.List
(1)List集合的特点
Collection
List
元素有序(存储顺序和取出顺序一致)，可重复。
Set
元素无序，唯一。
(2)List集合的特有功能
A.添加功能
add(int index, Object obj)
B.删除功能
remove(int index)
C.修改功能
set(int index, Object obj)
D.获取功能
get(int index)
E.列表迭代器
ListIterator  listIterator()
(3)案例
A.List存储字符串并遍历
public static void main(String[] args){
//创建集合对象
List list = new ArrayList();
//添加元素
list.add("Hello");
list.add("world");
list.add("java");
//方式一：迭代器遍历
Iterator it = list.iterator();
while(it.hasNext()){
String s = (String) it.next();
System.out.println(s);
}
//方式二：for循环遍历
for(int x=0; x<list.size(); x++){
String s = (String) list.get(x);
System.out.println(s);
}
}
B.List存储自定义对象并遍历
public static void main(String[] args){
//创建集合对象
List list = new ArrayList();
//创建学生对象
Student s1 = new Student("盖伦", 24);
Student s2 = new Student("盖伦", 18);
Student s3 = new Student("盖伦", 28);
//添加元素
list.add(s1);
list.add(s2);
list.add(s3);
//方式一：迭代器遍历
Iterator it = list.iterator();
while(it.hasNext()){
Student s = (Student) it.next();
System.out.println(s.getName+"---"+s.getAge);
}
//方式二：for循环遍历
for(int x=0; x<list.size(); x++){
Student s = (Student) list.get(x);
System.out.println(s.getName+"---"+s.getAge());
}
}
class Student{...}
(4)ListIterator
A.可以逆向遍历，但是不建议。因为它需要先正向遍历。
B.并发修改异常。(ConcurrentModificationException)
怎么产生的:迭代器操作集合的时候，不要通过集合去操作集合。
怎么解决的：
a.完全使用集合操作操作集合
b.完全使用迭代器操作集合


3.常见的数据结构
栈：先进后出
队列：先进先出
数组：查询快，增删慢
链表：查询慢，增删快

4.List的三个子类
(1)List三个子类的特点
ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
(2)你准备使用谁？
要安全吗：
要：Vector
不要：ArrayList或者LinkedList
查询多：ArrayList
增删多：LinkedList
如果你不知道，就用ArrayList。
(3)ArrayList
A.存储字符串和自定义对象并遍历。
B.去除重复值。
(4)Vector
A.存储字符串和自定义对象并遍历。
(5)LinkedList
A.存储字符串和自定义对象并遍历。
B.通过LinkedList模拟栈或者队列数据结构的集合。

5.泛型
(1)泛型是把明确数据类型的工作推迟到了创建对象或者调用方法时才去明确的一种特殊数据类型。
(2)泛型的格式：
<数据类型>
(3)泛型的好处：
A.优化了程序设计，解决了黄色警告线的问题。
B.把运行时期异常提前到了编译期。
C.避免了强制类型转换。
(4)什么时候用泛型？
看API，如果类或者接口后面有<>，说明这里用泛型。
一般来说，集合中用。

6.增强for
(1)格式：
for(数组或者Collection集合中的元素的数据类型  变量 : 数组或者Collection集合对象)
{
直接使用变量。这个时候，变量其实就是元素。
}
(2)好处：
方便了数组或者Collection集合的遍历。
(3)弊端：
在使用的时候，要注意，数组或者Collection集合对象不能为null。

7.可变参数
(1)在定义功能的时候，我们不知道别人将来要传递多少参数，用可变参数。
(2)格式：
修饰符  返回值类型  方法名(数据类型... 变量)
{
...
}
注意：
A.这个变量本质是指定数据类型的一个数组。会自动把参数进行封装。
B.如果一个方法有多个参数，可变参数必须放在最后。

8.Set
(1)Set的特点是：
元素无序，唯一。
(2)Set的子类特点：
HashSet:
如何保证元素的唯一性呢？
底层数据结构是哈希表。依赖于两个方法：hashCode和equals()。
执行流程：
先判断hashCode()是否相同：
是：继续执行equals()方法，看其返回值：
true:说明元素重复，不添加。
false:说明元素不重复，添加到集合。
否：直接添加到集合。
代码实现：
如果以后看到HashXxx这种集合类，那么，重写hashCode()和equals()。
代码自动生成。
子类：LinkedHashSet
底层数据结构是链表和哈希表。
由链表保证元素有序。
有哈希表保证元素唯一。
TreeSet:
这个集合是可以按照某种规则对元素进行排序。
底层数据结构是二叉树。
如何保证元素的唯一性的呢？
根据比较的返回是否为0。
如何保证元素的排序的呢？
A.元素具备比较性(自然排序)
让元素所属的类实现Comparable接口。
B.集合具备比较性(比较器排序)
在创建集合的时候，在构造参数中传递Comparator接口的子类对象。
(3)Set集合的案例：
HashSet存储自定义对象保证元素唯一性。
TreeSet存储自定义对象保证元素唯一性和排序。

9.Map
(1)Map:存储的是键值对元素。键是唯一的，值可以重复。
Map
HashMap
Hashtable
TreeMap
数据结构和Set的一致。
注意：Map集合的数据结构是针对键有效，和值无关。
(2)Collection和Map的区别
A.Collection，是单列集合，其子类List可重复，子类Set唯一。
B.Map，是双列集合，键是唯一的，值是可重复的。
(3)Map接口的功能概述：
A.添加功能
put(K key, V value)
B.判断功能
containsKey(Object key)
containsValue(Object value)
C.删除功能
remove(Object value)
D.获取功能
get(K key)
keySet()
values()
E.长度功能
size()
(4)Map集合的遍历
根据键找值。
A.获取所有键的集合。keySet()
B.遍历键的集合，获取到每一个键。增强for
C.根据键到Map集合中找值。get()
(5)HashMap案例：
A:键是String，值是String
B:键是Integer，值是String
C:键是String，值是Student
D:键是Student，值是String
键是自定义对象，请注意保证唯一性。
(6)TreeMap案例：
A:键是Student，值是String
键是自定义对象，请注意保证唯一性和排序。
(7)案例：
统计字符串中每个字符出现的次数。
public static void main(String[] args) {
// 键盘录入一个字符串。
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
// 定义一个TreeMap集合。
TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
// 把字符串转换成字符数组。
char[] chs = line.toCharArray();
// 遍历字符数组，得到每一个字符。
for (char ch : chs) {
// 拿这个字符做键去集合中找值，根据返回值
Integer i = tm.get(ch);
if (i == null) {
// 把字符做键，1做值存储。
tm.put(ch, 1);
} else {
// 把值加1，然后重新存储键和值。
i++;
tm.put(ch, i);
}
}
// 定义一个StringBuilder
StringBuilder sb = new StringBuilder();
Set<Character> set = tm.keySet();
for (Character key : set) {
Integer value = tm.get(key);
sb.append(key).append("(").append(value).append(")");
}
String result = sb.toString();
System.out.println(result);
}
10.其他知识点
(1)Hashtable和HashMap的区别?
A:HashMap：线程不安全，效率高。允许null键和null值
B:Hashtable：线程安全，效率低。不允许null键和null值
(2)collection和collections的区别？
Collection：是单列集合的顶层接口。定义了共性功能。
Collections：是对集合进行操作的工具类。定义了排序，查找等功能。