Java集合

最新推荐文章于 2024-05-25 15:56:40 发布

爱学习的小段

最新推荐文章于 2024-05-25 15:56:40 发布

阅读量982

点赞数 2

分类专栏：学习文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_57457954/article/details/124502277

版权

学习专栏收录该内容

21 篇文章 0 订阅

订阅专栏

Java集合

为了保存这些数目不确定的对象，Java中提供了一系列特殊的类，统称为集合，集合可以存贮任意类型的对象，并且长度可变。
集合类都位于java.util 包中，在使用时一定要注意导包的问题
Collection：单列集合的根接口，用于储存一系列符合某种规则的元素
- Collection集合有两个重要的子接口，分别是List和Set
- List集合的特点是元素有序，可重复
- Set集合的特点是元素无序并且不可重复
- List接口的主要实现类有Arraylist和LinkedList
- Set接口的主要实现类有HashSet和TreeSet
Map：双列口集合的根接口，用于储存具有键（Key），值（Value）映射关系的元素
- Map集合中的每个元素都包含一堆键值，并且Key是唯一的，在使用Map集合是可以通过指定的Key找到对应的Value
- Map接口的主要实现类有HashMap和TreeMap

List接口

List接口继承自Collection接口
List结合中允许出现重复的元素，所有的元素是一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素
List结合元素有序，即存入顺序和取出顺序一致

List集合常用的方法

方法声明	功能描述
add()	向集合添加一个元素
addAll()	将集合c的所有元素插入该集合中
clear()	删除该集合的所有元素
remove()	删除某个元素
removeAll()	删除集合中包含集合c的所有元素
isEmpty()	判断集合是否为空
contains()	判断集合是否包含某个元素
containsAll()	判断集合是否包含某个集合c中的所有元素
size()	获取集合元素的个数
get()	返回集合某处的元素
set()	将索引某处的元素替换，并将替换后的元素返回
indexOf()	返回某元素首次出现的位置
subList()	返回从[ )之间按的元素
toArray()	将集合元素转换为数组

ArrayList集合

ArrayList内部封装了一个长度可变的数组对象（可看作一个长度可变的数组）
ArrayList内部的数据存储结构式数组形式，增加和删除元素的效率低，遍历和查找的效率高

package top.dty.collection;

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

public class TestArrayList {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        //添加元素
        arrayList.add("10");
        arrayList.add("20");
        arrayList.add("30");
        arrayList.add("40");
        //集合的长度
        System.out.println(arrayList.size());
        //得到第二个元素，索引是从0开始的
        System.out.println(arrayList.get(1));
        //判断集合是否为空
        System.out.println(arrayList.isEmpty());
        //寻找某元素的位置
        System.out.println(arrayList.indexOf("40"));
        //返回某位置之间的元素[ )
        System.out.println(arrayList.subList(0,2));

        ArrayList arrayList1 = new ArrayList();
        arrayList1.add("50");
        System.out.println(arrayList1.addAll(arrayList));
        //将集合元素转换为数组
        Object[] objects = arrayList1.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
    }
}

LinkedList集合

ArrayList集合在查询元素时速度很快，但在增删元素效率较低
LinkedList集合是一个双向循环链表
LinkedList集合对于元素的增删操作效率很高，遍历和查找的效率低

方法声明	功能描述
push()	在集合首部添加元素
removeFirst()	删除集合第一个
pollLast()	删除集合最后一个元素
peek()	获取集合第一个元素

package top.dty.collection;

import java.util.LinkedList;

public class TestLinkedList {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        //添加元素
        linkedList.add("str1");
        linkedList.add("str2");
        System.out.println(linkedList);

        //在集合首部添加元素
        linkedList.push("first" );
        System.out.println(linkedList);

        //获取集合第一个元素
        Object o = linkedList.peek();
        System.out.println(o);

