java集合，你值得学习

最新推荐文章于 2024-07-10 21:37:49 发布

行行·失故路

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量180

点赞数 8

文章标签： java 后端集合

本文链接：https://blog.csdn.net/m0_62931396/article/details/121157659

版权

集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变

集合类的体系图

1. Collection集合

1.1 概述

Collection集合是单列集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素 JDK 不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现

Collection集合基本使用：

public class Demo {
    public static void main(String[] args) {
        //创建Collection集合的对象
        Collection<String> c = new ArrayList<String>();
        //添加元素：boolean add(E e)
        c.add("猫");
        c.add("狗");
        c.add("老鼠");
        //输出集合对象
        System.out.println(c);

    }
}

1.2 常用方法

boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

1.3 迭代器

介绍：迭代器是集合的专用遍历方式 Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到

迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的

代码演示：

public class Demo {
    public static void main(String[] args) {
        //创建Collection集合的对象
        Collection<String> c = new ArrayList<String>();
        //添加元素：boolean add(E e)
        c.add("猫");
        c.add("狗");
        c.add("老鼠");
        
        //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();

        //用while循环改进元素的判断和获取
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
    }
}

运行结果：

2. List集合

2.1 概述

有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素

特点：

1）有索引

2）可以存储重复元素

3）元素存取有序

2.2 特有方法

add(int index,E element)	指定位置插入指定的元素
remove(int index)	删除指定索引处的元素，返回被删除的元素
set(int index,E element)	修改指定索引处的元素，返回被修改的元素
get(int index)	返回指定索引处的元素

2.3 List集合迭代器

通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器

public class Demo {
    public static void main(String[] args) {
        //创建List集合对象
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("猫");
        list.add("狗");
        list.add("老鼠");
        //获取列表迭代器
        ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()) {
            String s = lit.next();
            System.out.println(s);
        }
    }
}

2.4 增强for循环

格式：

for(元素数据类型变量名 : 数组/集合对象名) {

循环体; }

内部原理是一个Iterator迭代器，使用增强for循环可以减少代码量，而且简单

代码演示：

public class Demo {
    public static void main(String[] args) {
        //创建List集合对象
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("猫");
        list.add("狗");
        list.add("老鼠");
        //增强for循环
        for(String s : list) {
            System.out.println(s);
        }
    }
}

2.5 实现类

ArrayList集合

1）底层是数组结构实现，查询快、增删慢

2）LinkedList集合底层是链表结构实现，查询慢、增删快

特有方法：

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

3. Set集合

3.1 特点

1）存储无序

2）没有索引

3）只能通过迭代器和增强型for循环

4）不能存储重复元素

3.2 哈希值

哈希值是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

特点：

1）同一个对象多次调用hashCode()方法返回的哈希值是相同的

2）重写hashCode()方法，可以实现让不同对象的哈希值相同

获取哈希值：hashCode()

3.3 HashSet集合

特点：

1）底层数据结构是哈希表

2）不保证存储和取出的元素顺序一致

3）没有带索引的方法，不能使用普通for循环遍历

4）不包含重复元素的集合

代码演示：

public class Demo {
    public static void main(String[] args) {
        //创建Set集合对象
        Set<String> set = new HashSet<>();
        //添加元素
        set.add("猫");
        set.add("狗");
        set.add("老鼠");
        //增强for循环
        for(String s : set) {
            System.out.println(s);
        }
    }
}

运行结果：

3.4 LinkedHashSet集合

特点：

1）哈希表和链表实现的Set接口，具有可预测的迭代次序

2）由链表保证元素有序，也就是说元素的存储和取出顺序是一致的

3）由哈希表保证元素唯一，也就是说没有重复的元素

代码演示：

public class Demo {
    public static void main(String[] args) {
        //创建Set集合对象
        Set<String> set = new LinkedHashSet<>();
        //添加元素
        set.add("猫");
        set.add("狗");
        set.add("老鼠");
        //增强for循环
        for(String s : set) {
            System.out.println(s);
        }
    }
}

运行结果：

3.5 TreeSet集合

1）元素有序，可以按照一定的规则进行排序，具体排序方式取决于构造方法

TreeSet()：根据其元素的自然排序进行排序

TreeSet(Comparator comparator) ：根据指定的比较器进行排序

