Java集合类的总结

最新推荐文章于 2024-03-15 06:00:00 发布
最新推荐文章于 2024-03-15 06:00:00 发布
阅读量296 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lhm_stick_to/article/details/55212634
版权

一、Collection层次结构中的根接口。Collection表示一组对象，这些对象也称为collection的元素。一些collection允许有重复的元素，而另一些则不允许。一些collection是有序的，而另一些则是无序的.JDK不提供此接口的任何直接实现：它提供更具体的子接口（如Set和List）实现。
1.List：有序的collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。列表通常允许重复的元素。更确切地讲，列表通常允许满足e1.equals(e2)的元素对e1和e2，并且如果列表本身允许null元素的话，通常它们允许多个null元素。List接口提供了特殊的迭代器，称为ListIterator，除了允许Iterator接口提供的正常操作外，该迭代器还允许元素插入和替代，以及双向访问。还提供了一个方法来获取从列表中指定位置开始的列表迭代器。hasNext()以正向遍历列表时，如果列表迭代器有多个元素，则返回true（换句话说，如果next返回一个元素而不是抛出异常，则返回true）。hasPrevious(用这个的是时候，它的迭代器为ListIterator）如果以逆向遍历列表，列表迭代器有多个元素，则返回true.List的对象要排序时，如果这个对象是String、Iterger这类似的酒可以直接用Collects.sort(List对象)，如果是自己新创建的一个类时，想要用sort()方法，就必须让这个类实现Comparable接口，并实现该接口中的comperTo方法；List的主要实现类有ArrayList、Stack、LinkedList 代码实例：TestList.java

package collection;

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

public class TestList {

    public static void print(Collection c){
        Iterator iterator=c.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    public static void main(String[] args) {
        List list=new ArrayList<>();
        list.add(new Student("SC", 22));
        list.add(new Student("ZM", 23));
        list.add(new Student("WYZ", 21));
        list.add(new Student("LHM", 22));
        print(list);
        Collections.sort(list);
        System.out.println();
        print(list);
    }

}

class Student implements Comparable{
    String name;
    int age;
    public Student() {
        super();
    }
    public Student(String name, int age) {
        super();
        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 "Student [name=" + name + ", age=" + age + "]";
    }
    @Override
    public int compareTo(Object o) {
        if(o!=null &&o instanceof Student){
            Student stu=(Student)o;
            if(this.age!=stu.age){
                return stu.age-this.age;  //先按年龄降序排序
            }else{
                return this.name.compareTo(stu.name); //如果年龄相同，就按姓名的升序排序
            }

        }
        return 0;
    }

}

输出接口为：

Student [name=SC, age=22]
Student [name=ZM, age=23]
Student [name=WYZ, age=21]
Student [name=LHM, age=22]

Student [name=ZM, age=23]
Student [name=LHM, age=22]
Student [name=SC, age=22]
Student [name=WYZ, age=21]

2.Set:一个不包含重复元素的collection。更确切地讲，set不包含满足e1.equals(e2)的元素对e1和e2，并且最多包含一个null元素。set是无序的，Set的主要实现类有HashSet和TreeSet

A.HashSet：通过hashCode和equals来进行排重，当hashCode返回只不一样时，就直接添加此元素；当hashCode返回值一样时，就比较equals方法，如果返回true，就丢弃这个元素，如果为false，就添加这个元素。实例代码：TestHashSet.java

package collection;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;



public class TestHashSet {

    public static void show(Collection c){
        Iterator it=c.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
    public static void main(String[] args) {
        Set set=new HashSet<>();
        Student1 s1=new Student1(1,"lhm",22);
        Student1 s2=new Student1(2,"wyz",22);
        Student1 s3=new Student1(3,"sc",21);
        Student1 s4=new Student1(4,"zm",21);
        Student1 s5=new Student1(3, "wyz", 21);
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);

        show(set);
    }

}
class Student1{
    private int id;
    private String name;
    private int age;
    public Student1() {
        super();
    }
    public Student1(int id, String name, int age) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    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 "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
    @Override
    public int hashCode() {

        return id+name.hashCode()+age;
    }
    @Override
    public boolean equals(Object o) {
        if(o==null) return false;
        if(this==o) return true;
        if(o instanceof Student1){
            Student1 stu=(Student1)o;
            if((this.getId()==stu.getId()) && (this.getName().equals(stu.getName())) &&(this.getAge()==stu.getAge())){
                return true;
            }else{
                return false;
            }
        }
        return false;
    }

}

输出结果为：

Student [id=3, name=sc, age=21]
Student [id=4, name=zm, age=21]
Student [id=3, name=wyz, age=21]
Student [id=2, name=wyz, age=22]
Student [id=1, name=lhm, age=22]

B.TreeSet：通过comperto来进行排重，通过哪个属性来返回comperto值，就对哪个属性排重 实例代码：TestTreeSet.java

package collection;

import java.util.Collection;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class TestTreeSet {
    public static void show(Collection c){
        Iterator it=c.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }

    public static void main(String[] args) {
        Set set=new TreeSet<>();
        Teacher t1=new Teacher("abc",20);
        Teacher t2=new Teacher("lisi",21 );
        Teacher t3=new Teacher("lisi",22);
        Teacher t4=new Teacher("wangwu",21);
        set.add(t1);
        set.add(t2);
        set.add(t3);
        set.add(t4);
        show(set);

    }

}

class Teacher implements Comparable{
    private String name;
    private int age;
    public Teacher() {
        super();
    }
    public Teacher(String name, int age) {
        super();
        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 + "]";
    }
    @Override
    public int compareTo(Object o) {
        if(o!=null && o instanceof Teacher){
            Teacher t=(Teacher)o;
//          if(this.age!=t.age){
//              return t.age-this.age;
//          }else{
                return this.getName().compareTo(t.getName());
//          }

        }
        return 0;
    }

}

输出结果为：

Teacher [name=abc, age=20]
Teacher [name=lisi, age=21]
Teacher [name=wangwu, age=21]

当把注释去掉时，输出结果为：

Teacher [name=lisi, age=22]
Teacher [name=lisi, age=21]
Teacher [name=wangwu, age=21]
Teacher [name=abc, age=20]

二、Map K-此映射所维护的键的类型 V-映射值的类型。将键映射到的值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。当要插入的键值对的键值在Map中已经有了，则会覆盖和这个键相同的对象。（而Set若有相同的对象，就迭起还没插入的对象）。Map的主要实现类有HashMap()和TreeMap();
A.HashMap()：基于哈希表的Map接口的实现。此实现提供所有可选的映射操作，并允许使用null值和null键。（除了非同步和允许使用null之外，HashMap类与Hashtable大致相同）。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。它的键值唯一性同HashSet唯一性一样，通过hashCode()和equals()来判断是否是一样的值 代码实例：

package map;

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

public class TestHashMap {

    public static void show(Map map){
        Set set=map.keySet();
        Iterator it=set.iterator();
        while(it.hasNext()){
            Object key=it.next();
            Object value=map.get(key);
            System.out.println(key+"--"+value);
        }
    }
    public static void main(String[] args) {
        Map map=new HashMap<>();
        Person p1=new Person("lhm", 21);
        Person p2=new Person("lhm", 20);
        Person p3=new Person("zhangsan",18);
        Person p4=new Person("lisi",18);
        map.put(p1, 1);
        map.put(p2, 2);
        map.put(p3, 3);
        map.put(p4, 4);
//      map.put(1, "one");
//      map.put(2, "one");
//      map.put(2, "two");
//      map.put(3, "three");
        show(map);

    }

}
class Person{
    private String name;
    private int age;
    public Person() {
        super();
    }
    public Person(String name, int age) {
        super();
        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 "Person [name=" + name + ", age=" + age + "]";
    }
    @Override
    public int hashCode() {
        return name.hashCode();
    }
    @Override
    public boolean equals(Object o) {
        if(o==null) return false;
        if(this==o) return true;
        if(o instanceof Person){
            Person p=(Person)o;
            if((p.name.equals(this.name))){
                return true;
            }else {
                return false;
            }
        }
        return false;
    }
}

输出结果为：

Person [name=lisi, age=18]--4
Person [name=zhangsan, age=18]--3
Person [name=lhm, age=21]--2

B.TreeMap()：该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的Comparator进行排序，具体取决于使用的构造方法。它的键值唯一性同TreeSet唯一性一样，通过CompareTo来判断。代码实例：TestTreeMap.java

package map;

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


public class TestTreeMap {

    public static void show(Map map){
        Set set=map.keySet();
        Iterator it=set.iterator();
        while(it.hasNext()){
            Object key=it.next();
            Object value=map.get(key);
            System.out.println(key+"--"+value);
        }

    }

    public static void main(String[] args) {
        Map map=new TreeMap<>();
        Person1 p1=new Person1("lhm", 20);
        Person1 p2=new Person1("zhangsan",18);
        Person1 p3=new Person1("lhm", 21);
        Person1 p4=new Person1("lhm",20);
        Person1 p5=new Person1("lisi",20);
        map.put(p1, 1);
        map.put(p2, 2);
        map.put(p3, 3);
        map.put(p4, 4);
        map.put(p5, 5);
//      map.put(1,"two");
//      map.put(1, "one");
//      map.put(3, "three");
//      map.put(2, "two");
        show(map);

    }

}
class Person1 implements Comparable{
    private String name;
    private int age;
    public Person1() {
        super();
    }
    public Person1(String name, int age) {
        super();
        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 "Person1 [name=" + name + ", age=" + age + "]";
    }
    @Override
    public int compareTo(Object o) {
        if(o!=null && o instanceof Person1){
            Person1 p=(Person1)o;
            if(!p.name.equals(this.name)){
                return this.name.compareTo(p.name);
            }else{
                return p.age-this.age;
            }
        }
        return 0;
    }

}

输出结果为：

Person1 [name=lhm, age=21]--3
Person1 [name=lhm, age=20]--4
Person1 [name=lisi, age=20]--5
Person1 [name=zhangsan, age=18]--2
lhm_stick_to
关注
专栏目录
Java8 Lambda Stream collect Collectors 常用详细实例
L_Cheng_H的博客
11-24 905
返回List集合: toList() 用于将元素累积到List集合中。它将创建一个新List集合(在不更改当前集合的情况下)。 List<Integer> integerList = Arrays.asList(1,2,3,4,5,6); integerList.stream().map(x -> x*x).collect(Collectors.toList()); 返回Set集合: toSet() 用于将元素累积到Set集合中。会删除重复元素。 List<Intege
高级java笔试题-YzyCollects:自己收藏的一些Android方面好的网站
06-03
高级java笔试题 自己收藏的一些关于Android的网址 如果觉得有用，不吝啬在右上角给我一个Star。谢谢！！ - 我的邮箱：yzytmac@163.com
Java基础系列-Collector和Collectors
qq_43842093的博客
02-18 385
Collector是专门用来作为Stream的collect方法的参数的。而Collectors是作为生产具体Collector的工具类。整个Collectors工具类就是在为Collector服务，用于创建各种不同的Collector。部分功能与Stream中的方法重合了，为了简化代码，完全不必采用Collectors实现，优先Stream方法。
java中的集合（Collections）“线程安全”是什么？有哪些线程安全的集合工具
最新发布
撸啊撸的博客
03-15 730
在Java开发中，集合是最常用的API之一，JDK提供的集合也是非常强大，在实际的开发中能很方便的解决很多需求问题。但是经常会听到“集合线程安全”，那么什么是集合线程安全？不安全又是什么情况？凡事谈到线程安全，必然是多线程环境，如果是单线程应用，一般不会有线程安全的说法。另外就是线程安全的主角应该是共享数据。如果用一句简单的话来总结，线程安全就是：在多线程的情况下，有一个共享数据能够按照我们自己设定的规则去变化。如果这个共享数据的变化没有按照我们既定的规则去执行，那线程就不安全了。
【Java 基础篇】Java Collection详解
繁依Fanyi的博客
06-25 6526
Collection是Java集合框架的根接口，它定义了一些基本的操作和行为，如添加、删除、遍历等。List和Set。List是一个有序的集合，可以包含重复元素。它提供了按索引访问、插入、删除等操作。常见的实现类有ArrayListLinkedList和Vector。Set是一个不允许包含重复元素的集合。它提供了高效的元素查找和去重。常见的实现类有HashSetTreeSet和。此外，Map接口也是Collection框架的一部分，它提供了键值对的存储和操作。Map中的键是唯一的，值可以重复。
java集合分类总结.doc
12-21
Java集合分类总结 Java集合分类总结是Java语言中的一种容器，用于存储和管理多个对象。集合可以自动扩容，部分集合允许存放不同类型的元素。集合的主要分类有List、Set、Map等。 List集合是一种有序列表，允许存放...
java集合类总结
03-23
本文将对Java集合框架中的Collection接口及其相关接口、类进行深入的探讨。 首先，Collection接口是所有单值容器的基础，它是Set、List和Queue接口的父接口。Collection接口定义了通用的操作方法，如`add()`用于...
JAVA集合类总结[整理].pdf
10-11
JAVA集合类总结[整理].pdf
Java集合类总结
09-01
### Java集合类总结 #### 一、概述 Java集合类框架是Java标准库的一个重要组成部分，主要用于存储和处理数据集合。这些集合类被定义在`java.util`包中，为开发者提供了灵活的数据结构来实现各种应用程序的需求。...
Java集合类知识点总结
08-27
Java集合类知识点总结 Java集合类是Java语言中最基本的数据结构之一，用于存储和操作对象的集合。下面是Java集合类的相关知识点总结： 集合的定义 集合是只能存储对象的数据结构，对象类型可以不一样，长度可变。...
Java 8 Stream 的终极技巧——Collectors 操作
码农小胖哥
01-02 2315
1. 前言 昨天在 Collection 移除元素操作[1] 相关的文章中提到了 Collectors 。相信很多同学对这个比较感兴趣，那我们今天就来研究一下 Collectors 。 2. Collectors 的作用 Collectors 是 Java 8 加入的操作类，位于 java.util.stream 包下。它会根据不同的策略将元素收集归纳起来，比如最简单常用的是将元素装入...
Java collect()方法
魔仙棒棒之主的博客
04-21 8369
这个方法在Stream类里定义 需要结合动态规约理解 三个参数 解析 <R> R collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner) supplier：生成用来保存结果的容器 accumulator：处理输入数据，数据会经过它的处理后保存到容器中 combiner：把产生的结果拼接到另一
Java8中Collectors详解
scofen的博客
03-10 2634
文章目录 1.averagingDouble 2.collectingAndThen 3.counting 4.groupingBy 4.1groupingBy(Function) 4.2groupingBy(Function, Collector) 4.3groupingBy(Function, Supplier, Collector) 5.groupingByConcurrent 5.1gro...
JAVA8之collect总结(给自己)
张肖的博客
07-18 3万+
一,collect是一个终端操作,它接收的参数是将流中的元素累积到汇总结果的各种方式(称为收集器) 二,预定义收集器包括将流元素归约和汇总到一个值.如下 工厂方法 返回类型 用于 toList List 把流中所有元素收集到List中 示例:List menus=Menu.getMenus.stre
java array 元素的位置_JAVA集合类，有这一篇就够了
weixin_39569747的博客
11-29 310
在使用Java的时候，我们都会遇到使用集合(Collection)的时候，但是JavaAPI提供了多种集合的实现，我在使用和面试的时候频频遇到这样的“抉择” 。 :)(主要还是面试的时候)久而久之，也就有了一点点的心得体会，写出来以供大家讨论 。总的说来，Java API中所用的集合类，都是实现了Collection接口，他的一个类继承结构如下：CollectionCollectionCollec...
Java中的Collections类
star_yang的博客
05-30 1万+
Java中的Collections类 从【Java】Java中的Collections类——Java中升级版的数据结构中学习整理而来。 一、 动态、有序、可变大小的一维数组Vector与ArrayList Collections类里面包括动态、有序、可变大小的一维数组Vector与ArrayList。 Vector与ArrayList，两者唯一的差别是：vector自带线程互斥，多个线程对...
java中Collections常用方法总结（包括sort，copy，reverse等）
Shiny0815的博客
03-16 1万+
1、sort(Collection)方法的使用(含义：对集合进行排序)。例：对已知集合c进行排序 public class Practice { public static void main(String[] args){ List c = new Arr...
java集合Collection常用方法详解
热门推荐
GalenGao
08-15 12万+
前言 出去面试的时候，对java的集合框架考察的知识点还是蛮多的。除了基础的集合常见API使用，对集合底层的实现原理以及数据结构等也有很多考察方面。而自己对这方面知之甚少，特地抽空进行研究和学习一下。 为什么要有集合 提到集合就不得不提一下数组，好多集合底层都是依赖于数组的实现。数组一旦初始化后，长度就确定了，存储数据对象不能达到动态扩展，其次数组存储元素不便于对数组进行添加、修改、删除操作，而且...
深入解析Java集合类HashMap的七页总结
资源摘要信息:"Java集合类HashMap总结" Java集合类是Java编程语言中用于存储对象集合的一个重要的组成部分，而HashMap是Java集合框架中最为常用的集合之一。HashMap实现了Map接口，是基于哈希表的Map接口实现，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值