黑马程序员--【学习日记七】——集合框架(二)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

知识列表

• 泛型
• Map集合
• 高级for循环
• 可变参数
• 静态导入
• Collections
• Arrays

?

1）泛型

泛型：JDK1.5新特性，是一个类型安全机制。明确要操作的引用数据类型，用以解决安全问题。

好处 
1.将运行时期出现的问题ClassCastException暴露在编译时期，便于程序员解决问题，使程序更加安全。

2.可以避免强制转换。

格式：在<>中定义要操作的引用数据类型。

何时定义：只要见到<>就要定义泛型，<> 就是用来接收类型的，例如集合的<>中定义的是集合要存储的数据类型。

要操作的类型不确定而且为了让不同方法操作不同的类型，可以将泛型定义在类上。

  1: class Demo<T>
  2: {
  3: 	public void show(T t)
  4: 	{
  5: 		System.out.println("show:"+t);
  6: 	}
  7: }

?

静态方法不可以访问类上定义的泛型,如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

  1: class Demo<T>
  2: {
  3: 	public  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: 	public  static <W> void method(W t)
 12: 	{
 13: 		System.out.println("method:"+t);
 14: 	}
 15: }

?

泛型还可以定义在接口上：

  1: interface Inter<T>
  2: {
  3: 	void show(T t);
  4: }

  1: class Inter1<T> implements Inter2<T>
  2: {
  3: 	public void show(T t)
  4: 	{
  5: 		System.out.println(t);
  6: 	}
  7: }

泛型限定：

泛型限定使用? 通配符。也可以理解为占位符。

上限和下限： 
上限：？ extends E: 可以接收E类型或者E的子类型 
下限：？ super E: 可以接收E类型或者E的父类型

2）Map集合：

Hashtable:底层是哈希表数据结构，不可以存入null键null值，线程同步的，效率低。 
HashMap：底层是哈希表数据结构，允许使用 null 键和 null 值，线程不同步。替代hashtable，效率高。 
TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

Map集合中的方法：

无论增加还是删除元素都是以键和值的形式成对存储和删除，而且键要保证唯一性。

增加：

put(K key, V value)

putAll(Map<? extends K,? extends V> m)

如果出现相同的键，那么新值就会替换旧值。put方法返回被替换的值。

  1: System.out.println("put:"+map.put("01","zhangsan1"));
  2: System.out.println("put:"+map.put("01","wnagwu"));//put方法会返回被覆盖的值
  3: map.put("02","zhangsan2");
  4: map.put("03","zhangsan3");

删除 
clear() 
remove(Object key)

判断 
containsValue(Object value)? 
containsKey(Object key)? 
isEmpty()

获取。 
get(Object key)? 
size() 
values()

  1: //获取map集合中所有的值。
  2: Collection<String> coll = map.values();
  3: System.out.println(coll);
  4: System.out.println(map);

entrySet()? 
keySet()

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中一个静态的内部接口，之所以定义在内部，是因为只有有了Map集合，有了键值对，才会有键值的映射关系，也就是说这种映射关系关系属于Map集合中的一个内部事物，而且该事物直接访问Map集合中的元素。

  1: //第一种取出方式。先获取map集合的所有键的Set集合,keySet();
  2: Set<String> keySet = map.keySet();
  3: //有了Set集合。就可以获取其迭代器。
  4: Iterator<String> it = keySet.iterator();
  5: while(it.hasNext())
  6: {
  7: 	String key = it.next();
  8: 	//有了键可以通过map集合的get方法获取其对应的值。
  9: 	String value  = map.get(key);
 10: 	System.out.println("key:"+key+",value:"+value);
 11: }
 12: 

?

  1: //第二种取出方式。将Map集合中的映射关系取出。存入到Set集合中。
  2: Set<Map.Entry<String,String>> entrySet = map.entrySet();
  3: Iterator<Map.Entry<String,String>> it = entrySet.iterator();
  4: while(it.hasNext())
  5: {
  6: 	Map.Entry<String,String> me = it.next();
  7: 	String key = me.getKey();
  8: 	String value = me.getValue();
  9: 	System.out.println(key+":"+value);
 10: }

?

HashMap和HashSet使用方法类似，都需要覆写HashCode和equals方法，保证对象的唯一性

TreeMap和TreeSet使用方法类似，都需要让对象自身具备比较性或者集合自身具备比较性，实现Comparetor接口自定义比较器并覆写compare方法，或者实现Comparbale接口并覆写compareTo方法。

使用Map集合场景：

当数据之间存在映射关系时，就考虑使用Map集合。

3）高级for循环

格式： 
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组) 
{ 
}

对集合进行遍历。只能获取集合元素，不能对集合进行操作。

迭代器除了遍历，还可以进行remove集合中元素的动作。 
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

与普通for循环的区别：

高级for循环局限性：必须有被遍历的目标。 正如三元运算符必须有运算结果一样。

使用普通for循环更好一些，因为可以定义脚标。

  1: for(Map.Entry<Integer,String> me : entrySet)
  2: for(Map.Entry<Integer,String> me : hm.entrySet())
  3: {
  4: 	System.out.println(me.getKey()+me.getValue());
  5: }

?

4）可变参数：

  1: public static void show(String str,int... arr)
  2: {
  3:    System.out.println(arr.length);
  4: }

可变参数是1.5新特性。可变参数一定要定义在参数列表的最后面

5）静态导入：

  1: import java.util.*;
  2: import static  java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
  3: import static java.util.Collections.*;

?

6）Collections：

集合框架的工具类，定义的都是静态方法。

Collections和Collection的区别： 
Collection是集合框架中的一个顶层接口，它里面定义了该类集合的共性方法。常用子子接口：List和Set。

Collections是集合框架中的一个工具类。该类中的方法都是静态的。例如有可以对list集合进行排序，二分查找等方法。并且对于线程不安全的集合，在多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

7）Arrays:

Arrays是用于操作数组的工具类，定义的都是静态方法。

Arrays中提供将数组变集合的方法，asList将数组变成list集合。

注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定。如果增删，就会有UnsupportedOperationException。

把数组变集合的好处是可以用集合的思想来操作数组

如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。 
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

将集合变数组，使用的是Collection中的方法：

  1: ArrayList<String> al = new ArrayList<String>();
  2: al.add("abc1");
  3: al.add("abc2");
  4: al.add("abc3")；
  5: String[] arr = al.toArray(new String[al.size()]);
  6: System.out.println(Arrays.toString(arr));

将集合变数组是为了限定对集合的操作，不需要进行增删。

定义存储集合的数组时，最好定义长度正好合适的数组，newString[al.size()]。

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------