JavaSE基础八----＜集合＞泛型集合体系Collection接口中的方法

Posted 小智RE0

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JavaSE基础八----＜集合＞泛型集合体系Collection接口中的方法相关的知识，希望对你有一定的参考价值。

目录

一、 泛型

在之前的常用类Arrays类学习中,初步认识了泛型;那么就从泛型开始进入集合的认识.

泛型:就是类型参数化(参数化类型)

在早期的Object中提供了存储任意类型的数据;由于数据转换的问题;又开发出了泛型;

例如:
在给这个链表添加元素时,没有说明要添加什么类型的元素,而Object类作为所有类的父类,包含了不同的类型;

import java.util.ArrayList;
//在早期的Object中提供了存储任意类型的数据;由于数据转换的问题;又开发出了泛型;
public class Demo001 {
    public static void main(String[] args) {
        ArrayList arrayList=new ArrayList();
        //add()方法进行添加元素
        arrayList.add("我");
        arrayList.add(1);
        arrayList.add(true);
        //进行for循环遍历
        for (int i = 0; i < arrayList.size(); i++) {
            //获取链表中的每一个元素
            Object obj=arrayList.get(i);
            //输出没有问题;
            System.out.println(obj);
        }
    }
}

但是在操作链表中的元素时,对于不同的数据类型;要开始进行数据向下转型;这里就需要用到instanceof进行数据类型检测;;链表包含数据类型越多处理起来就会越复杂;

//进行for循环遍历
        for (int i = 0; i < arrayList.size(); i++) {
            //获取链表中的每一个元素
            Object obj=arrayList.get(i);
           if(obj instanceof String){
               String S=(String)obj;
           }
           if(obj instanceof Integer){
               Integer I=(Integer)obj;
           }
           if(obj instanceof Boolean){
               Boolean B=(Boolean)obj;
           }
        }

那么引入泛型的概念后;创建对象后,传入什么类型的参数,就可以调用哪种类型的属性或者方法;或者不给参数,直接默认为Object类型的;

< 任意的单个大写字母> ;可以写多个;
注意:只能给引用类型;不能用基本类型;

//关于泛型
//泛型:参数化类型(类型参数化)
public class Demo001 <T,A>{
    
    //T类型的name
    T name;
    //A类型的age
    A age;
    
    //定义返回值为A类型的,参数为A类型的test方法
    public A  test(A a){
       return a;
    }
    //使用main方法进行测试
    public static void main(String[] args) {
        //创建对象;
        //将T设定为String类型的,A为Integer类型的
        Demo001<String,Integer> d1=new Demo001<>();
        d1.name="旺财";
        d1.age=10;
        d1.test(10);
        
        //当不写参数时,默认为Object类型的;
        Demo001 d2=new Demo001();
        d2.name=12;
        d2.age=10;
        d2.test("aaa");
    }
}

二、集合概念

集合也可以看做一个容器;存储数据元素;在之前学到的数组也是个容器,但是数组长度一旦给定之后,它不能再改变(且只能存储同一种类型的数据);那么就需要引入集合;可以进行动态调节的容器。

  • 实现动态存储长度;

  • 可存储不同类型;操作方式不同;数组,链表,树,哈希表等。

  • 在一个集合中默认可以存储任意类型的数据（建议使用泛型;一个集合存储同一种类型的数据，便于管理）

  • Java的集合框架是由很多接口、抽象类、具体类组成的，都位于java.util包中。

集合体系

单列可理解为单列存储数据,双列即键值对存储数据(不可重复);即两列存储数据

Collection 单列集合

Collection 单列集合
List: 元素可重复–数据对象有顺序且可以重复
ArrayList: 底层是数组实现
LinkedList:底层是链表实现
Vector:底层是数组实现,是线程安全的
Set:元素不可重复: – Set中所存储的元素是不重复的,是无序（元素的添加顺序）的, Set中的元素没有索引
HashSet:底层hash表实现
TreeSet:底层是红黑树实现

Map 双列集合

Map 双列集合
HashMap中元素的key值不能重复，即彼此调用equals方法，返回为false。排列顺序是不固定的。
TreeMap所有的元素都保持着某种固定的顺序，如果需要得到一个有序的Map就应该使用TreeMap，key值所在类必须实现Comparable接口。
Hashtable实现了同步

迭代器的学习

Collections类

简图:

在这里插入图片描述

List接口
Set接口
Map接口以及Collections类

三、Collection接口

Collection 接口:定义了存取一组对象的方法，其子接口Set和List分别定义了存储方式。

  • Set 中的数据对象没有顺序且不可以重复。

  • List 中的数据对象有顺序且可以重复。

例如;写个数据集合col0;

//Collection为接口,List接口继承Collection接口,ArraysList为实现List接口的类;
Collection<String> col0=new ArrayList<String>();

1.添加方法:

  • public abstract boolean add(E e)
    它默认向一个给定集合的末尾添加元素,返回值是布尔值;
 Collection<String> col0=new ArrayList<String>();
 //添加元素
//public abstract boolean add(E e)
//它默认向集合的末尾添加元素,返回值是布尔值;
col0.add("Jie1");
col0.add("Jie2");
col0.add("Jie1");
col0.add("Jie1");
System.out.println(col0);
 //输出的col0 [Jie1, Jie2, Jie1, Jie1]
  • public abstract boolean addAll( Collection<? extends E> c)
    将指定集合中的元素添加到这个集合;返回值为布尔值;