2）没有带索引的方法，所以不能使用普通for循环遍历

3）由于是Set集合，所以不包含重复元素的集合

代码演示：

public class Demo {
    public static void main(String[] args) {
        //创建TreeSett集合对象
        TreeSet<Integer> ts = new TreeSet<>();
        //添加元素
        ts.add(10);
        ts.add(50);
        ts.add(30);
        ts.add(20);
        ts.add(40);
        //增强for循环
        for(Integer i : ts) {
            System.out.println(i);
        }
    }
}

运行结果：

4. Map集合

4.1 概述

interface Map<K,V> K：键的类型；V：值的类型

特点：

1）键值对映射关系

2）一个键对应一个值键不能重复，

3）值可以重复元素存取无序

基本使用：

public class Demo {
    public static void main(String[] args) {
        //创建Map集合对象
        Map<Integer,String> map = new HashMap<>();
        //添加元素
        map.put(1,"猫");
        map.put(2,"老鼠");
        map.put(3,"狗");
        //输出集合对象
        System.out.println(map);
    }
}

4.2 基本方法

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

代码演示：

public class Demo {
    public static void main(String[] args) {
        //创建Map集合对象
        Map<Integer,String> map = new HashMap<>();
        //添加元素
        map.put(1,"猫");
        map.put(2,"老鼠");
        map.put(3,"狗");
        //V remove(Object key)：根据键删除键值对元素
//        System.out.println(map.remove(1));
//        System.out.println(map.remove(2));

        //void clear()：移除所有的键值对元素
//        map.clear();

        //boolean containsKey(Object key)：判断集合是否包含指定的键
//        System.out.println(map.containsKey(1));
//        System.out.println(map.containsKey(2));

        //boolean isEmpty()：判断集合是否为空
//        System.out.println(map.isEmpty());

        //int size()：集合的长度，也就是集合中键值对的个数
//        System.out.println(map.size());

        //输出集合对象
//        System.out.println(map);
    }
}

4.3 获取方法

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

代码演示：

public class Demo {
    public static void main(String[] args) {
        //创建Map集合对象
        Map<Integer,String> map = new HashMap<>();
        //添加元素
        map.put(1,"猫");
        map.put(2,"老鼠");
        map.put(3,"狗");
        //V get(Object key):根据键获取值
//        System.out.println(map.get(1));
//        System.out.println(map.get(2));

        //Set<K> keySet():获取所有键的集合
//        Set<String> keySet = map.keySet();
//        for(String key : keySet) {
//            System.out.println(key);
//        }

        //Collection<V> values():获取所有值的集合
//        Collection<String> values = map.values();
//        for(String value : values) {
//            System.out.println(value);
//        }
    }
}

5. Collections集合工具类

Collections集合工具类是针对集合操作的工具类

5.1常用方法

public static void sort(List<T> list)	将指定的列表按升序排序
public static void reverse(List<?> list)	反转指定列表中元素的顺序
public static void shuffle(List<?> list)	使用默认的随机源随机排列指定的列表

代码演示：

public class Demo {
    public static void main(String[] args) {
        //创建集合对象
        List<Integer> list = new ArrayList<Integer>();

        //添加元素
        list.add(30);
        list.add(20);
        list.add(50);
        list.add(10);
        list.add(40);

        //public static <T extends Comparable<? super T>> void sort(List<T> list)：将指定的列表按升序排序
//        Collections.sort(list);

        //public static void reverse(List<?> list)：反转指定列表中元素的顺序
//        Collections.reverse(list);

        //public static void shuffle(List<?> list)：使用默认的随机源随机排列指定的列表
        Collections.shuffle(list);

        System.out.println(list);
    }
}

行行·失故路

关注

8
点赞
踩
3

收藏

觉得还不错? 一键收藏
8
评论
java集合，你值得学习

目录1. Collection集合1.1 概述1.2 常用方法1.3 迭代器2. List集合2.1 概述2.2 特有方法2.3 List集合迭代器2.4 增强for循环2.5 实现类3. Set集合3.1 特点3.2哈希值3.3HashSet集合3.4 LinkedHashSet集合3.5 TreeSet集合 4. Map集合 4.1 概述4.2 基本方法4.3 获取方法5. Collections集合工具类...
复制链接

扫一扫