2020年Java集合课堂笔记

Java集合

1.集合概述

集合:集合是java中提供的一种容器,可以用来存储多个数据。

集合与数组的区别:

  • 数组长度固定,集合长度可变
  • 数组只能存储类型相同的元素,集合存储对象,对象类型可以不同

集合框架

在这里插入图片描述

2.Collection接口

Collection是所有单列集合的根接口,方法可用于操作所有单列集合

Collection接口的主要方法

方法声明功能描述
boolean add(Object o)向集合中添加一个元素
boolean addAll(Collection c)将集合c中的所有元素添加到该集合中
void clear()删除该集合的所有元素
boolean remove(Object o)删除该集合中的o
boolean removeAll(Collection c)删除该集合中包含集合c中的所有集合
boolean isEmpty()判断该集合是否为空
boolean contains(Object o)判断该集合中是否包含元素o
boolean containsAll(Collection c)判断该集合是否包含集合c的所有元素
int size()判断该集合元素的个数
Iterator iterator()用于遍历该集合的所有元素
Stream stream()将集合源转换为有序元素的流对象

3.List接口

List接口简介

List集合:实现了List接口的对象

List集合特点

  • 允许出现重复的元素
  • 元素有序

List集合的常用方法

方法声明功能描述
void add(int d,Object e)在该集合位置d插入元素e
boolean addAll(int i,Collection c)将集合c中的所有元素插入该集合位置i
Object get(int d)返回该集合位置d的元素
Object remove(int d)删除该集合位置d的元素
Object set(int d,Object e)将该集合位置d的元素替换成e,并返回替换值
int indexOf(Object e)返回元素e在集合中第一次出现的位置索引
int lastIndexOf(Object e)返回元素e在集合中最后一次出现的位置索引
List subList(int f,int t)返回该集合中位置f~t之间所有元素组成的子集合
Object[] toArray()将集合元素转换为数组

ArrayList集合

架构:数组

作用:适用于遍历查找元素

缺点:不适合对集合元素做大量增删操作

实例代码

import java.util.ArrayList;

public class Example{
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("23");
        arrayList.add("23");
        arrayList.add("23");
        arrayList.add("23");
        arrayList.set(3, "1");
        System.out.println(arrayList.size());  //4
        System.out.println(arrayList.get(3));  //1
    }
}

LinkedList集合

架构:双向循环链表

作用:更高效的增加和删除集合中的元素

LinkedList特有方法

方法声明功能描述
void add(int d,E e)在该集合位置d插入元素e
void addFirst(object o)在该集合开头插入元素o
void addLast(object o)在该集合结尾插入元素o
Object removeFirst()删除该集合开头的元素,并返回该元素
Object removeLast()删除该集合结尾的元素,并返回该元素
boolean offerFirst(Object o)在该集合开头插入元素o
boolean offer(Object o)在该集合结尾插入元素o
boolean offerLast(Object o)在该集合结尾插入元素o
Object peek()获取该集合开头的元素
Object peekLast()获取该集合结尾的元素
Object poll()删除并返回该集合的开头元素
Object pollLast()删除并返回该集合的结尾元素
void push(Object o)在该集合开头插入元素o
Object pop()删除并返回该集合的开头元素

实例代码

import java.util.LinkedList;

public class Example{
    public static void main(String[] args) {
        LinkedList link = new LinkedList();
        //1.添加元素
        link.add("stu1");
        link.add("stu2");
        System.out.println(link);  //[stu1, stu2]
        link.offer("offer");//在集合结尾添加
        link.push("push");//在集合开头添加
        System.out.println(link);  //[push, stu1, stu2, offer]
        //2.获取元素
        Object peek = link.peek();
        System.out.println(peek); //push
        //3.删除元素
        link.removeFirst();
        link.pollLast();
        System.out.println(link); //[stu1, stu2]
    }
}

4.3种Collection集合遍历

Iterator遍历集合

Iterator接口 ,Iterator对象被称为迭代器

作用:遍历Collection中的元素

遍历集合过程

  1. 调用集合对象的iterator()方法获得迭代器对象

  2. 使用迭代器对象的hashNext()方法判断集合是否存在下一个元素

  3. 判断结果为true,则调用next()方法取出元素,

    判断结果为false,则遍历结束

