JavaSE_day12:集合，泛型，增强for循环特性

集合：

      今天再来谈一谈这个集合：集合他是一种容器，是用来存储数据的。而之前还学过的数组也是一种容器，那么就来谈一谈集合和数组之间的区别：

        数组：首先数组的长度是固定的，不能改变。

                  数组只能存储一种数据类型。

                  数组可以存储基本数据类型，也可以存储引用数据类型，比如可以存储int类型，也可以存储Integer引用类型

       集合：

               集合的长度是可变的，

              集合可以存储多种数据类型，String Integer ....

              集合只能存储引用数据类型，不能存储基本数据类型。

下来我们再来看一看集合Collection的子接口List接口的特有的方法：

         void  add（int index，E，element）：在指定索引处添加元素。

        E  remove（int index）：移除指定索引处的元素。

       E  get（int index）：获取指定索引处的元素。

                      List list=new  ListArray（）；

                     list.add(1);

                     list.add(2);

                     list.add(0,3);          //在0索引处的元素为3

 遍历集合：   Iterator iterator= list.iterator( );

                       while(iterator.hasNext()){              //判断是否有元素可以迭代（遍历）

                     System.out.println(iterator.next());          

                    } 

        另外：获取最后一个索引的元素：list.get(list.size()-1);

用List迭代器的方法迭代元素：

      ListIterator<E>  listIterator():返回元素的迭代器，以一定的排列顺序

        List<String>   list=new  ArrayList<String >();    //<>:代表泛型，他是限定集合存储元素的数据类型

      list.add("周星驰 ");

      list.add(" 刘德华");

      list.add("成龙 ");

      list.add(" 靳东");

         //遍历集合：

    ListInterator<String> interator=list.listIterator();

while(interator.hasNext()){

  System.out.println(interator.next());

}

          boolean hasPrevious() 
              如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
             E previous()  返回列表中的前一个元素。

   现在要获取集合元素的逆向遍历：       注意：想要获取逆向遍历，必须进行正向遍历，否则出错。

   while（iterator.previous()）{

   System.out.println(iterator.previous());

}

在此处演示一个需求：我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。l

List <String> list =new ArrayList（）；

 list.add("hello");

 list.add("world");

ListIterator<String>  listIterator=list.listIterator();

while(listIterator.hasNext()){

                  String string= listIterator.next();

                 if(string.equals(list)){

           list.add("javaee");       此处发现错误：ConcurrentModificationException 并发修改异常

改正：

         listIterator.add("javaee");       //用迭代器的方法添加。

  此处发现异常的原因：我们用的是迭代器进行遍历的，而在进行遍历之前，迭代器已经知道我们集合里边的元素以及个数

         然后在迭代的过程中，想要突然添加一个元素，迭代器肯定是不允许的。

方案一：就是上述的用迭代器的方法添加。     即：listIterator.add("javaee");

方案二：用for循环进行遍历：

      for(int x=0;x<list.size();x++){

       String elec=listIterator.next();

       if("world".equals(elec)){

         list.add("javaee");

}

}

           System.out.println(list);

}

}

set() 替换集合中指定索引处的元素，返回的是被替换的元素

String string=list.set(list.size()-1,"大能猫");

System.out.println(string);

System.out.println(list);

好，现在我们正式谈一谈List接口：

     ArrayList：底层数据结构是数组，查询快，增删慢，线程不安全，效率高 可以存储重复元素

     int indexOf (Object o)返回此列表中指定元素的第一个出现的索引，或 - 如果此列表不包含元素，或 - 1。

     void sort (Comparator < ? super E > c)分类列表使用提供的 Comparator比较元素。

     List<E> subList ( int fromIndex, int toIndex)返回一个视图之间的指定 fromIndex，包容，和 toIndex这份名单的部分，独家

    Object[] toArray () 返回一个数组，包含在这个列表中的所有元素在适当的顺序（从第一个到最后一个元素）

区分：

 Object[] obj = list.toArray();                            //把一个集合转成数组

   List<int[]> ints = Arrays.asList(arrs);           / /把数组转成集合

LinkedList:

LinkedList 底层数据结构是链表，查询慢，增删快，线程不安全，效率高

LinkedList特有的方法：

public void addFirst (E e)及addLast(E e)：在开头或末尾加上一个元素

public E getFirst () 及getLast()：获取第一个元素或最后一个元素

public E removeFirst () 及public E removeLast()：把第一个或者最后一个元素移除掉

Vector

Vector:底层数据结构是数组，查询快，增删慢，线程安全，效率低。

vector特有的方法：

E elementAt(int index)：返回指定索引处的组件

Enumeration<E> elements()：返回此向量的组件的枚举。

E firstElement()返回第一个组件（在指数 0项目）这个载体。

E lastElement()返回向量的最后一个组件。

泛型：

         泛型机制：JDK1.5之后引入的一个新特性
        泛型机制是一种把数据类型明确工作推迟到创建对象或调用方法时才去明确的一种机制
        泛型的语法  <数据类型，数据类型> 数据类型只能写引用数据类型
        泛型只在编译期间有效，在运行期就擦除了
        泛型的好处1.把问题提前到了编译期
        2. 避免了向下转型
        泛型定义的位置：可以定义在接口，类，方法上面

泛型定义在接口上，等创建子类对象的时候就得明确泛型具体的数据类型

泛型方法，当你在调用方法时，明确泛型的具体类型

        泛型统配符 ? 统配任意类型
        Animal<?> objectAnimal = new Animal<Date>();
        向上限定 右边的泛型只能是他的本身，或者他的父类
        Animal<? super Animal> animal = new Animal<Object>();
        向下限定 右边的泛型只能是他的本身，或者他的子类
        Animal<? extends Animal> animal2 = new Animal<Dog>();
        boolean addAll (Collection < ? extends E > c)

增强for循环：

此处以一个具体的实例来讲解：

public class MyTest {
    public static void main(String[] args) {
        //JDK1.5之后 有一个 新式for循环
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(10);
        integers.add(20);
        integers.add(30);
        integers.add(40);
        for (int i=0;i<integers.size();i++){
            System.out.println(integers.get(i));
        }

        //Integer num 容器中的数据类型 以及元素的变量名
        //integers 容器名
        for (Integer num: integers){
            System.out.println(num);
        }

 

        Integer[] arr={10,30,50,60};
        for (Integer i:arr){
            System.out.println(i);
        }

        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("高圆圆",28));
        students.add(new Student("许晴", 60));
        students.add(new Student("王菲", 15));
        for(Student stu:students){
            System.out.println(stu.getName()+"----"+stu.getAge());
        }

    }
}