集合泛型

最新推荐文章于 2022-08-04 10:05:21 发布
最新推荐文章于 2022-08-04 10:05:21 发布
阅读量1k 收藏 5
点赞数 4
分类专栏： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyj____/article/details/103027980
版权
本文详细介绍了Java集合框架中的泛型概念及其在ArrayList、LinkedList、HashSet、TreeSet等集合类中的应用。泛型提供了类型安全性，使得在编译阶段就能检测到类型错误，避免了运行时的强制类型转换。同时，文章还讨论了泛型类、泛型方法、泛型接口以及泛型通配符的使用，并给出了示例代码。此外，还涵盖了Map接口及其实现类HashMap、Hashtable、TreeMap和LinkedHashMap的特点和遍历方式。
摘要由CSDN通过智能技术生成

1.集合的概述

2.Collection

3.List

4.Vertor

5.Stack

6.ArrayList

7.LinkedList

8.Set

9.HashSet

10.TreeSet

11.泛型

12.Map

13.HashMap

14.Hashtable

15.TreeMap

16.LinkedHashMap

 

一、集合的概述

1.集合的概念

        集合有时候也称为容器，它可以将系列元素组合成一个单元，用于存储、提取、管理数据。

        集合是存储对象最常用的一种方式。

        集合可以存储任意类型的对象，而且长度可变。在程序中有可能无法预知先知道多少个对象，那么用数组来装对象的话，长度不好定义，而集合解决了这样的问题。

2.集合和数组的比较

        相同点：数组和集合类都是存储数据的容器

        不同点：

        1.存储内容不同

        数组既可以存放基本数据类型，也可以存放引用数据类型；集合只能存储引用数据类型，如果要存放基本数据类型，封装成包装类。

        数组只能存储定义的数据类型；集合可以存储多种的类型

        2.存储数量不同

        数组的长度是不可变的，一旦大小确定就无法增删；集合的长度是可变的，是一个可以伸缩的容器

        3.方法不同

        数组中只有Object中定义的方法以及一个length属性；集合中有太多太多的方法。

        集合类的特点：用于存储对象，长度是可变的，可以存储不同类型的对象

3.集合家族

        集合的的分类：

        单列集合：每个元素都是一个单独的个体  value

        双列集合：每个操作都是针对一对数据进行操作，一对数据作为一个单位。Key--value

        单列集合的体系

        Collection:单列集合的顶层接口

             |--List:有序的子接口

                    |--ArrayList:数组、顺序存储

                    |--LinkedList:链表、链式存储

                    |--Vector:被Arraylist取代

             |--Set:无序的子接口

                    |--HashSet:哈希存储

                    |--TreeSet:二叉树存储

        双列集合的体系

            Map:双列集合的顶层接口

                     |--HashMap:哈希存储

                     |--TreeMap:二叉树存储

二、Collection

1.概述

        单列集合的顶层接口。接口不能创建对象，随便找个一个子类已实现的对象，调用接口的方法。

        学习Collection中的共性方法，多个容器在不断向上抽取就出现了该体系。发现Collection接口中具有容器具有的共性方法。查阅API时，就可以直接看该接口中的方法。并创建其子类对象对集合进行基本应用。当要使用集合对象中特有的方法，查看子类具体内容。

2.常用方法

boolean

add(E e) 

确保此集合包含指定的元素（可选操作）。

boolean

remove(Object o) 

从该集合中删除指定元素的单个实例（如果存在）（可选操作）。

void

clear() 

从此集合中删除所有元素（可选操作）。

boolean

isEmpty() 

如果此集合不包含元素，则返回 true 。

boolean

contains(Object o) 

如果此集合包含指定的元素，则返回 true 。

int

size() 

返回此集合中的元素数。

      代码示例