        //删除集合第一个和最后一个元素
        linkedList.removeFirst();
        linkedList.pollLast();
        System.out.println(linkedList);
    }
}

Collection集合遍历

Iterator遍历集合

Iterator主要用于迭代访问（遍历）Collection中的元素，因此Iterator对象也被称为迭代器

当遍历集合时，首先通过调用t集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素
在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历

package top.dty.collection;

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

public class TestIterator {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("10");
        arrayList.add("20");
        arrayList.add("30");
        
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
            Object o = iterator.next();
            System.out.println(o);
        }
        
    }
}

foreach遍历集合

foreach循环是一种更见简洁的佛如循环，也称增强for循环

for (Object o : arrayList) {
    System.out.println(o);
}

foreach循环在循环遍历集合和数组，只能访问集合中的元素不能对其中的元素进行修改

用forEach()方法来遍历函数

迭代器forEachRemaining()方法来遍历

package top.dty.collection;

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

public class TestForeach {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("10");
        arrayList.add("20");
        arrayList.add("30");
        for (Object o : arrayList) {
            System.out.println(o);
        }
        System.out.println("==========");
        //用forEach()方法来遍历函数
        arrayList.forEach((obj-> System.out.println(obj)));
        System.out.println("==========");
        //迭代器forEachRemaining()方法来遍历
        Iterator iterator = arrayList.iterator();
        iterator.forEachRemaining((obj-> System.out.println(obj)));
    }
}

Set接口

Set接口继承自Collection接口，比Collection接口更加严格
Set接口中的元素无序，并且以某种给规则保证存入的元素不会重复
Set接口主要有两个实现类，分别是HashSet和TreeSet
HashSet是根据对象的哈希值来确定元素在集合中的存储位置，具有良好的存取和查找性能
TreeSet是以二叉树的方式来存储元素，可以实现对集合中的元素进行排序

HashSet集合

无序不重复,集合内元素顺序与添加时元素顺序不一致
HashSet集合之所以能确保不出现重复的元素,是因为它在存入元素时做了很多工作。当调用HashSet集合的add()方法存入元素时，首先调用当前存入元素的hashCode()方法获得对象的哈希值，然后根据对象的哈希值计算出一个存储位置;如果该位置上没有元素，则直接将元素存人;如果该位置上有元素存在，则会调用equals()方法让当前存入的元素依次和该位置上的元素进行比较。如果返回的结果为false 就将该元素存入集合;返回的结果为true则说明有重复元素，就将该元素舍弃。

package top.dty.collection;

import java.util.HashSet;
//重写hashCode()和equals()方法
public class TestHashSet {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        hashSet.add("jack");
        hashSet.add("eve");
        hashSet.add("rose");
        hashSet.add("jack");
        hashSet.forEach(o -> System.out.println(o));

        HashSet hs = new HashSet();
        Student student1 = new Student("1","xiao");
        Student student2 = new Student("2","duan");
        Student student3 = new Student("2","duan");
        hs.add(student1);
        hs.add(student2);
        hs.add(student3);
        System.out.println(hs);
    }
}
class Student{
    private String id;
    private String name;

    public Student() {
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
    public int hashCode(){
        return id.hashCode();
    }
    public boolean equals(Object obj){
        if(this == obj){
            return true;
        }
        if(!(obj instanceof Student)){
            return false;
        }
        Student stu = (Student) obj;
        boolean b = this.id.equals(stu.id);
        return b;
    }
}

TreeSet集合

TreeSet是Set接口的另一个实现类，它内部采用平衡二叉树来存储元素，这样的结构可以保证TreeSet集合没有重复分元素，并且可以对元素进行排序

常用方法

方法声明	功能描述
first()	获取首个元素
last()	获取最后一个元素
floor()	获取集合中小于或等于*的最大一个元素
higher()	获取集合大于*的最小一个元素
pollFirst()	删除第一个元素，并返回对象
pollLast()	删除最后一个元素，并返回对象

package top.dty.collection;

import java.util.TreeSet;

public class TestTreeSet {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        //添加元素
        treeSet.add(5);
        treeSet.add(10);
        treeSet.add(1);
        treeSet.add(7);
        System.out.println(treeSet);
        //获取首个元素
        System.out.println(treeSet.first());
        //获取最后一个元素
        System.out.println(treeSet.last());
        //集合中小于或等于*的最大一个元素
        System.out.println(treeSet.floor(9));
        //集合大于*的最小一个元素
        System.out.println(treeSet.higher(4));
        System.out.println(treeSet.higher(10));
        //删除元素，并返回对象
        Object o = treeSet.pollFirst();
        System.out.println(o);
        System.out.println(treeSet);
    }
}

