JAVA—集合框架

news2024/11/26 4:48:18

         集合 大小可变 是存储数据的容器，本文是在学习过ArrayList集合后对于集合进行一个比较系统的学习，只要是对于Collection类和Map类的学习和案例实践。需要对于Stream流再进行加深学习和理解，功能比较强大和简洁。

目录

1.集合体系结构

（1）Collection 集合体系

           [1] Collection集合

Collection集合特点：

 Collection常用方法：

Collention遍历方式： 

  [2] List集合 

   特点

  特有方法 

遍历方式

  ArrayList的底层逻辑

  LinkedList的底层逻辑

 [3] set集合

HashSet集合

LinkedHashSet集合

TreeSet集合

 [4] 其他相关知识

可变参数

Collections

综合案例

（2）Map集合体系

[1] Map集合

Map集合特点：

Map常用方法

Map遍历方式

HashMap

LInkedHashMap

TreeMap

补充：集合的嵌套

（3）Stream流

认识Stream

获取Stream流

常用方法

终结方法

1.集合体系结构

（1）Collection 集合体系

           [1] Collection集合

             Collection  单列集合 每个元素（数据）只包含一个值  接口 实现类

81d44d3fd0ec4042842aead516feb838.png

Collection集合特点：

  • List系列集合 添加的元素是有序的，可重复，有索引

                 ArrayList,LinkedList：有序的，可重复，有索引

  • Set系列集合 添加的元素是无序  不重复 无索引

                 HashList :无序，不重复，无索引

                 LinkedHashSet：有序，不重复，无索引

                 TreeSet：按照大小默认升序排序，不重复，无索引

import java.util.ArrayList;
import java.util.HashSet;

public class Text {
    public static void main(String[] args) {
        //认识Collection集合
        ArrayList<String> list = new ArrayList<>(); //有序 可重复 有索引
        list.add("1");
        list.add("1");
        list.add("2");
        list.add("2");
        list.add("3");
        System.out.println(list);

        HashSet<String> set = new HashSet<>(); //无序 不重复 无索引
        set.add("1");
        set.add("1");
        set.add("2");
        set.add("3");
        System.out.println(set);

    }
}

 Collection常用方法：

     所有单列集合都可以使用

方法名说明
public boolean add(E e)把给定的对象添加到当前集合中
public void clear()清空集合中所有的元素
public boolean remove(E e)把给定的对象在当前集合中删除
public boolean contains(Object obj)判断当前集合中是否包含给定的对象
public boolean isEmpty()判断当前集合是否为空

public int size()

返回集合中元素的 个数
public Object[ ] toArray()把集合中的元素，存储到数组中
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class Text1 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>(); //多态写法
        //1.public boolean add(E e) //添加元素 添加成功返回ture
        c.add("1");
        c.add("1");
        c.add("2");
        c.add("2");
        System.out.println(c);

        //2.public void clear(); //清空集合的元素
        // c.clear();
        System.out.println(c);

        //3.public boolean isEmpty(); //判断集合是否为空 是空返回true
        System.out.println(c.isEmpty());//true

        //4.public int size() //获取集合大小
        System.out.println(c.size());

        //5.public boolean contains(Object obj) //判断集合中是否包含某个元素
        System.out.println(c.contains("1"));

        //6.public boolean remove(E e) //删除某个元素 如果有多个重复元素默认删除前面的第一个
        System.out.println(c.remove("1"));

        //7.public Object[] toArray(); //把集合转换成数组
        Object [] arr = c.toArray();
        System.out.println(Arrays.toString(arr));

        String [] arr2 = c.toArray(new String[c.size()]); //指定类型
        System.out.println(Arrays.toString(arr2));

        //把一个集合中的全部数据导入到另一个集合中
        Collection<String> c1 = new ArrayList<>();
        c1.add("23");
        c1.add("15");
        Collection<String> c2 = new ArrayList<>();
        c2.add("89*");
        c2.add("/56");
        c1.addAll(c2); //全部导入

    }
}

Collention遍历方式： 

（1）迭代器 

用来遍历集合的专用方法（数组中没有），在JAVA迭代器的代表是lterator

获取迭代器的方法

方法名称说明
Iterator<E> iterator() 返回集合中的迭代器对象，该迭代器对象默认指向当前集合的第一个元素

常用方法

