java第15天----泛型，集合中的

知识总结

1. List
2. Vector
3. LinkedList
4. List的去重—contains
5. Set
   • HashSet
   • treeSet

泛型

• 泛型：通过<数据类型>接收一种数据类型，在编译的时候会使用这种类型检测集合中的元素，如果不是<>中规定的类型，就不允许
• 添加的集合当中（编译不成立）
• 作用：使用了泛型不再需要进行强制转换，容错处理，向下转型----简化代码
• 2.将运行阶段的问题提前到了编译阶段检查，提高了代码的安全性和编程的效率，
• 泛型的擦除：泛型只是在编译阶段检查元素的类型，到运行阶段泛型就消失了
• 泛型的使用场景：
• 1.类上 2.接口上 3方法上

//当List制定了具体的String泛型之后，里面的元素只能是String
ArrayList<String> list = new ArrayList<String>();
list.add("java1");
list.add("java2");
list.add("java5");
list.add("java7");
System.out.println(list);
//获取迭代器
//当集合的泛型确定之后，让迭代器的泛型一致即可
Iterator<String> iterator = list.iterator();
//遍历
while (iterator.hasNext()) {
	String string = (String) iterator.next();
	System.out.println(string);
}

泛型在类上的使用

//这里通过使用泛型，保证了Student1类的使用灵活性可以简化代码，提高效率
Student1<Computer> student1 = new Student1();
student1.setObj(computer);
Computer computer3 = student1.getObj();
/*
* E代表任意一种数据类型，但<>中不一定是E，可以是任意字符
* 在E的后面加<>就是给类加泛型
* 在类上确定的泛型可以直接使用
*/
class Student1<E>{
	private E obj;

	public E getObj() {
		return obj;
	}

	public void setObj(E obj) {
		this.obj = obj;
	}

泛型在方法上的使用

方法与类的泛型相同

直接使用

方法与类的泛型不一致

• 泛型在使用之前一定要进行声明
• 声明的方式：在方法的最前面加<符号>就行
• 作用：让方法内与方法的泛型保持一致

静态方法

• 静态方法上无法使用类上的泛型，类上的泛型必须通过创建对象才能使用
• 静态方法的调用不需要对象，所以静态方法如果想要使用泛型，必须自己独立使用泛型

class Teacher<E>{
//	1.方法上的泛型与类上的泛型一致
	public E play(E e) {
		return e;
	}
//	2.方法上独立使用泛型
	public <F> void show(F f) {
		
	}
//	3.静态方法上使用泛型
	public static <W> void run(W w) {
		
	}

接口上使用泛型

interface Inter<E>{
	public void play(E e);
}

子类使用泛型的情况

第一种：

• 接口有泛型，子类没有遵守对应的泛型 注意：必须给接口制定一个具体的泛型

class Dog implements Inter<String>{
   //重写的方法的泛型与接口一致
   @Override
   public void play(String e) {
   	// TODO Auto-generated method stub
   	
   }
   //自定义的方法可以使用接口的泛型，也可以自定义泛型.
   public <F> void show(F f) {
   	
   }
}

第二种：

• 接口有泛型，子类遵守了对应的泛型,类上的泛型确定了，接口上的泛型就确定了，重写的方法的泛型就确定了

class Cat<E> implements Inter<E>{

   @Override
   public void play(E e) {
   	// TODO Auto-generated method stub
   	
   }
   
}

• ?:通配符，表示一种或几种数据类型
• 限制上限：<? extends E>限制的是这个<>中可以取得泛型类型是E类及E类的子类
• 限制下限：<? super E>限制的是整个<>中可以取得泛型类型是E类及E类的父类
• 注意点：在取类型的时候，类型之间一定有继承关系。

