首页 > 其他分享 >Collection集合

Collection集合

时间：2023-09-16 20:01:07浏览次数：34  
标签：list System Collection println add 集合 public out

一、Collection集合

    Collection是单列集合 (单列集合就是指每个元素只包含一个值) 的根接口，Collection接口下面又有两个子接口List接口、Set接口，List和Set下面分别有不同的实现类。

  1. List接口的实现类主要有：ArrayList、LinkedList、Stack以及Vector等；
  2. Set接口的实现类主要有：HashSet、TreeSet、LinkedHashSet等

1、常用方法

方法名 说明
boolean add(E e) 添加元素
boolean remove(Object o) 从集合中移除指定的元素
boolean removeIf(Object o) 根据条件进行移除
void clear() 清空集合中的元素
boolean contains(Object o) 判断集合中是否存在指定的元素
boolean isEmpty() 判断集合是否为空
int size() 集合的长度，也就是集合中元素的个数

代码演示

public class MyCollectonDemo {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<>();
//        boolean add(E e)		添加元素
        collection.add("aaa");
        collection.add("bbb");
        collection.add("ccc");
        collection.add("dddd");
        //System.out.println(collection);
        //method1(collection);
        //method2(collection);
        //method3(collection);
        //method4(collection);
        //method5(collection);
        //method6(collection);


    }

    private static void method6(Collection<String> collection) {
        //        int size()			集合的长度，也就是集合中元素的个数
        int size = collection.size();
        System.out.println(size);
    }

    private static void method5(Collection<String> collection) {
        //        boolean isEmpty()		判断集合是否为空
        collection.clear();
        boolean result = collection.isEmpty();
        System.out.println(result);
    }

    private static void method4(Collection<String> collection) {
        //        boolean contains(Object o)	判断集合中是否存在指定的元素
        boolean result = collection.contains("a");
        System.out.println(result);


        boolean result2 = collection.contains("aaa");
        System.out.println(result2);
    }

    private static void method3(Collection<String> collection) {
        //        void clear()			清空集合
        //就是将集合中所有的元素全部删除.
        collection.clear();
        System.out.println(collection);
    }

    private static void method2(Collection<String> collection) {
        //        boolean removeif(Object o)	根据条件进行删除
        //removeif底层会遍历集合,得到集合中的每一个元素
        //s依次表示集合中的每一个元素
        //就会把这每一个元素都到lambda表达式中去判断一下
        //如果返回的是true,则删除
        //如果返回的是false,则保留不删除.


        //boolean test(String t);
        collection.removeIf(
                (String s)->{
                    return s.length() == 3;
                }

        );
        System.out.println(collection);
    }

    private static void method1(Collection<String> collection) {
        //        boolean remove(Object o)	    从集合中移除指定的元素
        //如果删除成功了,则返回true
        //如果删除失败了,则返回false
        boolean result1 = collection.remove("aaa");
        boolean result2 = collection.remove("ddd");
        System.out.println(result1);
        System.out.println(result2);
        System.out.println(collection);
    }
}

2、Collection集合的遍历方式 2.1  迭代器 使用场景：遍历过程中需要删除元素时使用 三个方法：

 Iterator<E> iterator(): 获取迭代器对象,默认指向0索引
 boolean hasNext():判断当前位置是否有元素可以被取出
 E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

代码演示


public class MyCollectonDemo {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");


        //1,获得迭代器的对象
        //迭代器对象一旦被创建出来,默认指向集合的0索引处
        Iterator<String> it = list.iterator();


        //利用迭代器里面的方法进行遍历
        //当前位置是否有元素可以被取出
//        System.out.println(it.hasNext());
//        //取出当前位置的元素  + 将迭代器往后移动一个索引的位置
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());

        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

注意事项：一个迭代器只能使用一次

2.2 增强for循环 作用：简化数组和Collection集合的遍历,比迭代器简单也比for循环也简单 使用方法：

for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {
// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可
}

增强for的原理：

它是JDK5之后出现的,其内部原理是一个Iterator迭代器(数组是for，集合为Iterator)

增强for的应用场景：

实现Iterable接口的类才可以使用迭代器和增强for(数组)

对集合进行只要简单遍历时使用

代码演示：

public class MyCollectonDemo {
    public static void main(String[] args) {
        ArrayList<String> list =  new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        //1,数据类型一定是集合或者数组中元素的类型
        //2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
        //3,list就是要遍历的集合或者数组.
        for(String str : list){
            System.out.println(str);
        }
    }
}