方法名称说明
boolean hasNext()询问当前位置是否有元素存在，存在返回true，不存在返回false
E next()获取当前位置的元素，并将迭代器对象指向下一个元素处
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Text2 {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("陈平安");
        list.add("宁姚");
        list.add("阮秀");
        System.out.println(list);

        //迭代器遍历集合
        //1.集合对象中获取迭代器对象
        Iterator<String> it = list.iterator();
        //System.out.println(it.next());
        //System.out.println(it.next());
        //System.out.println(it.next());
        //System.out.println(it.next()); //三个数据取四次 越界异常

        //2.使用循环结合迭代器进行遍历
        while(it.hasNext()){
            String ele = it.next();
            System.out.println(ele);
        }
    }
}

（2）增强for循环

 格式：

                for(元素的数据类型 变量名 ：数组或者集合){ }

  • 增强for可以用遍历集合和数组
  • 增强for遍历集合，本质就是迭代器遍历集合的简化写法 
import java.util.ArrayList;
import java.util.Collection;

public class Text3 {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("陈平安");
        list.add("宁姚");
        list.add("阮秀");
        System.out.println(list);
        
        for(String ele :list){
            System.out.println(ele);
        }
    }
}

（3）Lambda表达式 

方法名说明
default void forEach(Consumer<? super T> action)结合Lambda遍历集合
import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;

public class Text3 {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("陈平安");
        list.add("宁姚");
        list.add("阮秀");
        System.out.println(list);

        //初始
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        //简化
        list.forEach((String s)-> { System.out.println(s);;});
      
        list.forEach(s->System.out.println(s));      
            
        list.forEach(System.out::println);
    }
}

  [2] List集合 

   特点

 有序 可重复 有索引 ArrayList和LinkedList的特点相同但是底层数据逻辑不同，使用场景也不相同

  特有方法 

方法名说明
void add(int index,E element)在此集合中的指定位置插入指定元素
E remove(int index)删除指定索引处的元素，返回被删除的元素
E set(int index,E element)修改指定索引处的元素，返回被修改的元素
E get(int index)返回指定索引处的元素
import java.util.ArrayList;
import java.util.List;

public class Text4 {
    public static void main(String[] args) {
        //List类
        //void add(int index,E element)	在此集合中的指定位置插入指定元素
        List<String> list = new ArrayList<>(); //经典代码
        list.add("陈平安");
        list.add("宁姚");
        list.add("宁姚");
        list.add("陆沉");
        System.out.println(list);
        
        //E remove(int index)	删除指定索引处的元素，返回被删除的元素
        list.add(2,"刘羡阳");
        System.out.println(list);

        //E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
        list.set(2,"陈清流");
        System.out.println(list);

        //E get(int index)	返回指定索引处的元素
        System.out.println(list.get(0));
    }
}

遍历方式

支持的遍历方式

（1）for循环（因为List有索引）

（2）迭代器

（3）增强for循环

（4）Lambda表达式

  ArrayList的底层逻辑

基于数组实现 ：                                      查询快 增删慢

  1. 查询速度快（根据索引查询速度快）
  2. 删除效率低 很多数据进行后移
  3. 添加速度极低 很多数据后移，在添加元素（还可能要进行数组的扩容）

 底层逻辑

【1】利用无参构造器创建的集合会在底层创建一个默认长度为零的数组。

【2】添加第一个元素是底层会创建一个新的长度为10的数组。

【3】存满时会扩容1.5倍。

【4】如果一次性存储多个元素，1.5倍还放不下，则新创建数组的长度以实际为准。

 应用场景

  • 适合根据索引查询数据，比如根据随机索引引取数据会更高效或者数据量不是很大。
  • 不适合数据量大的同时又要频繁进行增删操作。

  LinkedList的底层逻辑

基于双链表存储                                      查询慢 增删快

  1. 查询比较慢都要从头开始
  2. 链表增删比较快
  3. 对于首尾元素进行增删改查速度极快

首尾操作的特定方法

方法名说明
public void addFirst(E e)在该列表开头插入指定的元素
public void addLast(E e)将指定的元素追加到此列表的末尾
public E getFirst()返回列表的第一个元素
public E getLast()返回列表的最后一个元素
public E removeFirst()删除列表中删除并返回第一个元素
public E removeLast()删除列表中删除并返回最后一个元素

 应用场景

  • 可以用来设计队列
public class Text5 {
    public static void main(String[] args) {
        //1.创建一个队列
        LinkedList<String> queue = new LinkedList<>();
        //入队
        queue.addLast("1");
        queue.addLast("2");
        queue.addLast("3");
        queue.addLast("4");
        System.out.println(queue);
        //出队
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue);
    }
}
  • 可以用来设计栈
public class Text5 {
    public static void main(String[] args) {
        //创建一个栈
       LinkedList<String> stack = new LinkedList<>();
       //1.压栈
        stack.addFirst("1");
        stack.addFirst("2");
        stack.addFirst("3");
        stack.addFirst("4");
        System.out.println(stack);
        //2.出栈
        stack.removeFirst();
        stack.removeFirst();
        stack.removeFirst();
        System.out.println(stack);
    }
}

 [3] set集合