实例代码

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

public class Example{
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("data1");
        list.add("data2");
        list.add("data3");
        list.add("data4");
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println( iterator.next());
        }
    }
}

forEach遍历集合

foreach循环是一种更加简洁的for循环,也叫加强for循环

for(容器中元素类型 临时变量 : 容器变量){
    //执行语句
}

注意:foreach循环过程中,不能对元素的值进行修改

实例代码

public class Example{
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("data1");
        list.add("data2");
        list.add("data3");
        list.add("data4");
        for (Object o : list) {
            System.out.println(o);
        }
    }
}

JDK8的forEach遍历集合

forEach(Consumer action)方法,方法的参数是一个函数式接口。

实例代码

import java.util.ArrayList;

public class Example{
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("data1");
        list.add("data2");
        list.add("data3");
        list.add("data4");
        list.forEach(obj-> System.out.println("迭代集合元素:"+obj));
    }
}

5.Set接口

Set接口简介

set集合特点

  • 不允许存在重复元素
  • 元素无序

HashSet集合

Set接口的一个实现类,特点和Set接口一样

实例代码

import java.util.Iterator;

public class Example{
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        hashSet.add("stu1");
        hashSet.add("stu2");
        hashSet.add("stu2");
        hashSet.add("stu3");
        System.out.println(hashSet);
        Iterator iterator = hashSet.iterator();
        while(iterator.hasNext()){
            System.out.println("第一种遍历方式:"+iterator.next());
        }
        for (Object i : hashSet) {
            System.out.println("第二种遍历方式:"+i);
        }
        hashSet.forEach(o-> System.out.println("第三种遍历方式:"+o));
    }
}

TreeSet集合

架构:平衡二叉树

TreeSet集合的特有方法

方法声明功能描述
Object first()返回该集合的开头元素
Object last()返回该集合的结尾元素
Object lower(Object o)返回该集合中小于o的最大元素,没有返回null
Object floor(Object o)返回该集合中小于或等于o的最大元素,没有返回null
Object higher(Object o)返回该集合中大于o的最小元素,没有返回null
Object ceiling(Object o)返回该集合中大于或等于o的最小元素,没有返回null
Object pollFirst()删除并返回该集合的开头元素
Object pollLast()删除并返回该集合的结尾元素

实例代码

import java.util.TreeSet;

public class Example{
    public static void main(String[] args) {
       //创建TreeSet集合
        TreeSet ts = new TreeSet();
        ts.add(2);
        ts.add(31);
        ts.add(9);
        ts.add(18);
        ts.add(9);
        System.out.println("创建的TreeSet集合:"+ts);
        //获取首尾元素
        System.out.println("TreeSet首元素:"+ts.first());
        System.out.println("TreeSet结尾元素:"+ts.last());
        //比较并获取元素
        System.out.println("集合中小于或等于10的最大的一个元素"+ts.floor(10));
        System.out.println("集合中大于10的最小的一个元素"+ts.higher(10));
        System.out.println("集合中大于100的最小的一个元素"+ts.higher(100));
        //删除元素
        Object o = ts.pollFirst();
        System.out.println("删除元素:"+o);
        System.out.println("删除元素后的集合:"+ts);
    }
}

TreeSet的排序规则

  1. 自然排序
  • TreeSet集合中存储的元素所在类必须实现Comparable接口,并重写compareTo()方法
  • TreeSet集合会对该类型元素使用compareTo()方法进行比较,默认升序排序

实例代码


import java.util.TreeSet;

class Student implements Comparable{
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return name+":"+age;
    }

    @Override
    public int compareTo(Object obj) {
        Student student = (Student) obj;
        if(this.age-student.age>0){
           return 1;
        }else if(this.age-student.age==0){
            return this.name.compareTo(student.name);
        }
        return -1;
    }
}
public class Example{
    public static void main(String[] args) {
       //创建TreeSet集合
        TreeSet ts = new TreeSet();
        ts.add(new Student("阿凡",19));
        ts.add(new Student("阿凡",23));
        ts.add(new Student("阿凡",6));
        ts.add(new Student("阿凡",23));

        System.out.println(ts); //[阿凡:6, 阿凡:19, 阿凡:23]

    }
}
  1. 定制排序

