Java基础（十一）集合

1.概念

* A:集合的由来
    * 数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少
* B:数组和集合的区别
    * 区别1 :
        * 数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
        * 集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
    * 区别2:
        * 数组长度是固定的,不能自动增长
        * 集合的长度的是可变的,可以根据元素的增加而增长
* C:数组和集合什么时候用
        * 1,如果元素个数是固定的推荐用数组
        * 2,如果元素个数不是固定的推荐用集合

* D:集合继承体系图

2.迭代器

Collection c = new ArrayList();

Iterator it = c.iterator();     

* A:迭代器原理
    * 迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可
* B:迭代器源码解析
    * 1,在eclipse中ctrl + shift + t找到ArrayList类
    * 2,ctrl+o查找iterator()方法
    * 3,查看返回值类型是new Itr(),说明Itr这个类实现Iterator接口
    * 4,查找Itr这个内部类,发现重写了Iterator中的所有抽象方法

3.Vector

迭代

Vector v = new Vector();				//创建集合对象,List的子类
			v.addElement("a");
			v.addElement("b");
			v.addElement("c");
			v.addElement("d");
			
			//Vector迭代
			Enumeration en = v.elements();			//获取枚举
			while(en.hasMoreElements()) {			//判断集合中是否有元素
				System.out.println(en.nextElement());//获取集合中的元素
			}

4.List

* A:List的三个子类的特点
*
        ArrayList:
            底层数据结构是数组，查询快，增删慢。
            线程不安全，效率高。
        Vector:
            底层数据结构是数组，查询快，增删慢。
            线程安全，效率低。
        Vector相对ArrayList查询慢(线程安全的)
        Vector相对LinkedList增删慢(数组结构)
        LinkedList:
            底层数据结构是链表，查询慢，增删快。
            线程不安全，效率高。

        Vector和ArrayList的区别
            Vector是线程安全的,效率低
            ArrayList是线程不安全的,效率高
        共同点:都是数组实现的
        ArrayList和LinkedList的区别
            ArrayList底层是数组结果,查询和修改快
            LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
        共同点:都是线程不安全的
* B:List有三个儿子，我们到底使用谁呢?
        查询多用ArrayList
        增删多用LinkedList
        如果都多ArrayList

5.泛型

* A:泛型概述
* B:泛型好处
    * 提高安全性(将运行期的错误转换到编译期)
    * 省去强转的麻烦
* C:泛型基本使用
    * <>中放的必须是引用数据类型
* D:泛型使用注意事项
    * 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)  

（1）泛型类

* A:泛型类概述<T>
    * 把泛型定义在类上
* B:定义格式
    * public class 类名<泛型类型1,…>
* C:注意事项    

    * 泛型类型必须是引用类型

（2）泛型方法

* A:泛型方法概述
    * 把泛型定义在方法上
* B:定义格式    

    * public <泛型类型> 返回类型 方法名(泛型类型 变量名)

public class Tool<Q> {
	private Q q;

	public Q getObj() {
		return q;
	}

	public void setObj(Q q) {
		this.q = q;
	}
	
	public<T> void show(T t) {				//方法泛型最好与类的泛型一致
		System.out.println(t);				//如果不一致,需要在方法上声明该泛型
	}
	
	public static<W> void print(W w) {		//静态方法必须声明自己的泛型
		System.out.println(w);
	}
	
}

（3）泛型接口

* A:泛型接口概述
    * 把泛型定义在接口上
* B:定义格式    

    * public interface 接口名<泛型类型>

（4）通配符

* A:泛型通配符<?>
    * 任意类型，如果没有明确，那么就是Object以及任意的Java类了
* B:? extends E
    * 向下限定，E及其子类
* C:? super E
    * 向上限定，E及其父类

