JavaSE进阶：集合框架(二)

雙馬程序猿

已于 2023-02-08 10:54:54 修改

阅读量434

点赞数 1

分类专栏： Java 文章标签： java

于 2022-08-18 09:44:38 首次发布

本文链接：https://blog.csdn.net/m0_64095482/article/details/126399377

版权

本文详细介绍了Java集合框架中的List接口及其ArrayList、Vector和LinkedList的实现，探讨了它们的特性和使用场景。ArrayList是基于动态数组的数据结构，适合频繁访问元素，而LinkedList采用链表结构，适合频繁增删操作。此外，文章还讲解了List接口的遍历方式，包括迭代器和for-each循环，并提到了Set接口和其实现类HashSet、LinkedHashSet及TreeSet的区别。

摘要由CSDN通过智能技术生成

4.collection体系集合（单列集合）

1.1十个1-20之间随机数(随机数不重复)

2.LinkedHashSet集合概述和特点

3.TreeSet

3.1键盘录入5个学生的信息(姓名,成绩)，按照成绩从高到低输出到控制台

4.collection体系集合（单列集合）

Collection集合特点：

List系列集合：添加的元素是有序、可重复、有索引

ArrayList、LinekdList:有序、可重复、有索引

Set系列集合:添加的元素是无序、不重复、无索引

HashSet:无序、不重复、无索引；LinkedHashSet:有序、不重复、无索引

TreeSet:按照大小默认升序排序、不重复无索引

接口：是代表集合的抽象数据类型。之所以定义多个接口，是为了以不同的方式操作集合对象
实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构
算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

1.Collection父接口

Collection单列结婚，每个集合元素(数据)只包含一个值

特点:代表一组任意类型的对象，无序、无下标、不能重复。

Collections类，位于java.util 包中，提供的 sort() 方法可以对字符或数字列表进行排序：

方法
方法名称	说明
boolean add(Object obj)	添加一个对象
boolean remove (Object o)	在此集合中移除o对象
boolean contains (Object o)	检查此集合中是否包含o对象
boolean isEmpty()	判断此集合是否为空
int size()	返回此集合中的元素个数
void clear()	清空此集合中的所有对象
Object[] toArray()	将此集合转换成数组
boolean addAll (Collection c)	将一个集合中的所有对象添加到此集合中
boolean equals (Object o)	比较此集合是否与指定对象相等

迭代器：
Iterator（迭代器）是一个接口，它的作用就是遍历容器的所有元素
迭代器在Java中的代表是Iterator，迭代器是集合的专用的遍历方式，也是 Java 集合框架的成员Iterator 则主要用于遍历（即迭代访问）Collection 集合中的元素。

Collection集合获取迭代器

lIterator<E> iterator()：返回迭代器对象，默认指向当前集合的索引0
Iterator it = list.iterator();

Iterator(迭代器)中的常用方法
方法名称	说明
boolean hasNext()	询问当前位置是否有元素存在，存在true，不存在则相反
E next()	获取当前位置元素，并将迭代器移到下一个位置
void remove()	删除当前元素

package java_se.java_jinjie.jihe.collection.demo01;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**Collection接口的使用
 * 保存字符串
 * (1)添加元素
 * (2)删除元素
 * (3)遍历元素
 * (4)判断
 */