Java提供了两种TreeSet的排序规则，分别是：自然排序和定制排序

自然排序

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

package top.dty.collection;

import java.util.TreeSet;

public class TestTreeSet02 {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        treeSet.add(new Teacher("Jack",19));
        treeSet.add(new Teacher("Rose",18));
        treeSet.add(new Teacher("Tom",19));
        treeSet.add(new Teacher("Rose",18));
        System.out.println(treeSet);
    }
}
class Teacher implements Comparable{
    String name;
    int age;

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

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        Teacher teacher = (Teacher) o;
        if(this.age-teacher.age>0){
            return 1;
        }
        if(this.age-teacher.age == 0){
            return this.name.compareTo(teacher.name);
        }
        return -1;
    }
}

定制排序

有自己排序要求的时候使用

创建集合时，传入Comparator接口实现定制排序规则
创建集合时，使用Lambda表达式定制排序规则

package top.dty.collection;

import java.util.Comparator;
import java.util.TreeSet;

public class TestTreeSet03 {
    public static void main(String[] args) {
        //方法1；创建集合时，传入Comparator接口实现定制排序规则
        TreeSet treeSet = new TreeSet((Comparator) new MyComparator());
        treeSet.add("jack");
        treeSet.add("helena");
        treeSet.add("eve");
        System.out.println(treeSet);
        //方法2；创建集合时，使用Lambda表达式定制排序规则
        TreeSet treeSet1 = new TreeSet((obj1,obj2) -> {
            String s1 = (String) obj1;
            String s2 = (String) obj2;
            return s1.length() - s2.length();
        });
        treeSet1.add("jack");
        treeSet1.add("helena");
        treeSet1.add("eve");
        System.out.println(treeSet1);
    }
}
class MyComparator implements Comparator{

    //定制排序方式
    public int compare(Object obj1,Object obj2) {
        String str1 = (String) obj1;
        String str2 = (String) obj2;
        int temp = str1.length()-str2.length();
        return temp;
    }

}

Map接口

Map接口是一种双列集合，它的每个元素都包含一个键对象Key和值对象Value，键和值对象之间存在一种对应关系，称为映射。Map中的映射关系是一对一的，一个键对象Key对于唯一一个值对象Value，其中键对象Key和值对象Value可以时任意数据类型，并且键对象Key不允许重复，这样在访问Map集合中的元素时，只要指定了Key，就能找到对应的Value。

HashMap集合(简单)

HashMap集合是Map接口的一个实现类，它用于储存键值映射关系，该集合的键和值允许为空，但键不能重复，且集合中的元素是无序的
HashMap底层是由哈希表结构组成的，其实就是“数组+链表”的组合体，数组是HashMap的主体结构，链表则主要是为了解决哈希值冲突而存在的分支结构

Map集合常用方法

方法声明	功能描述
put()	向HashMap存储键值对象
containsKey()	查看键对象是否存在
get()	获取指定键对象映射的值
keySet()	获取集合中的键对象
values()	获取集合中的值对象
replac()	替换指定对象映射的值
remove()	删除指定键对象映射的键值对元素

package top.dty.collection;

import java.util.HashMap;

