java.集合类库

@Camelus

已于 2022-08-14 13:35:39 修改

阅读量423

点赞数

于 2022-04-05 11:57:42 首次发布

本文链接：https://blog.csdn.net/m0_61506558/article/details/123941259

版权

1.1集合概述

1.1.1集合的由来

当需要在Java程序中记录单个数据内容时,则声明一个变量。

当需要在Java程序中记录多个类型相同的数据内容时,则声明一个一维数组。

当需要在Java程序中记录多个类型不同的数据内容时，则创建一个对象。

当需要在Java程序中记录多个类型相同的数据内容时，则创建一个对象数组。

当需要在Java程序中记录多个类型不同的数据内容时，则准备一个集合。

1.1.2集合的框架结构

Java中集合框架顶级集合是:java.util.Collection集合和 java.util.Map集合

其中Collection集合存取元素的基本单位是：单个元素

其中Map集合存取元素的基本单位是: 单对元素

2.1Collection集合

2.2.1基本概念

java.util.Collection接口是List接口，Queue接口，Set接口的父类.

2.2.2常用方法

方法	功能
boolean add(E e)	向集合中添加对象
boolean addAll(Collection<? extendx E> c)	用于将参数指定集合c中的所有对象添加到当前集合中
boolean containsAll(Collection<?> c)	判断是否包含参数指定的所有对象
boolean retainAll(Collecton<?> c)	保留当前集合中存在且参数集合中的所有对象
boolean remove(Object o)	从集合中删除对象
boolean removeAll(Collection<?> c)	从集合中删除参数指定的所有对象
void clear();	清空集合
int size();	返回包含对象的个数
boolean isEmpty();	判断是否为空
boolean equals(Object o)	判断是否相等
int hashCode()	获取当前集合的哈希码值
Object[] toArray()	将集合转换为数组
iterator iterator()	获取当前集合的迭代器

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class CollectionTest {
    public static void main(String[] args){
        //多态构造集合
        Collection collection = new ArrayList();
        //1向集合中添加数据,里面只可以放对象

        boolean flag = collection.add(new String("金友鑫"));
        flag = collection.add(Integer.valueOf(18));
        flag = collection.add(new People("袁世龙",18,"泰州"));
        System.out.println("flag = " + flag);
        //自动调用个类中的toString方法
        System.out.println(collection);

        //2.准备其他collection添加到之前集合中
        Collection collection1 = new ArrayList();
        collection1.add("俏俏");//常量池
        collection.add(18);//自动装箱池
        flag = collection.addAll(collection1);//整体放入All
        System.out.println(collection);

        //3.判断集合中是否包含指定的单个元素

        flag = collection.contains("俏俏");
        System.out.println(flag);//true
        flag = collection.contains(new People("袁世龙",18,"泰州"));
        System.out.println(flag);//false
        /*  contains底层逻辑是调用equals方法和集合元素依次比较，因为People没有重写equals方法，
        *这个时候调用Object类中的方法，二个对象的内存地址
          为了比较内存应该重写该方法，具体不展开                                         */
        //4.判断集合中是否包含参数指定的所有元素
        flag = collection.containsAll(collection1);//true
        collection1.add("狗蛋");
        flag = collection.containsAll(collection1);//false

        //5.计算两个集合的交集并放在当前集合中
        /*flag = collection.retainAll(collection);//如果改变为true,没有改变是false
        System.out.println(flag);//false

        flag = collection.retainAll(collection1);
        System.out.println(flag);//true
            */
        //6.实现集合中元素的删除操作
        flag = collection1.remove( "狗蛋");
        System.out.println(flag);//true
        System.out.println(collection);//[金友鑫, 18, People{name='袁世龙', age=18, country='泰州'}, 18, 俏俏]
        flag = collection.removeAll(collection1);
        System.out.println(flag);//true
        System.out.println(collection);//[金友鑫, 18, People{name='袁世龙', age=18, country='泰州'}, 18]
        //7.清空集合，判断是否为空
       /* collection1.clear();
        System.out.println(collection1.size());//0
        System.out.println(collection1.isEmpty());//true
        */
        //8.实现集合与数组之间的转换
        //8.1集合向数组
        Object[] objects = collection.toArray();
        System.out.println("数组的长度是："+objects.length);
        for(int pos = 0;pos < objects.length;pos++){
            System.out.println(objects[pos]);
        }
        //8.2数组向集合
        Collection collection2 = Arrays.asList(objects);
        System.out.println(collection2);


    }
}

3.Iterator接口

3.1基本概念

java.util.Iterator接口主要用于描述迭代器对象，可以遍历Collection集合中所有元素

java.util.Collection接口继承Iterable接口,因此所有实现Collection接口的实现类都是使用上述迭代器的方法。

3.2常用方法

方法声明	功能
boolean hasNext()	判断集合中释放与科研迭代/访问的元素
E next()	取出一个元素并指向下一个元素
void remove()	删除访问到的最后一个元素

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