public class demo01 {
    public static void main(String[] args) {
        /**Collection接口的使用
         * 保存字符串
         * (1)添加元素:add(添加)、size(返回元素个数)、打印数组toString
         * (2)删除元素:remove(删除)、size(返回元素个数)、打印数组toString
         * (3)遍历元素:
         *      3.1增强for循环
         *      3.2迭代器:hasNext(有没有下一个元素)、next(获取下一个元素)、remove(删除当前元素)
         * (4)判断：contains(判断是否包含某个元素)、isEmpty(判断集合是否为空)
         */

        Collection collection=new ArrayList();
//                * (1)添加元素
        collection.add("苹果");
        collection.add("西瓜");
        collection.add("榴莲");
        collection.add("香蕉");
        //打印集合个数
        System.out.println("元素个数："+collection.size());//元素个数：4
        //打印集合内容(直接打印其实是调用了toString方法)
        System.out.println(collection);//[苹果, 西瓜, 榴莲, 香蕉]
//                * (2)删除元素
//        collection.remove("榴莲");
//        System.out.println("删除之后："+collection.size());//删除之后：3
//        System.out.println(collection);//[苹果, 西瓜, 香蕉]
//                * (3)遍历元素[重点]
        System.out.println("-----增强for循环-----");
        //3.1增强for
        for (Object object:collection){
            System.out.println(object);
        }
        //3.2迭代器(专门用来遍历集合的一种方式)
        //hasNext();有没有下个元素；
        //next();获取下个元素；
        //remove();删除当前元素
        System.out.println("-----迭代器-----");
        Iterator it = collection.iterator();
        while (it.hasNext()){//判断有没有下一个元素
            String s = (String) it.next();//如果有则获取下一个
            System.out.println(s);//输出获取的内容
            //collection.remove(s);//.ConcurrentModificationException并发修改异常，迭代器遍历元素的时候，通过集合是不能修改元素的
            //it.remove();//输出完后删除当前元素(输出了又删除了)   迭代器提供的删除的方法
        }
        System.out.println("元素个数："+collection.size());//删除了里面的内容所以没有值
//                * (4)判断
        System.out.println("-----判断-----");
        System.out.println(collection.contains("西瓜"));//判断集合中有没有西瓜
        System.out.println(collection.isEmpty());//判断是否为空，如果空则true,相反false
    }
}

package java_se.java_jinjie.jihe.collection.demo01;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * 保存学生信息
 */
public class Demo02 {
    public static void main(String[] args) {
        //新建Collection对象
        Collection collection1=new ArrayList();
        Student s1=new Student("张三",3);
        Student s2=new Student("李四",4);
        Student s3=new Student("王五",5);
        //1.添加数据
        collection1.add(s1);
        collection1.add(s2);
        collection1.add(s3);
        System.out.println("元素个数："+collection1.size());
        System.out.println(collection1.toString());//在Student类重写了toString方法
        //2.删除
//        collection1.remove(s1);//删除s1
//        collection1.clear();//清空  只是把地址指向给删除了，创建的对象还在
//        System.out.println("删除之后："+collection1.size());
        //3.遍历
        //3.1增强for
        System.out.println("------增强for------");
        for (Object o:collection1) {
            Student s=(Student)o;
            System.out.println(s.toString());
        }
        //3.迭代器：hasNext() next(); remove();  迭代过程中不能使用collection1的删除方法
        System.out.println("-----迭代器-----");
        Iterator it = collection1.iterator();
        while (it.hasNext()){
            Student s = (Student) it.next();
            System.out.println(s.toString());
        }
    }
}
/*
package java_se.java_jinjie.jihe.collection.demo01;

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

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

    public Student() {
    }

    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 +
                '}';
    }
}

 */

2.List子接口

特点:有序、有下标、元素可以重复。

有序：存储和取出的元素顺序一致

有索引(下标):可以通过索引操作元素

可重复:存储的元素可以重复

不仅有Collection父接口的方法，自己还有自己独有的方法:

List list =new ArrayList<>();

遍历的几种方式

1. for 循环遍历，基于计数器。在集合外部维护一个计数器，然后依次读取每一个位置的元素，当读取到最后一个元素后停止。
2. 迭代器遍历，Iterator。Iterator 是面向对象的一个设计模式，目的是屏蔽不同数据集合的特点，统一遍历集合的接口。Java 在 Collections 中支持了 Iterator 模式。
3. foreach 循环遍历。foreach 内部也是采用了 Iterator 的方式实现，使用时不需要显式声明 Iterator 或计数器。优点是代码简洁，不易出错；缺点是只能做简单的遍历，不能在遍历过程中操作数据集合，例如删除、替换。

