java 集合框架

本文为集合框架总的整理，方便以后快速查看，大部分为链接指引（别人写的好，自己则没必要写了），有一些是看别人博客觉得看不懂(一上来就灌输一大堆概念)不够友好而自己写的。

-------------------------------------------------------------------------------------------------------------------------------------

1.ArrayList：https://www.cnblogs.com/leesf456/p/5308358.html

2.LinkedList：https://www.cnblogs.com/leesf456/p/5308843.html

3.Vector：用法--->https://www.cnblogs.com/zheting/p/7708366.html    源码解析------>https://www.cnblogs.com/skywang12345/p/3308833.html 

　　　　   和ArrayList的区别---->https://www.cnblogs.com/wanlipeng/archive/2010/10/21/1857791.html

-------------------------------------------------------------------------------------------------------------------------------------------------------

4.Map

1). 实现 Map 接口的类用来存储键(key) -值(value)对
2). Map 接口的实现类有 HashMap 和 TreeMap 等
3). Map 类中存储的键-值对通过键来标识，所以键值不能
重复

4.1HashMap的使用

import java.util.Collection;
import java.util.HashMap;
import java.util.Set;

public class TestHashMap {
    public static void main(String[] args) {
        //Map接口的特点,key不允许重复，值可以重复，而且key是无序的
        //创建集合对象
        HashMap hm=new HashMap();
        //(1)添加元素
        hm.put("hello", 123);//123自动装箱，Integer类型
        hm.put("world",456);
        hm.put("hello", 1000); //集合中的key不能重复，如果重复，将进行值的覆盖
        hm.put("java", 1000);
        System.out.println("集合中元素的个数:"+hm.size());//3
        System.out.println("集合是否为空:"+hm.isEmpty());//false
        System.out.println(hm);//{world=456, java=1000, hello=1000}
        System.out.println(hm.remove("world"));//456 (先输出后移除)
        System.out.println(hm);//{java=1000, hello=1000}
        //判断
        System.out.println(hm.containsKey("java")+"	"+hm.containsKey("world"));//true    false
        System.out.println(hm.containsValue(1000)+"	"+hm.containsValue(2000));//true    false
        //获取元素
        System.out.println(hm.get("java")+"	"+hm.get("world"));//1000    null
        //获取所有key的集合
        Set set=hm.keySet();
        for(Object obj:set){        //java
            System.out.println(obj);//hello
        }
        //获取所有的value的集合
        System.out.println("
--------------------------");
        Collection coll=hm.values();
        for(Object obj:coll){         //1000
            System.out.println(obj);//1000
        }
        //获取所有key-value关系的集合
        Set entrySet=hm.entrySet();
        for(Object obj:entrySet){     //java=1000
            System.out.println(obj);//hello=1000
        }
        
        /**
         * HashMap与Hashtable用法相同
         * HashMap与Hashtable的区别
         * (1)版本不同 HashMap JDK1.2  Hashtable 1.0
         * (2)HashMap继承了AbstractMap，实现了Map接口，Hashtable继承了Dictionary实现Map接口
         * (3)HashMap允许null值和null键, 但是null作为key只允一个, Hashtable非null的键和值
         * (4)HashMap是线程不同步的 (效率高，安全性低),Hashtable(效率低，安全性高)线程同步
         * 
         * 
         * */
    }
}

4.2HashMap实现原理---->https://www.cnblogs.com/xwdreamer/archive/2012/05/14/2499339.html

4.3二叉树和红黑树----->https://www.cnblogs.com/guweiwei/p/7080971.html  深入理解--->http://www.cnblogs.com/yangecnu/p/Introduce-Red-Black-Tree.html

4.4TreeMap--->Key:唯 一，有序，升序  

如果使用 TreeMap 存储自定义对象做为 key 时，要求必须具
备比较规则，否则运行报错

浅析--->https://www.cnblogs.com/yueyanglou/p/5283915.html    深入理解--->https://www.cnblogs.com/skywang12345/p/3310928.html

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

5.Set：唯一、无序

Set的实现类都是基于Map来实现的(HashSet是通过HashMap实现的，TreeSet是通过TreeMap实现的)。

HashSet依赖于HashMap，它实际上是通过HashMap实现的。HashSet中的元素是无序的。

HashSet------->https://www.cnblogs.com/skywang12345/p/3311252.html
TreeSet依赖于TreeMap，它实际上是通过TreeMap实现的。TreeSet中的元素是有序的。

TreeSet-------->https://www.cnblogs.com/skywang12345/p/3311268.html

--------------------------------------------------------------------------------------------------------------------------------------------------------------

6.泛型

6.1 为什么需要使用泛型

JDK1.4 以前类型不明确：
装入集合的类型都被当作 Object 对待，从而失去自己的实际
类型。
从集合中取出时往往需要转型，效率低，容易产生错误。

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        
        ArrayList a1 = new ArrayList();
        a1.add("hello");
        a1.add(123);
        for(Object obj : a1) {
            String s = (String)obj;
            System.out.println(s);
        }        
    }
}

