1. 技术文章
  2. Java基础-集合

Java基础-集合

由 喜你入骨 提交于 2020-10-01 05:45:04

集合

集合的概念

  • 集合是对象的容器,定义了对多个对象进行操作的常用方法,可实现数组的功能

  • 集合和数组的区别:

  1. 数组长度固定,集合长度不固定

  2. 数组可以存储基本类型和引用类型,集合只能存储引用类型

Collection体系集合

Collection父接口方法

  • Iterator<E>iterator() 返回一个用于访问集合中各个元素的迭代器
  • int size() 返回当前存储在集合中的元素个数
  • boolean isEmpty() 如果集合中没有元素,返回true
  • boolean contains(Object obj) 如果集合中包含了一个与obj相等的对象,返回true
  • boolean containsAll(Collection<?> other) 如果这个集合包含other集合中的所以元素,返回true
  • boolean add(E element) 将一个元素添加到集合中,如果由于这个调用改变了集合,返回true
  • boolean addAll(Collection<? extends E> other) 将other集合中所以元素添加到这个集合.如果由于这个调用改变了集合,返回true
  • boolean remove(Object obj) 从这个集合中删除等于obj的对象.如果有匹配的对象被删除,返回true
  • boolean removeAll(Collectin<?> other) 从这个集合中删除other集合中存在的所以元素.如果这个调用改变了集合,返回true
  • default boolean removeIf(Predicate<? super E> filter) 从这个集合删除fileter返回true的所以元素.如果这个调用改变了集合,返回true
  • void clear() 从这个集合中删除所以的元素
  • boolean retainAll(Collection<?> other) 从这个集合中删除所以与other集合中元素不同的元素.如果由于这个调用改变了集合,返回true
  • Object[] toArray() 返回这个集合中的对象的数组
  • <T> T[] toArray(T[] arratToFill) 返回这个集合中的对象的数组.如果arrayToFill足够大,就将集合中的元素填入这个数组.剩余空间填补null;否则,分配一个新数组,其成员类型与arrayToFill的成员类型相同,其长度等于集合的大小,并填充集合元素.

List集合

  • 特点:有序,有下标,元素可重复,可使用sort排序
List接口新增方法
  • void add(int index,Object obj) 在index下标位置添加元素.如果由于这个调用改变了集合,返回true
  • boolean addAll(int index,Collection<? extends E> other) 在index下标的位置添加other集合中的所以元素
  • Object get(int index) 返回集合中指定位置的元素
  • List subList(int fromIndex,int toIndex) 返回fromIndex和toIndex之间的集合元素
List实现类
  • ArrayList
    1. 数组结构实现,查询快,增删慢
    2. JDK1.2版本,运行效率快,线程不安全
  • Vector
    1. 数组结构实现,查询快,增删慢
    2. JDK1.0版本,运行效率慢,线程安全
  • LinkedList
    1. 链表结构实现,增删快,查询慢
List代码实现
import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;