作用:自定义一个比较器

实例代码

import java.util.Comparator;
import java.util.TreeSet;
//根据首字母大小写排序
class MyComparator implements Comparator{
    @Override
    public int compare(Object o1, Object o2) {
        String name1 = (String) o1;
        String name2 = (String) o2;
        StringBuffer sb1 = new StringBuffer(name1);
        StringBuffer sb2 = new StringBuffer(name2);
        int temp = (int)sb1.charAt(0) - (int)sb2.charAt(0);
        return temp; //由低到高排序

    }
}
public class Example{
    public static void main(String[] args) {
       //创建TreeSet集合
        TreeSet ts = new TreeSet(new MyComparator());
        ts.add("Jack");
        ts.add("Tom");
        ts.add("Nancy");
        ts.add("Afan");
        System.out.println(ts); //[Afan, Jack, Nancy, Tom]
    }
}

6.Map接口

Map接口简介

Map接口是一种双列集合,它的每个元素都包含一个键对象Key和值对象Value,键和值对象之间存在一种对应关系,称为映射。Map的映射关系是一对一的。

特点:

  • Key与Value可以是任意数据类型
  • 键对象Key不可以重复

Map集合常用方法

方法声明功能描述
void put(Object k,Object v)往集合中添加键值对
int size()返回键值对的个数
Object get(Object k)根据键k得到值,没有则返回null
boolean containsKey(Object k)判断集合是否存在键k
boolean containValue(Object v)判断集合是否存在值v
Object remove(Object k)删除并返回键k对应的键值对
void clear()清空Map集合
Set keySet()将键转化为Set集合
Collection values()将值转化为Collection集合
Set<Map.Entry<K,V>>entrySet()将Map集合转化为存储类型为Map的Set集合
Object getOrDefault(Object k,Object dv)返回键k对应的值,没有则返回dv
Object putIfAbsent(Object k,Object v)添加键值对,重复则返回返回已存在值v
boolean remove(Object k,Object v)删除
boolean replace(Object k,Object v)将制定键k对应的值修改为值v

HashMap集合

架构:数组+链表

HashMap集合特点

  • 键和值允许为空,但键不能重复
  • 集合中的元素是无序的

实例代码

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Example{
    public static void main(String[] args) {
        Map map = new HashMap();
        //向Map存储键值对
        map.put(1,"Tom");
        map.put(2,"Afan");
        map.put(3,"Nancy");
        map.put(4,"Li");
        map.put(1,"Jack");
        System.out.println(map);
        //查看键对象是否存在
        System.out.println(map.containsKey(5));
        //将键转化为Set集合
        Set set = map.keySet();
        System.out.println(set);
        //获取指定键对象映射的值
        Object o = map.get(2);
        System.out.println(o);
        //替换指定键对应的值
        map.replace(3,"阿凡");
        System.out.println(map);
        //删除指定键映射的键值对元素
        map.remove(1);
        System.out.println(map);
    }
}

Map集合遍历

  1. Iterator迭代器遍历Map集合

    过程:

    1. 将Map集合转化为Iterator接口对象
    2. 两种方式遍历集合(KeySet()方法和entrySet()方法)

    实例代码1

    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    
    public class Example{
        public static void main(String[] args) {
            Map map = new HashMap();
            //向Map存储键值对
            map.put(1,"Tom");
            map.put(2,"Afan");
            map.put(3,"Nancy");
            map.put(4,"Li");
            map.put(5,"Jack");
            //keySet()方法
            Iterator iterator = map.keySet().iterator();
            while(iterator.hasNext()){
                Object key = iterator.next();
                Object value = map.get(key);
                System.out.println(key+":"+value);
            }
        }
    }
    

    实例代码2

    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    public class Example{
        public static void main(String[] args) {
            Map map = new HashMap();
            //向Map存储键值对
            map.put(1,"Tom");
            map.put(2,"Afan");
            map.put(3,"Nancy");
            map.put(4,"Li");
            map.put(5,"Jack");
            //entrySet()方法
            Set set = map.entrySet();
            Iterator iterator = set.iterator();
            while(iterator.hasNext()){
                Map.Entry next = (Map.Entry) iterator.next();
                Object key = next.getKey();
                Object value = next.getValue();
                System.out.println(key+":"+value);
            }
        }
    }
    

