快速掌握Java中List和Set接口的基本使用

叶落秋白

已于 2022-07-29 11:41:30 修改

阅读量2.1k

点赞数 63

分类专栏： # JavaSE 文章标签： java intellij-idea

于 2022-07-18 08:52:07 首次发布

本文链接：https://blog.csdn.net/m0_58618795/article/details/125839704

版权

JavaSE 专栏收录该内容

5 篇文章 8 订阅

订阅专栏

✅作者简介：C/C++领域新星创作者，热爱编程
✨个人主页：叶落秋白的主页
🔥系列专栏：JavaSE精品总结
📃推荐一款模拟面试、刷题神器👉注册免费刷题

🔥前言

别看我是个C/C++领域的活跃博主，其实放假以来都在卷java，就在昨天学习了java的反射和设计模式，正式结束了第一阶段。因此需要对重点部分做分析和总结来巩固这些基础知识，那么今天的主题就是List、Set集合的概念和使用了，接下来就请大家开始享用干货吧！

集合的概念

是一个工具类，作用为存储多个数据，通常用于替代数组

集合的特点

只能存放Object对象
- 只能存放引用类型
- 不能存放接口，只能存放接口实现类对象
来自java.util包

List接口

List的存储特点

有序、有下标、元素可以重复

常用实现类

ArrayList 最常用
- JDK1.2 底层数组实现查询快、增删慢线程不安全，效率高
一般不用
- JDK1.2 底层链表实现增删快，查询慢线程不安全，效率高
Vector 不用
- JDK1.0 底层数组实现都慢线程安全，效率低

创建

通常使用多态

List 集合名=new 实现类名();

常用方法

集合名.方法名

boolean add(元素)：将元素添加至集合末尾
void add(下标，元素)：将元素添加至指定下标位置
boolean addAll(集合名)：将指定集合所有元素添加至当前集合末尾
boolean addAll(下标，集合名)：将指定集合所有元素添加至当前集合指定下标位置
void clear()：清空集合元素
int size()：获取集合长度
boolean contains(元素)：判断集合中是否包含指定元素
boolean containsAll(集合名)：判断集合中是否包含指定集合的所有元素
元素 get(下标)：获取指定下标位置上的元素
int indexOf(元素)：获取指定元素第一次出现的下标，不存在返回-1
int lastIndexOf(元素)：获取指定元素最后一次出现的下标，不存在返回-1
boolean isEmpty()：判断集合元素是否为空，不能判比null值
元素 remove(下标)：移除指定下标的元素，返回该元素
元素 set(下标，新值)：将指定下标位置的值替换为新值，返回旧值
void sort(比较器实现类对象)：对集合元素按照指定规则排序
Object[] toArray()：将集合转换为数组

代码示例

public class Test {
        public static void main(String[] args) {
            List list = new ArrayList();
            list.add(66);
            list.add(5);
            list.add(77);//66 5 77
    
            list.add(2,44);//66 5 44 77
    
            List list2 = new ArrayList();
            list2.add(2);
            list2.add(1);
    
            list.addAll(list2);//66 5 44 77 2 1
            list.addAll(1, list2);//66 2 1 5 44 77 2 1
    
            System.out.println("清空之前："+list.size());
           // list.clear();
           // System.out.println("清空之后："+list.size());
            System.out.println(list.contains(5));//t
            System.out.println(list.containsAll(list2));//t
    
            List list3 = new ArrayList();
            list3.add(66);
            list3.add(77);
            list3.add(88);
            System.out.println(list.containsAll(list3));//f
    
            System.out.println(list.get(3));//5
    
            System.out.println(list.indexOf(88));//-1
            System.out.println(list.lastIndexOf(2));//6
    
            //list.clear();
            System.out.println(list.isEmpty());
            List list4=null;
            //System.out.println(list4.isEmpty()); 空指针异常
    
            System.out.println(list.remove(3));//66 2 1 44 77 2 1
            // System.out.println(list.remove(2));
    
            list.set(1, 88);//66 88 1 44 77 2 1
    
            Object[] os=list.toArray();
            for(int i=0;i<os.length;i++){
                System.out.print(os[i]+" ");
            }
            System.out.println();
        }
    }

遍历方法

for+get()

 for (int i = 0; i < 集合名.size(); i++) {
       //i代表当前下标
       //通过集合名.get(i)的方式获取当前元素
   }
   如：
 for (int i = 0; i < list.size(); i++) {
        System.out.print(list.get(i)+" ");
         }
        System.out.println();

迭代器遍历
- hasNext()：判断是否存在下一元素
- next()：指针后移，获取下一元素
  //获取迭代器对象
  Iterator it=集合名.iterator();
  while(it.hasNext()){//集合存在下一元素则继续后续操作
  //通过it.next()使指针后移，得到元素
  }
  如：
  Iterator it=list.iterator();
  while(it.hasNext()){
  System.out.print(it.next()+" ");
  }
  System.out.println();

tips：迭代过程中不允许对集合进行增删操作

外遍历forEach
for(数据类型元素名(随便起) ：集合名){
//元素名就代表当前元素
}
如：
for (Object o: list) {
System.out.print(o+" ");
}
System.out.println();
- 本质也是迭代器遍历，内部不允许进行增删操作
- JDK5.0

