------- android培训、java培训、期待与您交流！ ----------
对集合,泛型,高级for循环知识点的总结
1. 集合的特点：
集合的长度是可变的；集合可以存储不同类型的对象；
Collection定义了集合框架的共性功能。
一、添加
add(e); //e是形式参数的意思，没什么特别的，就是元素的意思；
addAll(collection);
二、删除
remove(e);
removeAll(collection);
clear();
三、判断。
contains(e);
isEmpty();
四、获取
iterator();
Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。
while(it.hasNext())
{
sop(it.next());
}
size();
五、获取交集。
retainAll();
六、集合变数组。
toArray();
1，add方法的参数类型是Object。以便于接收任意类型对象。
2，集合中存储的都是对象的引用(地址)
什么是迭代器呢？
其实就是集合的取出元素的方式。
迭代器是取出方式，会直接访问集合中的元素。
所以将迭代器通过内部类的形式来进行描述。
通过容器的iterator()方法获取该内部类的对象。
2. 对Collection进行总结；
list集合中特有的方法
Collection
|--List:元素是有序的，元素可以重复，因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构，特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的链表数据结构，特点：增删速度很快，查询稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
|--Set：元素是无序，元素不可以重复。、
List：特有方法。凡是可以操作角标的方法都是该体系特有的方法。
增
add(index,element);
addAll(index,Collection);
删
remove(index);
改
set(index,element);
查
get(index):
subList(from,to);
listIterator();
int indexOf(obj):获取指定元素的位置。
ListIterator listIterator();
List集合特有的迭代器。ListIterator，它是Iterator的子接口。
在迭代时，Iterator不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。
所以我们只能用ListIterator。接口里面的方法，来操作异常
所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，
只能对元素进行判断，取出，删除的操作，
如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。
该接口只能通过List集合的listIterator方法获取。
代码的体现；
/**
* 演示列表迭代器。
* 使用方式：在迭代过程中，准备添加和修改元素的时候，不能用Iterator。
* 因为Iterator里面之后移除方法，没有添加和修改等方法，
* 所以会包ConcurrentModificationException异常
*/
ListIterator<String> li = al.listIterator();
//sop("hasPrevious():"+li.hasPrevious());
while(li.hasNext())
{
String s = li.next();
if(s.equals("java02"))
//这里面我们就添加了元素。要是用Iterator就会产生
//ConcurrentModificationException异常，这个是并发访问异常。
// li.add("java009");
li.set("java006");
}
3. 去除ArrayList集合中的重复元素,用循环的方式，判断有没有一样的元素，然后去掉重复元素；因为list是有序的，可以重复的；
while(it.hasNext())
{
String str = it.next();
// 不包含此元素，我们就添加，包含我们就不添加此元素了；
if(!newAl.contains(str))
newAl.add(str);
}
return newAl;
4. 将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。
思路：
1，对人描述，将数据封装进人对象。
2，定义容器，将人存入。
3，取出。
List集合判断元素是否相同，依据是元素的equals方法。
// 判断同一个元素，我们要重写equals方法。这个只是用来告诉我们怎么判断元素相同。
// 去除重复元素的代码还要重新写；重点；
public boolean equals(Object obj)
{
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
//System.out.println(this.name+"....."+p.name);
return this.name.equals(p.name) && this.age == p.age;
}
然后还是利用包含特性，存到新的容器中去，因为毕竟list集合是可以存放重复元素的；
while(it.hasNext())
{
Person p = it.next();
// 也是利用人一个新的集合来判断是否有相同的对象。来去除同一个元素的。
// 判断的底层用到了equels方法；
if(!newAl.contains(p))
newAl.add(p);
}
return newAl;
5. |--Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。
|--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成。
如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashcode值不同，不会调用equals。
注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
|--TreeSet：
Set集合的功能和Collection是一致的。
本身是无序的，不可重复的，所以添加的元素不需要去除重复元素；
但是添加的是对象就不同了，需要判断一下是不是重复元素；
public int hashCode()
{
//字符串本身就有hashCode值，这里面体现了元素的唯一性，age*37也是在保证元素的唯一性。
return name.hashCode()+age*37;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Person01))
return false;
Person01 p = (Person01)obj;
return this.name.equals(p.name) && this.age == p.age;
}
6. Set:无序，不可以重复元素。
|--HashSet：数据结构是哈希表，线程是非同步的。
保证元素唯一性的原理：判断元素的hashCode值是否相同。
如果相同，还会继续判断元素的equals方法，是否为true。
|--TreeSet： 可以对Set集合中的元素进行排序，有自身排序的功能。
底层数据结构是二叉树。
保证元素唯一性的依据：
compareTo方法return 0.
TreeSet排序的第一种方式：让元素自身具备比较性。
元素需要实现Comparable接口，覆盖compareTo方法。
也种方式也成为元素的自然顺序，或者叫做默认顺序。
TreeSet的第二种排序方式。
定义一个类，实现Comparator接口，覆盖compare方法。
当元素自身不具备比较性时，或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。
记住，排序时，当主要条件相同时，一定判断一下次要条件。
一、具有比较性的代码；
class Studenter implements Comparable
{
public int compareTo(Object obj)
{
if(!(obj instanceof Studenter))
throw new RuntimeException("不是学生对象");
Studenter s = (Studenter)obj;
if(this.age>s.age)
return 1;
if(this.age==s.age)
{
return this.name.compareTo(s.name);
}
return -1;
}
二、具有比较器的代码；
//定义比较器；
class StrLenComparator implements Comparator<String> {
public int compare(String s1, String s2) {
// 因为长度的值是一个整形，所以我们通过转化成整形对象的方式，来进行判断顺序问题；
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if (num == 0)
// 这个是二级判断，字符串本身就具备比较性；
return s1.compareTo(s2);
return num;
}
7. LinkedList:特有方法：
addFirst();
addLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
getFirst();
getLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
在JDK1.6出现了替代方法。
添加元素
offerFirst();
offerLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。
peekFirst();
peekLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
使用LinkedList模拟一个堆栈或者队列数据结构。
堆栈：先进后出 如同一个杯子。
队列：先进先出 First in First out FIFO 如同一个水管。
8. 枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。
//获得枚举接口对象；
Enumeration<String> en = v.elements();
//通过枚举对象调用里面的方法，进行遍历；
while(en.hasMoreElements())
{
System.out.println(en.nextElement());
}
9. 泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。
好处
1.将运行时期出现问题ClassCastException，转移到了编译时期。，
方便于程序员解决问题，让运行时,问题减少，安全。
2，避免了强制转换麻烦。
泛型格式：通过<>来定义要操作的引用数据类型。
在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，
只要见到<>就要定义泛型。
其实<> 就是用来接收类型的。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
10. 下面这两种写法是一致的，因为装箱和拆箱的原理，java底层实现的功能
//al.add(4);
//al.add(new Integer(4));
11. 泛型类。
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展。
现在定义泛型来完成扩展。
class Utils<QQ>
{
private QQ q;
public void setObject(QQ q)
{
this.q = q;
}
public QQ getObject()
{
return q;
}
}
调用泛型类的时候就是这样的方便；
public static void main(String[] args)
{
Utils<Worker> u = new Utils<Worker>();
u.setObject(new Worker());
Worker w = u.getObject();;
12. //泛型类定义的泛型，在整个类中有效。如果被方法使用，
//那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
//为了让不同方法可以操作不同类型，而且类型还不确定。
//那么可以将泛型定义在方法上。
特殊之处：
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
class Demo<T>
{
// 方法的类型要和类的类型一致；
public void show(T t)
{
System.out.println("show:"+t);
}
// 这个是自己定义的泛型，可以和类不一致；
public <Q> void print(Q q)
{
System.out.println("print:"+q);
}
public static <W> void method(W t)
{
System.out.println("method:"+t);
}
13. ? 通配符。也可以理解为占位符，泛型的限定；
？ extends E: 可以接收E类型或者E的子类型，上限。
？ super E: 可以接收E类型或者E的父类型，下限
//接收子类型的集合；这个是限定的集合；
public static void printColl(Collection<? extends Person> al)
{
Iterator<? extends Person> it = al.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
14. Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
1，添加。
//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键，对应的值。
//并put方法会返回被覆盖的值。
put(K key, V value)
putAll(Map<? extends K,? extends V> m)
//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值。
//并put方法会返回被覆盖的值，返回原来的值，要是没有原来的值，那么我们就返回null；
System.out.println("put:"+map.put("01","zhangsan1"));
2，删除。
clear()
remove(Object key)
3，判断。
containsValue(Object value)
containsKey(Object key)
isEmpty()
4，获取。
get(Object key)
size()
values()
//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断
//获取map集合中所有的值。
Collection<String> coll = map.values();
entrySet()
keySet()
Map
|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。
|--TreeMap：底层是二叉树数据结构，线程不同步。可以用于给map集合中的键进行排序。
和Set很像。
其实大家，Set底层就是使用了Map集合
15. map集合的两种取出方式：
1，Set<k> keySet：将map中所有的键存入到Set集合，因为set具备迭代器。
所以可以用迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。
Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。
2，Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，
而这个关系的数据类型就是：Map.Entry
Entry其实就是Map中的一个static内部接口。
为什么要定义在内部呢？
因为只有有了Map集合，有了键值对，才会有键值的映射关系。
关系属于Map集合中的一个内部事物。
而且该事物在直接访问Map集合中的元素。
//将Map集合中的映射关系取出。存入到Set集合中。
Set<Map.Entry<String,String>> entrySet = map.entrySet();
Iterator<Map.Entry<String,String>> it = entrySet.iterator();
while(it.hasNext())
{
//Map.Entry<String,String>是一个类型；是一个关系类型，所以可以接收对象引用；
Map.Entry<String,String> me = it.next();
String key = me.getKey();
String value = me.getValue();
System.out.println(key+":"+value);
}
第二种获取map元素集合的键值对；
//先获取map集合的所有键的Set集合,keySet();
Set<String> keySet = map.keySet();
//有了Set集合。就可以获取其迭代器。
Iterator<String> it = keySet.iterator();
while(it.hasNext())
{
String key = it.next();
//有了键可以通过map集合的get方法获取其对应的值。
String value = map.get(key);
System.out.println("key:"+key+",value:"+value);
}
16. 注意我们可以通过set集合中的排序特点给map进行排序；我们这时用到的就是TreeMap，调用TreeMap里面的treeSet。TreeMap具有排序功能，
我们对元素进行去掉重复元素操作，我们用到的是hashMap，调用hashSet，hashMap具有去除重复的功能；
17. 高级for循环；
格式：
for(数据类型变量名 : 被遍历的集合(Collection)或者数组)
{
}
对集合进行遍历。
只能获取集合元素。但是不能对集合进行操作。
迭代器除了遍历，还可以进行remove集合中元素的动作。
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。
传统for和高级for有什么区别呢？
高级for有一个局限性。必须有被遍历的目标。
建议在遍历数组的时候，还是希望是用传统for，因为传统for可以定义脚标。
18. JDK1.5版本出现的新特性。
19. 方法的可变参数。
在使用时注意：可变参数一定要定义在参数列表最后面。
可变参数。
其实就是上一种数组参数的简写形式。
不用每一次都手动的建立数组对象。
只要将要操作的元素作为参数传递即可。
隐式将这些参数封装成了数组。
在使用时注意：可变参数一定要定义在参数列表最后面。
可变参数必须是同一类型的参数；
public static void show(String str,int... arr)
{
System.out.println(arr.length);
}
20. 集合框架的工具类。
Collections:集合框架的工具类，里面定义的都是静态方法。
Collections和Collection有什么区别？
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
它有两个常用的子接口，
List：对元素都有定义索引，有序的，可以重复元素。
Set：不可以重复元素，无序。
Collections是集合框架中的一个工具类，该类中的方法都是静态的
提供的方法中有可以对list集合进行排序，二分查找等方法。
通常常用的集合都是线程不安全的，因为要提高效率。
如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。
Collections.sort(list);
Collections.max();
Collections.binarySearch();
//默认的排序方式。也可以传入一个比较器，自定义排序；
Collections.sort(list,new StrLenComparator());
// 一种是默认排序最大值，默认排序时按照字母排序的。
// 一种是自定义模式最大值。按照长度求的最大值；
String max = Collections.max(list/*,new StrLenComparator()*/);
排序和二分法查找必须定义一个比较器；要是不定义的话，就会出现找不到的可能；
Collections.sort(list,new StrLenComparator());
sop(list);
二分法查找元素，返回元素的位置值，要是没有查到元素，返回元素应该在的位置值的负数减去1.
int index = Collections.binarySearch(list,"aaa",new StrLenComparator());
21. Collections.reverseOrder();
本方法是用来“逆转”容器里面的数据的，封装的很好。
使用方式，是在构造函数中传递，该方法。如下代码；
反向打印出通过长度来排序的元素；
TreeSet<String> ts =new
TreeSet<String>(Collections.reverseOrder(new StrLenComparatorln()));
Collections.shuffle(list);随机打乱顺序；
Collections.reverseOrder();倒序排序的方法；
所有的元素替换成指定的元素；
*Collections.fill(list,"pp");
替换相应的元素；
Collections.replaceAll(list,"aaa","pp");
*Collections.reverse(list);反向输出；
22. 为什么要将集合变数组？
为了限定对元素的操作。不需要进行增删了。
按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
al这个集合带着泛型呢。所以我们要用String类型；
String[] arr = al.toArray(new String[al.size()]);
将数组以字符串的形式打印出来
System.out.println(Arrays.toString(arr));