2.3  普通for循环

使用场景：遍历过程中需要操作索引时使用

代码演示：

public class MyCollectonDemo {
    public static void main(String[] args) {
        ArrayList<String> list =  new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");

     
 for (int i = 0; i < list.size(); i++) {
            System.out.println(i);
        }

    }
}

2.4 forEsch

forEach遍历集合是JDK8版本以后提供的。

forEach方法的参数是一个Consumer接口，而Consumer是一个函数式接口，所以可以传递Lambda表达式。

代码演示

Collection<String> c = new ArrayList<>();
c.add("赵敏");
c.add("小昭");
c.add("素素");
c.add("灭绝");

//调用forEach方法
//由于参数是一个Consumer接口，所以可以传递匿名内部类
c.forEach(new Consumer<String>{
    @Override
    public void accept(String s){
        System.out.println(s);
    }
});


//也可以使用lambda表达式对匿名内部类进行简化
c.forEach(s->System.out.println(s)); //[赵敏, 小昭, 素素, 灭绝]

二、List集合

1、List集合的特点： 存取有序；可以重复；有索引

//1.创建一个ArrayList集合对象（有序、有索引、可以重复）
List<String> list = new ArrayList<>();
list.add("蜘蛛精");
list.add("至尊宝");
list.add("至尊宝");
list.add("牛夫人"); 
System.out.println(list); //[蜘蛛精, 至尊宝, 至尊宝, 牛夫人]

//2.public void add(int index, E element): 在某个索引位置插入元素
list.add(2, "紫霞仙子");
System.out.println(list); //[蜘蛛精, 至尊宝, 紫霞仙子, 至尊宝, 牛夫人]

//3.public E remove(int index): 根据索引删除元素, 返回被删除的元素
System.out.println(list.remove(2)); //紫霞仙子
System.out.println(list);//[蜘蛛精, 至尊宝, 至尊宝, 牛夫人]

//4.public E get(int index): 返回集合中指定位置的元素
System.out.println(list.get(3));

//5.public E set(int index, E e): 修改索引位置处的元素，修改后，会返回原数据
System.out.println(list.set(3,"牛魔王")); //牛夫人
System.out.println(list); //[蜘蛛精, 至尊宝, 至尊宝, 牛魔王]

2、List集合的特有方法

方法名 描述
void add(int index,E element) 在此集合中的指定位置插入指定的元素
E remove(int index) 删除指定索引处的元素，返回被删除的元素
E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
E get(int index) 返回指定索引处的元素

代码演示：

public class MyListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
      //method1(list);
        //method2(list);
        //method3(list);
        //method4(list);
    }

  private static void method4(List<String> list) {
        //        E get(int index)		返回指定索引处的元素
        String s = list.get(0);
        System.out.println(s);
    }

    private static void method3(List<String> list) {
        //        E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
      //被替换的那个元素,在集合中就不存在了.
        String result = list.set(0, "qqq");
        System.out.println(result);
        System.out.println(list);
    }

    private static void method2(List<String> list) {
        //        E remove(int index)		删除指定索引处的元素，返回被删除的元素
        //在List集合中有两个删除的方法
        //第一个 删除指定的元素,返回值表示当前元素是否删除成功
      //第二个 删除指定索引的元素,返回值表示实际删除的元素
        String s = list.remove(0);
        System.out.println(s);
        System.out.println(list);
    }

    private static void method1(List<String> list) {
        //        void add(int index,E element)	在此集合中的指定位置插入指定的元素
        //原来位置上的元素往后挪一个索引.
        list.add(0,"qqq");
        System.out.println(list);
    }
}

3、数据结构 3.1  栈结构和队列结构

栈结构可以看做是一个上端开头，下端闭口的水杯的形状。元素永远是上端进，也从上端出，先进入的元素会压在最底下，所以栈结构的特点是先进后出，后进先出

队列结构你可以认为是一个上端开口，下端也开口的管子的形状。元素从上端入队列，从下端出队列，所以队列结构的特点是先进先出。

3.2 数组和链表

ArrayList集合的特点

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

LinkedList集合特点

底层是链表结构实现，查询慢、增删快

 3.3 ArrayList的扩容机制

a.ArrayList底层是一个数组

b.当初始化ArrayList，数组的长度为0

c.当第一次添加的时候，数组的长度为10

d.以后添加时，如果数组的长度不满足时，进行扩容 ，按1.5来进行扩容

e.扩容之后，将原数组中的元素拷贝到新的数组中

