Collection集合与泛型

最新推荐文章于 2023-03-20 14:45:00 发布

布斯安

最新推荐文章于 2023-03-20 14:45:00 发布

阅读量221

点赞数

分类专栏： Java高级编程

本文链接：https://blog.csdn.net/qq_40764966/article/details/99717470

版权

Java高级编程专栏收录该内容

29 篇文章 0 订阅

订阅专栏

集合：

集合是java中提供的一种容器，可以用来存储多个数据。
学习目标：
1.会使用集合存储数据。
2.会遍历集合，把数据取出来。
3.掌握每种集合的特性。

集合和数组既然都是容器，它们有啥区别呢？

数组的长度是固定的。集合的长度是可变的。
数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。

集合框架

JAVASE提供了满足各种需求的API，在使用这些API前，先了解其继承与接口操作架构，才能了解何时采用哪个类，以及类之间如何彼此合作，从而达到灵活应用。
集合框架的学习方式：
1学习顶层：学习顶层接口/抽象类中共性的方法，所有的子类都可以使用
2.使用底层：底层不是接口就是抽象类，无法创建对象使用，需要使用底层的子类创建对象使用
集合按照其存储结构可以分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map

一、Collection集合
在这里插入图片描述
Collection接口
1.定义的是所有单列集合中共性的方法
2.所有的单列集合都可以使用共性的方法
3.没有带索引的方法
List接口
1.有序的集合（存储和取出元素顺序相同）
2.允许存储重复的元素
3.有索引，可以使用普通的for循环遍历
Set接口
1.不允许存储重复元素
2.没有索引（不能使用普通的for循环遍历）

01 .Collection 常用功能

java.util.Collection接口
所有单列集合的最顶层的接口，里边定义了所有单列集合共性的方法。
任意的单列集合都可以使用Collection接口的方法。方法如下：

public boolean add(E e)：把给定的对象添加到当前集合中。
public void clear() :清空集合中所有的元素。
public boolean remove(E e): 把给定的对象在当前集合中删除。
public boolean contains(E e): 判断当前集合中是否包含给定的对象。
public boolean isEmpty(): 判断当前集合是否为空。
public int size(): 返回集合中元素的个数。
public Object[] toArray(): 把集合中的元素，存储到数组中。

02 .练习

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

/*

 * `public boolean add(E e)`：  把给定的对象添加到当前集合中 。
 * `public void clear()` :清空集合中所有的元素。
* `public boolean remove(E e)`: 把给定的对象在当前集合中删除。
* `public boolean contains(E e)`: 判断当前集合中是否包含给定的对象。
* `public boolean isEmpty()`: 判断当前集合是否为空。
 * `public int size()`: 返回集合中元素的个数。
* `public Object[] toArray()`: 把集合中的元素，存储到数组中。

 */

public class test1 {
public static void main(String[] args) {
    //1.创建集合对象可以使用多态。接口指向实现类。
    Collection<String> coll = new ArrayList<>();
    coll.add("张三");
    coll.add("李四");
    coll.add("王五");
    System.out.println(coll);
    Object[] o = coll.toArray();
    System.out.println("遍历1");
    System.out.println(Arrays.toString(o));
    System.out.println("遍历2");
    for (int i = 0; i < o.length; i++) {
        System.out.print(o[i]);
    }
    System.out.println();
    System.out.println("遍历3");
    for (Object t : o) {
        System.out.print(t + " ");

    }
    System.out.println();

    System.out.println("集合中元素的个数" + coll.size());
    boolean b = coll.remove("李四");
    // System.out.println(b);
    /*boolean b1 = coll.remove("张二");
    System.out.println(b1);*/
    boolean b2 = coll.contains("李四");
    boolean b3 = coll.contains("王五");
    System.out.println(coll);
    System.out.println("是否包含李四" + b2);
    System.out.println("是否包含王五" + b3);
    System.out.println(coll);
    boolean b4 = coll.isEmpty();
    System.out.println("集合是否为空" + b4);
    coll.clear();
    System.out.println(coll);
    boolean b5 = coll.isEmpty();
    System.out.println("集合是否为空" + b5);


   }
}

