集合类的笔记整理

最新推荐文章于 2022-08-19 22:43:11 发布

书中客522

最新推荐文章于 2022-08-19 22:43:11 发布

阅读量276

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_59227724/article/details/122505043

版权

集合

集合类的概念

Java提供了一些类，这些类相当于容器，能够存储一系列的对象的引用，统称为集合类，其中存储的每个内容称为元素。

集合中的接口有两个，分别是collection接口和map接口。

方法	功能描述
add(E e)	将指定元素添加到集合，E代指该集合中储存元素的类型
addAll(Collection<? extends E> e)	将指定集合全部添加到该集合当中
clear()	将集合内所有元素清除
contain(Object o)	判断该集合是否包含指定对象，包含则返回true，不包含则返回false
isEmpty()	判断该集合是否为空（即不包含任何元素）
remove(Object o)	将指定对象从集合中删除
size()	返回集合包含元素的个数
iterator()	返回该集合包括所有元素的迭代器

List集合

List集合概述

List接口可以保证元素在集合中的顺序，且可以重复，元素在集合中的索引与数组类似，额外提供了get()和set()方法，可以通过索引来获取List中的指定元素。

ArrayList类

实现类List接口，同时继承了AbstractList类，实现了可变大变小的数组（数组容量不可变，但是ArrayList容量可以动态增长），允许有null元素。但是要注意，ArrayList类在List的指定位置插入和移除元素时性能较差。

ArrayList类的一些常用方法:

方法	功能描述
sort(Comparator<? super E> e)	根据指定的Comparator比较器对所有元素排序
subList(int fromIndex,int toIndex)	根据索引范围获取指定集合内的子集合
trimToSize()	将ArrayList大小重新修正为当前所有元素的大小，用于缩减该集合所占内存
indexOf(Object o)	返回指定对象在该集合中的索引，如果有多个则返回第一个
lastIndexOf(Object o)	返回指定对象在该集合中的索引，如果有多个则返回最后一个

LinkedList类

实现了List接口，使用了链表结构*进行存储，允许有null元素。与ArrayList相对的，LinkedList在频繁插入和移除时性能较高，但是在遍历和随机访问时性能就较差了。

LinkedList的常用方法:

方法	功能描述
pop()	从该集合所在的堆栈中取出一个元素
push(E e)	将指定元素放入该集合所在的堆栈
offer(E e)	将指定元素添加到该集合的末尾
peek()	获取但不移除该集合的第一个元素

链表结构：在每个元素的前后会有两个节点，为null，第一个元素与第二个元素的一个节点会相互链接，从而定下顺序以及确定位置。

一些List集合中的用法举例

添加：

    private static List<StandEnvy> list=new ArrayList<>();
    public static List<StandEnvy> getDIOItem(){
        list.add(new StandEnvy("DIO","世界",90));
        list.add(new StandEnvy("荷尔荷斯","皇帝",40));
        list.add(new StandEnvy("花京院典明","绿色法皇",50));
        list.add(new StandEnvy("波鲁纳雷夫","银色战车",45));

        return list;
    }
    private static List<StandEnvy> list=new ArrayList<>();
    public static List<StandEnvy> getJOJOItem(){

        list.add(new StandEnvy("空条承太郎","白金之星",100));
        list.add(new StandEnvy("花京院典明","绿色法皇",50));
        //老家伙你的替身最没用啦！！
        list.add(new StandEnvy("乔瑟夫.乔斯达","隐者之紫",5));
        list.add(new StandEnvy("波鲁纳雷夫","银色战车",45));
        list.add(new StandEnvy("阿布嘟嘟","卖鸡小子",60));
        list.add(new StandEnvy("伊奇","沙子",40));

        return list;
    }