自遍历forEach
//匿名内部类
集合名.forEach(new Consumer() {
@Override
public void accept(Object o) {
//o就代表当前元素
}
});

 //lambda简化
         集合名.forEach(o-> {o就代表当前元素});
 如：
         list.forEach(new Consumer() {
             @Override
             public void accept(Object o) {
                 System.out.print(o + " ");
             }
         });
         System.out.println();
 
         // lambda
         list.forEach(o-> System.out.print(o+" "));

JDK8.0

泛型

作用

用于集合中，可以约束集合存储的数据类型

语法

List<数据类型> 集合名=new 实现类名<数据类型>();

使用

1. 如果集合中存放基本类型，则泛型必须声明为其包装类型
2. 声明泛型之后，集合中不允许存放其他类型的数据
3. 前后类型声明必须一致
4. 等号后边的泛型不声明，语法不规范
5. 等号前边的泛型不声明，泛型无意义

List<Integer> list = new ArrayList<Integer>();
        list.add(66);
        list.add(88);
       /* list.add("abc");
        list.add(5.5);*/
        list.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer i) {
                System.out.println(i);
            }
        });

Set接口

Collection

是一个接口
是List和Set的父接口
所有集合都由Collection或Map派生

特点

存放着List和Set的共有方法
没有自己的直接实现类

Set的存储特点

无序、无下标、元素不可重复

常用实现类

HashSet
- JDK1.2 底层哈希表实现(数组+链表又名散列表) 线程不安全，效率高
LinkedHashSet
- JDK1.2 是HashSet的子类，底层哈希表实现线程不安全，效率高
TreeSet
- JDK1.2 是SortedSet的实现类，底层红黑树实现线程不安全，效率高

创建

利用多态

Set<泛型类型> 集合名 = new 实现类名<泛型类型>();

常用方法

全部继承自Collection

遍历方法

Iterator迭代器遍历
外遍历forEach
自遍历forEach

哈希表的去重过程

先通过调用元素的hashCode()方法得到哈希码值
然后通过哈希码值%数组长度得到存放下标
若该下标位置未存放元素，则直接存放
若已存有元素，则调用当前元素的equals()方法与其位置的所有元素进行值的比较
都不相同，则链表存放
若有相同，舍弃当前元素

注意事项

当集合中存放的为自定义类型时，必须重写hashCode和equals才能保证去重
LinkedHashSet能够保证元素存入和取出顺序一致
TreeSet可以实现对元素进行默认的升序排序
- 如果存放的为自定义类型，必须重写排序规则
- 两种排序方式：
  1. 实现Comparable接口，重写compareTo方法
    - 要对谁排，就让谁实现
    - 原理：让当前对象与参数对象进行比较
    - 返回值规则：
      1. 从小到大：this的值>o的值,返回正数
      2. 从大到小：this的值>o的值,返回负数
      3. 相等返回0
  2. 实现Comparator接口，重写compare方法
    - 在集合创建处的小括号内传入该接口的实现类对象

          public class Test2 {
            public static void main(String[] args) {
                Set<Student> set = new TreeSet<Student>(new Comparator<Student>() {
                    @Override
                    public int compare(Student o1, Student o2) {
                        //根据学生年龄从大到小排序
                        return o2.getAge()-o1.getAge();
                    }
                });
                set.add(new Student("张三", 20));
                set.add(new Student("lisi", 21));
                set.add(new Student("lisi", 21));
                set.add(new Student("wangwu", 22));
                set.add(new Student("maliu", 19));
                set.forEach(s-> System.out.println(s));
            }
        }

默认识别第一种排序方式
第二种排序方式优先级高于第一种

List和set的区别

基本概念的区别

List 接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。List 接口存储一组不唯一，有序的对象。

Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。Set 接口存储一组唯一，无序的对象。

1.Set 接口实例存储的是无序的, 不重复的数据, List 接口实例存储的是有序的，可以重复的元素;
2.Set检索效率低下, 删除和插入效率高, 插入和删除不会引起元素位置改变
3.List和数组类似, 可以动态增长, 根据实际存储的数据的长度自动增长List的长度, 查找元素效率高, 插入删除效率低, 因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> ;

使用场景

List

常用的实现类有 ArrayList、LinkedList 和 Vector。ArrayList 最为流行，它提供了使用索引的随意访问，而 LinkedList 则对于经常需要从 List 中添加或删除元素的场合更为合适。

set

Set 接口最流行的几个实现类是 HashSet、LinkedHashSet 以及 TreeSet。最流行的是基于 HashMap 实现的 HashSet；TreeSet 还实现了 SortedSet 接口，因此 TreeSet 是一个根据其 compare() 和 compareTo() 的定义进行排序的有序容器。

📃结语

这篇博客就分析三个集合中的两个，下一篇博客总结Map接口的基本使用并附带一些面试的老生常谈问题。码文不易，觉得帮助到你了就给个三连呗~

叶落秋白

关注

63
点赞
踩
54

收藏

觉得还不错? 一键收藏
打赏
105
评论
快速掌握Java中List和Set接口的基本使用

别看我是个`C/C++`领域的活跃博主，其实放假以来都在卷`java`，就在昨天学习了java的反射和设计模式，正式结束了第一阶段。因此需要对重点部分做分析和总结来巩固这些基础知识，那么今天的主题就是`List、Set`集合的概念和使用了，接下来就请大家开始享用干货吧！.........
复制链接

扫一扫