无序 （添加和取出的顺序不一致）不重复 无索引

  • HashList :无序 不重复 无索引 
  • LinkedHashSet ：有序，不重复 无索引
  • TreeSet ：排序 不重复 无索引
  • Set集合基本没有独特方法，还是继承的Collection的用法
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class Text6 {
    public static void main(String[] args) {
        //了解Set
        Set<Integer> set = new HashSet<>(); //经典代码 无序不重复
        set.add(111);
        set.add(222);
        set.add(333);
        set.add(444);
        set.add(444);
        System.out.println(set);

        Set<Integer> set1 = new TreeSet<>(); //可排序 不重复 无索引
        set.add(111);
        set.add(222);
        set.add(333);
        set.add(444);
        set.add(444);
        System.out.println(set1);
    }
}

HashSet集合

基于哈希表实现

哈希表是一种增删改查性能都比较好的数据结构

哈希值

  • 一个int类型的数值，JAVA中每个对象都有一个哈希值
  • JAVA所有对象，都可以调用Object类提供的HashCode方法，返回对象自己的哈希值

                public int hashCode(); 返回对象的哈希码值

  • 同一对象多次调用HashCode返回的哈希值是相同的
  • 不同的对象哈希值一般不相同，但也有可能会相同
public class Text7 {
    public static void main(String[] args) {
        //哈希值
        Student s1 = new Student("陈平安",19,175);
        Student s2 = new Student("宁姚",18,169.5);
        System.out.println(s1.hashCode());
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
    }
}

JDK8之前的底层原理

 

【1】创建一个默认长度16的数组，默认加载因子为0.75，数组名table.

【2】使用元素的哈希值对数组长度求余计算应存入的位置，

【3】判断当前位置是否为null，如果是now直接存入

【4】如果不为null表示有元素，则调用equals方法比较,相同则不存,不相同，则存数组

  • JDK8之前，新元素。占用老元素位置，老元素挂下面
  • JDK8之后，新元素直接挂在老元素下面。

 JDK8后引入了红黑树，提高了操作数剧的性能 

LinkedHashSet集合

LinkedHashSet是HashSet的一个子类，底层逻辑仍然基于哈希表实现，但是每个元素都额外多了一个双链表的记录机制记录它前后元素的位置

TreeSet集合

特点：不重复，无索引 可排序（默认升序排序 按照元素的大小由小到大排序

94abcc7577604ccdba377b2fcf495611.png

import java.util.Set;
import java.util.TreeSet;

public class Text8 {
    public static void main(String[] args) {
        //TreeSet使用
        Set<String> set = new TreeSet<>();
        set.add("6");
        set.add("5");
        set.add("4");
        System.out.println(set);

    }
}

 注意：对于数值类型：Integer,Double 默认按照数值本身大小进行升序排序

            对于字符串类型：默认按照首字符的编号升序排序

            对于自定义类型如Student对象，默认是无法直接排序的（需要自定义比较规则）

方式一 ：让自定义的类实现Comparable接口，重写里面的compareTo方法来指定规则

方式二：通过调用TreeSet集合有参数构造器，可以设置比较器对象

                   public TreeSet (Comparator <? super E> coomparator)

 [4] 其他相关知识

可变参数

就是一种特殊形参，定义在方法，构造器的形参列表中，格式为：数据类型...参数名称；

 特点和好处

特点：可以不传数据给它，可以传一个或者多个数据给它，也可以传一个数组给它

好处：灵活接收数据

注意事项

  • 可变形参在方法内部就是一个数组
  • 一个形参列表中可变参数就只有一个
  • 可变参数必须放在形参列表的最后面
import java.util.Arrays;

public class Text9 {
    public static void main(String[] args) {
        //目标 认识可变参数 灵活传输数据
        text();             //传输0个数据
        text(10);  //传输1个数据
        int [] arr={1,2,3,4,5};
        text(arr);        //传输一个数组
    }
    //1.注意事项：1.一个形参列表中 只能有一个可变参数 text(int ... num.int ...can)和text(int ...nums,String ...name)都会报错
    //1.注意事项：2.可变参数必须放在形参列表的最后面
    public static void text(int...number){
        //可变参数在方法内部，本质是一个数据
        System.out.println(number.length);
        System.out.println(Arrays.toString(number));
    }
}

Collections

用来操作集合的工作类

 常用方法

