java 数据类型：集合接口Collection之常用ArrayList；lambda表达式遍历；iterator遍历；forEachRemaining遍历；增强for遍历；removeIf批量操作集合元素(Predicate);

java.util.Collection接口

Java的集合主要由两个接口派生出来，一个是Collection一个是Map，本章只记录Collection常用集合

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

集合类是一种特别有用的工具类，它可以存放数量不等的对象，实现常用的数据结构，如栈，队列等。除此之外，Java集合还可用于保存具有映射关系的关联数组。简单的来说，Java集合就是一个容器，可以把多个对象丢进该容器中。

Collection从父类接口Iterable中继承了抽象方法iterator()
所有Collection接口的实现类都需要重写抽象方法iterator()
---所有Collection集合都是可迭代的。

下图是Collection的继承树：

 

 

常用方法：

(1),boolean add(Object o) 向集合中添加一个元素。如果集合对象被添加操作改变了，就返回true。

(2),boolean addAll(Collection c) 把集合c里面的所有元素添加到指定的集合里，如果集合对象被添加操作改变了，那么返回true。

(3),void clear() 清除集合中的所有元素，集合长度将变为0

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

(5),boolean containsAll(Collection c) : 返回集合李是否包含集合c里面的所有元素

(6),boolean isEmpty() : 返回集合是否为空。当集合长度为0的时候返回true，否则返回false。

(7),Interator iterator()：返回一个Iterator对象，用于遍历集合里的元素。

(8),boolean remove(Object o)：删除集合中指定的元素o，当集合中包含一个或者多远元素的o时，该方法值删除第一个符合条件的元素，该方法返回true。

(9),boolean removeAll(Collection c) : 从集合中删除集合c里面包含的所有元素，如果删除了一个或者一个以上的元素，那么返回true.

(10),int size()：返回该方法里面集合元素的个数

(11),Object[] toArray()：把集合转化成一个数组

 

ArrayList

ArrayList类实了接口LIist，List接口继承了Collection接口

特点：有序，可重复

• 有序：存储顺序与添加顺序一样
• 可重复:可以存储重复的数据，List为每个元素指定了索引值，增加了针对索引值的操作
  
  

泛型：

实际应用中，一个集合一般只存储同一类型的数据，可以再定义集合时通过泛型指定存储元素的数据类型
//在定义集合存储String字符串，只需要在接口名Collection后面使用尖括弧<String> 泛型指定存储String
Collection<String> collection = new ArrayList<>();

List 接口实现类对比

• ArrayList:底层数据结构是数组，访问快、添加删除慢，初始化容量10，扩容1.5倍
• Vector：底层也是数组，是线程安全的，初始化容量10，扩容2.0倍
• LinkedList：底层数据结构是双向链表，访问慢、添加删除效率高

双向链表？：如何理解?

 

import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;

/**
 * @ClassName ArrayListExample
 * @projectName: object1
 * @author: Zhangmingda
 * @description： XXX
 * date: 2021/4/8.
 */
public class ArrayListExample {
    public static void main(String[] args) {
        Collection persons = new ArrayList();
        System.out.println(persons.size());//判断集合元素核数
        persons.add("帅哥");
        persons.add("美女");
        persons.add("大爷"); //添加元素
        System.out.println(persons);
        Collection persons2 = new ArrayList();
        persons2.add("QIQI");
        persons2.add("hh");
        persons.add(persons2);
        persons.addAll(persons2); //集合合并
        System.out.println(persons);
        System.out.println(persons.contains("hh")); //判断是否存在元素
        System.out.println(persons.containsAll(persons2));//判断是否存在另一个集合
        System.out.println(persons.isEmpty()); //判断是否为空
        System.out.println(persons.size());
        persons.clear();//清空集合
        System.out.println(persons.size());

        persons.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });
    }
}

1、lambda表达式遍历集合：

java8的Iterable接口新增了一个forEach(Consumer action)默认方法。该方法所需参数的类型是一个函数式接口，而Iterable接口是Collection接口的父接口，因此Collection集合也可以直接调用该方法。

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;

/**
 * @ClassName ArrayListLambdaExample
 * @projectName: object1
 * @author: Zhangmingda
 * @description： XXX
 * date: 2021/4/8.
 */
public class ArrayListLambdaExample {
    public static void main(String[] args) {
        Collection persons = new ArrayList();
        System.out.println(persons.size());//判断集合元素核数
        persons.add("帅哥");
        persons.add("美女");
        persons.add("大爷"); //添加元素
        //查找需要传入的匿名类对象
        persons.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });
        //使用lambda方式遍历
        persons.forEach(o -> System.out.println(o));
    }
}

