集合篇(Collection)

集合是什么？简单的说就是一种容器，用来装载各种封装后的数据，数组也能装载数据，他和集合有什么区别呢？简单的说，数组是固定的，而集合却是可以随时根据需要增加，删除，改变数据。
集合框架 看图

这是集合里面包含的接口和实现类，我可能知道不是那么多，只能将我学了的记下来
-List接口：存储有序的，可以重复的元素.—相当于“动态”数组
常用方法 ：删除remove(int index) 修改set(int index,Object obj) 获取get(int index)插入add(int index,Object obj)
主要实现类：-ArrayList（主要的实现类）
-LinkedList（更适用于频繁的插入、删除操作）

package collectior;
import java.util.ArrayList;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
/**此乃容器也，第一次接触容器，容器一共有collectior（List、set(Hasset)），map（HasMap）这么多接口
 * ArrayList:底层实现是数组，线程不安全，效率高。所以，查询快，修改，插入，删除慢。
 * LinkedList：底层实现是链表，线程不安全，效率高。所以，查询慢。修改，插入，删除快。
 * List与顺序有关，而且可以重复
 * set与顺序无关且不可以重复
 */
public class Test01 {
    public static void main(String[] args) {
        List list=new ArrayList();//父类指向子类的引用
        List list0=new LinkedList();//父类指向子类的引用 多态无时不在，面向接口编程
        list0.add("imiao");//向list0中添加一个字符串
        list0.add(new dog());//向list0中添加一个对象
        list0.remove(0);//删除第0个元素
         for(int i=0;i<list0.size();i++){
             System.out.println(list0.get(i));
         }
        list.add("aaa");
        list.add(new Date());
        list.add(new dog());
        list.add(1234);//包装类的：自动装箱
        System.out.println(list.size());
        System.out.println(list.isEmpty());
       // list.remove("aaa");       //hasshoode和equals
       //System.out.println(list.size());
        List list2=new ArrayList();//父类指向子类的引用
        list2.add("bbb");
        list2.add("ccc");
        list.add(list2);
        System.out.println(list.size());
        //跟顺序有关的操作
        String str=(String )list.get(0);
        System.out.println(str);
        list.set(1, "ababab");
        list.remove(0);
    }
}
class dog{
 public dog() {
System.out.println("this is dog");
 }
}
显示结果
this is dog
collectior.dog@77f2fbff
this is dog
4
false
5
aaa

Set接口：存储无序的，不可重复的元素。—相当于高中的“集合”概念
添加进Set集合中的元素所在的类一定要重写equals() 和 hashCode()。要求重写equals() 和 hashCode()方法保持一致。
1.无序性：无序性不等于随机性。真正的无序性，指的是元素在底层存储的位置是无序的。
2.不可重复性：当向Set中添加进相同的元素的时候，后面的这个不能添加进去。
HashSet（主要的实现类）
LinkedHashSet(是HashSet的子类，当我们遍历集合元素时，是按照添加进去的顺序实现的；频繁的遍历，较少的添加、插入操作建议选择他)
TreeSet（可以按照添加进集合中的元素的指定属性进行排序，默认升序）
添加进Set集合中的元素所在的类一定要重写equals() 和 hashCode()。要求重写equals() 和 hashCode()方法保持一致
两个对象equals相等，那么它的hashcode相等
两个对象equals不相等，那么它的hashcode并不要求它不相等，但一般建议不相等
hashcode相等不代表两个对象相等（采用equals比较）

package collectior;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class TestSet {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "小明";
        p1.age = 8;

        Person p2 = new Person();
        p2.name = "小红";
        p2.age = 5;

        Person p3 = new Person();
        p3.name = "小红";
        p3.age = 10;

        Set set = new HashSet();
        set.add(p1);
        set.add(p2);
        set.add(p3);

        for (Iterator iter=set.iterator(); iter.hasNext();) {
            Person p = (Person)iter.next();
            System.out.println("name=" + p.name + ", age=" + p.age);
        }

        System.out.println("p1.hashCode=" + p1.hashCode());
        System.out.println("p2.hashCode=" + p2.hashCode());
        System.out.println("p3.hashCode=" + p3.hashCode());
        Set set0 =new HashSet();
        set0.add("aaa");
        set0.add("ddd");
        set0.add(set);
        set0.add(new String ("aaa"));
        System.out.println(set0.size());//2，表明是不可以插入重复的数据的
        for (Iterator iter=set0.iterator(); iter.hasNext();) {
            System.out.println(iter.next());
        }
        /**
            * 3
            [(this Collection), aaa, ddd]
            aaa
            ddds
             *      
             */
    //表明输出结果是无序的
        //set.remove("aaa");
        }

    }
    显示结果:
    name=小明, age=8
    name=小红, age=5
    p1.hashCode=756703
    p2.hashCode=762995
    p3.hashCode=762995
    3
    [collectior.Person@b8bdf, collectior.Person@ba473]
    aaa
    ddd

