day07【集合】

今日内容

• Collections工具类
• 增强for循环
• 泛型
• 红黑树
• Set集合

目标

• 能够使用集合工具类的常用方法
• 能够使用Comparator比较器进行排序
• 能够使用增强for循环遍历集合和数组
• 能够使用集合存储自定义类型
• 能够使用泛型创建集合对象
• 能够理解泛型上下限
• 能够阐述泛型通配符的作
• 能够说出Set集合的特点
• 能够说出哈希表的特点
• 使用HashSet集合存储自定义元素

第一章 Collections工具类

1.1 概述

java.util.Collections此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。

1.2 常用方法

• public static void shuffle(List<?> list) ：打乱集合顺序。
• public static <T> void sort(List<T> list)：将集合中元素按照默认规则排序。
• public static <T> void sort(List<T> list，Comparator<? super T> )：将集合中元素按照指定规则排序。

public static void main(String[] args) {
	ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(100);
    list.add(300);
    list.add(200);
    list.add(50);
	//排序方法 
	Collections.sort(list);
	System.out.println(list);
}

1.3 比较器Comparator接口

创建一个学生类，存储到ArrayList集合中完成指定排序操作。

Student 类

public class Student{
    private String name;
    private int age;
	//构造方法
    //get/set
 	//toString
}

测试类

public static void main(String[] args) {
    ArrayList<Student> list = new ArrayList<Student>();
    list.add(new Student("rose",18));
    list.add(new Student("jack",16));
    list.add(new Student("abc",20));
    Collections.sort(list, new Comparator<Student>() {
        @Override
        public int compare(Student o1, Student o2) {
        return o1.getAge()-o2.getAge();//以学生的年龄升序
        }
        });
    }

    for (Student student : list) {
    	System.out.println(student);
    }
 }
Student{name='jack', age=16}
Student{name='rose', age=18}
Student{name='abc', age=20}

第二章 增强for循环

2.1 概述

java.lang.Iterable接口，实现这个接口允许对象成为 “foreach” 语句的目标。 也就是说Iterable接口下的所有子接口和实现类，都能使用”foreach”语句。而Iterbale接口的一个子接口就是Collection接口，我们学习的集合都可以使用“foreach”语句，同时也包括数组。

2.2 格式

for(元素的数据类型  变量 : Collection集合or数组){ 
  	//写操作代码
}

注意：它用于遍历Collection和数组。通常只进行遍历元素，不能在遍历的过程中对集合元素进行增删改操作。

2.3 遍历数组，集合

public static void main(String[] args) {
    int[] arr = {3,5,6,87};
    //使用增强for遍历数组
    for(int a : arr){//a代表数组中的每个元素
    	System.out.println(a);
    }

    Collection<String> coll = new ArrayList<String>();
    coll.add("小河神");
    coll.add("老河神");
    coll.add("神婆");

    for(String s :coll){
    	System.out.println(s);
    }
}

2.4 增强for循环原理：

• 增强for遍历数组，class文件反编译后就是传统形式for循环。
• 增强for遍历集合，class文件反编译后就是迭代器。

第三章 泛型

3.1 泛型概述

在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

大家观察下面代码：

public static void main(String[] args) {
    Collection coll = new ArrayList();
    coll.add("abc");
    coll.add("itcast");
    coll.add(5);//由于集合没有做任何限定，任何类型都可以给其中存放
    Iterator it = coll.iterator();
    while(it.hasNext()){
        //需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
        String str = (String) it.next();
        System.out.println(str.length());
    }
}

程序在运行时发生了问题java.lang.ClassCastException。

为什么会发生类型转换异常呢？

我们来分析下：由于集合中什么类型的元素都可以存储。导致取出时强转引发运行时 ClassCastException。 怎么来解决这个问题呢？

Collection虽然可以存储各种对象，但实际上通常Collection只存储同一类型对象。例如都是存储字符串对象。因此在JDK5之后，新增了泛型(Generic)语法，让你在设计API时可以指定类或方法支持泛型，这样我们使用API的时候也变得更为简洁，并得到了编译时期的语法检查。

• 泛型：可以在类或方法中预支地使用未知的类型。

注意：一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类为Object类型。

3.2 使用泛型的好处

上一节只是讲解了泛型的引入，那么泛型带来了哪些好处呢？

• 将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
• 避免了类型强转的麻烦。

通过我们如下代码体验一下：

public static void main(String[] args) {
    Collection<String> list = new ArrayList<String>();
    list.add("abc");
    list.add("itcast");
    // list.add(5);//当集合明确类型后，存放类型不一致就会编译报错
    // 集合已经明确具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样会知道具体遍历元素类型
    Iterator<String> it = list.iterator();
    while(it.hasNext()){
    String str = it.next();
    //当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
    	System.out.println(str.length());
    }
}

3.3 泛型的定义与使用

我们在集合中会大量使用到泛型，这里来完整地学习泛型知识。

泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

定义和使用含有泛型的类

定义格式：

修饰符 class 类名<代表泛型的变量> {  }

例如，API中的ArrayList集合：

泛型在定义的时候不具体，使用的时候才变得具体。在使用的时候确定泛型的具体数据类型。

class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

使用泛型： 即什么时候确定泛型。

在创建对象的时候确定泛型

例如，ArrayList<String> list = new ArrayList<String>();

此时，变量E的值就是String类型,那么我们的类型就可以理解为：

class ArrayList<String>{ 
     public boolean add(String e){ }

     public String get(int index){  }
     ...
}

再例如，ArrayList<Integer> list = new ArrayList<Integer>();

此时，变量E的值就是Integer类型,那么我们的类型就可以理解为：

class ArrayList<Integer> { 
     public boolean add(Integer e) { }

     public Integer get(int index) {  }
     ...
}

含有泛型的方法

定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

例如，

public class MyGenericMethod {	  
    public <MVP> void show(MVP mvp) {
    	System.out.println(mvp.getClass());
    }
    
    public <MVP> MVP show2(MVP mvp) {	
    	return mvp;
    }
}

调用方法时，确定泛型的类型

public static void main(String[] args) {
    // 创建对象
    MyGenericMethod mm = new MyGenericMethod();
    // 演示看方法提示
    mm.show("aaa");
    mm.show(123);
    mm.show(12.45);
}

含有泛型的接口

定义格式：

public interface MyGenericInterface<E>{
	public abstract void add(E e);
	
	public abstract E getE();  
}

使用格式：

1、定义类时确定泛型的类型

例如

public class MyImp1 implements MyGenericInterface<String> {
	@Override
    public void add(String e) {
        // 省略...
    }

	@Override
	public String getE() {
		return null;
	}
}

此时，泛型E的值就是String类型。

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

例如

public class MyImp2<E> implements MyGenericInterface<E> {
	@Override
	public void add(E e) {
       	 // 省略...
	}

	@Override
	public E getE() {
		return null;
	}
}

确定泛型：

public static void main(String[] args) {
	MyImp2<String>  my = new MyImp2<String>();  
	my.add("aa");
}

3.4 泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

通配符基本使用

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

此时只能接受数据,不能往该集合中存储数据。

举个例子大家理解使用即可：

public static void main(String[] args) {
    Collection<Intger> list1 = new ArrayList<Integer>();
    getElement(list1);
    Collection<String> list2 = new ArrayList<String>();
    getElement(list2);
}
//?为通配符，可以接收任意类型
public static void getElement(Collection<?> coll){
    Iterator<?> it = coll.iterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }
}

注意：泛型不存在继承关系 Collection