JAVA Collection集合框架

##Collection集合       

        java.util.Collection接口，所有的集合都实现自该接口，这个接口中定义了所有集合都必须具备的相关功能。
        Collection下面有两个非常常见的子类集合
java.util.List:线性表，是一个可以存放重复元素且有序的集合。
java.util.Set:不可重复的集合

       

注：集合只能存放引用型元素

集合常用方法:
boolean add(E e):向集合中添加一个元素，成功添加则返回true

int size():返回当前集合的元素个数

boolean isEmpty():判断当前集合是否为空集.当且仅当size=0时返回true.

void clear():清空集合

boolean contains(Object o):判断集合是否包含给定元素

boolean remove(Object o):从集合中删除给定元素，成功删除返回true.

boolean addAll(Collection c):将给定集合所有元素添加到当前集合中。

boolean removeAll(Collection c):删除当前集合中与给定集合的公有元素。

boolean containsAll(Collection c):判断当前集合是否包含给定集合中的所有元素。

Iterator iterator():获取用于遍历当前集合的迭代器

T.toArray(T[] t):将当前集合转换为一个数组。参数为要转换的数组。

public class CollectionDemo {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        /*
            集合只能存放引用类型元素!
            boolean add(E e)
            向集合中添加一个元素，成功添加后返回true。
         */
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        System.out.println(c);
        /*
            int size()
            返回当前集合的元素个数
         */
        int size = c.size();
        System.out.println("size:"+size);//5
        /*
            boolean isEmpty()
            判断当前集合是否为空集:集合中是否不含有元素
         */
        boolean isEmpty = c.isEmpty();//false
        System.out.println("是否为空集:"+isEmpty);
        /*
            void clear()
            清空集合
         */
        c.clear();
        System.out.println(c);
        System.out.println("是否为空集:"+c.isEmpty());//true
    }
}

##迭代器
java.util.Iterator

        迭代器用于遍历集合，不同的集合都提供了一个用于遍历自身元素的迭代器实现类。使用迭代器遍历集合遵循的过程为:问->取->删。其中删除不是必要操作。

常用方法:
boolean hasNext():判断集合是否还有"下一个"元素可以遍历

E next():获取集合下一个元素

void remove():从集合中删除迭代器当前位置的元素(通过next获取的元素)

Collection c = new ArrayList();
    c.add("one");
    c.add("#");
    c.add("two");
    c.add("#");
    c.add("three");
    c.add("#");
    c.add("four");
    c.add("#");
    c.add("five");
    System.out.println(c);
    /*
       迭代器中两个重要的方法:
       boolean hasNext()
       判断当前集合是否还有下一个元素可以遍历。
       注:迭代器默认开始位置为集合第一个元素之前，所以第一次调用是判断集合是否有第一个
       元素可以遍历。

       E next()
       使迭代器向后移动到下一个元素的位置并获取该元素。
    */
    Iterator it = c.iterator();
    while(it.hasNext()){
        String str = (String)it.next();//这里方法的默认类型为Object所以必须转型
        System.out.println(str);
        if("#".equals(str)){
            //迭代器要求在遍历的过程中不能通过集合的方法增删元素否则会抛出异常!
//           c.remove(str);
            //迭代器提供的remove可以删除迭代器当前位置表示的集合元素
            it.remove();
        }
    }
    System.out.println(c);

##List集合
list集合有两个常用的实现类:

java.util.ArrayList:内部使用数组实现，查询性能更好。

java.util.LinkedList:内部使用链表实现，增删性能更好，首尾增删性能最佳。

性能没有苛刻要求时，通常使用ArrayList。

常用方法
E get(int index):获取指定下标index处对应的元素

E set(int index, E e):将给定元素设置到index指定的位置，返回值为该位置被替换的元素。

void add(int index,E e):将给定元素插入到index指定的位置

E remove(int index):删除并返回下标index处对应的元素。

List subList(int start,int end):获取当前集合中start到end之间的子集。(含头不含尾)
 