再来看一个treeSet的例子

package collectior;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class TesttreeSet {
    public static void main(String[] args) {
        Set set0 = new TreeSet();
        set0.add(1);
        set0.add(8);
        set0.add(5);
        set0.add(3);
        for (Iterator set=set0.iterator(); set.hasNext();) {
            int int1 = (int)set.next();//强制类型转换成int
            System.out.print(int1+"\t");
        }
    }
}
显示结果
1   3   5   8   按升序排序输出

继续排序 实现Comparable接口

package collectior;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class TestSet {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "小明";
        p1.age = 8;

        Person p2 = new Person();
        p2.name = "小红";
        p2.age = 5;

        Set set = new TreeSet();

        set.add(p1);
        set.add(p2);
        for (Iterator iter=set.iterator(); iter.hasNext();) {
            Person p = (Person)iter.next();
            System.out.println("name=" + p.name + ", age=" + p.age);
        }
        }

    }




    package collectior;

public class Person implements Comparable {//实现Comparable接口
        String name;
        int age;
        //重写hashCode()
        public int hashCode() {
            return (name==null)?0:name.hashCode();  
        }   

        //重写equals
        public boolean equals(Object obj) {
            if (this == obj) {
                return true;    
            }
            if (obj instanceof Person) {
                Person p = (Person)obj;
                return this.name.equals(p.name);
            }
            return false;

        }

        public int compareTo(Object o) {//重写copareTo()方法
            if (o instanceof Person) {
                Person p = (Person)o;
                //降序
                return ( p.age-this.age);

            }
            throw new IllegalArgumentException("非法参数，o=" + o);
        }

}

显示结果：
name=小明, age=8
name=小红, age=5

继续排序 实现Comparator接口

package collectior;

import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class TestSet {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "小明";
        p1.age = 8;

        Person p2 = new Person();
        p2.name = "小红";
        p2.age = 5;
        //内部类实现Coparator方法，所谓内部类就是在new的同时把类给直接写出来了 不需类名，却可以访问外部类的属性和方法
        Set set = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (!(o1 instanceof Person)) {//instanceof的意思是检查传入的对象与原对象是否一致
                    throw new IllegalArgumentException("非法参数，o1=" + o1);
                }
                if (!(o2 instanceof Person)) {
                    throw new IllegalArgumentException("非法参数，o2=" + o2);
                }
                Person p1 = (Person)o1;
                Person p2 = (Person)o2;
                return p2.age - p1.age;
            }               
        });

        set.add(p1);
        set.add(p2);
        for (Iterator iter=set.iterator(); iter.hasNext();) {
            Person p = (Person)iter.next();
            System.out.println("name=" + p.name + ", age=" + p.age);
        }
        }

    }
    显示结果：
    name=小明, age=8
    name=小红, age=5

一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的集合就可以直接使用sort方法排序。
Comparator可以看成一种算法的实现，将算法和数据分离

Map接口：存储“键-值”对的数据 —-相当于高中的
key是不可重复的，使用Set存放。value可以重复的，使用Collection来存放。一个key-value对构成一个entry(Map.Entry)，entry使用Set来存放
常用方法：添加put(Object key,Object value)
删除remove(Object key)
获取get(Object key) size() / keySet() values() entrySet()
HashMap：主要的实现类，可以添加null键，null值
LinkedHashMap：是HashMap的子类，可以按照添加进Map的顺序实现遍历
TreeMap：需要按照key所在类的指定属性进行排序。要求key是同一个类的对象。对key考虑使用自然排序 或 定制排序

我不想举例了。。。。。。
Iterator接口：用来遍历集合Collection元素，foreach就是Iterator加入泛型后的产品
来了解一下这个类
Collections工具类：操作Collection及Map的工具类，大部分为static的方法。
泛型 ：这个就是C++中的函数模板，很相似，后面会夹带出现，但就不单独作为一个点来细细记了
这篇好像写得有点多了哦 ，我会加油的，博客的质量也会越来越好的