标签：
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
1、集合框架体系
2、集合与数组的区别
<1：数组是固定长度；集合可变长度。
<2：数组可以存储基本数据类型或者引用数据类型；集合只能存储引用数据 类型。
<3：数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数 据类型。
** 集合内容可分为两大部分Collection、Map
3、Collection
（一）List（抽象类）
List集合判断元素是否相同，依据的是元素的equals方法。
List：元素有序、可重复、有索引
凡是可操作角标的方法都是该体系的特有方法
增 add(index,element)
addAll(index,Collection);
删 remove(index);
改 set(index.element);
查 get(index);//获取指定位置的元素
subList(from,to);//获取字串，包含头不包含尾
indexOf();//获取制定元素的位置
listIterator();//列表迭代器
List集合特有的迭代器，ListIterator是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException异常。所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作。
如果想要其他的操作如添加、修改等，就需要使用其子接口：ListIterator.该接口只能通过List集合的listIterator方法获取。
List 要点：
|--Vector 同步的 底层数据结构是数组 v1.0出现。被ArrayList替代了。枚举：Vector特有的取出方式，和迭代一
样，但因名字长而被迭代取代
---------------------------------------------------------------------
|--ArrayList 不同步的 底层数据结构是数组 查询速度快，增删慢 最常用
---------------------------------------------------------------------
|--LinkedList 底层数据结构是链表 增删快，查询慢
（二）Set
Set集合功能和Collection是一致的。
Set
|--HashSet 不同步 底层数据结构是哈希表
|--TreeSet 底层数据结构是二叉树
元素存取无序，唯一。
===>因为Set是存取无序的，所以Set的成员方法中没有get()方法（因为无序，每次获得的索引不一定相同，所以得到索引也就没有意义了）
从而也不能用一些需要用到索引的方法，如二分查找。
泛型：
JDK1.5版本以后出现的新特性，用于解决安全问题，是一个安全机制
一.好处：
1.将运行时期出现问题ClassCastException，转移到了编译时期，方便程序员解决问题。让运行时期问题减少，安全。
2.避免了强制转换的麻烦
二.泛型格式：
通过<>来定义要操作的引用数据类型。
eg. ArrayList<String> al = new Arraylist<String>();
Iterator<String> it = new iterator();
在使用java提供的对象时，什么时候使用泛型呢？
通常在集合框架中很常见。只要见到<>就要定义泛型
其实<>就是用来接收类型的。当使用集合时，讲集合中要存储的数据类型作为参数传递到<>中即可。
如：
1 //泛型 2 import java.util.*; 3 class GenericDemo 4 { 5 public static void main(String[] args) 6 { 7 TreeSet<String> ts = new TreeSet<String>(); 8 ts.add("cdd"); 9 ts.add("abcd"); 10 ts.add("dff"); 11 ts.add("a"); 12 Iterator<String> it = ts.iterator(); 13 14 while (it.hasNext()) 15 { 16 String s = it.next(); 17 System.out.println(s); 18 } 19 } 20 } 21 class LenCompare implements Comparator<String> 22 { 23 public int compare(String o1,String o2) 24 { 25 int num = new Integer(o1.length()).compareTo(new Integer(o2.length())); 26 if(num == 0) 27 return o1.compareTo(o2); 28 return num; 29 } 30 }
三.泛型类
1 class Utils<QQ> 2 { 3 private QQ q; 4 public void setObject(QQ q) 5 { 6 this.q = q; 7 } 8 public QQ getObject() 9 { 10 return q; 11 } 12 }
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，早期定义Object完成扩展，现在定义泛型来完成扩展。
四.泛型方法
泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。
注意：泛型放在返回值类型的前面，不要放错位置
1 class Demo 2 { 3 public <T> void show(T t) 4 { 5 System.out.println("show:"+t); 6 } 7 public <Q> void print(Q q) 8 { 9 System.out.println("print:"+q); 10 } 11 }
特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上
1 public static <Q> void method(Q q) 2 3 { 4 5 System.out.println("print:"+q); 6 7 }
五.泛型接口
1 interface Inter<T> 2 3 { } 4 5 class InterImpl<T> implements Inter<T> 6 7 { }
六.泛型限定
泛型限定是用于泛型扩展的
? 通配符，也可以理解成占位符
1 import java.util.*; 2 3 class GenericDemo2 4 { 5 public static void main(String[] args) 6 { 7 ArrayList<String> al = new ArrayList<String>(); 8 al.add("abc1"); 9 al.add("abc2"); 10 al.add("abc3"); 11 ArrayList<Integer> al2 = new ArrayList<Integer>(); 12 al2.add(new Integer(4)); 13 al2.add(5); 14 getColl(al); 15 getColl(al2); 16 } 17 public static void getColl(ArrayList<?> al) 18 { 19 Iterator<?> it = al.iterator(); 20 21 while (it.hasNext()) 22 { 23 System.out.println(it.next()); 24 } 25 } 26 }
泛型的限定：
? extends E:可以接收E类型或者E的子类型。上限
? super E:可以接收E类型或者E的父类型。下限
//上限Demo
1 import java.util.*; 2 class GenericDemo3 3 { 4 public static void main(String[] args) 5 { 6 ArrayList<Person> al = new ArrayList<Person>(); 7 al.add(new Person("person1")); 8 al.add(new Person("person2")); 9 al.add(new Person("person3")); 10 printColl(al); 11 ArrayList<Student> al2 = new ArrayList<Student>(); 12 al2.add(new Student("student1")); 13 al2.add(new Student("student2")); 14 al2.add(new Student("student3")); 15 printColl(al2); 16 } 17 18 public static void printColl(ArrayList<? extends Person> al) 19 { 20 Iterator<? extends Person> it = al.iterator(); 21 while (it.hasNext()) 22 { 23 System.out.println(it.next().getName()); 24 } 25 } 26 } 27 28 class Person 29 { 30 private String name; 31 32 Person(String name) 33 { 34 this.name = name; 35 } 36 37 public String getName() 38 { 39 return name; 40 } 41 } 42 43 class Student extends Person 44 { 45 Student(String name) 46 { 47 super(name); 48 } 49 }
//下限Demo
1 import java.util.*; 2 class GenericDemo4 3 { 4 public static void main(String[] args) 5 { 6 TreeSet<Student> ts = new TreeSet<Student>(new comp()); 7 ts.add(new Student("stu1")); 8 ts.add(new Student("stu9")); 9 ts.add(new Student("stu3")); 10 ts.add(new Student("stu6")); 11 Iterator<Student> it = ts.iterator(); 12 while (it.hasNext()) 13 { 14 System.out.println(it.next().getName()); 15 } 16 TreeSet<Worker> ts2 = new TreeSet<Worker>(new comp()); 17 ts2.add(new Worker("stu1")); 18 ts2.add(new Worker("stu9")); 19 ts2.add(new Worker("stu3")); 20 ts2.add(new Worker("stu6")); 21 Iterator<Worker> it2 = ts2.iterator(); 22 while (it2.hasNext()) 23 { 24 System.out.println(it2.next().getName()); 25 } 26 } 27 } 28 29 class comp implements Comparator<Person> 30 { 31 public int compare(Person p1,Person p2) 32 { 33 return p1.getName().compareTo(p2.getName()); 34 } 35 } 36 37 class Person 38 { 39 private String name; 40 Person(String name) 41 { 42 this.name = name; 43 } 44 45 public String getName() 46 { 47 return name; 48 } 49 } 50 51 class Student extends Person 52 { 53 Student(String name) 54 { 55 super(name); 56 } 57 } 58 59 class Worker extends Person 60 { 61 Worker(String name) 62 { 63 super(name); 64 } 65 }
1.基本概念
2.Map和Collection的区别？
3.基本功能：重点掌握 键集合keySet()以及值集合values()
4.（重要代码！）Map集合遍历的两种方式，重点掌握第一种：通过键找值；
理解第二种：通过键值对对象找键和值。
Map共性方法
1.添加
put(K key, V value) 注：如果添加时，出现相同的键，那么后添加的值会覆盖原有键的值，并且put方法会返回被覆盖的值。
putAll(Map<? extends K,? extends V> m)
2.删除
clear()
remove(Object key)
3.判断
containsValue(Object value)
containsKey(Object key)
isEmpty()
4.获取
get(Object key) 注：可以通过get方法的返回值来判断一个键是否存在。 通过返回值null来判断
size()
values()
Demo：
1 import java.util.*; 2 class MapDemo 3 { 4 public static void main(String[] args) 5 { 6 Map<String,String> map = new HashMap<String,String>(); 7 8 //添加元素。如果添加时，出现相同的键，那么后添加的值会覆盖原有键的值，并且put方法会返回被覆盖的值。 9 map.put("01","lisi1"); 10 map.put("02","lisi2"); 11 map.put("03","lisi3"); 12 13 //判断 14 System.out.println("containsKey："+map.containsKey("02"));//true 15 System.out.println("containsKey："+map.containsKey("022"));//false 16 17 //删除 18 System.out.println("remove:"+map.remove("02"));//remove:lisi2 19 System.out.println("remove:"+map.remove("022"));//remove:null 20 21 //获取 22 System.out.println("get:"+map.get("03"));//get:lisi3 23 24 map.put("04",null); 25 System.out.println("get:"+map.get("04"));//get:null 26 //可以通过get方法的返回值来判断一个键是否存在。通过返回值null来判断 27 28 //获取map集合中所有的值 29 Collection<String> coll = map.values(); 30 System.out.println(coll);//[lisi1, lisi3, null] 31 32 System.out.println(map);//{01=lisi1, 02=lisi2, 03=lisi3} 33 } 34 }
Map集合的两种取出方式：
1.Set<K> keySet()重点：将map中所有的键存入到Set集合中。因为Set具备迭代器，所以可以通过迭代方式取出所有键，再根据get方法，获取每一个键对应的值。
Map集合的取出原理：将map集合转成Set集合，再通过迭代器取出。
2.Set<Map.Entry<K,V>> entrySet() 重点：将Map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry
Map.Entry Entry其实也是一个接口，它是Map接口中的一个内部接口。
1 interface Map 2 3 { 4 5 public static interface Entry 6 7 { 8 9 public abstract Object getKey(); 10 11 public abstract Object getValue(); 12 13 } 14 15 }
Demo：
1 import java.util.*; 2 class MapDemo2 3 { 4 public static void main(String[] args) 5 { 6 Map<String,String> map = new HashMap<String,String>(); 7 8 map.put("01","lisi1"); 9 map.put("02","lisi2"); 10 map.put("03","lisi3"); 11 map.put("04","lisi4"); 12 13 //方式一：keySet 14 Set<String> keySet = map.keySet(); 15 Iterator<String> it = keySet.iterator(); 16 while (it.hasNext()) 17 { 18 String key = it.next(); 19 String value = map.get(key); 20 System.out.println("key:"+key+",value:"+value); 21 } 22 //方式二：entrySet 23 Set<Map.Entry<String,String>> entrySet = map.entrySet(); 24 Iterator<Map.Entry<String,String>> it2 = entrySet.iterator(); 25 while (it2.hasNext()) 26 { 27 Map.Entry<String,String> me = it2.next(); 28 String key = me.getKey(); 29 String value = me.getValue(); 30 System.out.println(key+"::"+value); 31 } 32 } 33 }
Map子类对象
|--Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。 JDK1.0 效率低
|--HashMap：底层是哈希表数据结构，允许使用null键null值，该集合是不同步的。JDK1.2 效率高 ｝二者关系
|--TreeMap：底层是二叉树数据结构，线程不同步。可以用于给map集合中的键进行排序
和Set很像，其实Set底层就是使用了Map集合
标签：
原文地址：http://www.cnblogs.com/ZkSnug/p/4457343.html
