JAVA的集合框架

目录

什么是集合

集合的接口

Collection下面有两个常见的子接口:

集合的操作

集合的遍历

增强for循环

List集合常见方法

集合的转换

集合排序

（1）java.util.Collections类

（2）Collections.sort(List list)方法

重载的Collections.sort(List list,Comparator c)方法

（6） 排序字符串

---

什么是集合

集合与数组一样,可以保存一组元素,并且提供了操作元素的相关方法,使用更方便

集合的接口

• java.util.Collection是所有集合的顶级接口.Collection下面有多种实现类,因此我们有更多的数据结构可供选择.

• Collection下面有两个常见的子接口:

• java.util.List:线性表.是可重复集合,并且有序.
• java.util.Set:不可重复的集合,大部分实现类是无序的.

• package collection;
  
  import java.util.ArrayList;
  import java.util.Collection;
  
  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);
          /*
              boolean isEmpty()
              判断当前集合是否为空集(不含有任何元素)
           */
          boolean isEmpty = c.isEmpty();
          System.out.println("是否为空集:"+isEmpty);
          /*
             清空集合
           */
          c.clear();
          System.out.println(c);
          System.out.println("size:"+c.size());//0
          System.out.println("是否为空集:"+c.isEmpty());
  
  
      }
  }
  

  集合的操作

• 删 取  判断自交集

• package collection;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashSet;
  
  /**
   * 集合间的操作
   */
  public class CollectionDemo4 {
      public static void main(String[] args) {
  //        Collection c1 = new ArrayList();
          Collection c1 = new HashSet();//不可重复元素
          c1.add("java");
          c1.add("c");
          c1.add("c++");
          System.out.println("c1:"+c1);
          Collection c2 = new ArrayList();
          c2.add("android");
          c2.add("ios");
          c2.add("java");
          System.out.println("c2:"+c2);
           /*
              boolean addAll(Collection c)
              将给定集合中的所有元素添加到当前集合中。当前集合若发生了改变则返回true
           */
          boolean tf = c1.addAll(c2);
          System.out.println(tf);
          System.out.println("c1:"+c1);
          System.out.println("c2:"+c2);
  
          Collection c3 = new ArrayList();
          c3.add("ios");
          c3.add("c++");
          c3.add("php");
          System.out.println("c3:"+c3);
          /*
              boolean containsAll(Collection c)
              判断当前集合是否包含给定集合中的所有元素
           */
          boolean contains = c1.containsAll(c3);
          System.out.println("包含所有元素:"+contains);
  
          /*
              boolean removeAll(Collection c)
              删除当前集合中与给定集合中的共有元素
           */
          c1.removeAll(c3);
          System.out.println("c1:"+c1);
          System.out.println("c3:"+c3);
      }
  }
  

  集合的遍历

• java.util.Iterator接口
  迭代器接口,定义了迭代器遍历集合的相关操作.

  不同的集合都实现了一个用于遍历自身元素的迭代器实现类,我们无需记住它们的名字,用多态的角度把他们看做为Iterator即可.

  迭代器遍历集合遵循的步骤为:问,取,删.其中删除元素不是必要操作
   

  package collection;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  
  /**
   * Collection接口没有定义单独获取某一个元素的操作，因为不通用。
   * 但是Collection提供了遍历集合元素的操作。该操作是一个通用操作，无论什么类型的
   * 集合都支持此种遍历方式:迭代器模式。
   *
   * Iterator iterator()           die(二声)
   * 该方法会获取一个用于遍历当前集合元素的迭代器
   *
   * java.util.Iterator接口，是迭代器接口，规定了迭代器遍历集合的相关操作，不同的
   * 集合都提供了一个用于遍历自身元素的迭代器实现类，不过我们不需要直到它们的名字，以
   * 多态的方式当成Iterator使用即可。
   * 迭代器遍历集合遵循的步骤为:问->取->删
   * 其中删除不是必须操作。
   *
   */
  public class IteratorDemo {
      public static void main(String[] args) {
          Collection c = new ArrayList();
          c.add("one");
          c.add("two");
          c.add("three");
          c.add("four");
          c.add("five");
          System.out.println(c);
          //获取迭代器
          Iterator it = c.iterator();
          /*
              迭代器提供的相关方法：
              boolean hasNext()
              判断集合是否还有元素可以遍历
  
              E next()
              获取集合下一个元素(第一次调用时就是获取第一个元素，以此类推)
           */
          while(it.hasNext()){
              String str = (String)it.next();
              System.out.println(str);         
          }
          System.out.println(c);
  
      }
  }
  

  增强for循环