注意:Entry是Map接口的内部类

  1. 使用forEach()方法遍历集合

    实例代码

    import java.util.HashMap;
    import java.util.Map;
    public class Example{
        public static void main(String[] args) {
            Map map = new HashMap();
            //向Map存储键值对
            map.put(1,"Tom");
            map.put(2,"Afan");
            map.put(3,"Nancy");
            map.put(4,"Li");
            map.put(5,"Jack");
    
            map.forEach((key,value)-> System.out.println(key+":"+value));
        }
    }
    

LinkedHashMap集合

LinkedHashMap类是HashMap的子类,内部是双向链表

作用:保证元素取出顺序与存入顺序一致

实例代码

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
public class Example{
    public static void main(String[] args) {
        Map map = new HashMap();
        //向Map存储键值对
        map.put(4,"Tom");
        map.put(3,"Afan");
        map.put(2,"Nancy");
        map.put(1,"Li");
        System.out.println(map);
        System.out.println("-------两者比较---------");
        LinkedHashMap map2 = new LinkedHashMap();
        map2.put(4,"Tom");
        map2.put(3,"Afan");
        map2.put(2,"Nancy");
        map2.put(1,"Li");
        System.out.println(map2);
    }
}

TreeMap集合

架构:二叉树,用法参考TreeSet集合

实例代码

import java.util.*;

class MyComparator implements Comparator{

    @Override
    public int compare(Object o1, Object o2) {
        String key1 = (String)o1;
        String key2 = (String)o2;
        return key1.compareTo(key2);
    }
}
public class Example{
    public static void main(String[] args) {
        Map map = new TreeMap(new MyComparator());
        map.put("2","Li");
        map.put("1","Afan");
        map.put("3","Tom"); //两个参数必须是String类型,否则异常
        System.out.println(map);
    }
}

Properties集合

Properties类是Hashtable类的子类

实例代码

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Properties;

public class Example{
    public static void main(String[] args) throws Exception {
        //1.通过Properties进行属性文件读取操作
        Properties pps = new Properties();
        //加载要读取的文件
        pps.load(new FileInputStream("test.properties"));
        //遍历test.Properties键值对信息
        pps.forEach((key,value)-> System.out.println(key+"="+value));
        //2.通过Properties进行属性文件读取操作
        //指定要写入操作的文件名称和位置
        FileOutputStream out = new FileOutputStream("test.properties");
        //向properties文件进行写入键值对信息
        pps.setProperty("charset","UTF-8");
        //将此新添键值对写入配置文件
        pps.store(out,"新增charset编码");
    }
}

7.泛型

作用:防止程序运行时出现类型转换异常

具体格式:

ArrayList<参数化类型> list = new ArrayList<参数化类型>();

8.常用工具类

Collection工具类

作用:集合工具类,提供了大量静态方法用于对集合中元素进行排序、查找和修改

  1. 添加、排序操作
方法声明功能描述
staticboolean addAll(Collection<?super T>c,T…e)将所有指定元素添加到指定集合c中
static void reverse(List list)反转指定List集合中元素的顺序
static void shuffle(List list)对List集合中的元素随机排序
static void sort(List list)对List集合中的元素自然排序
static void swap(List list,int i,int j)将指定List集合第i和j处的元素交换

实例代码

import java.util.ArrayList;
import java.util.Collections;

public class Example{
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"c","z","a","w");
        System.out.println("排序前:"+list);
        Collections.reverse(list);
        System.out.println("反转后:"+list);
        Collections.sort(list);
        System.out.println("自然排序后:"+list);
        Collections.shuffle(list);
        System.out.println("随机打乱后:"+list);
        Collections.swap(list,0,list.size()-1);
        System.out.println("首尾元素位置交换:"+list);
    }
}
  1. 查找、替换操作
