List、Set、Map中的方法使用、Stream流、Collections工具类

呜呼~225142024-09-06 11:56

目录

一、List集合

二、Set集合

三、Map集合

四、Stream流

五、Collections工具类

一、List集合

1.特点

有序集合,这里的有序指的是存取顺序；用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素，元素可以重复。

1.常用方法

方法名 描述
void add(int index,E element) 在此集合中的指定位置插入指定的元素
E remove(int index) 删除指定索引处的元素，返回被删除的元素
E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
E get(int index) 返回指定索引处的元素

代码示例：

java 复制代码 
public class Test2 {
    public static void main(String[] args) {
        //创建集合对象
        List<Integer> list = new ArrayList<>();
        //添加元素
        list.add(1);
        list.add(2);
        list.add(1);
        list.add(3);
        list.add(4);
        //删除元素,此时删除的是1索引上的元素。
        list.remove(1);
        //手动装箱，把基本数据类型1变为Integer类型,此时删除元素1
        Integer i = Integer.valueOf(1);
        list.remove(i);
        //修改指定索引的元素
        list.set(1,5);
        //获取索引1处的元素
        System.out.println(list.get(1));
        System.out.println("==============");
        System.out.println(list);
    }
}

二、Set集合

1.Set集合的特点

不可存储重复元素、无序、没有索引、不能使用普通for循环遍历。

2.存储字符串的遍历

