Java 集合

最新推荐文章于 2024-10-16 10:13:45 发布

Patient365

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量191

点赞数

分类专栏： java基础文章标签： java 开发语言数据结构

本文链接：https://blog.csdn.net/weixin_51750759/article/details/125649443

版权

java基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

集合

集合就像是一种容器，用于存储、获取、操作对象的容器

数组的弊端

数组的长度不可变
数组中没有提供可以查看有效元素个数的方法

集合的特点

集合的长度是可变的
集合可以存储任意类型的对象
集合中只能存储对象

集合框架

在这里插入图片描述

Collection : 集合层次的根接口
	List : 有序的，并且允许重复的。List 系列集合都有索引值
		ArrayList :  采用数组结构存储元素。查询操作多时选择。  **10 1.5倍扩容**
		LinkedList : 采用链表结构存储元素。增删操作多时选择。
		Vector:是一个古老的实现，采用数组结构存储元素，是线程安全的，因此效率低。
	Set : 无序的，并且不允许重复。
		HashSet：是 Set 接口的典型实现类。判断元素是否存在的依据是 先比较 hashCode() 若 hashCode() 存在，则通过 equals() 比较对象的内容，若不存在则直接存储   16   0.75扩容 2倍  链表长度大于7  总元素个数大于64 链表转为红黑树
			 LinkedHashSet: 是 HashSet 的子类，相较于 HashSet 多了链表维护元素的顺序，遍历的效率高于 HashSet ，增删效率低于 HashSet
		TreeSet:拥有指定的排序方式
			自然排序（Comparable）：
				 添加到 TreeSet 集合中对象的类实现 Comparable 接口
				 实现接口中的 compareTo(Object o)
		    定制排序（Comparator）：
				 声明一个类实现 Comparator 接口
				 实现接口中的 compare(Object o1, Object o2)
				 将该实现类的实例作为参数传递给 TreeSet 的构造器

collection的方法

