1.容器

        1.什么是容器

                容器就是存放对象的集合

        2.java中的容器

                容器就是一系列的类或接口，用来存储一系列对象的地址

        3.容器里存放的是引用数据类型（存对象的地址，不是对象本身），不能存基本数据类型

        4.容器存放的两种格式

                1.单一的类型：直接存对象地址

                2.键值对：存入关键字和对应的value

        5.容器类所在的包

                java.util包中，所以引入容器的时候引入的是java.util.容器类名

        6.容器的分类

                1.Collection，存放单一的类型

                        1.Collection下有三个接口，Set，List,Queue

                        2.有序是指存入的顺序和取出的顺序

                        3.Collection里面的方法

                 以下表格基于Collection list = new ArrayList();

名	形参	返回值	性质	例子	作用
add	要存入的对象		非静态	list.add("asd")	插入一个元素
iterator		"Iterator对象"	非静态	Iterator i = list.iterator	获取迭代器对象
size		int	非静态	int a = list.size();	获取容器长度
isEmpty		boolean	非静态	boolean b = list.isEmpty();	判断容器是否为空
contains	非静态	对象	boolean	String temp = new String("zjh"); System.out.println("contains:\t"+list.contains(temp));	看看容器中是否有temp对象
remove	非静态	对象		list.remove(”asd“);	按照对象内容指定删除

为什么要用容器而不直接使用数组来存储。数组存储单一的类型而且数组需要规定长度，但是容器不需要而且可以在一个容器中存储多种不同的数据类型

迭代器的作用是获取容器中的对象

迭代器就是用来获取一个有个的对象的

所以想要拿出来容器的数据就要用Collection父类的iterator方法获取到Iterator迭代器，然后使用方法hasNext来判断后面还有没有对象了，如果有就把通过next方法对象给拿出来

public class Run {public static void main(String[] args) {Collection list = new ArrayList();list.add("1234567");list.add("zjh");list.add(1234);Iterator it= list.iterator();//通过方法获取迭代器接口实现类的对象//迭代器主要有两个方法，一个是hasNext，一个是nextwhile(it.hasNext()){Object o = it.next();//把对象拿出来System.out.println(o.toString());//从这个出来的顺序可见是先进先出，也就是说ArrayList也具有对列的特性}}
}

                        1.List：有序，可重复，存入的数据有下标

                                1.List是一个继承了Collection接口的接口，拥有Collection的所有方法

                                2.有两个常用的实现类：

                                        1.ArrayList(非线程安全，线程不安全发生在数组扩容时)：

                                                1.底层实现

                                                        底层实现就是个数组，适合查询等操作较多的集合

                                                2.构造方法：

                                                        分为有参和无参两个版本：

                                                        无参的构造方法默认长度为10

                                                        有参的构造方法可以指定默认长度

                                                        扩容的时候每次增加原长度的1.5倍

                                        2.LinkedList()：

                                                1.底层实现

                                                        底层实现就是双向链表，适合插入删除等操作较多的集合

                                                2.构造方法

                                                        空构造方法，构造空链表

                                                        有参构造方法传入一ArrayList，ArrayList转LinkedList

                                        3.ArrayList和LinkedList拥有相同的方法

                                                remove，contains方法比较都是用equals方法比较来判断是否删除和是否有该元素的

                        2.Set：无序，不可重复(重复时只保留最后存入的一次对象（覆盖原来的）)

                                1.也是个继承Collect的接口

                                2.三个实现类

                                        1.HashSet:

                                                1.底层实现

                                                        底层实现是Map

                                                2.构造方法

                                                        默认容量是16，哈希桶是0.75，意思是当容器里元素达到容量百分之七十五之后就开始扩容

                                                        无参构造方法形成的是没有元素的集合

                                                        有参构造方法可以传递进去一个ArrayList