用法混合：

        List<StandEnvy> JOJOTeam =JOJO.getJOJOItem();
        List<StandEnvy> DIOTeam=DIO.getDIOItem();

        //retainAll(collection coll):交集:获取当前集合和coll的交集部分
        JOJOTeam.retainAll(DIOTeam);
        System.out.println(JOJOTeam);

        //equal:所有元素相同才会返回ture
        System.out.println(JOJOTeam.equals(DIOTeam));

        //定向插入
        JOJOTeam.add(1,new StandEnvy("空条徐伦","石之海",75));
        for (StandEnvy standEnvy:JOJOTeam){
            System.out.println(standEnvy);
        }
        //求集合长度 size
        System.out.println(JOJOTeam.size());
        //获得指定元素的位置 index
        System.out.println(JOJOTeam.indexOf(new StandEnvy("空条徐伦","石之海",75)));
      
        //更改指定位置元素 set
        JOJOTeam.set(4,new StandEnvy("波鲁纳雷夫（战损）","白银镇魂曲",500));
        for (StandEnvy standEnvy:JOJOTeam){
            System.out.println(standEnvy);
        }

        //指定位置输出 sublist(start,end) 注意输出的量是end-start 输出范围是左开右闭
        System.out.println(JOJOTeam.subList(0,2));

两种遍历方法：

        //1.使用迭代器
        Iterator<StandEnvy> DIOit=DIOTeam.iterator();
        while (DIOit.hasNext()){
            System.out.println(DIOit.next());
        }
        //2.使用增强for循环
        for (Object Dio:DIOTeam){
            System.out.println(Dio);
        }

Set集合

Set集合概述

继承了Collection接口，且与List类似，也支持元素的插入和移除等操作。与List不同的是，Set集合具有无序性和不可重复性。Set的不可重复性的底层是建立在hashMap的逻辑上实现的。也就是说，Set集合查重本质上也是通过比较元素的哈希值，这就为我们对数据进行排序提供了操作空间。我们在自定义对象时，进行equals和hashCode方法的重写，就可以按照我们想要的方法进行添加数据。

注意点1*虽然Set允许null的存在，但是Set集合的某些方法是不允许null的，会有空指针异常和ClassCaseException异常。且不提供Set()和Get()方法。

注意点2*虽然Set具有无序性，但是无序性和随机性是不同的，Set使用了某种逻辑进行排序。

有关哈希值的注意点：

1.重写hashCode方法时，在equals中出现过的属性，都应包含在hashCode方法中。
2.当两个对象equals相同时，其哈希值也应当相同
3.默认情况下，哈希值是由地址决定的，因此使用new造对象时，即使两个对象内容相同，也会被重复添加，因此，添加对象时，往往要求重写hashCode方法

HashSet类

实现了Set接口，由哈希表支持。不保证Set内元素的顺序，因而输入和输出顺序会有所不同。

Set和List的方法基本相同，因此这里就不再重复了。

LinkedHashSet类

LinkedHashSet算是HashSet的衍生了，也是采用了链式列表的逻辑。

TreeSet类

同时实现了Set接口和NavigableSet接口。这使得其可以使用自然排序对元素进行排序，也可以根据自定义排序进行排序。

TreeSet常用方法：

方法	功能描述
ceiling(E e)	返回该集合中大于等于给定元素的最小元素，若不存在，则返回null
descendingIterator()	返回该集合按降序进行迭代的迭代器
first()	返回该集合中当前第一个元素
floor(E e)	返回该集合中小于等于给定元素的最最大元素，若不存在，则返回null
last()	返回该集合中当前最后一个元素
higher(E e)	返回该集合中严格大于给定元素的最小元素，若不存在，则返回null
lower(E e)	返回该集合中严格小于给定元素的最大元素，若不存在，则返回null
headSet(E toElement)	返回该集合中的部分集合，其元素严格小于入参元素（不包括）
subSet(E fromElement,E toElement)	返回该集合中的部分集合，其元素从fromElement（包括）到toElement（不包括）
tailSet(E fromElement)	返回该集合中的部分集合，其元素严格大于或等于入参元素（包括）

一些Set集合的用法举例

添加

    private static TreeSet<StandEnvy> set=new TreeSet<StandEnvy>();

    public static TreeSet<StandEnvy> getSet() {
        set.add(new StandEnvy("波鲁纳雷夫（残疾）","白银镇魂曲",500));
        set.add(new StandEnvy("乔鲁诺.乔巴纳","黄金镇魂曲",600));
        set.add(new StandEnvy("华强","西瓜刀",250));
        set.add(new StandEnvy("穿山甲","鸡汤配手雷",321));
        return set;
    }

一些用法、遍历

参照Set

Map集合

Map集合概述

提供了键值对的存储能力，即key-value。具体理解可以参照数学中的y=f(x)。

注意Map中的key是不可以重复的，而value可以重复，打个比方，世界上不可能有两个相同的人，但是这两个人可以同岁。

