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

<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));
		}
	}
}