import java.util.ArrayList;
import java.util.Collection;
class Test1 {
	public static void main(String[] args) {
		Collection c = new ArrayList();

		//添加
		c.add(111);
		c.add("222");
		c.add("abc");
		c.add("zxc");
		System.out.println(c);//[111, 222, abc, zxc]

		//删除
		c.remove(111);
		System.out.println(c);//[222, abc, zxc]

		//元素个数
		System.out.println(c.size());//3

		//判断是否为空
		System.out.println(c.isEmpty());//false

		//判断是否包含该元素
		System.out.println(c.contains("zxc"));//true

		//清空所有元素
		System.out.println(c.clear());
		System.out.println(c.isEmpty());//true

	}
}

boolean

addAll(Collection<? extends E> c) 

将指定集合中的所有元素添加到此集合（可选操作）。

boolean

containsAll(Collection<?> c) 

如果此集合包含指定 集合中的所有元素，则返回true。

boolean

removeAll(Collection<?> c) 

删除指定集合中包含的所有此集合的元素（可选操作）。

boolean

retainAll(Collection<?> c) 

仅保留此集合中包含在指定集合中的元素（可选操作）。

      代码示例

import java.util.ArrayList;
import java.util.Collection;
class Test1 {
	public static void main(String[] args) {
		Collection c1 = new ArrayList();

		c1.add("123");
		c1.add("abc");
		c1.add(120);
		c1.add("aaa");
		c1.add("bbb");
		c1.add("ccc");
		System.out.println(c1);//[123, abc, 120, aaa, bbb, ccc]

		//将集合2中的元素全部添加到集合1中
		Collection c2 = new ArrayList();
		c2.add("111");
		c2.add("222");
		c2.add("333");
		c1.addAll(c2);
		System.out.println(c1);//[123, abc, 120, aaa, bbb, ccc, 111, 222, 333]

		//判断一个集合1是否包含集合3中的所有数据
		Collection c3 = new ArrayList();
		c3.add("123");
		c3.add("abc");
		System.out.println(c1.containsAll(c3));//true

		//删除集合1中包含集合3中的所有元素
		System.out.println(c1);//[123, abc, 120, aaa, bbb, ccc, 111, 222, 333]
		c1.removeAll(c3);
		System.out.println(c3);//[123, abc]
		System.out.println(c1);//[120, aaa, bbb, ccc, 111, 222, 333]
		
		//仅保留集合1中包含集合2中的元素
		System.out.println(c2);//[111, 222, 333]
		c1.retainAll(c2);
		System.out.println(c1);//[111, 222, 333]
		
	}
}

3.自定义类的对象在集合中的操作

      练习：定义一个Person类，完成在Collection中的增删改查操作。

import java.util.ArrayList;
import java.util.Collection;
class Test1 {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		Person p1 = new Person(1,"小一",11);
		Person p2 = new Person(2,"小二",22);
		Person p3 = new Person(3,"小三",33);
	
		c.add(p1);
		c.add(p2);
		c.add(p3);
		System.out.println(c);//[id:1,name:小一,age:11, id:2,name:小二,age:22, id:3,name:小三,age:33]
	
		c.remove(p3);
		System.out.println(c);//[id:1,name:小一,age:11, id:2,name:小二,age:22]

		System.out.println(c.size());//2
		c.clear();
		System.out.println(c.size());//0

	}
}

class Person{
	private int id;
	private String name;
	private int age;
	public Person(){
	}
	public Person(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	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;
	}
	public String toString(){
		return "id:"+id+",name:"+name+",age:"+age;
	}
}

4.遍历

      （1）集合转成数组，然后再对数组进行遍历。

       代码示例

import java.util.ArrayList;
import java.util.Collection;
public class Test1 {
	public static void main(String[] args) {
		
		Collection c = new ArrayList();
		c.add(new Person("小一",11));
		c.add(new Person("小二",22));
		c.add(new Person("小三",33));
		c.add(new Person("小四",44));
		c.add(new Person("小五",55));

		Object[] obj = c.toArray();
		for(int i=0;i<obj.length;i++){
			Person p = (Person)obj[i];
			System.out.println(p);
		}

	}
}
class Person {
	private String name;
	private int age;
	
	public Person() {
		super();
	}

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

	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 "Person [name=" + name + ", age=" + age + "]";
	}		
}

     （2）使用迭代器

Iterator<E>

iterator() 