4、LinkedList集合 1、特有方法

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

代码演示

public class MyLinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("aaa");
      list.add("bbb");
        list.add("ccc");
//        public void addFirst​(E e)	在该列表开头插入指定的元素
      //method1(list);

//        public void addLast​(E e)	将指定的元素追加到此列表的末尾
        //method2(list);


//        public E getFirst​()		返回此列表中的第一个元素
//        public E getLast​()		返回此列表中的最后一个元素
        //method3(list);


//        public E removeFirst​()		从此列表中删除并返回第一个元素
//        public E removeLast​()		从此列表中删除并返回最后一个元素
        //method4(list);


    }

    private static void method4(LinkedList<String> list) {
        String first = list.removeFirst();
      System.out.println(first);

        String last = list.removeLast();
        System.out.println(last);

        System.out.println(list);
    }

    private static void method3(LinkedList<String> list) {
        String first = list.getFirst();
        String last = list.getLast();
        System.out.println(first);
      System.out.println(last);
    }

    private static void method2(LinkedList<String> list) {
        list.addLast("www");
        System.out.println(list);
    }

    private static void method1(LinkedList<String> list) {
        list.addFirst("qqq");
        System.out.println(list);
    }
}

## 三、Set集合 1、Set集合的特点 不可以存储重复元素

没有索引,不能使用普通for循环遍历

2、Set集合的使用

public class MySet1 {
    public static void main(String[] args) {
      	//创建集合对象
        Set<String> set = new TreeSet<>();
      	//添加元素
        set.add("ccc");
        set.add("aaa");
        set.add("aaa");
        set.add("bbb");

//        for (int i = 0; i < set.size(); i++) {
//            //Set集合是没有索引的，所以不能使用通过索引获取元素的方法
//        }
      
      	//遍历集合
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-----------------------------------");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

 3、TreeSet集合 3.1TreeSet集合概述和特点

  • 不可以存储重复元素
  • 没有索引
  • 可以将元素按照规则进行排序 TreeSet()：根据其元素的自然排序进行排序 TreeSet(Comparator comparator) ：根据指定的比较器进行排序 3.2 TreeSet集合基本使用
public class TreeSetDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Integer> ts = new TreeSet<Integer>();

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

        ts.add(30);

        //遍历集合
        for(Integer i : ts) {
            System.out.println(i);
        }
    }
}

3.3 自然排序Comparable的使用

案例需求

存储学生对象并遍历，创建TreeSet集合使用无参构造方法

要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

  • 实现步骤

1.使用空参构造创建TreeSet集合

用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的

2.自定义的Student类实现Comparable接口

自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法

3.重写接口中的compareTo方法

重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

代码实现 学生类

public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        //按照对象的年龄进行排序
        //主要判断条件: 按照年龄从小到大排序
        int result = this.age - o.age;
        //次要判断条件: 年龄相同时，按照姓名的字母顺序排序
        result = result == 0 ? this.name.compareTo(o.getName()) : result;
        return result;
    }
}

测试类

public class MyTreeSet2 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<>();
	    //创建学生对象
        Student s1 = new Student("zhangsan",28);
        Student s2 = new Student("lisi",27);
        Student s3 = new Student("wangwu",29);
        Student s4 = new Student("zhaoliu",28);
        Student s5 = new Student("qianqi",30);
		//把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
		//遍历集合
        for (Student student : ts) {
            System.out.println(student);
        }
    }
}

3.4比较器排序Comparator的使用

  • 案例需求

    存储老师对象并遍历，创建TreeSet集合使用带参构造方法

    要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

  • 实现步骤

    用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的

    比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法

    重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

代码实现 老师类

public class Teacher {
    private String name;
    private int age;

    public Teacher() {
    }

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类

public class MyTreeSet4 {
    public static void main(String[] args) {
      	//创建集合对象
        TreeSet<Teacher> ts = new TreeSet<>(new Comparator<Teacher>() {
            @Override
            public int compare(Teacher o1, Teacher o2) {
                //o1表示现在要存入的那个元素
                //o2表示已经存入到集合中的元素
              
                //主要条件
                int result = o1.getAge() - o2.getAge();
                //次要条件
                result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
                return result;
            }
        });
		//创建老师对象
        Teacher t1 = new Teacher("zhangsan",23);
        Teacher t2 = new Teacher("lisi",22);
        Teacher t3 = new Teacher("wangwu",24);
        Teacher t4 = new Teacher("zhaoliu",24);
		//把老师添加到集合
        ts.add(t1);
        ts.add(t2);
        ts.add(t3);
        ts.add(t4);
		//遍历集合
        for (Teacher teacher : ts) {
            System.out.println(teacher);
        }
    }
}

3.5两种比较方式总结