public class CollectionPrintTest {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("汤家凤");
        collection.add("张宇");
        collection.add("姜晓千");
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }//先获取迭代器，使用迭代器得到
        iterator = collection.iterator();
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("[");
        while (iterator.hasNext()) {
            stringBuilder.append(iterator.next());
            if (iterator.hasNext()) {
                stringBuilder.append(",").append(" ");
            } else {
                stringBuilder.append("]");
            }
        }
        System.out.println(stringBuilder);//[汤家凤, 张宇, 姜晓千]
        //4.迭代过程中实现集合中元素的删除
        iterator = collection.iterator();
        while(iterator.hasNext()){
            Object object = iterator.next();
            if("汤家凤".equals(object)){
                iterator.remove();
                //collection.remove(object);会有ConcurrentModificationException并发修改异常
                //在反复迭代的过程中，原集合不能发生改变
            }
        }
        System.out.println(collection);//[张宇, 姜晓千]
    }
}

4.for each循环

4.1基本概念

Java5之后改进for循环,可以实现数组与集合的遍历

4.2语法格式

for(元素类型变量名 : 数组/集合名称){

循环体;

}

for(Object object : collection){
            System.out.println(object);
        }//一般使用Object类,它是所有类型的父类。

tip:

遍历集合方式有toString,iterator,for each

4.3 执行流程

不断地从数组/集合中取出一个元素赋值给变量名并执行循环体，直到取完所有元素为止

5.*List集合

5.1基本概念

5.1.1’’java.util.List集合是Collection集合的子集合,该集合中可以有重复的元素并有先后放入次序。

5.1.2该集合的主要实现类有:ArrayList类，LinkedList类，Stack类，Vector类。

5.1.3其中ArrayList类的底层是采用动态数组进行管理，支持下标访问，增删元素不方便。

5.1.4其中LinkList类中底层逻辑是双向链表进行处理，访问不方便，增删元素方便。

5.1.5其中Stack的底层逻辑是采用动态数组管理，具有栈的特性，后进先出（LIFO）

5.1.6 其中Vector类底层采用动态数组管理，与ArrayList类相比属于线程安全的类，效率比较低。

5.2常用方法

方法声明	功能
void add(int index ,E element)	向集合中指定位置添加元素
boolean addAll(int index,Collection<? extends E> c)	向集合中添加所有元素
E get(int index)	从集合中获取指定位置元素
int indexOf(Object o)	查找参数指定的对象
int lastIndexOf(Object o)	反向查找参数指定的对象
E set(int index ,E element)	修改指定位置的元素
E remove(int index)	删除指定位置的元素
List subList(int fromIndex, int toIndex)	获取子List集合

import java.util.LinkedList;
import java.util.List;

public class ListTest {
    public static void main(String[] args){
        //1.准备List集合
        List list = new LinkedList();
        //2.插入元素
        list.add(0,"金");
        list.add(1,"鑫");
        list.add(1,"友");
        System.out.println(list);//[金, 友, 鑫]
        //3.按照下标获取所有元素并打印
        for(int pos = 0;pos < list.size();pos++){
            System.out.println("下标为" +pos+"的元素是" + list.get(pos));
        }//如果实现要字符的拼接
        StringBuilder  stringBuilder = new StringBuilder();
        stringBuilder.append("[");
        for(int pos = 0;pos < list.size();pos++){
            stringBuilder.append(list.get(pos));
            if(pos == list.size()-1){
                stringBuilder.append("]");
            }else{
                stringBuilder.append(" ,");
            }
        }
        System.out.println(stringBuilder);//[金 ,友 ,鑫]

        //4.实现元素的查找
        int pos = list.indexOf("鑫");//2
        int pos1 = list.lastIndexOf("鑫");//0
        //5.实现按照下标修改元素的功能
        Object object = list.set(0,"袁");
        System.out.println(object);//金
        System.out.println(list);//[袁, 友, 鑫]
        //6.实现按照下标将list集合中所有元素进行删除
       /* for(int pos2 = 0;pos2<list.size();){//while(!list.isEmpty())
            System.out.println("被删除的元素是:"+ list.remove(0));
        }*/
        //7.实现子集合的打印
        List list1 = list.subList(0,2);//取得到0，但是取不到2
        System.out.println(list1);
        //注意子集合和原始集合共用一块内存空间
    }
}

@Camelus

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
java.集合类库

1.1集合概述1.1.1集合的由来当需要在Java程序中记录单个数据内容时,则声明一个变量。当需要在Java程序中记录多个类型相同的数据内容时,则声明一个一维数组。当需要在Java程序中记录多个类型不同的数据内容时，则创建一个对象。当需要在Java程序中记录多个类型相同的数据内容时，则创建一个对象数组。当需要在Java程序中记录多个类型不同的数据内容时，则准备一个集合。1.1.2集合的框架结构Java中集合框架顶级集合是:java.util.Collection集合和 ja
复制链接

扫一扫