方法名说明
public static <T>boolean adAll(Collection <?  super  T>)c,T...element)给集合批量添加元素
public static void shuffle(List<?> list )打乱List集合中的元素顺序
public static <T> void sort(list<T> list)对List集合中的元素进行升序排序
public static <T> void sort(List <T> list,Comparator<? super T> c)按照List集合中，按照比较器指定规则进行排序
import java.util.*;

public class Text10 {
    public static void main(String[] args) {
        //Collections工具类的使用
        //public static <T>boolean adAll(Collection <？super T>)c,T...element)	给集合批量添加元素
        List<String> names = new ArrayList<>();
        Collections.addAll(names,"1","2","3","4");
        System.out.println(names);

        //public static void shuffle(List<?> list )	打乱List集合中的元素顺序
        Collections.shuffle(names);
        System.out.println(names);

        //public static <T> void sort(list<T> list)	对List集合中的元素进行升序排序
        Collections.sort(names);
        System.out.println(names);
        //排序对象是要接入比规则的接口

        //public static <T> void sort(List <T> list,Comparator<? super T> c)	按照List集合中，按照比较器指定规则进行排序
        List<Student> students = new ArrayList<>();
        students.add(new Student(9.0));
        students.add(new Student(2.0));
        students.add(new Student(3.0));
        Collections.sort(students, new Comparator<Student>() {
          @Override
          public int compare (Student o1,Student o2){
              return Double.compare(o1.score,o2.score);
          }
      });
        System.out.println(students.toString());
    }


}

 Colllection 只能支持对集合进行排序

排序方式1：

方法名说明
public static <T> void sort(List <T> list)对集合中元素按照默认排序
排序方式2：
方法名说明
public static <T> void sort(List <T> list,Comparator <? super T> c)

对List集合中元素，按照比较器的对象指定的规则进行排序

 

综合案例

斗地主游戏

需求：总共54张牌，

           点数3 4 5 6 7 8 9 10 J  Q K A 2

           花色，♠，♥，◇，大小王

          斗地主发出51张牌，剩下三张作为底牌。

          完成洗牌 发牌 看牌

package Demo;

public class Card {
    private String  number;
    private String color;
    private int size;

    public Card() {
    }

    public Card(String number, String color, int size) {
        this.number = number;
        this.color = color;
        this.size = size;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    @Override
    public String toString() {
        return color+ number;
    }
}

package Demo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Room {
    List<Card> AllCards = new ArrayList<>();

    public Room(){
        String [] s1 = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        String [] s2 = {"♠","♥","♣️","♦"};
        int size = 0;
        for (String number : s1) {
            size++;
            for (String colors : s2) {
                Card c = new Card(number,colors,size);
                AllCards.add(c);
            }
        }
        Card c1 = new Card("","🃏",++size);
        Card c2 = new Card("","🃏",++size);
        AllCards.add(c1);
        AllCards.add(c2);

        System.out.println("新牌"+AllCards);
    }

    public void start() {
        Collections.shuffle(AllCards);
        System.out.println("洗牌"+AllCards);

        List<Card> D = new ArrayList<>() ;
        List<Card> M = new ArrayList<>() ;
        List<Card> m = new ArrayList<>() ;
        List<Card> TreeCard = new ArrayList<>() ;


        for (int i = 0; i < AllCards.size() - 3; i++) {
            Card c = AllCards.get(i);
            if(i % 3 == 0){D.add(c);}
            else if (i%3 == 1){M.add(c);}
            else {m.add(c);}
        }
        for (int i = AllCards.size() - 3; i < AllCards.size() ; i++){
            Card c= AllCards.get(i);
            TreeCard.add(c);
        }

        //排序
        //看牌
        D.addAll(TreeCard);
        sort(D);
        System.out.println("底牌" + TreeCard);
        System.out.println("地主" + D);
        sort(M);
        sort(m);
        System.out.println("农民1" + M);
        System.out.println("农民2" + m);

    }

    public void sort(List<Card> list){
        Collections.sort(list, new Comparator<Card>() {
            @Override
            public int compare(Card o1, Card o2) {
                return o1.getSize()- o2.getSize(); //升序
            }
        });

    }
}

package Demo;

public class GameDemo {
    public static void main(String[] args) {

        Room r = new Room();

        r.start();
    }
}

（2）Map集合体系

双列集合

  • Map集合称为双列集合，一次需要存一对数据为一个元素
  • 每个元素包含两个值称为一个键值对，因此也称为“键对值集合”
  • Map所有的键是不允许重复的，但是值可以是重复的，键和值是一一对应的

[1] Map集合

                       Map集合在存储一一对应的数据的业务场景下使用 接口 实现类

 4fd8f382f9dc4b60ac452d5e3ea7e9cf.png

Map集合特点：