public void test1(){
        //1. 通过 Collection 接口的实现类 ArrayList 创建实例
        Collection coll = new ArrayList();

        //2. add(Object o):向集合中添加元素
        coll.add("BB");
        coll.add(123);//自动装箱
        coll.add(new Person("张三", 18));
        coll.add(new String("AA"));

        System.out.println(coll);

        //3. size() : 获取集合中有效元素的个数
        int size = coll.size();
        System.out.println(size);

        //4. clear() : 清空集合中所有的元素
//        coll.clear();
        System.out.println(coll);

        //5. isEmpty() : 判断集合是否为空
        boolean boo = coll.isEmpty();
        System.out.println(boo);

    public void test2(){
        Collection coll = new ArrayList();
        coll.add("BB");
        coll.add(123);//自动装箱
        coll.add(new Person("张三", 18));
        coll.add(new String("AA"));

        //6. addAll(Collection coll) : 将 coll 中所有的元素添加到当前集合中
        Collection coll2 = Arrays.asList(1, 2, 3, 4, 5);//将数组转换成集合
        coll.addAll(coll2);
        System.out.println(coll);


        //7. contains(Object o) : 判断集合中是否包含某对象,判断元素是否存在的依据是 equals()
        /*boolean bb1 = coll.contains(new String("AA"));
        System.out.println(bb1);

        boolean bb2 = coll.contains(new Person("张三", 18));
        System.out.println(bb2);*/

        //8. containsAll(Collection coll) : 判断 coll 中所有的元素是否包含在当前集合
        Collection coll3 = new ArrayList();
        coll3.add("BBb");
        coll3.add(new Person("张三", 18));

        System.out.println(coll.containsAll(coll3));
    }
    public void test3(){
        Collection coll = new ArrayList();
        coll.add("BB");
        coll.add(123);//自动装箱
        coll.add(new Person("张三", 18));
        coll.add(new String("AA"));
        coll.add("hello");

        //9. remove(Object o) : 删除集合中的指定对象
        /*coll.remove("BB");
        coll.remove(new Person("张三", 18));*/

        System.out.println(coll);

        //10. removeAll(Collection coll) : 删除 coll 中所有的元素
        Collection coll3 = new ArrayList();
        coll3.add("BB");
        coll3.add(new Person("张三", 18));
        coll3.add("abcde");

        /*coll.removeAll(coll3);
        System.out.println(coll);*/

        //11. retainAll(Collection coll):取交集
        coll.retainAll(coll3);
        System.out.println(coll);

        //12. toArray() : 将集合转换成数组
        Object[] objects = coll.toArray();

        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
    }

List 集合特有的方法

void add(int index, Object ele) : 向执行索引位置添加元素
boolean addAll(int index, Collection eles)
Object get(int index) : 获取指定索引位置的元素
int indexOf(Object obj) : 获取指定元素的索引值,若找不到则返回 -1
int lastIndexOf(Object obj)
Object remove(int index) : 删除指定索引位置的元素
Object set(int index, Object ele) : 修改指定索引位置的元素
List subList(int fromIndex, int toIndex) : 截取子集合, 包含头不包含尾

public void test1(){
        List list = new ArrayList();
        list.add("AA"); 
        list.add("BB");
        list.add("CC");

        list.add(1, "FFF");

        list.add("BB");
        list.add("YY");

        List list2 = Arrays.asList(1,2,3);
        list.addAll(1, list2);
        System.out.println(list);

        Object obj = list.get(4);
        System.out.println(obj);

        int index = list.indexOf("FFFFFFF");
        System.out.println(index);

        System.out.println(list.lastIndexOf("BB"));

        list.remove(4);
        System.out.println(list);
    }


	public void test2(){
        List list = new ArrayList();
        list.add("AA");
        list.add("BB");
        list.add("CC");
        list.add("DD");
        list.add("EE");

        list.set(1, "bbbbb");

        System.out.println(list);

        List list1 = list.subList(1, 3);
        System.out.println(list1);
    }

LinkedList 特有方法

addFirst()
addLast()

getFirst()
getLast()

removeFirst()
removeLast()

public void test1(){
        LinkedList ll = new LinkedList();
        ll.add("AA");
        ll.add("BB");
        ll.add("CC");

        ll.addFirst("DD");
        ll.addLast("EE");
        System.out.println(ll);

        Object first = ll.getFirst();
        System.out.println(first);
        System.out.println(ll.getLast());

        Object o = ll.removeFirst();
        System.out.println(o);
        System.out.println(ll);

        System.out.println(ll.removeLast());
        System.out.println(ll);
    }

自然排序

//实现接口中的compareTo 方法
public int compareTo(Object o) {
        if(o instanceof Person){
            Person p = (Person) o;

            if(this.getAge().equals(p.getAge())){
                return this.getName().compareTo(p.getName());
            }

            return -this.getAge().compareTo(p.getAge());
        }

        return 0;
    }

定制排序

TreeSet ts = new TreeSet(new MyComparator());


public class MyComparator implements Comparator {
    @Override
    public int compare(Object o1, Object o2) {

        if(o1 instanceof Person && o2 instanceof Person){
            Person p1 = (Person) o1;
            Person p2 = (Person) o2;

            if(p1.getAge().equals(p2.getAge())){
                return p1.getName().compareTo(p2.getName());
            }

            return -p1.getAge().compareTo(p2.getAge());
        }

        return 0;
    }
}

public void test2(){
        //匿名内部类
        Comparator com = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Person && o2 instanceof Person){
                    Person p1 = (Person) o1;
                    Person p2 = (Person) o2;

                    if(p1.getAge().equals(p2.getAge())){
                        return p1.getName().compareTo(p2.getName());
                    }

                    return -p1.getAge().compareTo(p2.getAge());
                }

                return 0;
            }
        };

        TreeSet ts = new TreeSet(com);
        ts.add(new Person("张三", 18));
        ts.add(new Person("李四", 8));
        ts.add(new Person("王五", 38));
        ts.add(new Person("赵六", 15));
        ts.add(new Person("田七", 40));
        ts.add(new Person("王五", 38));

        System.out.println(ts);
    }


	public void test3(){
        //匿名内部类+匿名对象
        TreeSet ts = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Person && o2 instanceof Person){
                    Person p1 = (Person) o1;
                    Person p2 = (Person) o2;

                    if(p1.getAge().equals(p2.getAge())){
                        return p1.getName().compareTo(p2.getName());
                    }

                    return -p1.getAge().compareTo(p2.getAge());
                }

                return 0;
            }
        });

        ts.add(new Person("张三", 18));
        ts.add(new Person("李四", 8));
        ts.add(new Person("王五", 38));
        ts.add(new Person("赵六", 15));
        ts.add(new Person("田七", 40));
        ts.add(new Person("王五", 38));

        System.out.println(ts);
    }

//增强for循环遍历数组
    @Test
    public void test3(){
        int[] array = {1,2,3,4,5};

        for(int a : array){//增强for循环不擅长修改数组中元素的值
            System.out.println(a);
        }

        for (int i = 0; i < array.length; i++) {
            if(array[i] == 3){
                array[i] = 3333;
            }
        }
    }

public void test4(){
        List list = new ArrayList();
        list.add("AA");
        list.add("BB");
        list.add("CC");

        //1. 获取当前集合的 Iterator 迭代器
        Iterator it = list.iterator();

        //2. 通过 hasNext() 与 next() 配合遍历集合元素
        while(it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }
    }