二、Iterator迭代器

01 . Iterator接口

在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口java.util.Iterator。Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。
想要遍历Collection集合，那么就要获取该集合迭代器完成迭代操作，下面介绍一下获取迭代器的方法：

public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。

迭代的概念

迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

Iterator接口的常用方法如下：

public E next():返回迭代的下一个元素。
public boolean hasNext():如果仍有元素可以迭代，则返回 true。

02 . 迭代器的使用步骤：
1.使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收(多态)。
2.使用Iterator接口中的方法hasNext判断还有没有下一个元素。
3.使用Iterator接口中的方法next取出集合中的下一个元素。

03 .练习

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

public class test2 {
  public static void main(String[] args) {
    Collection<String> coll = new ArrayList<>();
    coll.add("大粽子");
    coll.add("中粽子");
    coll.add("小粽子");
    System.out.println(coll);
    /*
    1.使用集合中的方法iterator() 获取迭代器的实现类对象，使用Iterator接口接收(多态)
注意：
Iterator<E> 接口也是有泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就		是什么泛型。
     */
    Iterator<String> it = coll.iterator();
    //2.使用Iterator接口中的方法hasNext判断还有没有下一个元素
    boolean b = it.hasNext();
    System.out.println(b);
    //3.使用Iterator接口中的方法next取出集合中的下一个元素。
   /* String s = it.next();
    System.out.println(s);

    boolean b1 = it.hasNext();
    System.out.println(b1);
    String s1 = it.next();
    System.out.println(s1);

    boolean b2 = it.hasNext();
    System.out.println(b2);
    String s2 = it.next();
    System.out.println(s2);
    boolean b3 = it.hasNext();
    System.out.println(b3);
    ///String s3 = it.next();报错。*/
   //发现代码有重复，到最后一个返回false，使用while循环。
    while(it.hasNext()){
        String s = it.next();
        System.out.print(s);
    }
    System.out.println();
    //使用for循环
    for(Iterator<String> it2 = coll.iterator();it2.hasNext();){
        String s1 = it2.next();
        System.out.println(s1);
    }
    }
}

04 . 迭代器的实现原理

当遍历集合时，首先通过调用t集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素。
Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素。

三、增强for

增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实也是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
格式：

for(元素的数据类型  变量 : Collection集合or数组){ 
	//写操作代码
}

它用于遍历Collection和数组。通常只进行遍历元素，不能在遍历的过程中对集合元素进行增删操作。

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

public class test {
 public static void main(String[] args) {
    //demo1();
    demo2();
}

private static void demo2() {
    //使用增强for遍历集合
    Collection<String> coll = new ArrayList<>();
    coll.add("aa");
    coll.add("bb");
    coll.add("cc");
    for (String s : coll) {
        System.out.println(s);
    }
}

private static void demo1() {
    int arr[] ={1,2,3,4};
    //使用增强for遍历数组
    for (int i : arr) { //i代表数组中的每个元素
        System.out.println(i);
   	 }
   }
}

练习：遍历元素3种方式
遍历元素的三种方式
1.直接使用集合名隐式调用toString方法遍历。
2.使用迭代器遍历。
3.使用for语句遍历。与数组一样。

public class IteratorTest {
public static void main(String[] args) {
    Collection<String> ca = new ArrayList<>();
    ca.add("理工学院");
    ca.add("信息系");
    ca.add("小明");
    //1.使用Iterator遍历集合
    Iterator<String> it = ca.iterator();
    String s= null;
    while(it.hasNext()){
        s = it.next();
        System.out.println(s);
    }
    //2.使用Foreach遍历集合，JDK1.5以上版本。
    for (String s1 : ca) {
        System.out.println(s1);
    }
    //3.使用toString()输出集合的所有元素。
    System.out.println(ca.toString());

	 }
}

二、泛型

1.集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

