集合 ArrayList，linkedList，Set，Map

最新推荐文章于 2023-02-04 20:16:55 发布

贫民窟的代言人

最新推荐文章于 2023-02-04 20:16:55 发布

阅读量498

点赞数

文章标签： servlet java 数据库

本文链接：https://blog.csdn.net/qq_44618872/article/details/126291526

版权

集合：

Collenction接口存储一组不唯一，无序的对象

List接口存储一组不唯一，有序（插入顺序）的对象

Set接口存储一组唯一，无序的对象

Map接口存储一组键值对象，提供key到value的映射

List：

ArrayList：

实现了长度可变的数组，在内存中分配连续的空间，遍历元素和随机访问元素的效率比较高

方法名	说明
boolean add（Object o）	在列表的末尾顺序添加元素，起始索引位置从0开始
void add(int index, Object o)	在指定的索引位置添加元素，索引位置必须介于0和列表中元素个数之间
int size()	返回列表中的元素个数
boolean contains(Object o )	判断列表中是否存在指定元素
boolean remove(Object o)	在列表中删除元素
Objece remove(int index)	从列表中删除指定位置元素，起始索引位置从0开始
clear()，isEnmpty(),iterator(),toArray()	清除列表，判断集合是否为空，迭代器，转换为数组
Object get(int index)	返回指定索引位置处的元素。取出的元素是Object类型，使用前需要进行强制类型转换

步骤：创建容器，准备数据，方法实现

public static void main(String[] args) {
        // 准备数据，创建五个对象
        Newstitle ne1 = new Newstitle(1001, "论怎么学会唱", "百度");
        Newstitle ne2 = new Newstitle(1002, "让中国人的饭碗牢牢端在自己手中", "百度");
        Newstitle ne3 = new Newstitle(1003, "中国成功发射一箭十六星", "百度");
        Newstitle ne4 = new Newstitle(1004, "论怎么学会rop", "百度");
        Newstitle ne5 = new Newstitle(1005, "论怎么学会跳", "百度");
        //准备容器，创建ArrayList集合存储数据
        ArrayList al =new ArrayList(); 
        //将数据存储到集合中，向集合中添加元素不是通过元素下标来赋值，而是通过集合对象调用方法来实现
        al.add(ne1);
        al.add(ne5);
        al.add(ne3);
        al.add(ne5);
        al.add(ne2);
        //可以通过集合调用对象的方法来实现对集合的元素的操作
        //获取集合中的元素个数
        int size = al.size();
        System.out.println("集合的个数"+size);
        //获取集合中指定的位置元素
        Object obj0=al.get(0);
        Newstitle new0 = (Newstitle)obj0;
        System.out.println(new0);
        
        //利用循环来遍历集合
        for (int i = 0; i < al.size(); i++) {
            Object object = al.get(i);
            Newstitle news = (Newstitle)object;
            System.out.println(news);
        }
        System.out.println("------------------------");
        //增强for循环
        for (Object object : al) {
            Newstitle news = (Newstitle)object;
            System.out.println(news);
        }
        //利用迭代器
        /*
         * 集合对象调用iterator()方法将集合中所有元素按照顺序取出来放入到迭代器容器里面
         * 然后通过迭代对象调用hasNext()方法判断迭代器中是否有元素，有元素就通过next()方法取出这个元素
         * 然后判断一个就取出来一个， 判断一个取出一个，所以可以使用循环来取出里面所有的元素 
         */
        
        Iterator it= al.iterator();
        while(it.hasNext()){
            Object object = it.next();
            Newstitle news = (Newstitle)object;
            System.out.println(news);   
        }
        System.out.println("------------------------");
        //将数据存储到集合中指定的位置
        al.add(2, ne4);
        for (Object object : al) {
            Newstitle news = (Newstitle)object;
            System.out.println(news);
        }
        System.out.println("------------------------");
        
        //删除集合中的某个元素
        Object object = al.remove(1);
        al.remove(ne2);
        for (Object object1 : al) {
            Newstitle news = (Newstitle)object;
            System.out.println(news);
        }
        System.out.println("------------------------");
        //判断集合中是否包含指定的元素
         boolean result =al.contains(ne5);
         System.out.println(result);
         
         //判断几个是不是空的
         System.out.println("集合是否为空"+al.isEmpty());
         
         System.out.println("****************************");
         //将集合转换成数组
        Object[] objects= al.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
        
         System.out.println("****************************");
         
         //清空集合
         al.clear();
         System.out.println("集合是否为空"+al.isEmpty());
         System.out.println(al.size());
    }

LinkedList：

采用链表存储方法，插入，删除元素时效率比较高

方法名	说明
void addFirst(Object o)	在列表的首部添加元素
void addLast(Object o)	在列表的末尾添加元素
Object getFirst()	返回列表的第一个元素
Object getLast()	返回列表的最后一个元素
Object removeFirst()	删除并返回列表的第一个元素
Object removeLast()	删除并返回列表的最后一个元素