//新建个集合col1;
Collection<String> col1=new ArrayList<String>();
//public abstract boolean addAll( Collection<? extends E> c)
//将指定集合中的元素添加到这个集合;
//例如:将col0中的元素添加到col1中;
col1.addAll(col0);
System.out.println(col1);
//输出的col1 [Jie1, Jie2, Jie1, Jie1]

2.删除方法:

  • public abstract void clear()
    清除所有元素;

  • public abstract boolean remove(Object o)
    从前向后,删除第一个出现的指定元素;返回值为布尔值.

  • public boolean removeIf(java.util.function.Predicate<? super E> filter)
    指定条件地精确删除(相当于过滤器)

//新建集合col3
Collection<String> col3=new ArrayList<String>();
col3.add("asd");
col3.add("sdf");
col3.add("abc");
col3.add("d");
System.out.println(col3);//原来的col3 [asd, sdf, abc, d]
 //public boolean removeIf(java.util.function.Predicate<? super E> filter)
//指定条件地精确删除
col3.removeIf(new Predicate<String>() {
public boolean test(String s) {
//这里指定删除以d结尾的元素
return s.endsWith("d");
        }
  });
System.out.println(col3);//删除后的col3  [sdf, abc]

3.判断方法:

  • public abstract boolean contains(Object o)
    判断是否包含某个元素,返回布尔值;

  • public abstract boolean isEmpty()
    判断集合是否为空,返回布尔值;

遍历方法:

  • public java.util.stream.Stream stream()
    以流的方式进行遍历
System.out.println(col6);//[asd, b, c, g]
//public java.util.stream.Stream<E> stream()
//以流的方式进行遍历
//里面写了拉莫达表达式
col6.stream().forEach((a)-> System.out.println(a));
System.out.println(col6);
//asd
//b
//c
//g

4.集合与数组之间的转换

4.1集合转数组

  • public abstract Object[] toArray()
    默认转换为Object类型的
 Collection<String> col10=new ArrayList<>();
col10.add("asd");
col10.add("qwe");
//集合转数组
//1.public abstract Object[] toArray()
 //默认转换为Object类型的
Object obj=col10.toArray();
  • public abstract T[] toArray( T[] a)
    用集合的类型创建相应的数组,数组的长度是集合的长度;
//2.public abstract <T> T[] toArray( T[] a)
//用集合的类型创建相应的数组,给的长度是集合的长度;
//这里的size()方法调出集合长度;
String[] str=col10.toArray(new String[col10.size()]);
System.out.println(Arrays.toString(str));//[asd, qwe]

4.2数组转集合

这里用到的是Arrays类中的asList( )方法;

在这里插入图片描述
一般用法:

实际上是将一个数组对象直接存储为集合的一个元素

//数组转集合
int[] a={5,2,7};
int[] b={1,2,4};
//public static <T> java.util.List<T> asList(@NotNull T... a)
Collection col11=Arrays.asList(a,b);
//实际上是将一个数组对象直接存储为集合的一个元素
System.out.println((col11));
//[[I@1b6d3586, [I@4554617c]

public static java.util.List asList(T… a)
注意到这个方法的参数是(T…a); T作为数据类型 ,a是变量;

知识点: int...a 就是一个可变长度的参数;本质上是个数组;
一个参数列表只能有一个可变长度的参数,并且要放在参数列表的末尾.

例如:

import java.util.Arrays;

//关于可变长度参数的知识:
public class Demo02 {
    public static void main(String[] args) {
        //在main方法中调用study方法,
        study(10,20,30,40,50);
    }
    //study方法的参数列表中,int...Q就是个可变长度参数;
    public static void study(int A,int... Q){
        System.out.println(A);
        System.out.println(Arrays.toString(Q));
    }
}
//输出结果:
//10
//[20, 30, 40, 50]

可变长度参数

注意,刚才的数组转集合时,我们输出集合col11;发现这个显示有问题;

在这里插入图片描述
实际上,这个asList方法在转换时,只是将数组转换为Arrays类的内部类ArrayList类型,(注意,和之后要学习的集合中的ArratyList实现类不是一个概念);

效果图:

Arrays类的内部类ArrayList
那么;再看一下asList方法的源码,发现底层实现了List接口;

底层实现了List接口

那么,这里要进行一个操作,将List类型的集合,通过List的实现类ArrayList的构造方法进行转换,然后对数组转过来的集合进行操作;

//数组转集合
//public static <T> java.util.List<T> asList(@NotNull T... a)
//这里实际返回的是List类型;本质上为Arrays$ArrayList;
Collection col11=Arrays.asList(5,2,7,1,7,2,5);
//通过List的实现类ArrayList的构造方法进行转换,然后对数组转过来的集合进行操作;
ArrayList arrayLs=new ArrayList(col11);
//这里调用ArrayList中的删除方法remove;按下标索引位置删除元素;
System.out.println(arrayLs.remove(5));//删除的是下标第五位元素2;
System.out.println(arrayLs);//[5, 2, 7, 1, 7, 5]

以上是关于JavaSE基础八----＜集合＞泛型集合体系Collection接口中的方法的主要内容，如果未能解决你的问题，请参考以下文章

JavaSE-集合

JavaSE基础八----＜集合＞List接口及其实现类,List接口的迭代

JavaSE基础八----＜集合＞Map接口及其实现类 Collections类

JavaSE基础八----＜集合＞Set接口及其实现类,Set接口的迭代方式

编程基础系列--之--浅谈ListSetMap和泛型——单列集合

《JavaSE 基础知识》泛型的基本介绍和应用。