集合框架《二》泛型

 

泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。

好处

1.将运行时期出现问题ClassCastException，转移到了编译时期。，

 方便于程序员解决问题。让运行时问题减少，安全。，

2，避免了强制转换麻烦。

泛型格式：通过<>来定义要操作的引用数据类型。

在使用java提供的对象时，什么时候写泛型呢？

通常在集合框架中很常见，

只要见到<>就要定义泛型。

其实<> 就是用来接收类型的。

当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

 泛型是提供给javac编译器使用的，可以限定集合中的输出类型。

整个称为ArrayList<E>泛型类型

ArrayList<E>中的E称为类型变量或类型参数

整个ArrayList<Integer>称为参数化类型，

其中的Integer称为类型参数的示例或实际类型参数

<>念着typeof

自定义泛型

private static <T> void swap(T[] a,int i,int j){

 T tmp=a[i];

 a[i]=a[j];

 a[j]=tmp;

 }

 String[] s=new String[]{"abc","xxx","yyy","zzz"};

 swap(s,0,3);

 for(String e : s){

  System.out.println(e);

 }

 

*/

class GenericDemo

{

 public static void main(String[] args)

 {

  ArrayList<String> al = new ArrayList<String>();

  al.add("abc01");

  al.add("abc0991");

  al.add("abc014");

  //al.add(4);//al.add(new Integer(4));

  

  Iterator<String> it = al.iterator();

  while(it.hasNext())

  {

   String s = it.next();

   System.out.println(s+":"+s.length());

  }

 }

}//泛型限定2  <? super >

import java.util.*;

class GenericTest1{

 public static void main(String[] args){

  TreeSet<Cat> ts =new TreeSet<Cat>(new Comp());

  ts.add(new Cat("cat 07"));

  ts.add(new Cat("cat 08"));

  ts.add(new Cat("cat 06"));

  ts.add(new Cat("cat 09"));

  Iterator<Cat> it =ts.iterator();

  while(it.hasNext()){

   System.out.println(it.next().getName());

  }

  

  TreeSet<Dog> ts1 =new TreeSet<Dog>(new Comp());

  ts1.add(new Dog("dog 07"));

  ts1.add(new Dog("dog 08"));

  ts1.add(new Dog("dog 06"));

  ts1.add(new Dog("dog 09"));

  Iterator<Dog> it1 =ts1.iterat
4000
or();

  while(it1.hasNext()){

   System.out.println(it1.next().getName());

  }

 }

}

class Comp implements Comparator<Animal>{

 public int compare(Animal c1,Animal c2){

  return c1.getName().compareTo(c2.getName());

 }

}

class Animal{

 private String name;

 Animal(String name){

  this.name=name;

 }

 public String getName(){

  return name;

 }

 public String toString(){

  return "animal :"+name;

 }

}

class Cat extends Animal{

 Cat(String name){

  super(name);

 }

}

class Dog extends Animal{

 Dog(String name){

  super(name);

 }

 

/*

Map集合：public interface Map<K,V>将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

 1添加 V put(K key, V value)

          将指定的值与此映射中的指定键关联（可选操作）。

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

          从指定映射中将所有映射关系复制到此映射中（可选操作）。

 2删除 void clear()

          从此映射中移除所有映射关系（可选操作）。

 3判断 boolean containsKey(Object key)

          如果此映射包含指定键的映射关系，则返回 true。

  boolean containsValue(Object value)

          如果此映射将一个或多个键映射到指定值，则返回 true

 4获取int size()

          返回此映射中的键-值映射关系数。

  Collection<V> values()

          返回此映射中包含的值的 Collection 视图

  Set<Map.Entry<K,V>> entrySet()

          返回此映射中包含的映射关系的 Set 视图

  Set<K> keySet()

          返回此映射中包含的键的 Set 视图

Map |—-Hastable

 |--HashMap

 |--TreeMap

 

*/

import java.util.*;

class MapTest{

 public static void main(String args[]){

  Map<String,String> map=new HashMap<String,String>();

  map.put("01","java1");

  map.put("02","java3");

  map.put("03","java3");

  /*System.out.println("containsKey "+map.containsKey("03"));

  System.out.println("remove "+map.remove("03"));

  System.out.println(map);*

  

  

  

  Set<String> s=map.keySet();

  Iterator<String> it=s.iterator();

  while(it.hasNext()){

   String key=it.next();

   String value=map.get(key);

   System.out.println("key "+key+",value "+value);

  }*/

  

  

  Set<Map.Entry<String,String>> s1=map.entrySet();

  Iterator<Map.Entry<String,String>> it1=s1.iterator();

  while(it1.hasNext()){

   Map.Entry<String,String> me=it1.next();

   String key=me.getKey();

   String value=me.getValue();

   System.out.println("key "+key+",value "+value);

  }

 }