2、iterator遍历集合：

Iterator也是java集合框架的成员，但是它与Collection系列，Map系列的集合不一样。Collection系列集合，Map系列集合主要用于装其他对象。而Iterator主要用于遍历。

Iterator接口隐藏了各种Collection实现类的底层细节，向应用程序提供了遍历Collection集合元素的统一接口。

Iterator接口提供了如下4个方法：

1. boolean hasNext()：如果被迭代的集合元素没有被遍历完，则返回true
2. Object next(): 返回集合中的下一个元素
3. void remove(): 删除集里里上一次next方法返回的元素。
4. void forEachRemaining(Consumer action)，这是Java8为Iterator新增的默认方法，该方法可以使用Lambda表达式来遍历集合元素。

用法：

调用集合对象的 iterator()方法生成java.util.Iterator对象;再调用Iterator对象的如上方法使用。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * @ClassName ArrayListIteratorExample
 * @projectName: object1
 * @author: Zhangmingda
 * @description： XXX
 * date: 2021/4/9.
 */
public class ArrayListIteratorExample {
    public static void main(String[] args) {
        Collection persons = new ArrayList();
        persons.add("张三");
        persons.add("李四");
        persons.add("王五");
        Iterator personsIter = persons.iterator();//生成可遍历对象
        while (personsIter.hasNext()){
            String person = (String) personsIter.next(); //返回的对象是Object 强制转换为String对象
            System.out.println(person);
            if(person.equals("李四")){
                personsIter.remove(); //移除上一次next()返回的对象，改变ArrayList 集合对象本身
            }
        }
        System.out.println(persons); //[张三, 王五]
    }
}

3、forEachRemaining遍历集合

        Collection persons = new ArrayList();
        persons.add("张三");
        persons.add("李四");
        persons.add("王五");
        Iterator personsIter = persons.iterator();//生成可遍历对象
        //forEachRemaining遍历集合
        personsIter.forEachRemaining(o -> System.out.println(o));

4、增强for循环直接遍历ArrayList对象

        //增强for循环遍历
        for(Object o : persons){
            System.out.println(o);
        }

5、Java8新增的Predicate操作集合(java.util.function.Predicate)：

Java8开始为Collection集合新增了一个removeIf(Predicate filter)方法，该方法会批量的删除符合filter条件的元素。

用法：

集合对象.removeIf(匿名内部类Predicate过滤对象)

import java.util.ArrayList;
import java.util.Collection;

/**
 * @ClassName ArrrayListPredicateExample
 * @projectName: object1
 * @author: Zhangmingda
 * @description： XXX
 * date: 2021/4/9.
 */
public class ArrrayListPredicateExample {
    public static void main(String[] args) {
        Collection languages = new ArrayList();
        languages.add("java");
        languages.add("php");
        languages.add("cpp");
        languages.add("python");
        languages.add("ruby");
        languages.add("golang");
        System.out.println(languages); //[java, php, cpp, python, ruby, golang]
        languages.removeIf(o -> o.toString().length() > 3);
        System.out.println(languages); //[php, cpp]
    }
}

6、通过Predicate函数式接口实现自定义功能方法，比如根据自定义条件筛选符合条件的集合元素个数

Predicate接口test方法要求返回个boolean值

 

 测试示例：

自己通过Predicate实现自定义功能，比如设计一个统计ArrayList集合元素toString长度大于3的个数的功能方法

import java.util.ArrayList;
        import java.util.Collection;
import java.util.function.Predicate;

/**
 * @ClassName ArrrayListPredicateExample
 * @projectName: object1
 * @author: Zhangmingda
 * @description： XXX
 * date: 2021/4/9.
 */
public class ArrrayListPredicateExample {
    private static Object Predicate;

    public static void main(String[] args) {
        Collection languages = new ArrayList();
        languages.add("java");
        languages.add("php");
        languages.add("cpp");
        languages.add("python");
        languages.add("ruby");
        languages.add("golang");
        System.out.println(languages); //[java, php, cpp, python, ruby, golang]
        System.out.println(getLengthNumber(languages, o -> o.toString().length() > 3)); //4
    }
    //自己通过Predicate实现自定义功能，比如设计一个统计ArrayList集合元素toString长度大于3的个数的功能方法
    public static int getLengthNumber(Collection collection, Predicate predicate){
        int total = 0;
        for(Object o : collection){
            if(predicate.test(o)){
                total++;
            }
        }
        return total;
    }
}