向下类型转换时产生错误，Integer是不能去转成String的

---------------------------------------------------------------------------------------------------------------

6.2 解决办法：
泛型，在定义集合的时候同时定义集合中对象的类型

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        //在创建集合对象时，明确集合中所存储的元素的类型
        
        ArrayList<String> al=new ArrayList<String>();
        al.add("hello");
        //al.add(123);//指定为String存储类型后再添加Integer类型会报错
        for (String str : al) {
            System.out.println(str);
        }
    }
}

6.3 好处：
增强程序的可读性和安全性

6.4 泛型的分类
(1)泛型类

public class MyGeneric<T> {//T就是一个英文字母，代表一种数据类型，在创建实例时确定

}
class TestMyGeneric{
    public static void main(String[] args) {
        MyGeneric<String> my1=new MyGeneric<String>();
        MyGeneric<Integer> my2=new MyGeneric<Integer>();
    }
}

(2)泛型接口

public interface MyInterface<T> {

}
class MyImplement implements MyInterface<String>{
    
}
class MyImplement1<T> implements MyInterface<T>{
    
}
class TestMyInterface{
    public static void main(String[] args) {
        MyImplement my=new MyImplement();
        
        MyImplement1<Integer> my2=new MyImplement1<Integer>();
    }
}

(3)泛型方法

public class MyMethod<T> {//泛型类
    public void show(T t){  //在创建MyMethod类的对象时决定
        System.out.println(t);
    }
    public <Q> void method(Q q){ //在调用method这个方法时明确
        System.out.println(q);
    }
    public <K>void fun(K...k){ //可变参数的泛型方法
        for (int i = 0; i < k.length; i++) {
            System.out.println(k[i]);
        }
    }
}

public class TestMyMethod {
    public static void main(String[] args) {
        MyMethod<String> my=new MyMethod<String>();
        my.show("hello");//在创建类的对象时明确了数据类型为String
        
        //有了泛型方法，解决了参数个数相同的情况下的方法重载
        my.method("hello");
        my.method(123);
        my.method('a');
        
        //可变参数的泛型方法，解决参数的个数不同，类型不同的方法重载
        my.fun("hello");
        my.fun("hello","world","java");
        my.fun(123,456);
    }
}

------------------------------------------------------------------------

 6.5 泛型的高级使用

泛型的上限:使用关键字 extends，表示参数化的类型可能是
所指定的类型或者是此类型的子类

泛型的下限:使用关键字 super 进行声明，表示参数化的类型
可能是所指定的类型，或者是此类型的父类型，直至 Object
类

 

先创建一个Person类，包含姓名，年龄属性，get() set()方法，有参无参构造函数，重写toString方法

public class Person{
    private String name; //姓名
    private int age;//年龄
    
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
    }            
}

再创建一个Student类，继承Person类,包含学号属性，get() set()方法，有参无参构造函数，重写toString方法

public class Student extends Person {
    private String stuNo;//学号

    @Override
    public String toString() {
        return super.toString()+"Student [stuNo=" + stuNo + "]";
    }
    
    public String getStuNo() {
        return stuNo;
    }
    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }
    public Student(String name, int age, String stuNo) {
        super(name, age);
        this.stuNo = stuNo;
    }
    public Student() {
        super();
    }
}