public static void main(String[] args) {
		//List<?> list = new ArrayList<Integer>();			//当右边的泛型是不确定时,左边可以指定为?
		ArrayList<Person> list1 = new ArrayList<>();
		list1.add(new Person("张三", 23));
		list1.add(new Person("李四", 24));
		list1.add(new Person("王五", 25));
		
		ArrayList<Student> list2 = new ArrayList<>();
		list2.add(new Student("赵六", 26));
		list2.add(new Student("周七", 27));
		
		list1.addAll(list2);
		System.out.println(list1);
		
	}

6.HashSet

（1）存储自定义对象

重写hashcode  和 equals 方法     * 为了减少比较，优化hashCode()代码写法

* 1.HashSet原理
    * 我们使用Set集合都是需要去掉重复元素的, 如果在存储的时候逐个equals()比较, 效率较低,哈希算法提高了去重复的效率, 降低了使用equals()方法的次数
    * 当HashSet调用add()方法存储对象的时候, 先调用对象的hashCode()方法得到一个哈希值, 然后在集合中查找是否有哈希值相同的对象
        * 如果没有哈希值相同的对象就直接存入集合

        * 如果有哈希值相同的对象, 就和哈希值相同的对象逐个进行equals()比较,比较结果为false就存入, true则不存

* 2.将自定义类的对象存入HashSet去重复
    * 类中必须重写hashCode()和equals()方法
    * hashCode(): 属性相同的对象返回值必须相同, 属性不同的返回值尽量不同(提高效率)

    * equals(): 属性相同返回true, 属性不同返回false,返回false的时候存储

自动生成   ，31原因：质数，不大不小，2^5-1（容易算）

class Person{
    private String name;
    private int  age;
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;

        Person person = (Person) o;

        if (getAge() != person.getAge()) return false;
        return getName() != null ? getName().equals(person.getName()) : person.getName() == null;
    }

    @Override
    public int hashCode() {
        int result = getName() != null ? getName().hashCode() : 0;
        result = 31 * result + getAge();
        return result;
    }
}

（2）LinkedHashSet   * 可以保证怎么存就怎么取
7.TreeSet

（1）存储自定义对象   要实现compareble 接口，重写compareTo方法

     * 当compareTo方法返回0的时候集合中只有一个元素
     * 当compareTo方法返回正数的时候集合会怎么存就怎么取
     * 当compareTo方法返回负数的时候集合会倒序存储

（2）比较器排序  comparetor

public static void main(String[] args) {
        TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.length() - o1.length();
            }
        });
    }

（3）原理

* 1.特点
    * TreeSet是用来排序的, 可以指定一个顺序, 对象存入之后会按照指定的顺序排列
* 2.使用方式
    * a.自然顺序(Comparable)
        * TreeSet类的add()方法中会把存入的对象提升为Comparable类型
        * 调用对象的compareTo()方法和集合中的对象比较
        * 根据compareTo()方法返回的结果进行存储
    * b.比较器顺序(Comparator)
        * 创建TreeSet的时候可以制定 一个Comparator
        * 如果传入了Comparator的子类对象, 那么TreeSet就会按照比较器中的顺序排序
        * add()方法内部会自动调用Comparator接口中compare()方法排序
        * 调用的对象是compare方法的第一个参数,集合中的对象是compare方法的第二个参数
    * c.两种方式的区别
        * TreeSet构造函数什么都不传, 默认按照类中Comparable的顺序(没有就报错ClassCastException)

        * TreeSet如果传入Comparator, 就优先按照Comparator

8.Map

* 将键映射到值的对象
* 一个映射不能包含重复的键
* 每个键最多只能映射到一个值

        * Set<Map.Entry<K,V>> entrySet():           Entry 是Map中的接口           entrySet将map的key和value封装成一个对象
        * V get(Object key):根据键获取值
        * Set<K> keySet():获取集合中所有键的集合

        * Collection<V> values():获取集合中所有值的集合

* HashMap和Hashtable的区别
        * Hashtable是JDK1.0版本出现的,是线程安全的,效率低,HashMap是JDK1.2版本出现的,是线程不安全的,效率高

        * Hashtable不可以存储null键和null值,HashMap可以存储null键和null值