public class ListTest {
    public static void main(String[] args) {

        //1.定义ArrayList和LinkedList集合
        List<A> list1 = new ArrayList<>();
        List<A> list2 = new LinkedList<>();

        //2.添加元素
        list2.add(new A(0,"白龙马"));

        list1.add(new A(1,"唐玄奘"));
        list1.add(new A(2,"孙悟空"));
        list1.add(new A(3,"猪悟能"));
        list1.add(new A(4,"沙悟净"));
        list1.add(2,new A(10,"牛魔王"));

        list1.addAll(0,list2);

        //3.查看集合元素
        System.out.println(list1.toString());
        list2.forEach(a -> System.out.println(a));

        //4.遍历元素并获取要删除的牛魔王
        A tmp = null;
        for(A a:list1){
           if(a.ID == 10&&a.name.equals("牛魔王")){
               tmp = a;
               System.out.println("找到牛魔王啦");
           }
        }

        //5.删除元素
        System.out.println("牛魔王所在的下标位置是:"+list1.indexOf(tmp));
        list1.remove(tmp);
        System.out.println("删除牛魔王啦");
        System.out.println(list1.toString());

        //6.判断是否包含元素
        System.out.println("集合1中是否还有牛魔王:"+list1.contains(tmp));
        System.out.println("集合1中是否有集合2中的白龙马:"+list1.containsAll(list2));

        //7.判断集合的元素个数
        System.out.println("集合1中有多少个元素:"+list1.size());
        System.out.println("集合1中元素是否为空:"+list1.isEmpty());

        //8.将白龙马和孙悟空的视图存入个集合3
        List<A> list3 = list1.subList(0,3); //返回的是(0-3]区间的视图,
        System.out.println(list3.toString());

        //9.对集合按照ID进行排序
        list1.sort(new Comparator<A>() {
            @Override
            public int compare(A o1, A o2) {
                if(o1.ID<o2.ID)return 1;
                else if(o2.ID<o1.ID)return -1;
                else return 0;
            }
        });
        System.out.println("按照降序进行排列:");
        System.out.println(list1);

        //10.清空所有集合
        list1.clear();
        list2.clear();
        list3 = null; //视图不可清空否则异常
    }
}


class A{
    public int ID;
    public String name;

    public A(int ID, String name) {
        this.ID = ID;
        this.name = name;
    }

    @Override
    public String toString() {
        return "ID=" + ID +
                ", name=" + name ;
    }
}

Set集合

  • 特点:无序,无下标,元素不可重复
Set接口新增方法
  • 全部继承自Collection父接口方法
Set实现类
  • HashSet
    1. 基于HashCode实现元素不重复,如果自定义类型不实现HashCode将取消去重功能
    2. 当存入元素的哈希码相同时,会调用==或equals进行确认,结果为true,拒绝后者存入
  • LinkedHashSet
    1. 链表实现的HashSet,按照链表进行存储,即可保留元素的插入顺序
  • TreeSet
    1. 基于排列顺序实现元素不重复
    2. 实现类SortedSet接口,对集合元素自动排序
    3. 元素对象的类型必须实现Comparable接口,指定排序规则
    4. 通过ComparTo方法确定是否为重复元素
Set代码实现
import java.util.*;

public class SetTest {
    public static void main(String[] args) {

        Set<B> set1 = new HashSet<>();
        Set<B> set2 = new LinkedHashSet<>();
        Set<B> set3 = new TreeSet<>(new Comparator<B>() {	//必须实现Comparator接口否则异常
            @Override
            public int compare(B o1, B o2) {
                if(o1.ID>o2.ID)return 1;
                else if(o1.ID<o2.ID)return -1;
                return 0;
            }
        });

        //1.添加元素
        set1.add(new B(5,"孙悟空"));
        set1.add(new B(5,"孙悟空"));
        set1.add(new B(4,"猪悟能"));
        set1.add(new B(3,"唐玄奘"));

        set2.add(new B(1,"沙悟净"));
        set2.add(new B(0,"白龙马"));
        set2.add(new B(3,"唐玄奘"));

        set3.addAll(set2);
        set1.addAll(set2);

        //2.查看元素(这里对象定义了HashCode和equals所有具有去重效果,只添加了一个孙悟空)
        System.out.println(set1.toString());
        System.out.println(set2.toString());    //按照插入顺序进行
        System.out.println(set3.toString());    //按照Comparator比较顺序进行

        //3.遍历集合
        for (B b:set1){
            System.out.println(b);
        }

        //4.数组转换
        Object[] arrb = set1.toArray();
        System.out.println("数组转换后打印"+Arrays.toString(arrb));

        //5.判断元素是否包含
        System.out.println("集合1是否包含集合2:"+set1.containsAll(set2));

        //6.删除元素
        set1.removeAll(set2);
        System.out.println(set1);

        //7.清空集合
        set1.clear();
        set2.clear();
        set3.clear();
    }
}

class B{
    public int ID;
    public String name;

    public B(int ID, String name) {
        this.ID = ID;
        this.name = name;
    }