public class TestHashMap {
    public static void main(String[] args) {
        HashMap hashMap = new HashMap();
        //向HashMap存储键值对象
        hashMap.put("1","Jack");
        hashMap.put("2","Rose");
        hashMap.put("3","Luck");
        hashMap.put("4","Luck");
        hashMap.put("1","Tom");
        System.out.println(hashMap);
        //查看键对象是否存在
        System.out.println(hashMap.containsKey("1"));
        //获取指定键对象映射的值
        System.out.println(hashMap.get("1"));
        //获取集合中的键对象和值对象
        System.out.println(hashMap.keySet());
        System.out.println(hashMap.values());
        //替换指定对象映射的值
        hashMap.replace("1","Tom");
        System.out.println(hashMap);
        //删除指定键对象映射的键值对元素
        hashMap.remove("1");
        System.out.println(hashMap);
    }
}

LinkedHashMap集合

LinkedHashMap集合是HashMap的子类，和LinkedList一样也是使用双向链表来维护内部元素的关系，使LinkedHashMap元素迭代的顺序与簇内的顺序一致

package top.dty.collection;

import java.util.HashMap;
import java.util.LinkedHashMap;

public class TestLinkedHashMap {
    public static void main(String[] args) {
        HashMap hashMap = new HashMap();
        hashMap.put("2","Jack");
        hashMap.put("1","Rose");
        hashMap.put("4","Luck");
        hashMap.put("3","Tom");
        System.out.println(hashMap);
        hashMap.forEach((key,value) -> System.out.println(key+":"+value));

        LinkedHashMap linkedHashMap = new LinkedHashMap();
        linkedHashMap.put("2","Jack");
        linkedHashMap.put("1","Rose");
        linkedHashMap.put("4","Luck");
        linkedHashMap.put("3","Tom");
        System.out.println(linkedHashMap);
        linkedHashMap.forEach((key,value) -> System.out.println(key+":"+value));
    }
}

TreeMap集合（简单）

TreeMap集合是Map接口的一个实现类，它用于储存键值映射关系，该集合的键和值允许为空，但键不能重复，且集合中的元素是无序的
在TreeMap内部是通过二叉树的原理来保证键的唯一性
TreeMap中所有的键是按照某种顺序排列的（默认升序）
可以通过比较器Comparator的方式对所有的键进行定制排序

package top.dty.collection;

import java.util.Comparator;
import java.util.TreeMap;

public class TestTreeMap {
    public static void main(String[] args) {
        TreeMap treeMap = new TreeMap(new CustomComparator());
        treeMap.put("2","Rose");
        treeMap.put("1","Jack");
        treeMap.put("3","Luck");
        treeMap.put("1","Tome");
        System.out.println(treeMap);
    }
}
//通过比较器Comparator的方式对键降序排列
class CustomComparator implements Comparator{

    @Override
    public int compare(Object o1, Object o2) {
        String key1 = (String) o1;
        String key2 = (String) o2;
        return key2.compareTo(key1);
    }
}

Properties集合

Map接口还有一个实现类Hashtable，它和HashMap十分相似
Hashtable是线程安全的
Hashtable有一个重要的子类Properties
Properties集合类来存取应用的配置项

package top.dty.collection;

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

public class TestProperties {
    public static void main(String[] args) throws IOException {
        //1.通过Properties进行属性文件读取操作
        Properties properties = new Properties();
        //加载要读取的文件的绝对路径
        properties.load(new FileInputStream("D:\\Application\\IntelliJ IDEA Community Edition 2021.1.2\\JAVASE\\JAVA学习\\src\\txt.properties"));
        //遍历txt.properties键值对元素信息
        properties.forEach((k,v) -> System.out.println(k+":"+v));
        //2.通过Properties进行属性文件写入操作
        //指定要写入操作文件名称和位置
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\Application\\IntelliJ IDEA Community Edition 2021.1.2\\JAVASE\\JAVA学习\\src\\txt.properties");
        //向Properties类文件进行写入键值对信息
        properties.setProperty("charset","UTF-8");
        //将此Properties集合中新增键值对信息写入配置文件
        properties.store(fileOutputStream,"新增charset编码");
    }
}