创建一个Test类测试

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        //创建集合对象，同时明确了集合中所存储的对象的类型只能是Person类型
        ArrayList<Person> al=new ArrayList<Person>();
        //创建Person类型的对象添加到集合中
        Person p1=new Person("marry", 20);
        Person p2=new Person("lili",29);
        Person p3=new Person("jack",18);
        //添加以集合中
        al.add(p1);
        al.add(p2);
        al.add(p3);
        //遍历集合
        print(al);
        /*    Person [name=marry, age=20]
            Person [name=lili, age=29]
            Person [name=jack, age=18]
         * */
        
        
        //创建一个集合对象，用于存储Student类型的对象
        ArrayList<Student> al2=new ArrayList<Student>();
        Student stu1=new Student("sean", 20, "sxt1001");
        Student stu2=new Student("nico",19,"sxt1002");
        //添加到集合中
        al2.add(stu1);
        al2.add(stu2);
        //需要遍历集合
        print(al2);
        /*
         *     Person [name=sean, age=20]Student [stuNo=sxt1001]
            Person [name=nico, age=19]Student [stuNo=sxt1002]
         */
        
        
        //调用show方法
        System.out.println("
---------------------------
");
        
        show(al);
        /*
         *     Person [name=marry, age=20]
            Person [name=lili, age=29]
            Person [name=jack, age=18]
         */
        
        show(al2);
        /*
         *     Person [name=sean, age=20]Student [stuNo=sxt1001]
            Person [name=nico, age=19]Student [stuNo=sxt1002]
         */
        
        ArrayList<Object> alObject=new ArrayList<Object>();
        Object ob1=new Object();
        Object obj2=new Object();
        alObject.add(ob1);
        alObject.add(obj2);
        
        show(alObject);//泛型下限 Object类型也可以使用show()方法
        /*
         *     java.lang.Object@1175e2db
            java.lang.Object@36aa7bc2
         */
    }
    
    //泛型上限，Person及Person的子类
    //<? extends Person>解释：?(通配符) 谁 extends 继承了 Person 谁就可以使用这个方法
    public static void print(ArrayList<? extends Person> al){ 
        for (Person p : al) {
            System.out.println(p);
        }
    }
    
    //泛型下限,Student及Student的父类
    //<? super Student>解释: ?(通配符) 谁 super Student 是Student的父类 谁就可以使用这个方法
    public static void show(ArrayList<? super Student> al){
        for (Object obj : al) {
            System.out.println(obj);
        }
    }
}

6.6 泛型的好处

类型安全。 泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中）。

消除强制类型转换。 泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。

尽管减少强制类型转换可以降低使用泛型类的代码的罗嗦程度，但是声明泛型变量会带来相应的罗嗦。比较下面两个代码例子。

该代码不使用泛型：

List li = new ArrayList();
li.put(new Integer(3));
Integer i = (Integer) li.get(0);

该代码使用泛型：

List<Integer> li = new ArrayList<Integer>();
li.put(new Integer(3));
Integer i = li.get(0);

在简单的程序中使用一次泛型变量不会降低罗嗦程度。但是对于多次使用泛型变量的大型程序来说，则可以累积起来降低罗嗦程度。

6.7 容器中使用泛型

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.TreeMap;
import java.util.TreeSet;

public class Test2 {
    public static void main(String[] args) {
        
        ArrayList<String> al=new ArrayList<String>();
        al.add("hello");
        
        LinkedList<Integer> linkedList=new LinkedList<Integer>();
        linkedList.add(123);//123进行了自动装箱
        
        //存储自定时对象时，要求Person类重写hashCode()及equals()方法
        HashSet<Person> hs=new HashSet<Person>();
        
        //Person 对象具备比较规则 ，可以是内部比较器，也可以外部比较器
        TreeSet<Person> treeSet=new TreeSet<Person>();
        
        HashMap<String,Integer> hm=new HashMap<String,Integer>();
        hm.put("hello", 123);
        
        HashMap<Person,String> hm2=new HashMap<Person,String>();
        Person p1=new Person("marry",20);
        hm2.put(p1, p1.getName());
        
        TreeMap<Person,Integer> tm=new TreeMap<Person,Integer>();
        tm.put(p1, p1.getAge());
        
        //泛型只在编译期间起作用
    }

 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

7.集合体系框架总结