java 复制代码 
public class Test2 {
    public static void main(String[] args) {
      	//创建集合对象
        Set<String> set = new TreeSet<>();
      	//添加元素
        set.add("ccc");
        set.add("aaa");
        set.add("aaa");
        set.add("bbb");
//        for (int i = 0; i < set.size(); i++) {
//            //Set集合是没有索引的，所以不能使用通过索引获取元素的方法
//        }      
      	//遍历集合
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-----------------------------------");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

3.自然排序Comparable案例：

存储手机对象并遍历，创建TreeSet集合。要求：按照价格从小到大进行排序，价格相同时，按照姓名的字母顺序排序。

java 复制代码 
//手机类
public class Phone implements Comparable<Phone>{
    private String brand;
    private int price;
    public Phone() {
    }
    public Phone(String brand, int price) {
        this.brand = brand;
        this.price = price;
    }
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Phone{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                '}';
    }

    @Override
    public int compareTo(Phone o) {
        //按照价格排序
        int result=this.getPrice()-o.getPrice();
        //价格相同，按照品牌排序
        result=result==0?this.brand.compareTo(o.getBrand()):result;
        return result;
    }
}

//测试类
public class Test2 {
    public static void main(String[] args) {
        //创建手机对象
        Phone p1=new Phone("小米",3999);
        Phone p3=new Phone("苹果",7999);
        Phone p2=new Phone("小米",5999);
        Phone p4=new Phone("华为",5999);
        //创建集合对象
        TreeSet<Phone>ts=new TreeSet<>();
        //把手机对象添加到集合中
        ts.add(p1);
        ts.add(p2);
        ts.add(p3);
        ts.add(p4);
        //遍历集合
        for (Phone phone : ts) {
            System.out.println(phone);
        }
    }
}

4.比较器排序Comparator的使用

java 复制代码 
//存储老师对象并遍历，创建TreeSet集合使用带参构造方法。要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
//老师类
public class Teacher {
    private String name;
    private int age;

    public Teacher() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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


//测试类
public class Test2 {
    public static void main(String[] args) {
      	//创建集合对象
        TreeSet<Teacher> ts = new TreeSet<>(new Comparator<Teacher>() {
            @Override
            public int compare(Teacher o1, Teacher o2) {
                //o1表示现在要存入的那个元素
                //o2表示已经存入到集合中的元素
              
                //主要条件
                int result = o1.getAge() - o2.getAge();
                //次要条件
                result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
                return result;
            }
        });
		//创建老师对象
        Teacher t1 = new Teacher("zhangsan",23);
        Teacher t2 = new Teacher("lisi",22);
        Teacher t3 = new Teacher("wangwu",24);
        Teacher t4 = new Teacher("zhaoliu",24);
		//把老师添加到集合
        ts.add(t1);
        ts.add(t2);
        ts.add(t3);
        ts.add(t4);
		//遍历集合
        for (Teacher teacher : ts) {
            System.out.println(teacher);
        }
    }
}

三、Map集合

1.常用方法

方法名 说明
V put(K key,V value) 添加元素
V remove(Object key) 根据键删除键值对元素
void clear() 移除所有的键值对元素
boolean containsKey(Object key) 判断集合是否包含指定的键
boolean containsValue(Object value) 判断集合是否包含指定的值
boolean isEmpty() 判断集合是否为空
int size() 集合的长度，也就是集合中键值对的个数

代码示例：

java 复制代码 
public class Test02 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<>();
        //添加元素
        map.put("张三","A");
        map.put("李四","B");
        map.put("王五","C");
        map.put("赵六","D");
        //根据键删除键值对元素
        System.out.println(map.remove("张三"));
        //移除所有键值对元素：map.clear();
        //判断集合是否包含指定的键
        System.out.println(map.containsKey("李四"));
        //判断集合是否包含指定的值
        System.out.println(map.containsValue("B"));
        //判断集合是否为空
        System.out.println(map.isEmpty());
        //int size()：集合的长度，也就是集合中键值对的个数
        System.out.println(map.size());
        //输出集合对象
        System.out.println(map);
    }
}

2.Map集合的获取方法

方法名 说明
V get(Object key) 根据键获取值
Set<K> keySet() 获取所有键的集合
Collection<V> values() 获取所有值的集合
Set<Map.Entry<K,V>> entrySet() 获取所有键值对对象的集合

示例代码：

java 复制代码 
public class Test02 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("张三","A");
        map.put("李四","B");
        map.put("王五","C");
        map.put("赵六","D");
        //根据键获取值
        System.out.println(map.get("李四"));
        //获取所有键的集合
        Set<String>keyset = map.keySet();
        for (String key : keyset) {
            System.out.println(key);
        }
        System.out.println("-----------------");
        //获取所有值的集合
        Collection<String>values=map.values();
        for (String value : values) {
            System.out.println(value);
        }
        System.out.println("-----------------");
        //获取所有键值对对象的集合.用getKey()得到键;用getValue()得到值
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        for (Map.Entry<String, String> entry : entrySet) {
            String key=entry.getKey();
            String va=entry.getValue();
            System.out.println(key+","+va);
        }
    }
}

四、Stream流

1.获取Stream流

获取集合的Stream流

java 复制代码 
//List生成Stream流
List<String> list = new ArrayList<>();
Stream<String> liststream = list.stream();

//Set生成Stream流
Set<String> set = new HashSet<>();
Stream<String> setstream = set.stream();

//Map生成Stream流
Map<String,String> map = new HashMap<>();
Stream<String> keyStream = map.keySet().stream();
 Stream<String> valueStream = map.values().stream();
Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();


//数组获取Stream流
String [] name = {"张三","李四","王五"}; 
//数组可以通过Arrays中的静态方法stream生成流     
Stream<String> stream1 = Arrays.stream(name);
//同种数据类型的多个数据可以通过Stream接口的静态方法of生成流
Stream<String> stream2 = Stream.of(name);

2.Stream流中间操作方法

方法名 说明
Stream<T> filter(Predicate predicate) 用于对流中的数据进行过滤
Stream<T> limit(long maxSize) 返回此流中的元素组成的流，截取前指定参数个数的数据
Stream<T> skip(long n) 跳过指定参数个数的数据，返回由该流的剩余元素组成的流
static <T> Stream<T> concat(Stream a, Stream b) 合并a和b两个流为一个流
Stream<T> distinct() 返回由该流的不同元素（根据Object.equals(Object) ）组成的流