key和value必须是成对出现的。

Map中的常用方法：

方法	功能描述
put(K key,V value)	将指定的key-value映射添加到该集合中，K指代存储在该集合中的key类型，V指代映射值的value类型
putAll(Map<? extends K,? extends V> m)	将指定的Map集合添加到该集合中
clear()	将该集合内所有键值对清除
containsKey(Object key)	判断该集合的key中是否包含指定对象，包含则返回true，不包含则返回false
containsValue(Object value)	判断该集合的value中是否包含指定对象，包含则返回true，不包含则返回false
isEmpty()	判断集合是否为空（即不包含任何键对）
remove(Object key)	将指定的key-value映射从该集合中删除
size()	返回该集合包含key-value映射的个数
entrySet()	返回该集合中所有键值对的Set集合
keySet()	返回该集合中所有key的Set集合
get(Object key)	返回指定key映射的值，若不存在该key则返回null
hashCode()	返回此映射的哈希值

HashMap

实现了Map接口，同时继承于AbstractMap类。利用哈希值来存储，不允许重复键的出现。

TreeMap

基本与TreeSet相同，见上即可

Map常用方法

        Map map=new HashMap();
        //添加操作
        map.put("aa",11);
        map.put("bb",22);
        map.put("cc",33);
        System.out.println(map);
        //修改
        map.put("aa",12);
        System.out.println(map);

        Map map1=new HashMap();
        map1.put("dd",78);
        map1.put("ee",94);
        map1.put("bb",16);
        //全部存放
        map1.putAll(map);
        System.out.println(map1);

        //移除 remove(Object key)
        map1.remove("aa");
        System.out.println(map1);
        //Object get(Object key)
        System.out.println(map.get("aa"));
        //containKey(Object key)
        boolean isExist=map1.containsKey("aa");
        System.out.println(isExist);
        isExist=map1.containsValue(78);
        System.out.println(isExist);

        //遍历遍历key
        Set set = map1.keySet();
        System.out.println(set);
        //遍历所有value
        Collection values = map1.values();
        for (Object obj:values){
            System.out.println(obj);
        }
        //遍历key-value
        Set entry = map1.entrySet();
        for (Object obj : entry) {
            Map.Entry entry1 = (Map.Entry) obj;
            System.out.println(entry1.getKey()+"--->"+entry1.getValue());
        }

排序法（补充）

上次被提问到结果没答出来，这里稍微整理一下*

自然排序

1.直接使用Arrays的sort方法-->底层使用comparaTo

        String[] arr=new String[]{"AA","CC","KK","MM","GG","JJ","DD"};
        Arrays.sort(arr);
        for (Object o:arr){
            System.out.println(o);
        }

2.使用自定义的comparable

某些自定义类要进行排序时，要继承接口

例：

public class Goods implements Comparable{
    private String name;
    private double price;
        @Override
    public int compareTo(Object o) {
        if (o instanceof Goods){
            Goods goods=(Goods) o;
            //方式一:
            if (this.price>goods.price){
                return 1;
            }else if(this.price<goods.price){
                return -1;
            }else return 0;
           //方式二:
         //   return Double.compare(this.price,goods.price);
        }
        return 0;
    }
}

此时再使用Arrays的sort方法就可以按照想要的顺序排序

2.定制排序

比较器comparator中的方法与comparaTo是很相似的

        String[] arr=new String[]{"AA","CC","KK","MM","GG","JJ","DD"};
        Arrays.sort(arr, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                if (o1 instanceof String && o2 instanceof String){
                    String s1=(String) o1;
                    String s2=(String) o2;
                    return -s1.compareTo(s2);
                }
                return 0;
            }
        });
        for (Object o:arr){
            System.out.println(o);
        }

材料来自：尚硅谷、《零基础Java从入门到精通》

书中客522

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
集合类的笔记整理

目录集合集合类的概念List集合Set集合集合集合类的概念Java提供了一些类，这些类相当于容器，能够存储一系列的对象的引用，统称为集合类，其中存储的每个内容称为元素。集合中的接口有两个，分别是collection接口和map接口。方法功能描述 add(E e) 将指定元素添加到集合，E代指该集合中储存元素的类型 addAll(Collection<? extends E> e) 将指定集合全部添加...
复制链接

扫一扫