方法声明功能描述
static int binarySearch(List,Object k)二分法搜索指定对象在List集合中的索引(查找的元素必须是有序的)
static Object max(Collection col)根据元素的自然顺序,返回给定集合中最大的元素
static Object min(Collection col)根据元素的自然顺序,返回给定集合中最小的元素
static boolean replaceAll(List list,Object o,Object n)用n替换集合list里所有的o

实例代码

import java.util.ArrayList;
import java.util.Collections;

public class Example{
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,9,0,4,2,1,0,6);
        System.out.println("集合中的元素:"+list);
        System.out.println("集合中最大元素"+ Collections.max(list));
        System.out.println("集合中最小元素"+ Collections.min(list));
        Collections.replaceAll(list,8,0);
        System.out.println("替换后的集合:"+list);
        Collections.sort(list);
        int index = Collections.binarySearch(list, 2);
        System.out.println("集合通过二分查找法查找元素2的索引:"+index);

    }
}

Arrays工具类

作用:数组工具类,提供了大量针对数组操作的静态方法。

  1. 使用sort()方法排序

    实例代码

    import java.util.Arrays;
    
    public class Example{
        public static void main(String[] args) {
           int[] arr = {2,5,2,4,1,6,8};
            System.out.println("排序前:");
            printArray(arr);
            Arrays.sort(arr);
            System.out.println("排序后:");
            printArray(arr);
        }
        public static void printArray(int[] arr){
            for (int i : arr) {
                System.out.print(i+" ");
            }
            System.out.println();
        }
    }
    
  2. 使用binarySearch(Object[] a,Object key)方法查找元素

    实例代码

    import java.util.Arrays;
    
    public class Example{
        public static void main(String[] args) {
          int[] arr = {9,3,8,2,1};
          Arrays.sort(arr);
          int index = Arrays.binarySearch(arr, 1);
          System.out.println("元素1的索引:"+index);
        }
    }
    

    注意:二分法前提是这是有序数组

  3. copyOfRange(int[] original,int from,int to)方法拷贝元素

    实例代码

    import java.util.Arrays;
    
    public class Example{
        public static void main(String[] args) {
            int[] arr = {9,3,8,2,1};
            int[] copied = Arrays.copyOfRange(arr,2,8);
            for (int i = 0; i < copied.length; i++) {
                System.out.print(copied[i]+" "); //8 2 1 0 0 0 
            }
        }
    }
    
  4. 使用fill(Object[] a,Object val)方法替换元素

    实例代码

    import java.util.Arrays;
    
    public class Example{
        public static void main(String[] args) {
           int arr[] = {1,2,3,4};
           Arrays.fill(arr,8);
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i]+" "); //8 8 8 8 
            }
        }
    }
    

9.聚合操作

聚合操作简介

​ JDK8增加了一个Stream接口,该接口可以将集合、数组中的元素转换为Stream流的形式,并结合Lamabda表达式的优势来进一步简化集合、数组中的查找、过滤、转换等操作,这一功能称为聚合操作

使用聚合操作的3个步骤

  1. 将原始集合或数组对象转换为Stream流对象。
  2. 对Stream流对象中的元素进行一系列的过滤、查找等中间操作,然后仍返回一个Stream流对象。
  3. 对Stream流进行遍历、统计、收集等终结操作,获取想要的结果。

实例代码

import java.util.ArrayList;
import java.util.stream.Stream;

public class Example{
    public static void main(String[] args) {
        //创建一个List集合对象
        ArrayList<String> list = new ArrayList<>();
        list.add("阿凡");
        list.add("张三");
        list.add("李四");
        list.add("王五");
        //创建一个Stream流对象
        Stream<String> stream = list.stream();
        //链式调用
        stream.filter(i->i.startsWith("张")).limit(2)
                .forEach(j-> System.out.println(j));
    }
}

创建Stream流对象的三种方式

  • 所有的Collection集合都可以使用stream()静态方法获取Stream流对象

  • Stream接口的of()静态方法可以获取基本类型包装类数组、引用类型数组和单个元素的

    Stream流对象

  • Arrays数组工具类的stream()静态方法可以获取数组元素的Stream流对象

实例代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.Stream;