泛型：是一种未知的数据类型，当我们不知道使用什么数据类型的时候可以使用泛型
泛型也可以看出是一个变量，用来接收数据类型
E e: Element元素
T t Type类型
ArrayList集合在定义的时候不知道集合中都会存储什么类型的数据，所以类型使用泛型。
在这里插入图片描述
2.使用泛型和不使用泛型的好处或弊端?
01.创建集合对象，不使用泛型
好处：
集合不使用泛型，默认的类型就是object类型，可以存储任意类型的数据
弊端：
不安全，会引发异常
02.创建集合对象，使用泛型
好处：
1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
2.把运行期异常（代码运行之后会批出的异常），提升到了编译期（写代码的时候会报错）
弊端：
泛型是什么类型，只能存储什么类型的数据

3.使用泛型的好处

将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
避免了类型强转的麻烦。

4.泛型的定义与使用

泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

01 . 定义和使用含有泛型的类
定义格式：

修饰符 class 类名<代表泛型的变量> {  }

02.含有泛型的方法

定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

练习1泛型的类

/*
定义一个含有泛型的类，模拟ArrayList集合
泛型是一个未知的数据类型，当我们不确定什么数据类型的时候，可以使用泛型
泛型可以接收任意的数据类型，可以使用Integer,String,Student。。
创建对象的 时候确定泛型的数据类型。
 */
class test <E>{
    private E name;

    public E getName() {
 	   return name;
	  }

   public void setName(E name) {
    this.name = name;
 }
}
public class GenericClass {
public static void main(String[] args) {
    //不写泛型默认为Object类型。
    test t1 = new test();
    t1.setName("是字符串");
    Object o1 = t1.getName();
    System.out.println(o1);
    //创建test对象，
    test<Integer> t2 = new test<>();
    t2.setName(1);
    Integer i1 = t2.getName();
    System.out.println(i1);
 }
}

练习2含有泛型的方法

/*
定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间。
格式：
修饰符 <泛型> 返回值类型 方法名(参数列表（使用泛型）){
       方法体；
       }
含有泛型的方法，在调用的时候确定泛型的数据类型
传递什么类型的参数，泛型就是什么类型
 */
class MT{
   //定义一个含有泛型的方法。
 public static<E> void method(E e){
    	System.out.println(e);
	}
}

public class MethodTest {
   public static void main(String[] args) {
    MT.method(10);
    MT.method("哈哈哈");
    MT.method(8.8);
    MT.method(true);
  }
}

5.泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

01.通配符基本使用

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

此时只能接受数据,不能往该集合中存储数据。
02.通配符高级使用----受限泛型
设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

格式： 类型名称 <? extends 类 > 对象名称
意义： 只能接收该类型及其子类

泛型的下限：

格式： 类型名称 <? super 类 > 对象名称
意义： 只能接收该类型及其父类型

练习

import java.util.ArrayList;
import java.util.Collection;
public class TongPeifu {
public static void main(String[] args) {
    Collection<Integer> list1 = new ArrayList<>();
    Collection<String> list2 = new ArrayList<>();
    Collection<Number> list3 = new ArrayList<>();
    Collection<Object> list4 = new ArrayList<>();


    getElement1(list1);
    getElement1(list2);//报错
    getElement1(list3);
    getElement1(list4);//报错

    getElement2(list1);//报错
    getElement2(list2);//报错
    getElement2(list3);
    getElement2(list4);
 }
/*
类与类的继承关系
Integer extends Number extends Object
String extends Object
*/

//泛型的上限:此时的泛型?,必须是Number类型或者Number类型的子类。
private static void getElement1(Collection<? extends Number>coll) { }
//泛型的下限此时的泛型?,必须是Number类型或者Number类型的父类。
 private static void getElement2(Collection<? super Number>coll) { }
}

布斯安

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Collection集合与泛型

集合：集合是java中提供的一种容器，可以用来存储多个数据。学习目标：1.会使用集合存储数据。2.会遍历集合，把数据取出来。3.掌握每种集合的特性。集合和数组既然都是容器，它们有啥区别呢？数组的长度是固定的。集合的长度是可变的。数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。集合...
复制链接

扫一扫