Map集合遍历

一般使用Iterator迭代器遍历Map集合和forEach(Consumer action)方法遍历结合

Iterator迭代器遍历Map集合

使用Iterator迭代器遍历Map集合，需要先将Map集合转换为Iterator接口对象，然后进行遍历，由于Map集合中元素是由简直对组成的，所以使用Iterator接口遍历Map集合时，会有两种方法keySet()方法和entrySet()方法

keySet()方法

keySet()方法需要先将Map集合中所有舰队下转换为Set单列集合，接着将包含舰队下的Set集合转换为Iterrator接口对象，然后遍历Map集合中所有的键，再根据键获取相应的值

package top.dty.collection;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class TestMapKeySet {
    public static void main(String[] args) {
        HashMap hashMap = new HashMap();
        hashMap.put("1","Jack");
        hashMap.put("2","Rose");
        hashMap.put("3","Luck");
        hashMap.put("4","Tom");
        System.out.println(hashMap);
        //获取键的集合
        Set keySet = hashMap.keySet();
        //迭代键的集合
        Iterator iterator = keySet.iterator();
        while ((iterator.hasNext())){
            Object key = iterator.next();
            Object value = hashMap.get(key);//获取对应键的值
            System.out.println(key+":"+value);
        }
    }

}

entrySet()方法

entrySet()方法将原有Map集合中的键值对作为一个整体返回为Set集合，截至将包含键值对对象的Set集合转换为Interator接口对象，然后获取集合中的所有键值对映射关系，再从映射关系中取出键和值

package top.dty.collection;

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

public class TestMapEntrySet {
    public static void main(String[] args) {
        HashMap hashMap = new HashMap();
        hashMap.put("1","Jack");
        hashMap.put("2","Rose");
        hashMap.put("3","Luck");
        hashMap.put("4","Tom");
        System.out.println(hashMap);
        Set entrySet = hashMap.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()){
            //获取集合中键值对映射关系
            Map.Entry entry = (Map.Entry) (iterator.next());
            Object key = entry.getKey();
            Object value = entry.getValue();
            System.out.println(key+":"+value);
        }
    }

}

forEach(Consumer action)方法遍历结合

package top.dty.collection;

import java.util.Collection;
import java.util.HashMap;

public class TestMapForEach {
    public static void main(String[] args) {
        HashMap hashMap = new HashMap();
        hashMap.put("1","Jack");
        hashMap.put("2","Rose");
        hashMap.put("3","Luck");
        hashMap.put("4","Tom");
        System.out.println(hashMap);
        hashMap.forEach((key,value) -> System.out.println(key+":"+value));
        Collection values = hashMap.values();
        values.forEach(v -> System.out.println(v));
    }
}

泛型

集合可以储存任意类型的对象元素，当把一个对象存入集合后，集合就会”忘记“这个对象的而类型，将该对象从集合中取出时，这个对象的编译类型就统一变成Object类型。
泛型可以限定操作的数据类型，在定义集合类时，可以使用”<参数化类型>“的方式只当该集合中存储的数据类型
```
  ArrayList<参数化类型> list = new ArrayList<参数化类型>();
```

实例

package top.dty.collection;

import java.util.ArrayList;

public class TestGeneric {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("String");
        list.add("Collection");
    for (String s: list) {
            System.out.println(s);
        }
    }
}

集合工具类

Collections工具类

Collections类中提供类名大量的静态方法用于对集合中元素进行排序，查找和修改等操作

常用方法