        Map系列的特点由键决定，值只是附属不做要求

  • HashMap(由键决定特点) ：无序，不重复，无索引（用的最多）
  • LinkedHashMap (由键决定特点) ：有序，不重复，无索引
  • TreeMap(由键决定特点) ：按照大小默认升序排列，不重复，无索引

Map常用方法

方法名说明
public V put (K key,V value)添加元素
public int size()获取集合的大小
public void clear()清空集合
public boolean isEmpty()判断集合是否为空，为空返回ture
public V get(Object key)根据键获取对应值
public V remove (Object key)根据键删除整个元素
public boolean containsKey(Object key)判断是否包含某个键
public boolean containValue(Object value)判断是否包含某个值
public Set <K> keySet()获取全部键的集合
public Collection<V> values()获取Map集合的全部值
import java.util.*;

public class MapText {
    public static void main(String[] args) {
        //1.添加元素
        Map<String,Integer> map = new HashMap<>();
        map.put("手表",100);
        map.put("手机",1000);
        map.put("电脑",10000);
        map.put(null,null);
        System.out.println(map);

        //2.获取集合的大小
        System.out.println(map.size());

        //3.清空集合
        map.clear();
        System.out.println(map);

        //4.判断集合为空 为空则返回ture
        System.out.println(map.isEmpty());

        //5,根据键获取对应值
        int vi = map.get("手表");
        System.out.println(vi);
        System.out.println(map.get("电脑"));

        //6.根据键删除整个元素 删除后返回键的值
        System.out.println(map.containsKey("手表"));

        //7.判断是否包含某个键，包含返回ture
        System.out.println(map.containsKey("手表"));

        //8.判断是否包含某个值，包含返回ture
        System.out.println(map.containsValue(1000));

        //9.获取全部键
        Set<String> keys = map.keySet();
        System.out.println(keys);

        //10获取全部值
        Collection<Integer> values = map.values();
        System.out.println(values);

        //11.把其他集合中的数据倒入到自己的集合中
        Map<String,Integer> map1 = new HashMap<>();
        map1.put("java1",1);
        map1.put("java2",2);
        map.putAll(map1);

    }
}

Map遍历方式

键找值 ：先获取集合全部的键，再通过遍历键来找到值

方法名说明
public Set <K> keySet()获取全部键的集合
public V get(Object key)根据键获取对应值

 

键对值 ：把键值对看成一个整体来遍历

方法名说明
Set <Map.Entry<K,V>> entrySet()获取全部“键对值”的集合

 

Lambda表达式

方法名说明
default void forEach(Biconsumer <? super K ,? super V> action)结合lambda遍历Map集合

[2] HashMap

底层原理

基于哈希表实现，和HashSet的底层原理一致，实际上，Set系列就是基于Map实现，只是Set集合的元素只要键数据，不要值数据

     提供的键和值合成一个Entry对象，计算哈希值是利用键计算，与值无关

[3] LInkedHashMap

底层原理

基于哈希值实现，但是对于每个键值又额外多一个双链表的机制记录元素顺序（保证有序）

[4] TreeMap

底层原理

TreeMap跟TreeSet集合的底层原理是一样的，都是红黑树实现的排序

  •  同样让类实现Comparable接口，重写比较规则
  •  有一个参数构造器，支持创建comparator比较器对象，以便于用来指定比较规则 

[5] 补充：集合的嵌套

                                        集合中的元素又是一个集合

import java.util.*;

public class Text11 {
    public static void main(String[] args) {
        //存储省市信息
        Map<String, List<String>> map = new HashMap<>();

        List<String> city = new ArrayList<>();
        Collections.addAll(city,"南京","扬州","苏州","无锡");
        map.put("江苏省",city);
        System.out.println(map);
    }
}

（3）Stream流

[1] 认识Stream

Stream流 新增一套用于操作集合或者数组数据的API，提供更简洁，更强大的方式操作数据

 f0b27f3e0bc24269bd4b39844146666c.png

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class Text12 {
    public static void main(String[] args) {
        List<String> names= new ArrayList<>();
        Collections.addAll(names,"张三丰","张无忌","周芷若","张强","赵敏");
        System.out.println(names);
        
        //
        List<String>  list = new ArrayList<>();
        for (String name : names) {
            if(name.startsWith("张") && name.length() == 3){
                list.add(name);
            }
        }
        System.out.println(list);
        
        //stream流
        List<String> list2 = names.stream().filter(s->s.startsWith("张")).filter(a->a.length() == 3).collect(Collectors.toList());
    }
}

[2] 获取Stream流

  • 获取集合的Stream流

Collection 提供的方法

说明

default Stream<E> stream()

获取当前集合的Stream流