• package collection;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  
  /**
   * JDK5推出时，推出了一个新的特性:增强型for循环
   * 也称为新循环，它可以用相同的语法遍历集合或数组。
   *
   * 新循环是java编译器认可的，并非虚拟机。
   */
  public class NewForDemo {
      public static void main(String[] args) {
          String[] array = {"one","two","three","four","five"};
          for(int i=0;i<array.length;i++){
              String str = array[i];
              System.out.println(str);
          }
  
          for(String str : array){
              System.out.println(str);
          }
  
  
          Collection c = new ArrayList();
          c.add("one");
          c.add("two");
          c.add("three");
          c.add("four");
          c.add("five");
          //迭代器遍历
          Iterator it = c.iterator();
          while(it.hasNext()){
              String str = (String)it.next();
              System.out.println(str);
          }
          //新循环遍历
          for(Object o : c){
              String str = (String)o;
              System.out.println(str);
          }
  
      }
  }
  

  List集合常见方法

• get set

• package collection;
  
  import java.util.ArrayList;
  import java.util.List;
  
  /**
   *  List集合
   *  List是Collection下面常见的一类集合。
   *  java.util.List接口是所有List的接口，它继承自Collection。
   *  常见的实现类:
   *  java.util.ArrayList:内部由数组实现，查询性能更好。
   *  java.util.LinkedList:内部由链表实现，增删性能更好。
   *
   *  List集合的特点是:可以存放重复元素，并且有序。其提供了一套可以通过下标
   *  操作元素的方法。
   */
  public class ListDemo {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
  //        List<String> list = new LinkedList<>();
  
          list.add("one");
          list.add("two");
          list.add("three");
          list.add("four");
          list.add("five");
  
          /*
              E get(int index)
              获取指定下标对应的元素
           */
          //获取第三个元素
          String e = list.get(2);
          System.out.println(e);
  
          for(int i=0;i<list.size();i++){
              e = list.get(i);
              System.out.println(e);
          }
  
          /*
              E set(int index,E e)
              将给定元素设置到指定位置，返回值为该位置原有的元素。
              替换元素操作
           */
          //[one,six,three,four,five]
          String old = list.set(1,"six");
          System.out.println(list);
          System.out.println("被替换的元素是:"+old);
      }
  }
  

  重载 add  跟remove

• package collection;
  
  import java.util.ArrayList;
  import java.util.List;
  
  /**
   * List集合提供了一对重载的add,remove方法
   */
  public class ListDemo2 {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("one");
          list.add("two");
          list.add("three");
          list.add("four");
          list.add("five");
          System.out.println(list);
          /*
              void add(int index,E e)
              将给定元素插入到指定位置
           */
          //[one,two,six,three,four,five]
          list.add(2,"six");
          System.out.println(list);
  
          /*
              E remove(int index)
              删除并返回指定位置上的元素
           */
          //[one,six,three,four,five]
          String e = list.remove(1);
          System.out.println(list);
          System.out.println("被删除的元素:"+e);
      }
  }
  

  集合的转换

• 集合转数组
• Collection提供了一个方法:toArray,可以将当前集合转换为一个数组

• package collection;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  
  /**
   * 集合转换为数组
   * Collection提供了方法toArray可以将当前集合转换为一个数组
   */
  public class CollectionToArrayDemo {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("one");
          list.add("two");
          list.add("three");
          list.add("four");
          list.add("five");
          System.out.println(list);
  
  //        Object[] array = list.toArray();
          /*
              重载的toArray方法要求传入一个数组，内部会将集合所有元素存入该数组
              后将其返回（前提是该数组长度>=集合的size）。如果给定的数组长度不足，
              则方法内部会自行根据给定数组类型创建一个与集合size一致长度的数组并
              将集合元素存入后返回。
           */
          String[] array = list.toArray(new String[list.size()]);
          System.out.println(array.length);
          System.out.println(Arrays.toString(array));
      }
  }
  

  数组转集合

