集合 和 泛型

集合框架

List、Set是Collection接口的子接口。
- Collection 接口存储一组不唯一，无序的对象；
- List 接口存储一组 不唯一、有序（插入顺序）的对象；
- set 接口存储一组唯一，无序的对象。
Map 不继承COllection,接口存储一组键值对象，提供到key到value的映射。

---

List接口

• ArrayList 和 LikedLiet是List的实现类
• ArrayList 实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高。
• LinkedList 采用链表存储方式。插入、删除元素时效率。

ArrayList

• ArrayList 的构造方法
  
  • ArrayList (int size);
  • ArrayList (Colection c);
  • ArrayList ();
• ArrayList 的常用方法 。
  
  • .add();
  • .remove(); //可以是index和Object类型。Object移除第一次出现的指定元素。
  • .indexOf(“ab”);
  • .lastIndexOf(“a”);
  • .size();
  • .get(index);
  • .set(idnex,obj); //修改集合的数值
  • .contains(Object o) //list是否包含对象o;
  • .clear //移除所有元素;

ArrayList list = new ArrayList();
list.add("aaa");
list.add("ccc");
list.add(2,"ccc");
for (int i=0;i<list.size();i++) {
    String obj =(String) list.get(i);  
    System.out.orintln(obj);

}
list.set(1,"bbb");      //集合的修改。
list.remove(2);   //通过索引删除集合的值。list.remove("ccc") 通过值删除
System.out.println();  
for (Object obj:list){
    System.out.println(obj);
}

LikedList

• 可以添加头条和最末顺序。
• LinkedList类是List接口的一个具体实现类
• LinkedList类用于创建链表数据结构
• 插入后者删除元素时，它提供更好的心能
  LikedList常用方法
  .addFirst(Object o) 在列表首部添加元素
  .addLast(Object o) 在列表的末尾添加元素
  .getFirst() 返回列表中的第一个元素
  .getLast() 返回Object;
  .removeFirst() 返回Object;
  .removeLast() 返回Object;
  .size();
  

  ---

Set接口

• Set接口存储一组唯一，无序的对象
• HashSet是Set接口常用的实现类
• Set中存放对象的引用

HashSet

• 无序的集合遍历方法。
  
  • 遍历方法1：通过for eatch进行遍历
    
for (Object obj :hashset){
String str = (HashSet)obj;
System.out.println(str);
}

  • 遍历方法2：通过迭代器进行遍历
    
Iterator iterator = hashset.iterator();
while(iterator.hasNext()){
Object obj= iterator.next();
String str = (String)obj;
System.out.println(str);
}

    示例：

import java.util.HashSet;
import java.util.Iterator;
/**
 * 创建一个Dog类
 * @author Wondf
 *
 */
class Dog{
    private String name;
    private String type;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Dog() {

    }

    public Dog(String name, String type) {
        super();
        this.name = name;
        this.type = type;
    }

    public String toString() {
        return "Dog [name=" + name + ", type=" + type + "]";
    }
}
public class DogHashSet {
    public static void main(String[] args) {
        HashSet<Dog> hashSet = new HashSet<Dog>();
        for (int i = 0; i < 100; i++) {
            Dog dog = new Dog("name"+i,"Dog"+i);
            hashSet.add(dog);
        }
        System.out.println("forEach遍历");
        showForEach(hashSet);
        System.out.println("迭代器遍历");
        showIterator(hashSet);
    }
    private static void showIterator(HashSet<Dog> hashSet){
        Iterator<Dog> iterator = hashSet.iterator();
        while (iterator.hasNext()){
            Dog dog = iterator.next();
            System.out.println(dog);
        }
    }
    private static void showForEach(HashSet<Dog> hashSet) {
        for (Dog dog :hashSet){
            System.out.println(dog);
        }
    }
}

---

HashMap

• 实现了Map接口
• 用于存储键/值映射关系；
• 不能保证其元素的存储顺序。
• HashCode
• 无索引的概念
• key键值唯一，可以null,但只能一个。

HashMap()的常用构造方法和方法

- .put(key,value);  //添加、修改。
- .size();          //返回元素的个数
- .get(key);        //根据键返回相关联的值，如果不存在指定的键，返回null
- .keySet()         //返回Set,键的集合
- .values           //返回Collection,值的集合

遍历实例：

 import java.util.HashMap;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;
/**
 * 创建Student 类
 * @author Wondf
 * 
 */
class Student {
    private String name;
    private String sex;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Student(){
        super();
    }
    public Student(String name, String sex) {
        super();
        this.name = name;
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", sex=" + sex + "]";
    }
}
public class JobHashMap {
    public static void main(String[] args) {
        HashMap<String, Student> hashMap = new HashMap<String, Student>();
        for (int i = 0; i < 5; i++) {
            Student student = new Student("nanme" + i, "男");
            hashMap.put("enName" + i, student);
        }
        System.out.println("请输入要查找的学员英文名称：");
        Scanner scanner = new Scanner(System.in);
        String enName = scanner.next();
        Student student = hashMap.get(enName);
        System.out.println("你查找的学员信息为：" + "\n" + student);
        System.out.println("*****************");
        System.out.println("增强for遍历");
        for (String key : hashMap.keySet()) {
            Student stu = hashMap.get(key);
            System.out.println(stu);
        }
        System.out.println("迭代器遍历");
        Set<String> keySet = hashMap.keySet();
        Iterator<String> iterator = keySet.iterator();
        while (iterator.hasNext()) {
            String obj = iterator.next();
            Student stu = hashMap.get(obj);
            System.out.println(stu);
        }
    }
}

另：按顺序查找，可以先建立一个ArrayList，将HashMap的值存放在里面，然后进行遍历

---

Iterator 迭代器

.hasNext();     //返回 boolean，如果仍有元素可以迭代，则返回true。  
.next();        //E 返回迭代的下一个元素。  
.remove();      //从迭代器指向的collection中移除迭代器返回的最最后一个元素。   

Java的容器类引申

---

泛型

泛型集合
- 泛型集合可以约束集合内的元素类型
集合+泛型 ==> 泛型集合
安全性，提高效率。

- ArrayList <Integer> = new ArrayList <Integer> ();    //类型必须是包装类  
- HashMap <String,String> = new HashMap <String,string>();  

• 接口不能被实例化，只能通过他的实现类进行实例.
  
//HashMap的遍历方法2：
for (Map.Entry<String,student> entry :list.entrySet()){
String key =entity.getKey();
Student value =entity.getValue();
System.out.println("key="+key+",value+"+value);
}


泛型类

    public classs pair<T> {
        <T> max ;
        <T> min ;
    }

泛型方法

要定义泛型方法，只需将泛型参数列表置于返回值前。如：

    //extends 在这是实现了Comporable的接口，而不是继承。
    public static <T extends Comparable> pair <T> minMax(T [] nums){
            mMax.compareTO(nums[i])>0
    }

compareTo()
- 泛型在使用中的一些规则和限制：
- 泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
- 同一中类型可以对应多个版本(因为参数类型是不确定的)，不同版本的泛型类实例是不兼容的。
- 泛型的类型参数可以有多个。
- 泛型的参数类型可以使用extends语句，习惯上称为“有界类型”。 pair .
- 泛型的参数类型还可以是通配符类型。例如：Class