  • 获取数组的Stream流

Arrays类 提供的方法

说明

public static <T> Stream<T> stream (T[ ] array)

获取当前数组的Stream流

Stream类 提供的方法

说明

public static <T> Stream<T> of(T ... values)

获取当前接收数据的Stream流                                                                                                                                   

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

public class Text13 {
    public static void main(String[] args) {
        //1.获取集合中的Stream流
        List<String> names = new ArrayList<>();
        Collections.addAll(names,"张三丰","张无忌","周芷若","张强","赵敏");
        
        Stream<String> stream = names.stream(); 
        
        //2.如何获取Set集合的Stream流
        Set<String> set = new HashSet<>();
        Collections.addAll(set,"刘德华","张曼玉","蜘蛛精","马德","德玛西亚");
        Stream<String> stream1 = set.stream();
        
        //3.获取Map集合的Stream流
        Map<String,Double> map = new HashMap<>();
        map.put("陈平安",1.2);
        map.put("宁 姚",1.3);
        map.put("阮 秀",1.4);
        map.put("陈清流",1.5);
        
        Set<String> keys = map.keySet();
        Stream<String> stream2 = keys.stream();
        
        Collection<Double> values = map.values();
        Stream<Double> stream3  = values.stream();
        
        Set<Map.Entry<String,Double>> entries = map.entrySet();
        Stream<Map.Entry<String,Double>> stream4 = entries.stream();
        stream4.filter(e->e.getKey().contains("陈")).forEach(e->System.out.println(e.getKey()+"--->"+e.getValue()));
        
        //4.获取数组的Stream流
        String [] names2 = {"陈平安","宁 姚","阮 秀","陈清流"};
        Stream<String> s1 = Arrays.stream(names2);
        Stream<String> s2 = Stream.of(names2);
    }
}

[3] 常用方法

方法名说明
Stream<T> filter (Predicate <? super ?> predicate)用于对流中的数据进行过滤
Stream <T>sorted()对元素进行升序排序
Stream<T>sorted (Comparator<?super?> comparator)按照指定规则排序
Stream<T>limit (long maxSize)获取前几个元素
Stream<T> skip(long n)跳过前几个元素
Stream<T> distinct()去除流中重复的元素
<R>Stream<R>map(Function<? super T ? extends R> mapper)对元素进行加工，并返回对应的新流
static <T> Stream concat(Stream a,Stream b)合并a和b两个流为一个流
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;

public class Text14 {
    public static void main(String[] args) {
        List<Double> scores = new ArrayList<>();
        Collections.addAll(scores,88.5,100.0,60.0,99.0,90.5,99.6,25.0);
        //需求1：找出成绩大于等于60分的数据 升序后输出

        Stream<Double> s = scores.stream();
        s.filter(e->e>=60).forEach(System.out::println);

        List<Student> students = new ArrayList<>();
        Student s1 = new Student("陈",45,172.5);
        Student s2 = new Student("武",25,180.5);
        Student s3 = new Student("李",26,156.2);
        Student s4 = new Student("王",15,180.3);
        Student s5 = new Student("王",15,180.3);
        Collections.addAll(students,s1,s2,s3,s4,s5);
        //需求2：找出年龄大于23，小于30岁的学生，并按照年龄降序输出
        Stream<Student> stu = students.stream();
        stu.filter(e->e.getAge()<30&&e.getAge()>23).forEach(System.out::println);

        //需求3：取出身高最高的前3名学生 并输出
        students.stream().sorted((o1,o2)->Double.compare(o1.getHeight(),o2.getHeight()))
                .limit(3).forEach(System.out::println);

        //需求4：取出身高倒数的2名学生，并输出
        students.stream().sorted((o1,o2)->Double.compare(o1.getHeight(),o2.getHeight()))
                .skip(students.size()-2).limit(2).forEach(System.out::println);

        //需求5:找出身高超过165的学生叫什么名字 取出重复的名字 再输出
        students.stream().filter(e->e.getHeight()>165.0).map(Student::getName).distinct().forEach(System.out::println);
    }
}

[4] 终结方法

                收集Stream流，把操作后的结果转回到集合或者数组中去返回

                使用后就无法使用该流了

方法名说明
void forEach（Consumer action）对此流运算后的元素执行遍历
long count()统计此流运算后的元素个数
Optional <T> max(Comparator <?super T?> comparator)获取此流运算后的最大值元素
Optional <T> min (Comparator <?super T?> comparator)获取此流运算后的最小值元素