                                                        有参构造方法也可以传入进去一个HashSet的大小，指定的值最好是二的幂次，因为源码在扩容的时候用的是位移扩容

                                                3.HashSet的方法

                                        2.TreeSet（类似于HashSet，但是再进行遍历的时候会进行自动排序）：

TreeSet比较特殊，使用的时候不使用多态，而是多数调用它独有的方法，所以定义引用的时候不用Set而用TreeSet

                                                1.底层实现

                                                        底层实现是二叉树

                                                2.TreeSet存储数据

                                                        1.TreeSet在存储数据的时候要求数据的类型需要一致，否则会在运行时报异常ClassCastException，

                                                        2.在TreeSet存储数据后会自动按照自平衡二叉树的方式来对这些对象进行排序

                                                        3.如何对于自定义的数据进行排序

                                                                由于TreeSet会自动进行存入数据的排序，调用的是对象的compareTo方法，所以自定义的类需要实现Comparable接口并且重写他的抽象方法：compareTo(),

//compareTo方法在重写的时候由于重写访问权限修饰符不能更小所以就是public
public int compareTo(Object o){//逻辑结构:如果对象比传入进来的对象小就返回一个负值，大就正值，等就是0
}

                                                         4.自定义类型存入TreeSet                       

//下列是自定义类型存入TreeSet
public class Run {public static void main(String[] args){TreeSet ts1 = new TreeSet();ts1.add(new Person(14));ts1.add(new Person(12));ts1.add(new Person(14));ts1.add(new Person(15));for(Object o : ts1){System.out.print(o+"\t");}//如果要打印记得要重写equals方法System.out.println("\n");}
}public class Person implements Comparable{private int age;public Person(){}public Person(int age){this.age = age;}public int getAge(){return age;}public void set(int age){this.age = age;}@Overridepublic int compareTo(Object o){//重写方法的时候如果原来的小，就返回负数，如果原来的大就返回正值Person p = (Person) o;return this.age-p.age;}@Overridepublic String toString(){return String.valueOf(age);}
}

                                                    3.TreeSet的方法 

System.out.println("自定义存入TreeSet后的第一个元素：\t"+ts1.first());

System.out.println("自定义存入TreeSet后的最后一个元素\t:"+ts1.last());

TreeSet ts1 = new TreeSet();ts1.add(new Person(14));ts1.add(new Person(12));ts1.add(new Person(14));ts1.add(new Person(15));ts1.add(new Person(16));ts1.add(new Person(17));ts1.add(new Person(19));System.out.print("自定义数据存入TreeSet\t" );for(Object o : ts1){System.out.print(o+"\t");}System.out.println("\n自定义存入TreeSet后的第一个元素：\t"+ts1.first()+"\t最后一个元素"+ts1.last());

运行结果：

 自定义数据存入TreeSet    12    14    15    16    17    19    
自定义存入TreeSet后的第一个元素：    12    最后一个元素19

                                        3.LinkedHashSet：的底层实现就是在Map上加了个链表 （区别就是有序了，但是这个有序是针对存入取出有序，但是仍然不重复）      

                                3.collection总结代码

public class Person implements Comparable{private int age;public Person(){}public Person(int age){this.age = age;}public int getAge(){return age;}public void set(int age){this.age = age;}@Overridepublic int compareTo(Object o){//重写方法的时候如果原来的小，就返回负数，如果原来的大就返回正值Person p = (Person) o;return this.age-p.age;}@Overridepublic String toString(){return String.valueOf(age);}
}public class Run {public static void main(String[] args) {collection();}public static void collection(){Collection list = new ArrayList();list.add("1234567");list.add("zjh");list.add(1234);Iterator it= list.iterator();//通过方法获取迭代器接口实现类的对象//迭代器主要有两个方法，一个是hasNext，一个是nextwhile(it.hasNext()){//看看迭代器是否有下一个Object o = it.next();//把对象拿出来。且让迭代器向下指一个元素System.out.println(o.toString());//从这个出来的顺序可见是先进先出，也就是说ArrayList也具有对列的特性}System.out.println("容器长度为：\t"+list.size());System.out.println("容器为空：\t"+list.isEmpty());//ArrayList部分List a = new ArrayList();//add的重载默认是尾插a.add("adw");a.add("adw");//可以体现重复a.add("zjh");a.add(2,199);//相当于就是插入//按常理来讲对容器进行遍历是要通过迭代器的，但是ArrayList有下标，所以此时选择的是直接通过下标来进行遍历//此时就有了get方法来获取对象，get的形参时对象的下标System.out.print("容器内现有元素:\t");for(int i = 0;i<a.size();i++){Object o = a.get(i);System.out.print(o+"\t");}//contains方法：比较容器当中是否有某个对象//判断是否有这个对象的时候调用的这个对象的equals方法//在添加对象进入容器的时候要把这个对象的equals方法重写String temp = new String("zjh");System.out.println("\ncontains:\t"+a.contains(temp));//虽然s指向的是字符串对象，字符串对象里面含有字符串的地址，也就是说s指向的地址和容器当中所保存的字符串地址是不同的，但是contains在比较的时候调用了对象的equals方法，所以返回值是true//remove方法System.out.println("删除前容器长度"+a.size());a.remove(2);//删除下标为2的元素,删除某个元素后其余元素会填补回来a.remove("adw");//按照对象删除的时候只删除一遍System.out.println("删除后容器长度"+a.size());System.out.print("容器内剩余的元素:");for(int i = 0;i<a.size();i++){Object o = a.get(i);System.out.print(o+"\t");}System.out.println("\n");//LinkedList部分List list1 = new LinkedList(a);Iterator itr = list1.iterator();System.out.print("list1容器里的元素为\t");while(itr.hasNext()){Object o = itr.next();System.out.print(o+"\t");}list1.add("wada");list1.remove("adw");System.out.print("\n删除“adw”，插入“wada之后还剩”"+list1.size()+"个元素，分别是\t");for(int i = 0;i<list1.size();i++){System.out.print(list1.get(i)+"\t");}//也可以直接使用增强型for循环
//        for(Object o :list1){
//            System.out.println(o);
//        }System.out.println("\n");//Set//HashSet部分Set s=new HashSet();s.add("牛马");s.add("sad");s.add(new String("sad"));//此处说明了和contains一样，判断重复与否是根据equals方法的s.add("asd");s.add("asd");System.out.println("HashSet容器长度为："+s.size()+"体现了Set的不可重复性，如果重复后面的会覆盖前者的数据");System.out.print("s中的元素有：\t");//从打印结果来看就可以知道这个时候是无序的取出for (Object o :s) {System.out.print(o+"\t");}s.clear();System.out.println("\nclear之后的s的长度：\t"+s.size());//TreeSet部分,存储的数据，数据类型必须保持一致TreeSet ts = new TreeSet();//会按照自平衡二叉树的方式对于给定的数据进行排序ts.add(22);ts.add(33);ts.add(453);ts.add(3);ts.add(34);ts.add(231);System.out.print("ts里面的元素为：\t");for(Object o : ts){System.out.print(o+"\t");}System.out.println("\n");//自定义类型的比较需要在自定义的类当中实现Comparable接口并且重写compareTo方法TreeSet ts1 = new TreeSet();ts1.add(new Person(14));ts1.add(new Person(12));ts1.add(new Person(14));ts1.add(new Person(15));ts1.add(new Person(16));ts1.add(new Person(17));ts1.add(new Person(19));System.out.print("自定义数据存入TreeSet\t" );for(Object o : ts1){System.out.print(o+"\t");}System.out.println("\n自定义存入TreeSet后的第一个元素：\t"+ts1.first()+"\t最后一个元素"+ts1.last());}
}

                2.Map，存放键值对的类型