示例代码：

java 复制代码 
public class Test003 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        list.add("赵六");
        //filter :把集合中以李开头的元素在控制台输出
        list.stream().filter(s->s.startsWith("李")).forEach(System.out::println);
        System.out.println("-------------");
        //limit：取出前两个数据在控制台打印
        list.stream().limit(2).forEach(System.out::println);
        System.out.println("-------------");
        //skip：跳过一个元素，输出剩余元素
        list.stream().skip(1).forEach(System.out::println);
        System.out.println("-------------");
        //concat:合并流
        //取前2个数据作为第一个流
        Stream<String> s1 = list.stream().limit(2);
        //跳过3个数据作为第二个流
        Stream<String> s2 = list.stream().skip(3);
        //合并两个流,输出不同元素
        Stream.concat(s1,s2).distinct().forEach(System.out::println);
    }
}

3.Stream流的终结方法

方法名 说明
void forEach(Consumer action) 对此流的每个元素执行操作
long count() 返回此流中的元素数

示例代码：

java 复制代码 
public class Test003 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        //forEach:对流的每个元素进行操作
        list.stream().forEach(System.out::println);
        //统计元素的个数
        long count = list.stream().count();
        System.out.println("此流中元素的个数为："+count);
    }
}

4.收集操作

方法名 说明
R collect(Collector collector) 把结果收集到集合中

工具类Collectors收集方法：

方法名 说明
public static <T> Collector toList() 把元素收集到List集合中
public static <T> Collector toSet() 把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper) 把元素收集到Map集合中

代码示例：

java 复制代码 
public class Test03 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六七");
        //得到名字为两个字的流
        Stream<String> liststream = list.stream().filter(a->a.length()==2);
        //把操作完的数据手机到List集合中
        liststream.collect(Collectors.toList());
        Set<Integer> set = new HashSet<>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(33);
        //得到大于25的流
        Stream<Integer> setStream = set.stream().filter(b->b>25);
        //把操作完的数据手机到Set集合中
        setStream.collect(Collectors.toSet());
    }
}

五、Collections工具类

常用的方法示例代码：

java 复制代码 
public class Test03 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        //添加元素
        Collections.addAll(list,"A","C","D","B");
        //反转集合
        Collections.reverse(list);
        //按自然顺序排序
        Collections.sort(list);
        //随机打乱集合中的元素
        Collections.shuffle(list);
        //指定集合中索引i的元素和索引i的元素交换
        Collections.swap(list,0,list.size()-1);
    }
}
相关推荐
AIAdvocate18 分钟前
Pandas_数据结构详解
数据结构·python·pandas
jiao0000143 分钟前
数据结构——队列
c语言·数据结构·算法
kaneki_lh1 小时前
数据结构 - 栈
数据结构
铁匠匠匠1 小时前
从零开始学数据结构系列之第六章《排序简介》
c语言·数据结构·经验分享·笔记·学习·开源·课程设计
C-SDN花园GGbond1 小时前
【探索数据结构与算法】插入排序：原理、实现与分析（图文详解）
c语言·开发语言·数据结构·排序算法
迷迭所归处2 小时前
C++ —— 关于vector
开发语言·c++·算法
架构文摘JGWZ2 小时前
Java 23 的12 个新特性！！
java·开发语言·学习
leon6252 小时前
优化算法（一）—遗传算法（Genetic Algorithm）附MATLAB程序
开发语言·算法·matlab
CV工程师小林2 小时前
【算法】BFS 系列之边权为 1 的最短路问题
数据结构·c++·算法·leetcode·宽度优先
Navigator_Z3 小时前
数据结构C //线性表（链表）ADT结构及相关函数
c语言·数据结构·算法·链表
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07浏览器插件——ModHeader 的分享和学习08Coze扣子平台完整体验和实践（附国内和国际版对比）09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10CCF-CSP认证考试 202406-3 文本分词 100分题解