方法声明	功能描述
addAll()	将所有指定元素添加到指定集合中
reverse()	反转指定List集合中元素的排序
shuffle()	对List集合中的元素进行随机排序
sort()	根据元素的自然排序对List集合中的元素进行排序
swap()	将指定List集合中角标i处元素和j处元素进行交换
max()	根据元素的自然排序，返回给定集合中最大的元素
min()	根据元素的自然排序，返回给定集合中最小的元素
replaceAll()	用一个新值newVal替换List集合中所有的旧值oldVal
binarySearch()	集通过二分搜索指定对象在List集合中的索引，查找的List集合中的元素必须有序

package top.dty.collection;

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

public class TestCollections {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        //将所有指定元素添加到指定集合中
        Collections.addAll(list,"C","Z","B","K");
        System.out.println(list);
        //反转指定List集合中元素的排序
        Collections.reverse(list);
        System.out.println(list);
        //对List集合中的元素进行随机排序
        Collections.shuffle(list);
        System.out.println(list);
        //根据元素的自然排序对List集合中的元素进行排序
        Collections.sort(list);
        System.out.println(list);
        //将指定List集合中角标i处元素和j处元素进行交换
        Collections.swap(list,0,list.size()-1);
        System.out.println(list);

        ArrayList<Integer> arrayList = new ArrayList<>();
        Collections.addAll(arrayList,1,2,-2,5,4,-7);
        System.out.println(arrayList);
        //根据元素的自然排序，返回给定集合中最大的元素
        System.out.println(Collections.max(arrayList));
        //根据元素的自然排序，返回给定集合中最小的元素
        System.out.println(Collections.min(arrayList));
        //用一个新值newVal替换List集合中所有的旧值oldVal
        Collections.replaceAll(arrayList,2,0);
        System.out.println(arrayList);
        //使用二分查找前，必须保证蒜素有序
        Collections.sort(arrayList);
        System.out.println(arrayList);
        //集通过二分搜索指定对象在List集合中的索引，查找的List集合中的元素必须有序
        int i = Collections.binarySearch(arrayList, 4);
        System.out.println(arrayList);
    }
}

Arrays工具类

Arrays工具类除了提供了一个集合工具类Collections，话针对数组操作提供了一个数组工具类——Arrays。Arrays工具类提供了大量针对数组操作的静态方法

通过copyOfRange方法拷贝指定数组中指定长度的数组，超出范围的用默认值0（不怕破坏原数组的情况下）
通过fill方法将一个数组中的所有元素替换成同一个元素

package top.dty.collection;

import java.util.Arrays;

public class TestArrays {
    public static void main(String[] args) {
        int[] arr = {9,8,3,5,2};
        printArray(arr);
        Arrays.sort(arr);
        printArray(arr);
        //集通过二分搜索指定对象在集合中的索引，查找的List集合中的元素必须有序
        int i = Arrays.binarySearch(arr, 3);
        System.out.println(i);
        //通过copyOfRange方法拷贝指定数组中指定长度的数组，超出范围的用默认值0
        int[] copyOfRange = Arrays.copyOfRange(arr, 1, 7);
        printArray(copyOfRange);
        //通过fill方法将一个数组中的所有元素替换成同一个元素
        Arrays.fill(arr,6);
        printArray(arr);
    }

    //定义打印数组元素方法
    public static void printArray(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i != arr.length-1){
                System.out.print(arr[i]+",");
            }else {
                System.out.println(arr[i]+"]");
            }
        }
    }
}

聚合操作（Stream接口）

Stream接口

Stream接口可以将集合，数组中的元素转换为Stream流的形式，并结合Lambda表达式的又是来进一步简化集合，数组中的元素查找，过滤，转换等操作，者一i性能功能就是聚合操作

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

创建Stream流对象

使用集合对象的stream()静态方法创建Stream流对象
使用Stream接口的of()静态方法创建Stream流对象
使用Arrays数组工具的stream()静态方法创建Stream流对象

package top.dty.collection;

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