public static void main(String[] args) {
        // 准备数据，创建五个对象
        Newstitle ne1 = new Newstitle(1001, "论怎么学会唱", "百度");
        Newstitle ne2 = new Newstitle(1002, "让中国人的饭碗牢牢端在自己手中", "百度");
        Newstitle ne3 = new Newstitle(1003, "中国成功发射一箭十六星", "百度");
        Newstitle ne4 = new Newstitle(1004, "论怎么学会rop", "百度");
        Newstitle ne5 = new Newstitle(1005, "论怎么学会跳", "百度");
                
        //准备容器：创建集合的对象，创建LinkedList对象
        //List是一个接口，LinkedList是List接口的实现类，用List接口引用指向了实现类的实例
        //向上转型：父类（接口）的引用指向子类的实例，父类引用无法调用子类特有的方法
        List list = new LinkedList();
        list.add(ne1);
        list.add(ne3);
        list.add(ne2);
        list.add(ne2);
        
        System.out.println(list.size());
        
        //使用迭代其将list集合进行遍历
        Iterator it= list.iterator();
        while(it.hasNext()){
            Object obj1= it.next();
            Newstitle str1 = (Newstitle)obj1;
            System.out.println(str1);
        }
        
        System.out.println("-----------------------------");
    
        //list.addFirst  父类List无法调用子类LinkedList的独有的方法所以要进行向下转型
        //向下转型：子类的引用指向父类的对象 需要进行向下转型的原因是父类无法调用子类中的方法
        LinkedList link = (LinkedList)list;
        link.addFirst(ne5);
        link.addLast(ne4);
        for (Object object : link) {
            System.out.println(object);
        }
        System.out.println("-------------------------");
        
        //获取集合中的第一个元素和最后一个元素
        System.out.println(link.getFirst());
        System.out.println(link.getLast());
        System.out.println("-------------------------");
        
        //删除集合中的第一元素和最后一个元素
        link.removeFirst();
        link.removeLast();
        for (Object object : link) {
            System.out.println(object);
        }
        
        link.clear();
        System.out.println(link.size());
    }

Set接口：

Set接口储存一组唯一，无序的对象

HashSet是Set接口常用的实现类

public static void main(String[] args) {
        /*
         * Set集合的特点：无序，唯一
         */
        // //准备容器 创建HashSet对象
        Set set=new HashSet();
        //准备数据
        String s1=new String("java");
        String s2=s1;
        String s3=new String ("java");
        //添加数据
        set.add(s1);
        set.add(s2);
        set.add(s3);
        //集合长度为1
        System.out.println(set.size());

    }

遍历Set集合：

方法一：通过迭代器Iterator实现遍历

获取Iterator：Collextion接口的iterator（）方法

Iterator的方法：

boolean hasNect（）：判断是否存在另一个可访问的元素

Object next（）；返回要访问的下一个元素

Iterator it= hs.iterator();
        while(it.hasNext()){
            Object object= it.next();
            Newstitle nt =(Newstitle)object;
            System.out.println(nt);
        }

方法二：增强for循环

for (Object object : hs) {
            Newstitle nt =(Newstitle)object;
            System.out.println(nt);
        }

Map接口：

方法名	说明
Object put(Object key ,Object val)	以”键--值“对的方式进行存储
Object get(Object key)	根据键返回相关联的值，如果不存在指定的键，返回null
Object remove(Object key)	删除有指定的键映射的”键-值对“
int size();	返回元素个数
Set keySet();	返回键的集合
Collection Values()	返回值的集合
boolean containsKey(Object key)	如果存在指定的键映射的”键-值对“，返回ture

//获取集合中的元素
        System.out.println(hm.size());
        
        //根据键获取对应的值
        Object object = hm.get("CN");
        String str = (String)object;
        System.out.println(str);
        
        System.out.println(hm.get("CNN"));//null
        
        //删除集合的元素
        Object object1 = hm.remove("JP");
        String str1 = (String)object1;
        System.out.println(str1);
        System.out.println(hm.size());
        System.out.println("---------------------");
        //获取HashMap集合中所有的键值对的键
        Set keys= hm.keySet();
        for (Object object2 : keys) {
            String key = (String) object2;
            System.out.println(key);
        }
        System.out.println("-------------------");
        //获取集合中键直对的值
        Collection values= hm.values();
        for (Object object2 : values) {
            String val = (String)object2;
            System.out.println(val);
        }
        //查询集合中是否存在指定键对应的键值对
        
        System.out.println(hm.containsKey("JP"));
        System.out.println(hm.containsValue("中国"));

遍历Map集合：

方式一：通过迭代器Iterator实现遍历：先用HashMap对象调用keySet（）方法获取键值对的键的Set集合，再用Set对象调用iterator（）方法进行取出集合，然后再利用hasNext（）方法进行判断，再用next（）方法对下一个值进行判断，按照键类型强制转换，再利用get（）方法获取键值对的值，在进行强制转换输出

        Set keys1= hm.keySet();
        Iterator it= keys1.iterator();
        while(it.hasNext()){
            Object object= it.next();
            String key1=(String)object;
            Object object1= hm.get(key1);
            Student val = (Student)object1;
            System.out.println(key1+"对应的学员姓名是："+val.getName()+"性别是："+val.getGender());
        }

方式二：利用增强for循环先利用HashMap对象hm用keySet()方法获取键值对的键，然后增强for循环在按照键的对应类型强制转换，再用get();方法获取键值对的值，再按照值的类型进行强制转换

        Set keys =hm.keySet();
        for (Object object : keys) {
            String key = (String)object;
            Object object1= hm.get(key);
            Student stu = (Student)object1;
            System.out.println(key+"对应的学员姓名是："+stu.getName()+"性别是："+stu.getGender());
        }

方式三：利用entrySet（）方法整体取出键值对，然后利用循环，依次取出，，取出来的是Object类型，实际上键值对的真正类型是Map.Entry类型，所以将取出来的元素强制类型转化为Map.Entry类型，Map.Entry类中有getKey()方法获取键值对的键，有getValue方法获取键的值

 Set keysVal= hm.entrySet();
         for (Object object : keysVal) {
            Map.Entry md = (Map.Entry)object;
            Object ob= md.getKey();
            String key = (String)ob;
            Object ob1=md.getValue();
            Student stu =(Student)ob1;
            System.out.println(key+"对应的学员姓名是："+stu.getName()+"性别是："+stu.getGender());
        }