                                                                                               学习时间 2024.8.10 - 2024.8.11

 

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2035638.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

流程图语法Mermaid教程

流程图语法Mermaid教程

在使用Markdown来编写博客的过程中&#xff0c;尤其是需要更醒目的逻辑说明时&#xff0c;就需要使用流程图。 既然CSDN官方推荐Mermaid作为流程图语法&#xff0c;那我也针对Mermaid来做一期教程。 在学习之前&#xff0c;先总结一下流程图的需求&#xff1a; 节点设置方向设…
阅读更多...
好看的超清4K视频素材去哪里找？下载素材资源网站分享

好看的超清4K视频素材去哪里找？下载素材资源网站分享

在当前高清与4K视频素材盛行的时代&#xff0c;创作出色的视频内容离不开优质的超清4K视频素材。以下是一些宝藏网站&#xff0c;它们提供了丰富的4K视频素材&#xff0c;可以使您的视频创作更加引人注目。 蛙学网 蛙学网是获取高质量4K视频素材的首选之地。该网站详细标注了视…
阅读更多...
lvs、集群

lvs、集群

1.集群和分布式 当多个用户当用户访问一个服务器时&#xff0c;服务器server1可能就会崩&#xff0c;假如这时候我们新加一个服务器server2来缓解server1的压力&#xff0c;那么就需要一个调度器lvs来分配&#xff0c;所以现在就是用户的访问就需要通过调度器之后到达服务器&a…
阅读更多...
期望薪资3k，面试官笑了但没说话

期望薪资3k，面试官笑了但没说话

吉祥知识星球http://mp.weixin.qq.com/s?__bizMzkwNjY1Mzc0Nw&mid2247485367&idx1&sn837891059c360ad60db7e9ac980a3321&chksmc0e47eebf793f7fdb8fcd7eed8ce29160cf79ba303b59858ba3a6660c6dac536774afb2a6330#rd 《网安面试指南》http://mp.weixin.qq.com/s?…
阅读更多...
Linux系统编程（8）进程进阶

Linux系统编程（8）进程进阶

一、进程的执行 子进程被创建好后&#xff0c;就需要去执行它所该执行的功能&#xff0c;根据子进程需要做的事&#xff0c;将其分为两类&#xff1a; 1.子进程所做的事与父进程差不多&#xff0c;两者功能几乎一样 //子承父业 2.子进程所做的事和父进程做的事完全不同&…
阅读更多...
随手记录第十四话 -- 在 Spring Boot 3.2.3 中使用 springdoc-openapi-starter-webmvc-ui

随手记录第十四话 -- 在 Spring Boot 3.2.3 中使用 springdoc-openapi-starter-webmvc-ui

项目升级到JDK21后&#xff0c;SpringBoot版本也到了3.2.3&#xff0c;之前的Swagger-ui不在支持了&#xff0c;找了其他的一直忘记记录了&#xff0c;这里记录一下。 快捷目录 1.引言2.添加依赖3.配置类4.Java代码实现5.启动应用6.总结 1.引言 随着 Spring Boot 版本的更新&a…
阅读更多...
一个C++模板有意思的小实验

一个C++模板有意思的小实验

看面经遇到一个C模板的问题&#xff0c;顺手做了下实验看看结果&#xff0c;觉得比较有意思就记录一下 我们一般用模板会把声明和定义放在一起(放在同一个头文件内)&#xff0c;那么如果我们在一个头文件内声明我们要使用的模板函数&#xff0c;并在另一个cpp文件内实现会怎么样…
阅读更多...
HarmonyOS NEXT星河版零基础入门（2）

HarmonyOS NEXT星河版零基础入门（2）

1.Scroll滚动容器-核心用法 1&#xff08;1&#xff09;.Scroll的核心用法 快速得到一个长度为5的数组 Array.from({length:5}) 代码&#xff1a; 这种是默认是竖向的 要是想要实现横向的 就得把Scroll里边的Column改为Row组件 并且把scrolllable设置为Horizontal横向 1&a…
阅读更多...
Spring AI 更新：支持OpenAI的结构化输出，增强对JSON响应的支持

Spring AI 更新：支持OpenAI的结构化输出，增强对JSON响应的支持

就在昨晚&#xff0c;Spring AI发了个比较重要的更新。由于最近OpenAI推出了结构化输出的功能&#xff0c;可确保 AI 生成的响应严格遵守预定义的 JSON 模式。此功能显着提高了人工智能生成内容在现实应用中的可靠性和可用性。Spring AI 紧随其后&#xff0c;现在也可以对OpenA…
阅读更多...
如何在萤石云视频app转移设备

如何在萤石云视频app转移设备

本文将详述如何在萤石云视频app转移设备 一&#xff0e; 注意事项 1. 若设备正在分享中,无法转移 2. 若设备已开通云存储等可以转移的增值服务&#xff0c;相应的服务也会转移&#xff1b;若开通了订阅服务将取消订阅服务&#xff0c;次月不再扣费续订 3. 转移设备时若设备…
阅读更多...
【iOS】—— Runloop和多线程问题总结

【iOS】—— Runloop和多线程问题总结

Runloop和多线程问题总结 runloop总结1. runloop简介2. runloop的基本作用3. 获取runloop的流程4. runloop和线程的关系5. runloop中的Mode有几种以及作用6.runloop的事件源7. 讲一下source0和source18. runloop的六种观察者模式9. 针对定时器在滑动时停止工作的问题10. 如何解…
阅读更多...
【pytorch学习】transforms的使用

【pytorch学习】transforms的使用

1 ToTensor() 作用&#xff1a;将 PIL Image 类型或者 numpy.ndarray 类型转为 tensor 类型 实例&#xff1a; from torchvision import transforms from PIL import Imageimg_path "data/train/bees/17209602_fe5a5a746f.jpg" img Image.open(img_path)print(i…
阅读更多...
[数据结构]-快速排序

[数据结构]-快速排序

学习快排的基础 不想自己推导时间复杂度或者了解随机化的合理性,可以忽视下面这一条. 推导时间复杂度的方法:主定理随机化算法—数学基础:概率统计 QuickSort 快速排序: 1962年,Tony Hoare发明了这种如此高效实用的强大排序算法 分治法的体现:Divide and Conquer原地排序,…
阅读更多...
数据结构+二叉遍历算法的应用

数据结构+二叉遍历算法的应用

一、问题描述 编写一个程序&#xff0c;先用二叉树表示一个简单算术表达式&#xff0c;树的每一个 结点包括一个运算符或运算数。在简单算术表达式中只包含、-、 *、/和一位正整数且格式正确(不包含括号)&#xff0c;并且要按照先乘除后 加减的原则构造二叉树。如图 7.35 所示…
阅读更多...
QT5生成独立运行的exe文件

QT5生成独立运行的exe文件

目录 1 生成独立运行的exe文件1.1 设置工程Release版本可执行文件存储路径1.2 将工程编译成Release版本 2 使用QT5自带的windeployqt拷贝软件运行依赖项3 将程序打包成一个独立的可执行软件exe4 解决QT5 This application failed to start because no Qt platform plugin could…
阅读更多...
批量快递中问题件筛选技巧大揭秘

批量快递中问题件筛选技巧大揭秘

批量快递中问题件筛选技巧大揭秘&#xff1a;固乔快递查询助手的强大功能 在电商行业日益繁荣的今天&#xff0c;快递服务成为了连接商家与消费者的关键纽带。然而&#xff0c;随着订单量的激增&#xff0c;如何高效处理并筛选出快递中的问题件&#xff0c;成为了许多商家面临…
阅读更多...
shuishusihui

shuishusihui

互斥量 使用互斥量可以用于保护某些临界资源&#xff0c;同一时间只能有一个任务来使用它。 使用互斥量会引入其他问题&#xff0c;比如说优先级反转&#xff0c;于是提出了优先级继承等方法解决问题 任务通知 任务通知就是通知任务&#xff0c;前边都是多对多的关系&#xff0…
阅读更多...
算法解析——双指针算法（3）数据匹配

算法解析——双指针算法（3）数据匹配

欢迎来到博主的专栏——算法解析 博主ID&#xff1a;代码小豪 文章目录 LCR179、查找总价格为目标值的两个商品leetcode11——盛水最多的容器leetcode611——有效三角形的个数 我们前面已经盘点了两种双指针算法的使用场景&#xff0c;现在来看看最常见的一种。 通常&#xff0…
阅读更多...
社交电商系统开发功能定制

社交电商系统开发功能定制

社交电商系统开发功能定制是一项综合性的服务&#xff0c;它涉及到需求分析、界面设计、功能开发、系统测试以及上线后的持续维护。以下是社交电商系统开发中应考虑的关键功能点&#xff1a; 需求分析和规划&#xff1a;开发前&#xff0c;企业需要明确业务需求&#xff0c;包…
阅读更多...
【数据分析：一篇文章带你掌握Pandas高级可视化技巧】

【数据分析：一篇文章带你掌握Pandas高级可视化技巧】

前言&#xff1a; &#x1f49e;&#x1f49e;大家好&#xff0c;我是书生♡&#xff0c;本阶段和大家一起分享和探索数据分析的数据可视化&#xff0c;本篇文章主要讲述了&#xff1a;掌握Pandas高级可视化技巧等等。欢迎大家一起探索讨论&#xff01;&#xff01;&#xff01…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023