黑马程序员=======总结集合笔记

<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">一.集合：</span>

1.数组的弊端：
1).其长度一旦确定，后期不能更改；
2).只能存储一种类型的数据；
2.集合的优点：
1).对于我们来说，集合是无限大的，我们不用关系长度的问题；
2).集合可以存储任何的引用数据类型；
3.集合的层次结构：
Collection(接口)
|--List(接口)：1.有序；2.能存储重复值；
|--ArrayList(类):数组实现；不同步，效率高；
|--Vector(类)：数组实现；同步的，效率低；
|--LinkedList(类):链表实现；不同步，效率高；

|--Set(接口)：1.无序的；2.不能存储重复值；

二.Collection(接口)：
1.常用方法：
boolean add(E e)
boolean remove(Object o)
void clear()
boolean contains(Object o)
boolean isEmpty()
int size()
批量的方法：
boolean addAll(Collection c)
boolean removeAll(Collection c)
boolean containsAll(Collection c)
boolean retainAll(Collection c)
2.遍历的方式：
Object[] toArray()：把集合转成数组，可以实现集合的遍历
Iterator iterator()：迭代器，集合的专用遍历方式

三.集合List的子类：
1).ArrayList:数组实现。不同步的，效率高；
2).Vector:数组实现。同步的，效率低；
3).LinkedList:链表实现。不同步的，效率高；

四.泛型：
1).基本使用：(必须掌握)
ArrayList<String> list = new ArrayList<String>();
或者：
ArrayList<String> list = new ArrayList<>();(常用格式)
或者：
ArrayList<String> list = new ArrayList();(会有黄色警告线)
2).泛型类：
class MyArrayList<T>{
public void add(T t){
}
}
3).泛型方法：
class MyArrayList{
//能保证接收什么类型的参数，就返回一个什么类型的值；
public <T> T show(T  t){
return t;
}
}
4).泛型接口：
interface IA<T>{

public void show(T t);
}
  子类实现：
1).可以丢弃泛型：
class A implements IA{
public void show(Object obj){
}
}
2).可以指定为某个具体类型：
class A implements IA<String>{
public void show(String s){
}
}
3).可以继续使用泛型：
class A<T> implements IA<T>{
public void show(T t){
}
}

五.其它语法：
1).增强for(foreach循环);
1.格式：
for(数据类型   变量名  ：  数组名/集合){
}
2.注意：
1).当增强for应用于遍历集合时，实际上是被编译为"迭代器"使用，
  注意：并发修改异常；

2).静态导入：
import static java.lang.Math.abs;
使用通配符：
import static java.lang.Math.*;//*号通配所有"静态方法"，不包括其它方法；
3).可变参数：
public static int sum(int ... nums){
for(int n : nums){
}
}
1.可变参数内部作为"数组实现"；
2.调用时，可以不传递参数，可以传递多个参数；
3.可变参数可以同其它普通参数共存，但可变参数一定要位于参数列表的末尾；
4).将数组转换为集合对象：Arrays的asList()方法
1.转换后得到的对象，不能添加、删除成员，但可以修改成员；
5).集合嵌套；
1.集合的add()方法接收的是Object类型；
2.集合对象也是Object的子类，所以可以可以添加到集合中；

六.Set集合：
1.特点:
1).无序的；
2).不存储重复值；
2.HashSet(类)：
1).内部使用：哈希表结构；
2).验证元素的唯一性：
hashCode() && equals()
3).遍历方式：没有特殊方式，使用Collection的方式；
A.Object数组；
B.迭代器；
C.增强for;
3.LinkedHashSet(类):
1).内部使用：
链表：保证有序；
哈希表：保证唯一；
4.TreeSet(类):
1).内部使用："树"结构；
2).树结构要对元素进行"排序"：
A.自然排序：
元素实现Comparable接口；
重写compareTo()方法；
B.比较器排序：
自定义比较器，或者匿名内部类，实现：Comparator接口
重写compare()方法；
实例化TreeSet时，传递自定义比较器对象；

class TreeSet{
private TreeMap map = null;
public TreeSet(){
map = new TreeMap();
}
public TreeSet(Comparator com){
map = new TreeMap(com);
}
return m.put(e, PRESENT)==null;
}
class TreeMap{
private Comparator comparator;//比较器
//构造方法
public TreeMap(Comparator con){
comparator = con;
}
public V put(K key, V value) {

Comparator cpr = comparator;

if (cpr != null) {
//比较器
}
else {//new TreeSet()-->cpr对象为null;
//自然排序
}
Entry<K,V> e = new Entry<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
fixAfterInsertion(e);
size++;
modCount++;
return null;
}

七.Map集合：
1.特点：
1).无序；
2).双列的；键值对存储；
3).所有的数据结构，都应用于"键"，跟值无关；
2.Map的方法:
V put(K key,V value)
V remove(Object key)
void clear()
boolean containsKey(Object key)
boolean containsValue(Object value)
boolean isEmpty()
int size()
获取：
V get(Object key)
Set<K> keySet()（可以用于遍历）
Collection<V> values()
Set<Map.Entry<K,V>> entrySet()（可用于遍历）
3.遍历的方式：
1).keySet()和get(Object key):
2).entrySet()和Map.Entry的getKey()和getValue():
4.HashMap(类):
1).键不能重复，使用hashCode和equals()验证；
5.LinkedHashMap(类):
1).有序的；
6.TreeMap(类):
1).对"键"进行"排序"，使用两种方式：
A.自然排序；
B.比较器排序；

public class Demo {
public static void main(String[] args) {
//1.实例化一个集合
TreeMap<String,String> map = new TreeMap<>();
//2.填充集合
map.put("it001", "张学友");
map.put("it004", "刘德华");
map.put("it002", "张惠妹");
map.put("it003", "章子怡");

Set<String> keySet = map.keySet();
for(String key : keySet){
System.out.println(key + "----" + map.get(key));
}
}
}