public class Example{
    public static void main(String[] args) {
        //创建一个List集合对象
        Integer[] arr = {2,3,7,5,0,1};
        ArrayList<String> list = new ArrayList<>();
        list.add("阿凡");
        list.add("张三");
        list.add("李四");
        list.add("王五");
        //创建一个Stream流对象
        Stream<String> stream1= list.stream();
        stream1.forEach(o-> System.out.print(o+" "));
        System.out.println();
        Stream<Integer> stream2 = Stream.of(arr);
        stream2.forEach(o-> System.out.print(o+" "));
        System.out.println();
        Stream<Integer> stream3 = Arrays.stream(arr);
        stream3.forEach(o-> System.out.print(o+" "));
        System.out.println();
    }
}

Stream流的常用方法

Stream流的常用方法

方法声明功能描述
Stream filer(函数式接口)将指定流对象中的元素进行过滤,并返回一个子流对象
Streammap(Function函数式接口)将流中的元素按规则映射到另一个流中
Stream distinct()删除流中的重复元素
Stream sorted()将流中的元素按自然顺序排序
Stream limit(long max)截取流中元素的长度
Stream skip(long n)跳过流中的前n个元素
staticStream concat(Stream 1,Stream 2)将两个流合并为一个流
long count()统计流中的元素个数
R collect(Collector collector)将流中的元素收集到一个容器中(如集合)
Object[] toArray()将流中的元素收集到一个数组中
void forEach(Lamabda表达式)将流中的元素进行遍历
  1. 遍历

实例代码

import java.util.stream.Stream;

public class Example{
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张三", "李四", "阿凡", "张晓明");
        stream.forEach(o-> System.out.println(o));
    }
}
  1. 过滤

实例代码

public class Example{
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张三", "李四", "阿凡", "张晓明");
        stream.filter(i->i.startsWith("张"))
                .filter(i->i.length()>2)
                .forEach(System.out::println);
    }
}
  1. 映射

实例代码

import java.util.stream.Stream;

public class Example{
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("a1","a2","b1","c1","c2");
        stream.filter(s->s.startsWith("c"))
                .map((String s)->s.toUpperCase() )
                .sorted()
                .forEach(i-> System.out.println(i));

    }
}
  1. 截取

实例代码

import java.util.stream.Stream;

public class Example{
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张三","李四","张晓明","张阳");
        stream.skip(1)  
                .limit(2)
                .forEach(i-> System.out.println(i));
        
    }
}
  1. 收集

作用:终结操作,把Stream元素保存为集合、字符串等。

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Example{
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("张三","李四","张晓明","张阳");
        List<String> list = stream.filter(i -> i.startsWith("张"))
                .collect(Collectors.toList());
        System.out.println("转化为集合:"+list);
        //转化为集合:[张三, 张晓明, 张阳]
        Stream<String> stream2 = Stream.of("张三","李四","张晓明","张阳");
        String str = stream2.filter(i -> i.startsWith("张"))
                .collect(Collectors.joining("and"));
        System.out.println("转化为字符串:"+str);
        //转化为字符串:张三and张晓明and张阳
    }
}

注意:一个Stream流对象可以有多次中间操作,仍返回一个流对象,

​ 一个流对象只能进行一次终结操作,且一旦进行,该流对象就不复存在。

Parallel Stream(并行流)

之前介绍的创建Stream流对象的3种方式都是串行流,即单线程下执行聚合操作的流

并行流将源数据分为多个子流对象支持多线程操作,最后结果汇总为一个流对象

创建并行流的两种方式

  1. 通过Collection集合接口的parallelStream()方法直接将集合类型的源数据转变为Stream并行流
  2. BaseStream接口的parallel()方法将Stream串行流转变为Stream并行流,还有一个isParallel()方法用于判断当前Stream流对象是否是并行流。

实例代码

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Example{
    public static void main(String[] args) {
        List<String> list = Arrays.asList("张三", "李四", "张晓明", "张阳");
        Stream<String> parallelStream = list.parallelStream();
        System.out.println(parallelStream.isParallel());  //true
        Stream<String> stream = Stream.of("张三", "李四", "张晓明", "张阳");
        Stream<String> parallel = stream.parallel();
        System.out.println(parallel.isParallel());  //true

    }
}
  • 2
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值