返回此集合中的元素的迭代器。

boolean

hasNext() 

如果迭代具有更多元素，则返回 true 。

E

next() 

返回迭代中的下一个元素。

     注：hasNext判断是否有下一个元素；next获取下一个元素，还会移动迭代器的位置。

    代码示例

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Test1 {
	public static void main(String[] args) {
		
		Collection c = new ArrayList();
		c.add(new Person("小一",11));
		c.add(new Person("小二",22));
		c.add(new Person("小三",33));
		c.add(new Person("小四",44));
		c.add(new Person("小五",55));

		Iterator iterator = c.iterator();//获取迭代器
		//System.out.println(iterator.hasNext());//true
		//System.out.println(iterator.next());//Person [name=小一, age=11]
		
		while(iterator.hasNext()){
			Person p = (Person)iterator.next();
			System.out.println(p);
		}
	}
}
class Person {
	private String name;
	private int age;
	
	public Person() {
		super();
	}

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

	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 "Person [name=" + name + ", age=" + age + "]";
	}		
}

      （3）高级for循环底层就是迭代器。

       代码示例

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Test1 {
	public static void main(String[] args) {
		
		Collection c = new ArrayList();
		c.add(new Person("小一",11));
		c.add(new Person("小二",22));
		c.add(new Person("小三",33));
		c.add(new Person("小四",44));
		c.add(new Person("小五",55));

		Object[] objs = c.toArray();
		for(Object obj : objs){
			Person p = (Person) obj;
			System.out.println(p);
		}
	}
}
class Person {
	private String name;
	private int age;
	
	public Person() {
		super();
	}

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

	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 "Person [name=" + name + ", age=" + age + "]";
	}		
}

5.Collections-扩展

static <T> void

fill(List<? super T> list, T obj) 

用指定的元素代替指定列表的所有元素。