    @Override
    public String toString() {
        return "ID=" + ID +
                ", name=" + name ;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        B b = (B) o;
        return ID == b.ID &&
                Objects.equals(name, b.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(ID, name);
    }
}

Collections和Arrays工具类

Collections常用方法

  • public static void reverse(List<?> list) 反转集合中元素的顺序
  • public static void shuffle(List<?> list) 随机重置集合中元素的顺序
  • public static void sort(List<?> list) 升序排序(元素必须实现Comparable接口)
  • public static void sort(List<?> list,Comparator c) 定制排序,按照Comparator顺序排序
  • void swap(List<?>list ,int i,int j) 交换两个索引位置的元素
  • void rotate(List list, int distance) 旋转.当distance为正数时,将list后distance个元素整体移到前面.当distance为负数时,将list的前distance个元素整体移到后面
  • int binarySearch(List list, Object key) 对List进行二分查找,返回索引,注意List必须是有序的
  • int max(Collection coll) 根据元素的自然顺序,返回最大的元素
  • int max(Collection coll, Comparator c) 根据定制排序,返回最大元素,排序规则由Comparator类控制
  • void fill(List list, Object obj) 用指定的元素代替指定list中的所有元素
  • int frequency(Collection c, Object o) 统计元素出现次数a
  • int indexOfSubList(List list, List target) 统计target在list中第一次出现的索引,找不到则返回-1
  • boolean replaceAll(List list, Object oldVal, Object newVal) 用新元素替换旧元素
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CollectionsTest {
    public static void main(String[] args) {

        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(4);
        list.add(3);
        list.add(5);
        list.add(2);
        System.out.println("原数组:");
        System.out.println(list);

        System.out.println("反转:");
        Collections.reverse(list);
        System.out.println(list);

        System.out.println("排序:");
        Collections.sort(list);
        System.out.println(list);

        System.out.println("乱排:");
        Collections.shuffle(list);
        System.out.println(list);

        System.out.println("交换:");
        Collections.swap(list,0,4);
        System.out.println(list);

        System.out.println("旋转:");
        Collections.rotate(list,-1);
        System.out.println(list);

        System.out.println("最大数:");
        int max = Collections.max(list);
        System.out.println(max);
    }

}

Arrays常用方法

  • 排序 : sort()
  • 查找 :binarySearch()
  • 比较: equals()
  • 填充 : fill()
  • 转列表: asList()
  • 转字符串 : toString()
  • 复制: copyOf()
import java.util.Arrays;
import java.util.List;

public class ArraysTest {
    public static void main(String[] args) {

        int[] arr = new int[]{5,3,4,2,1};

        System.out.println("原数组:");
        System.out.println(Arrays.toString(arr));

        System.out.println("排序:");
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

        System.out.println("转List接口:");
        List list = Arrays.asList(8,5,7);
        System.out.println(list);
    }
}

Map体系集合

Map父接口方法

  • V get(Object key) 获取与键关联的值;返回与键关联的对象,或者如果映射中没有这个对象,则返回null,实现类可以禁止键为null
  • default V getOrDefault(Object key,V defaultValue) 获得与键关联的值;返回与键关联的对象,或者如果未在映射中找到这个键,则返回defaultValue
  • V put(K key,V value) 将关联的一对键和值放到映射中.如果这个键已经存在,新对象将取代与这个键关联的旧对象.这个方法将返回键关联的旧值.如果之前没有这个键,则返回null.实现类可以禁止键或值为null
  • void putAll(Map<? extends K,? extends V> entries) 将给定映射中的所有映射条目添加到这个映射中
  • boolean containsKey(Object Key) 如果在映射中已经有这个值,返回true
  • default void forEach(BiConsumer<? super K,? super V> action) 对这个映射中的所以键/值对应用这个动作
  • Set<Map.Entry<K,V>> entrySet() 返回此地图中包含的映射的Set视图
  • Set<K> KeySet() 返回此地图中包含的键的Set视图
  • Collection<V> values() 返回此地图中包含的值的Collection视图

Map实现类