  public static void main(String[] args) {
  	//
  	ArrayList<Student2> list1 = new ArrayList<
  	list1.add(new Student2("bingbing", 1));
  	//可以传参:因为Student2是Person1的子类,可以实现遍
  	bianli(list1);
  	
  	ArrayList<Teacher8> list2 = new ArrayList<
  	list2.add(new Teacher8("bingbing", 1));
  	//可以传参:因为Teacher1是Person1的子类,可以实现遍
  	bianli(list2);
  	
  	ArrayList<Person1> list3 = new ArrayList<>
  	list3.add(new Person1("bingbing", 1));
  	//可以传参
  	bianli(list3);
  	
  	ArrayList<Object> list4 = new ArrayList<>(
  	list4.add(new Object());
  	//可以传参:因为Object是Person1的父类,不可以实现遍历
  	//bianli(list4);
  }
  
  
  public static void bianli(Collection<? extends
  	System.out.println("遍历了");
  }
}

class Person1{
  String name;
  int age;
  public Person1() {
  	super();
  	// TODO Auto-generated constructor stub
  }
  public Person1(String name, int age) {
  	super();
  	this.name = name;
  	this.age = age;
  }
  @Override
  public String toString() {
  	return "Person1 [name=" + name + ", age=" 
  }
}

class Teacher8 extends Person1{
  public  Teacher8(String name, int age) {
  	super(name, age);
  }
}

class Student2 extends Person1{
  public  Student2(String name, int age) {
  	super(name, age);
  }

}

public class Demo7 {
  public static void main(String[] args) {
  	//限制下限 <? super E>
  	//TreeSet(Comparator<? super E> comparator) :这里的E跟Tre
  	
  	//创建Student3类的比较器对象
  	ComWithStu comWithStu = new ComWithStu();
  	//创建Teacher1类的比较器对象
  	ComWithTea comWithTea = new ComWithTea();
  	//创建Person1类的比较器对象
  	ComWithPerson comWithPerson = new ComWithPerson();
  	//创建GoodStudent类的比较器对象
  	ComWithGood comWithGood = new ComWithGood();
  	
  	TreeSet<Student3> set = new TreeSet<>(comWithStu);//因为
  	//TreeSet<Student3> set = new TreeSet<>(comWithTea);//
  	//TreeSet<Student3> set = new TreeSet<>(comWithPerson)
  	//TreeSet<Student3> set = new TreeSet<>(comWithGood);/
  	set.add(new Student3("bingbing"));
  	set.add(new Student3("bingbing1"));
  	set.add(new Student3("bingbing2"));
  }
}
//创建Student3类的比较器
class ComWithStu implements Comparator<Student3>{

  public int compare(Student3 o1, Student3 o2) {
  	
  	return o1.name.compareTo(o2.name);
  }
}
//创建Teacher2类的比较器
class ComWithTea implements Comparator<Teacher2>{
  public int compare(Teacher2 o1, Teacher2 o2) {
  	
  	return 0;
  }
}
//创建Person2类的比较器
class ComWithPerson implements Comparator<Person2>{
  public int compare(Person2 o1, Person2 o2) {
      return 0;
  }
}

//创建GoodStudent类的比较器
class ComWithGood implements Comparator<GoodStudent>{
  public int compare(GoodStudent o1, GoodStudent o2) {
  	return 0;
  }
}

class Person2{
   String name;

  public Person2(String name) {
  	super();
  	this.name = name;
  }

  public String toString() {
  	return "Person2 [name=" + name + "]";
  }
}

class Teacher2 extends Person2{
  public Teacher2(String name) {
  	super(name);
  }
}
class Student3 extends Person2{
  public Student3(String name) {
  	super(name);
  }
}

class GoodStudent extends Student3{
  public GoodStudent(String name) {
  	super(name);
  }
}

Map：

• 比较Map和Collection
• Collection：是集合，是接口，直接存值
• Map：是结合，是接口，存储的是键值对，一个元素就是一个键（key）值（value）对，键必须是惟一的，值可以相同.
• Map需要设置两个泛型，一个是key的，一个是value的
• 设置key时最好使用一个常量作为key比如String ,因为他本身是固定的，从map的底层实现来看，进行存取的效率更高

Map常用方法

• 介绍Map接口的方法
• 1.增加
• V put(K key,V value) - 增加一个键值对
• void putAll(Map<? - extends K,? extends V> - map) 增加多个
• 2.删除
• V remove(Object key) - 根据key删除元素
• void clear() - 删除全部
• 3.获取
• V get(Object key) - 根据key查找元素
• int size() - 获取键值对的个数
• Set keySet() - 遍历方法一
• Set<Map.Entry<K,V>> - entrySet() 遍历方法二
• 4.常用的判断
• boolean isEmpty()
• boolean - containsKey(K key) - 是否包含当前的key
• boolean - containsValue(V value) - 是否包含当前的value

Map的遍历

keySet() 遍历方法一

• 通过这个方法得到所有的key，存放在set中，利用set的迭代器遍历到所有的key，再利用key得到值

 //Set<K> keySet()
//得到Set 
Set<String> set1 = map.keySet();
//得到迭代器
Iterator<String> iterator1 = set1.iterator();
//遍历set，遍历key，通过可以得到value
while (iterator1.hasNext()) {
	String string = (String) iterator1.next();
	System.out.println("key:"+string + "   value:"+ map.get(string));
}

entrySet() 遍历方法二

• 通过这个方法得到所有的entry（键值对），存放在set中，利用set的迭代器便利得到
• 了解：
• 为什么要将Entry映射关系接口放入Map接口中？
  *Entry是Map内的一个静态接口，因为有了子集和中的键值对才有映射关系，而当前的映射关系又是对集合内部的描述，所以
  *要将Entry映射关系接口放入Map接口中

//Set<Map.Entry<K,V>> entrySet()
//得到set
Set<Map.Entry<String, String>> set2 = map.entrySet();
Iterator<Map.Entry<String, String>> iterator = set2.iterator();
while (iterator.hasNext()) {
  Map.Entry<String, String> entry = (Map.Entry<java.lang.String, java.lang.String>) iterator.next();
  //注意：这里可以通过
  System.out.println("key:"+entry.getKey()+"  value:"+entry.getValue());