Collection集合方法
方法名称	说明
boolean add(Object obj)	添加一个对象
boolean remove (Object o)	在此集合中移除o对象
boolean contains (Object o)	检查此集合中是否包含o对象
boolean isEmpty()	判断此集合是否为空
int size()	返回此集合中的元素个数
void clear()	清空此集合中的所有对象
Object[] toArray()	将此集合转换成数组
boolean addAll (Collection c)	将一个集合中的所有对象添加到此集合中
boolean equals (Object o)	比较此集合是否与指定对象相等

List集合独有方法
方法名称	说明
void add(int index,element)	在此集合的指定位置插入指定的元素
E remove(int index)	删除指定索引元素
boolean addAll(int index, Collection c)	将一个集合中的元素添加到此集合中的index位置
List subList(int fromIndex, int toIndex)	返回fromIndex和toIndex之间的集合元素
E set(int index,E element)	修改指定索引出的元素
E get(int index)	返回指定索引处的元素

迭代器：遍历

Iterator it = arrayList.iterator();

列表迭代器：用于前后遍历
ListIterator lit = list.listIterator();

列表迭代器
方法名称	说明
boolean hasNext()	询问当前位置是否有元素存在，存在true，不存在则相反(顺序)
next()	获取当前位置元素，并将迭代器移到后一个位置
void remove()	删除当前元素
int nextIndex()	获取当前位置下标，并将迭代器移到后一个下标
boolean hasPrevious()	询问当前位置是否有元素存在，存在true，不存在则相反(逆序)
E previous()	获取当前位置元素，并将迭代器移到前一个位置
int previousIndex()	获取当前位置下标，并将迭代器移到前一个下标

package java_se.java_jinjie.jihe.collection.demo01;

import java.util.*;

/**
 * List子接口使用
 * 特点：有序有下标  可以重复
 */
public class Demo1 {
    public static void main(String[] args) {
        //先创建集合对象
        List list =new ArrayList<>();
        //1.添加元素
        list.add("苹果");
        list.add("华为");
        //在index的位置插入对象element
        list.add(0,"小米");
        //2.修改元素
        list.set(0,"石头");
        System.out.println("元素个数:"+list.size());
        System.out.println(list.toString());
        //3.删除元素
//        list.remove("苹果");
//        list.remove(0);
//        System.out.println("元素个数:"+list.size());
//        System.out.println(list.toString());
        //4.遍历
        //4.1使用for循环
        System.out.println("----for循环----");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //4.2使用增强for循环
        System.out.println("----增强for循环----");
        for(Object obj:list){
            System.out.println(obj);
        }
        //4.3使用迭代器
        System.out.println("----迭代器----");
        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //4.4使用列表迭代器
        //和Iterator的区别，ListIterator可以向前或者向后遍历，添加、删除、修改元素
        System.out.println("----列表迭代器从前往后----");
        ListIterator lit = list.listIterator();
        while (lit.hasNext()){
            System.out.println(lit.nextIndex()+":"+lit.next());
        }
        System.out.println("----列表迭代器从后往前----");
        while (lit.hasPrevious()){
            System.out.println(lit.previousIndex()+":"+lit.previous());
        }
        //5.判断
        System.out.println(list.contains("苹果"));
        System.out.println(list.isEmpty());
        //6.获取位置
        System.out.println(list.indexOf("华为"));
        System.out.println(list.get(0));


    }
}

package java_se.java_jinjie.jihe.collection.demo01;

import java.util.ArrayList;
import java.util.List;

public class Demo2 {
    public static void main(String[] args) {
        //创建集合
        List list = new ArrayList();
        //1.添加数字类型(自动装箱)
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        System.out.println("元素个数:"+list.size());
        System.out.println(list.toString());
        //2.删除操作
//        list.remove(0);//取的是下标，而不能直接取20删除
//        list.remove((Object) 20);
//        list.remove(new