  • HashMap
    1. JDK1.2版本,线程不安全,运行效率快,允许用null作为键或值
    2. 基于HashCode实现元素不重复,如果自定义类型不实现HashCode将取消去重功能
    3. 当存入元素的哈希码相同时,会调用==或equals进行确认,结果为true,拒绝后者存入
    4. 插入元素按照散列码排列,无序
  • LinkedHashMap
    1. 在HashMap的基础增加了链表,使插入的元素变得有序
  • HashTable
    1. JDK1.0版本,线程安全,运行效率慢,不允许null作为键或值
  • Properties
    1. HashTable的子类,要求键和值都是String类型,通常用于配置文件的读取
  • TreeMap
    1. 实现了SortedMap接口,可以对键自动排序,Key需要实现Comparable接口,Key不允许为null

Map代码实现

import java.util.*;

public class MapTest {
    public static void main(String[] args) {

        Map<C,Integer> map1 = new HashMap<>();
        Map<C,Integer> map2 = new LinkedHashMap<>();
        Map<C,Integer> map3 = new TreeMap<>(new Comparator<C>() {
            @Override
            public int compare(C o1, C o2) {
                if(o1.ID>o2.ID)return 1;
                else if(o1.ID<o2.ID)return -1;
                return 0;
            }
        });

        //1.添加元素
        map1.put(new C(0,"孙悟空"),1);
        map1.put(new C(0,"孙悟空"),1); //没有插入进去
        map1.put(new C(1,"猪悟能"),2);
        map1.put(new C(2,"沙悟净"),3);
        map1.put(null,4);
        map1.put(new C(3,"唐玄奘"),null);

        map2.put(new C(4,"白龙马"),4);
        map2.put(new C(5,"红孩儿"),5);
        map1.putAll(map2);
        map3.putAll(map2);

        //2.查看元素
        System.out.println("乱序:"+map1.toString());
        System.out.println("按顺序排序"+map3.toString());
        
        //3.遍历Key键值并获取红孩儿的对象
        C tmpc = null;
        Set<C> setc = map1.keySet();
        System.out.println("遍历key值:");
        for (C c: setc){
            if(c != null &&5 == c.ID&&"红孩儿".equals(c.name)){
                tmpc = c;
            }
            System.out.print(c);
        }

        //4.遍历values值
        System.out.println();
        Collection<Integer> inti = map1.values();
        System.out.println("遍历values值:");
        for(Integer i:inti){
            System.out.print(i);
        }

        //5.使用entry对象遍历
        System.out.println();
        Iterator<Map.Entry<C,Integer>> it =map1.entrySet().iterator();
        for (;it.hasNext();){
            Map.Entry<C,Integer> me= it.next();
            System.out.print("键:"+me.getKey());
            System.out.print("值:"+me.getValue());
            System.out.println();
        }

        //6.替换红孩儿值为99999
        map1.replace(tmpc,99999);
        System.out.println(map1.toString());

    }
}
class C{
    public int ID;
    public String name;

    public C(int ID, String name) {
        this.ID = ID;
        this.name = name;
    }

    @Override
    public String toString() {
        return "ID=" + ID +
                ", name=" + name ;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        C c = (C) o;
        return ID == c.ID &&
                Objects.equals(name, c.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(ID, name);
    }
}

总结

  • 集合的概念:对象的容器,存储对象的对象,定义了对多个对象进行操作的方法
  • List集合:有序,有下标,元素可以重复(ArrayList,LinkedList,Vector)
  • Set集合:无下标,元素不可重复(HashSet,LinkedHashSet,TreeSet)
  • Map集合:存储一对数据,键不可重复,值可重复(HashMap,HashTable,Properties,TreeMap)
  • Collections:集合工具类,定义了除了存取以外的集合常用方法
  • Arrays:数组工具类,实现数组快速排序
标签
JDK
treemap
Entry
java
ASList
next
element
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!