  • 两种比较方式小结

    自然排序: 自定义类实现Comparable接口,重写compareTo方法,根据返回值进行排序

    比较器排序: 创建TreeSet对象的时候传递Comparator的实现类对象,重写compare方法,根据返回值进行排序

    在使用的时候,默认使用自然排序,当自然排序不满足现在的需求时,必须使用比较器排序

  • 两种方式中关于返回值的规则

    如果返回值为负数，表示当前存入的元素是较小值，存左边

    如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存

    如果返回值为正数，表示当前存入的元素是较大值，存右边

标签：list,System,Collection,println,add,集合,public,out
From： https://blog.51cto.com/u_16245664/7495950

相关文章

  • 50-集合-特点-创建和删除-交集并集差集运算
          ......
  • 集合不相等容斥 笔记
    学习自zhouyuhang老师的ABC236Ex题解。其实就是完善了一下zhouyuhang老师没写的一些简单部分。我们先从一个经典的容斥理解：正难则反，我们钦定\(S\)内部全部相等，那么容斥系数是\((-1)^{|S|}\)，于是答案就是\(\sum\limits_{S}(-1)^{|S|}f(S)\)。注意到这个集合不相等容斥......
  • Redis7 10大数据类型(Redis集合)
    一、常用二、单值多value，且无重复三、案例SADDkeymember[member...]添加元素SMEMBERSkey遍历集合中的所有元素SISMEMBERkeymember判断元素是否在集合中SREMkeymember[member...]删除元素scard获取集合里面的元素个数SRANDMEMBERkey[数字]从集合中随机展现......
  • 封装一个用来获取多层数组对象的最后一层对象集合
    //获取多层数组对象的最后一层的对象functiongetAllIds(tree:any,result:any){//遍历树获取id数组for(constiintree){if(tree[i].id)result.push(tree[i]);//遍历项目满足条件后的操作if(tree[i].children){//存在子节点就递归ge......
  • 将List对象数据集合转为PageInfo分页结构
    之前用到一个项目就是将List数据转成PageInfo的分页结构手写的一个转换格式应该还有别的解决办法好像应该可以直接转后面有时间再研究研究importcom.github.pagehelper.PageInfo;/***@Description:缓存数据分页用来替代pagehelp自动分页方法*@Param:[page页码......
  • 可持久化非确定状态AC自动分块维护线段平衡仙人掌优化最小费用最大流预处理混合图上莫
    P8946TheLostSymbol这种类型的dp的特点就是大部分转移形如\(f(i,j)\rightarrowf(i+1,j+1)\)之类的，并且当以上转移出现时原数组被清空，这就可以用一个deque来维护，然后对于全局赋值/全局加，需要对每个位置维护一个时间戳，并记录上一次赋值/加是什么时候，以便标记下传。（貌似......
  • Java反序列化：CommonsCollections7调试分析
    CommonsCollections7基础知识1.HashTable散列表，也称为哈希表，以key-value形式进行访问的数据结构HashTable具有线程安全：多个线程同时访问它时，不会导致数据不一致。相对于HashMap、ConcurrentHashMap等线程安全性散列表，HashTable比较古老诸如散列表，常见的类方法：putget......
  • SQL基础总结(八)：集合操作
    本系列blog源自前年写的SQL学习笔记，汇总一下发上来。(1月份发了前三篇笔记，原以为后面的笔记误操作删了，今天在硬盘里又找到了，一起发上来)--------------------------------使用UNION合并行UNION操作将两个查询返回的结果合并成一个结果。UNION从结果中去掉重复的行，UNIONALL不去掉重......
  • Golang map集合丶struct结构体
    一.map集合1//map键值对集合2functestMap(){3//Map的定义:var变量名map[keytType]valueType4//细节:5//1.key唯一6//2.map是引用7//3.直接遍历map是无序的8//4.map会自动扩容,make中设置的长度并没有对map任何限制......
  • Java基础-2-集合
    目录简介ListSetMap互相转换简介Java中有三大类集合：List（列表）、Set（集合）、Map（映射），三者都属于接口类，分别有各自的实现。Collection为基本的集合接口，声明了集合的通用方法，List和Set都是继承于此。add(Objecto)：新增对象set(intindex,Objecto)：设置对象值remove(Objecto)：删......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99