• package collection;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  
  /**
   * 数组转换为List集合
   * 数组的工具类Arrays提供了一个静态方法asList，可以将数组转换为一个List集合。
   */
  public class ArrayToListDemo {
      public static void main(String[] args) {
          String[] array = {"one","two","three","four","five"};
          System.out.println(Arrays.toString(array));
          List<String> list = Arrays.asList(array);
          System.out.println(list);
  
          list.set(1,"six");
          System.out.println(list);
          //数组跟着改变了。注意:对数组转换的集合进行元素操作就是对原数组对应的操作
          System.out.println(Arrays.toString(array));
  
          /*
              由于数组是定长的，因此对该集合进行增删元素的操作是不支持的，会抛出
              异常:java.lang.UnsupportedOperationException
           */
  //        list.add("seven");
  
          /*
              若希望对集合进行增删操作，则需要自行创建一个集合，然后将该集合元素
              导入。
           */
  //        List<String> list2 = new ArrayList<>();
  //        list2.addAll(list);
          /*
              所有的集合都支持一个参数为Collection的构造方法，作用是在创建当前
              集合的同时包含给定集合中的所有元素
           */
          List<String> list2 = new ArrayList<>(list);
          System.out.println("list2:"+list2);
          list2.add("seven");
          System.out.println("list2:"+list2);
      }
  }
  

  集合排序

• （1）java.util.Collections类

  Collections是集合的工具类,里面定义了很多静态方法用于操作集合.

  （2）Collections.sort(List list)方法

  可以对List集合进行自然排序(从小到大)

• package collection;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
  import java.util.Random;
  
  /**
   * 集合的排序
   * 集合的工具类:java.util.Collections提供了一个静态方法sort,可以对List集合
   * 进行自然排序
   */
  public class SortListDemo1 {
      public static void main(String[] args) {
          List<Integer> list = new ArrayList<>();
          Random random = new Random();
          for(int i=0;i<10;i++){
              list.add(random.nextInt(100));
          }
          System.out.println(list);
          Collections.sort(list);
          System.out.println(list);
      }
  }
  

  重载的Collections.sort(List list,Comparator c)方法

• package collection;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.List;
  
  /**
   * 排序自定义类型元素
   */
  public class SortListDemo2 {
      public static void main(String[] args) {
          List<Point> list = new ArrayList<>();
          list.add(new Point(1,2));
          list.add(new Point(97,88));
          list.add(new Point(7,6));
          list.add(new Point(9,9));
          list.add(new Point(5,4));
          list.add(new Point(2,3));
  
          System.out.println(list);
          /*
              Collections.sort(List list)在排序List集合时要求集合元素必须实现了
              Comparable接口。实现了该接口的类必须重写一个方法compareTo用与定义比较
              大小的规则，从而进行元素间的比较后排序。否则编译不通过。
  
              侵入性:
              当我们调用某个API时，其反过来要求我们为其修改其他额外的代码，这种现象就
              成为侵入性。侵入性不利于程序后期的维护，尽可能避免。
              compare:比较
           */
  //        Collections.sort(list);
  
           //匿名内部类的形式创建一个比较器
          Comparator<Point> com = new Comparator<Point>() {
              @Override
              /**
               * 实现比较器接口后必须重写方法compare.
               * 该方法用来定义参数o1与参数o2的比较大小规则
               * 返回值用来表示o1与o2的大小关系
               */
              public int compare(Point o1, Point o2) {
                  int len1 = o1.getX() * o1.getX() + o1.getY() * o1.getY();
                  int len2 = o2.getX() * o2.getX() + o2.getY() * o2.getY();
                  return len1-len2;
              }
          };
          Collections.sort(list,com);//回调模式
  
  
  
          System.out.println(list);
      }
  }
  

  （6） 排序字符串

  java中提供的类,如:String,包装类都实现了Comparable接口,但有时候这些比较规则不能满足我们的排序需求时,同样可以临时提供一种比较规则来进行排序

• package collection;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.List;
  
  public class SortListDemo3 {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
  //        list.add("Tom");
  //        list.add("jackson");
  //        list.add("rose");
  //        list.add("jill");
  //        list.add("ada");
  //        list.add("hanmeimei");
  //        list.add("lilei");
  //        list.add("hongtaoliu");
  //        list.add("Jerry");
  
          list.add("传奇");
          list.add("小泽老师");
          list.add("苍老师");
          System.out.println(list);
          
          //按照字符多少排序
  //        Collections.sort(list);
  //        Collections.sort(list, new Comparator<String>() {
  //            public int compare(String o1, String o2) {
                  return o1.length()-o2.length();
  //                return o2.length()-o1.length();//反过来减就是降序
  //            }
  //        });
  
          Collections.sort(list,(o1,o2)->o2.length()-o1.length());
          System.out.println(list);
      }
  }
  

  .