static <T> int
最低0.47元/天 解锁文章
通天云计算
关注
专栏目录
集合泛型简介与常用方法
qq_33194230的博客
11-05 439
集合 什么是集合 概念 对象的容器，实现了对对象常用的操作 和数组的区别 数组长度固定，集合长度不固定 数组可以存储基本类型和引用类型，集合只能存储引用类型 位置 java.util.*; Collection体系 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tru7Wmy1-1604564315647)(https://raw.githubusercontent.com/836890151/Image/master/1.png)] Collection父接口 特点：
集合【泛型】
qq_48336929的博客
08-10 622
泛型 泛型部分知识思维导图 1、泛型介绍 1.1、为什么会出现泛型？ 集合中是可以存放任意对象的，只要把对象丢尽集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。 但是由于集合中什么类型的元素都可以存储。导致取出时，如果出现强转就会引发运行时 ClassCastException。 而因为集合存放的数据类型不固定，故网集合里面存放元素时，存在安全隐患，如果定义集合时，可以像定义数组一样指定数据类型，那么就可以解决该类安全问题。 JDK1.5
集合,泛型
weixin_61557810的博客
05-04 923
集合,List，Set，Map
集合的泛型
酷酷的锐的博客
08-30 215
在JDK1.5以前，容器可以储存Object的任意子类型，         但是在对元素进行操作时比如调用元素的方法等，         我们必须知道元素的类型，         因此在编程中增加了大量代码，来强制转换，增加了开发难度 所以JDK1.5开始支持了一个新特性，叫泛型机制。         用来规定容器中存储的元素类型。         此机制可以在编译期间就可以判断元素类型。  ...
集合中的泛型
qq_33420835的博客
08-24 234
如果集合中存储同一种数据类型，就可以通过泛型来指定 List&lt;Integer&gt;list=new ArrayList&lt;Integer&gt;(); 在向集合添加数据时，也可以添加泛型的子类 自定义泛型 package leetcode; import java.util.Arrays; public class GenericDemo&lt;T&gt; { priv...
集合、泛型
z874290647的博客
06-05 1494
一、集合   集合即Java实例类库中存在的一套完整的容器类，基本类型有：List、Set、Queue、Map。 1、List集合   List接口在Collection基础上添加了大量的方法，可以在List的中间插入和移除元素。 1、ArrayList   ArrayList实现了长度可变的数组，在内存中分配连续的空间，遍历元素和随机访问元素的效率比较高。 常用方法： 方法名 说明 ...
java反射之通过反射了解集合泛型的本质(详解)
08-30
在本篇中，我们将探讨如何通过反射深入理解Java集合泛型的本质。 首先，泛型是Java SE 5引入的一个重要特性，它的主要目的是在编译时提供类型安全，避免在集合中存储不兼容类型的对象。例如，`ArrayList<String>` ...
泛型集合泛型集合泛型集合
06-26
在C#中，`System.Collections.Generic`命名空间提供了多个泛型集合类，如`List<T>`、`Dictionary, TValue>`等，它们替代了早期的非泛型集合，如`ArrayList`和`Hashtable`，因为泛型集合能确保在编译时就检查类型匹配...
java 集合泛型+数据结构
最新发布
08-07
java 集合泛型+数据结构
list集合泛型等常用
12-19
list集合泛型等常用
集合 和 泛型
Wonf的博客
02-17 725
集合框架 List、Set是Collection接口的子接口。 - Collection 接口存储一组不唯一，无序的对象； - List 接口存储一组 不唯一、有序（插入顺序）的对象； - set 接口存储一组唯一，无序的对象。 Map 不继承COllection,接口存储一组键值对象，提供到key到value的映射。 List接口 ArrayList 和 LikedLiet是List
集合和泛型
qq_58631644的博客
08-04 1111
在向 HashSet 集合中增加元素时，会先计算此元素的 hashcode 值，如果 HashSet 集合中没有此 hashcode 值，那么此元素就可以插入。如果 hashcode 值与 HashSet 集合中的某个元素的 hashcode 值相同，HashSet 就会继续调用 euqals() 方法进一步判断它们的内容是否相同，如果相同就忽略这个新增的元素，如果不同才能把它增加到 HashSet 集合中。......
集合与泛型
shujuboke的博客
07-22 2693
集合与泛型 一、集合：就像是一种容器。用于存储、获取、操作对象的容器。 1. 数组的弊端 ①数组的长度不可变     ②数组没有提供可以查看有效元素个数的方法 2. 集合的特点 ①集合的长度是可变的 ②集合可以存储任意类型的对象 ③集合只能存储对象 3. 集合框架 java.util.Collection : 集合层次的根接口  
面试中的知识点------集合中的泛型（详细详细！！！）
qq_46540738的博客
06-09 617
泛型集合知识点整理什么是泛型？ 什么是泛型？         泛型就相当于标签，集合容器在设计、声明阶段不能确定这个类型到底存的都是什么类型的对象，所有在jdk1.5之前只能把元素设计为Object类型，jdk1.5之后就采用泛型来解决了，即把元素的类型设计成一个参数，这个类型参数叫做泛型。比如：ArrayList，这个就是参数，即泛型。        &nb
java 集合 泛型
07-27
Java集合框架是一组用于存储和操作数据的类和接口。泛型是Java中的一种特性，它允许我们在使用集合类时指定其中存储的元素类型。 在集合框架中，使用泛型可以实现类型安全，避免在运行时出现类型转换错误。通过指定泛型参数，我们可以告诉编译器集合中应该存储什么类型的对象。 例如，我们可以使用泛型来声明一个ArrayList集合，其中存储的元素类型为String： ```java ArrayList<String> list = new ArrayList<String>(); ``` 在上面的代码中，`ArrayList<String>`中的`<String>`是泛型参数，表示该集合只能存储String类型的对象。 使用泛型后，我们可以在编译时检查集合中存储的对象类型是否与指定的泛型参数类型匹配，从而避免在运行时出现类型错误。此外，还可以通过泛型获取到正确的对象类型，避免了需要进行类型转换的麻烦。 Java集合框架中的许多类都支持泛型，例如ArrayList、LinkedList、HashSet等。通过使用泛型，我们可以更好地利用Java集合框架提供的功能，并提高代码的可读性和可维护性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值