public class TestStream02 {
    public static void main(String[] args) {
        Integer[] array = {9,8,3,5,2};
        List<Integer> list = Arrays.asList(array);
        //1.使用集合对象的stream()静态方法创建Stream流对象
        Stream<Integer> stream1 = list.stream();
        stream1.forEach(i -> System.out.print(i+" "));
        System.out.println();
        //2.使用Stream接口的of()静态方法创建Stream流对象
        Stream<Integer> stream2 = Stream.of(array);
        stream2.forEach(i -> System.out.print(i+" "));
        System.out.println();
        //3.使用Arrays数组工具的stream()静态方法创建Stream流对象
        Stream<Integer> stream3 = Arrays.stream(array);
        stream3.forEach(i -> System.out.print(i+" "));
        System.out.println();

        Stream<String> stream = Stream.of("a1", "b2", "c3", "d4", "c1", "c6");
        stream.filter(s -> s.startsWith("c"))
                .map(String::toUpperCase)
                .sorted()
                .forEach(System.out::println);

    }
}

Stream流的常用方法

方法声明	功能描述
	中间方法
filter()	将指定流对象中的二元酸进行过滤，并返回一个子流对象
map()	将流中的元素按规则映射到两一个流中
distinct()	删除流中重复的元素
sorted()	将流中的元素按自然顺序排序
limit()	截取流中元素的长度
skip()	丢弃流中前n个元素
long count()	统计流中元素的个数
	终结方法
collect()	将流中的方法收集到一个容器中
toArray()	将流中的元素收集到一个数组中
forEach()	将流中的元素进行遍历

forEach(System.out::println)打印流元素

package top.dty.collection;

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

public class TestStream01 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("小刘");
        list.add("小王");
        list.add("小张");
        list.add("小小段");
        System.out.println(list);
        //1.创建一个Stream流对象
        Stream<String> stream = list.stream();
       //2.对Stream流中的元素分别进行过滤，截取操作
        Stream<String> stream1 = stream.filter(i -> i.startsWith("小"));
        Stream<String> stream2 = stream1.limit(2);
        //3.对Stream流中的元素进行终结操作，进行遍历输出
        stream2.forEach(i -> System.out.println(i));
        System.out.println("==============");
        //通过链式表达式的形式文成聚合操作
        list.stream().filter(i ->i.startsWith("小"))
                .filter(i -> i.length()>2)
                .limit(2)
                .forEach(j -> System.out.println(j));

        List<String> list1 = list.stream().filter(i -> i.startsWith("小"))
                .collect(Collectors.toList());
        System.out.println(list1);

        String collect = list.stream().collect(Collectors.joining("and"));
        System.out.println(collect);
          //统计流中元素个数
        long count = list.stream().count();
        System.out.println(count);
    }
}

Parallel Stream（并行流）

串行流就是将数据转换为一个流对象，然后在单线程执行聚合操作的流（单一管道流），前面所学的Stream就是
并行流就是将源数据分为多个子流对象进行多线程操作（多个管道），然后将处理结果再汇总为一个流对象
串行流和并行流都是属于Stream流对象，拥有相同的方法操作
在创建Stream流对象是，除非特别声明，否则默认创建都是串行流

创建并行流

直接使用Collection接口的parallelStream()创建并行流
使用BaseStream接口的parallel()方法将串行流转变为并行流

package top.dty.collection;

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

public class TestParallelStream {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("张明", "王五", "张伟", "李四", "张三");
        //1.直接使用Collection接口的parallelStream()创建并行流
        Stream<String> parallelStream = list.parallelStream();
        //判断流对象是否是并行流
        System.out.println(parallelStream.isParallel());

        Stream<String> stream = Stream.of("张明", "王五", "张伟", "李四", "张三");
        //2.使用BaseStream接口的parallel()方法将串行流转变为并行流
        Stream<String> parallel = stream.parallel();
        System.out.println(parallel.isParallel());
    }
}