Java集合框架

什么是集合

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

java集合框架中相关接口

java.util.Collection接口:

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

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

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

这里可重复指的是集合中的元素是否可以重复,而判定重复元素的标准是依靠元素自身equals比较

的结果.为true就认为是重复元素.

 

常用方法:

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

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

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

void clear():清空集合

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());
​
​
   }
}

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

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

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
​
public class CollectionDemo2 {
   public static void main(String[] args) {
//        Collection c = new ArrayList();
       Collection c = new HashSet();
       c.add(new Point(1,2));
       c.add(new Point(3,4));
       c.add(new Point(5,6));
       c.add(new Point(7,8));
       c.add(new Point(1,2));
       /*
           集合重写了Object的toString方法，输出的格式为:
           [元素1.toString(), 元素2.toString(), ....]
        */
       System.out.println(c);
​
       Point p = new Point(1,2);
       /*
           boolean contains(Object o)
           判断当前集合是否包含给定元素，这里判断的依据是给定元素是否与集合
           现有元素存在equals比较为true的情况。
        */
       boolean contains = c.contains(p);
       System.out.println("包含:"+contains);
       /*
           remove用来从集合中删除给定元素，删除的也是与集合中equals比较
           为true的元素。注意，对于可以存放重复元素的集合而言，只删除一次。
        */
       c.remove(p);
       System.out.println(c);
   }
}

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

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

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

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);
   }
}

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

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

 

迭代器

java.util.Iterator

迭代器用于遍历集合，不同的集合都提供了一个用于遍历自身元素的迭代器实现类。

使用迭代器遍历集合遵循的过程为:问->取->删。其中删除不是必要操作。

常用方法

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

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

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

import java.util.ArrayList;
import java.util.Collection;
import java.util.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);
​
   }
}

 

集合转换为数组的操作

集合转换为数组，使用集合的toArray方法即可。 数组转换为集合，只能转换为List集合，使用的是Arrays.asList()方法。

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);
​
       String[] array = list.toArray(new String[list.size()]);
       System.out.println(array.length);
       System.out.println(Arrays.toString(array));
   }
}

 

import java.util.*;
​
/**
* 数组转换为集合
* 数组的工具类java.util.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));
​
       //asList方法会返回Arrays定义的内部类ArrayList,该集合内部直接引用给定数组array
       List<String> list = Arrays.asList(array);
       System.out.println("list:"+list);
       //因为集合直接引用数组array,所以对该集合操作就是对array数组的操作
       list.set(1,"six");
       System.out.println("list:"+list);
       System.out.println("array:"+ Arrays.toString(array));
       //对数组操作后,集合也会改到改变.
       array[2] = "seven";
       System.out.println("array:"+ Arrays.toString(array));
       System.out.println("list:"+list);
//        list.add("!!!!!");
​
       /*
           如果我们需要增删元素,可另行创建一个集合同时包含该集合元素即可.
        */
       List<String> list2 = new ArrayList<>(list);//等同于先new再addAll()
//        Set<String> set = new HashSet<>(list);//等同于先new再addAll()
​
       System.out.println("list2:"+list2);
       list2.add("!!!!");
       System.out.println("list2:"+list2);
​
​
   }
}