List<String> list = new LinkedList<>();
     list.add("one");
     list.add("two");
     list.add("three");
     list.add("four");
     list.add("five");
     System.out.println(list);
     //获取第三个元素
     String str = list.get(2);
     System.out.println(str);

     String old = list.set(2,"six");
     for(int i=0;i< list.size();i++){
         str = list.get(i);
         System.out.print(str+" ");//得到每个对应下标值得原数值
     }
     System.out.println(old);//返回被替换位置的元素

/*     将list中前后元素位置互换                */
     for(int i=0;i< list.size()/2;i++){
        String s = list.get(i);
         s = list.set(list.size()-1-i,s);
         old = list.set(i,s);
     }
        System.out.print(list);

     String old = list.remove(2);//第二个位置的元素并返回元素的对应值
     System.out.println(list);
     System.out.println(old);

     List<Integer> sublist = list.subList(1,3);//截取含1不含3位置的元素
     System.out.println(sublist);//输出 “two three”
    
    //对子集合的操作就是对原集合的操作
    list.subList(0,2).clear();
    System.out.println(list);// 输出"three，four，five"

        JDK5之后推出了一个新特性:增强型for循环也称为新循环，使得我们可以用相同的语法遍历集合或数组。
语法:
for(元素类型 变量名 : 遍历的集合或数组){
      ...
}

String[] array = {"one","two","three","four","five"};
    for(int i=0;i<array.length;i++){
        String str = array[i];
        System.out.println(str);
    }
    /*
        新循环是编译器认可的，编译器会将它改为传统的for循环来遍历数组。
     */
    for(String str : array){
        System.out.println(str);
    }

    //迭代器也需要指定泛型，具体类型应当与其遍历的集合指定的泛型一致
    Iterator<String> it = c.iterator();//使用泛型指定类型
    while(it.hasNext()){
        String str = it.next();//获取元素时无需再手动造型。
        System.out.println(str);
    }

数组转换为List集合
数组的工具类Arrays提供了一个静态方法asList，可以将一个数组转换为List集合

public class ArrayToListDemo {
  public static void main(String[] args) {
      String[] array = {"one","two","three","four","five"};
      System.out.println("array:"+ Arrays.toString(array));
      List list = Arrays.asList(array);
      System.out.println("list:"+list);

      list.set(1,"six");
      System.out.println(list);
      //输出内容和list集合内容一样，对list集合进行操作就相当于对数组进行操作，
      //由于数组是定长的，所以不支持对集合进行增删元素操作
      System.out.println(Arrays.toString(array));

//      list.add("seven");
//      System.out.println(list);  报错

      //若希望对集合元素进行增删动作，则需要创建一个新集合并包含数组转换的集合中所有元素即可,
      //所有集合都支持一个参数为Collection的构造器，作用是创建当前集合同时包含给定集合所有元素
      List list2 = new ArrayList(list);
      list2.add("seven");
      System.out.println("list2:"+list2);
  }
}

集合转数组

Collection提供了方法：toArray()可以将一个集合转换为数组

/**
 * 集合转换为数组
 * Collection提供了方法：toArray()可以将一个集合转换为数组
 */
public class CollectionToArrayDemo {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        System.out.println(c);

        //Object[] array = c.toArray();   默认
        String[] array = c.toArray(new String[0]);
        String[] array1 = c.toArray(new String[c.size()]);
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(array1));
    }
}

##对List集合进行排序

   使用该sort方法排序List集合时有一个前提条件：集合元素必须实现Comparable接口，sort方法会利用该接口上定义的抽象方法来对元素两两比较从而得知大小后进行排序元素没有实现该接口则编译器不通过该操作具有侵入性：当我们使用一个API时，如果该API反过来要求我们修改。

public class SortListDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        Random rand = new Random();
        for(int i=0;i<10;i++){
            list.add(rand.nextInt(100));
        }
        System.out.println(list);
        Collections.sort(list);//小到大排序
        System.out.println(list);
        Collections.reverse(list);//反转
        System.out.println(list);
    }
}

    List<String> list = new ArrayList<>();

    list.add("刘桑");
    list.add("苍老师");
    list.add("简");
    list.sort((o1,o2)->o2.length()-o1.length());

    /*Collections.sort(list,(o1, o2) ->
        o1.length() - o2.length()
    );*/
    System.out.println(list);