集合01，泛型

最新推荐文章于 2023-04-08 09:18:28 发布
最新推荐文章于 2023-04-08 09:18:28 发布
阅读量97 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/swop_/article/details/89606362
版权

文章目录

集合

集合的特点

1.集合能够对数据进行增加删除修改查询的操作

2.集合能够存储引用类型,如果是基本类型可以是包装类类型

3.集合的长度是可变的

4.部分集合是有序的,部分集合是无序的 (这里的有序指的是存储有序,并不是排序)

5.部分集合是唯一的,部分集合是可重复 (11, 22 ,33, 33, 22)

6.部分集合是可排序的,部分集合是不可排序的

7.部分集合是线程安全的,部分集合是线程不安全 (synchronized)

##### 常见的和集合相关的数据结构

数组,栈,队列,链表,哈希表,二叉树 . 存储方式不一样决定了该集合的性能效率不一样

##### 集合常用的方法

1.增加功能

boolean add(E e) boolean addAll(Collection<? extends E> c)

2.删除功能

void clear() boolean remove(Object o) boolean removeAll(Collection<?> c)

3.修改功能

4.查询功能

Iterator iterator() Object[] toArray() T[] toArray(T[] a)

5.获取功能

int size()

6.判断功能

boolean contains(Object o) boolean containsAll(Collection<?> c) boolean isEmpty()

7.其他功能

boolean retainAll(Collection<?> c) 返回原集合是否发生改变？改变了返回true，没改变返回false 
	public class Test09 {
		public static void main(String[] args) {
			Collection c = new ArrayList();
			c.add("张三");
			c.add("李四");
			c.add("王五");
			c.add("赵六");
			System.out.println(c); // [张三, 李四, 王五, 赵六]
			
			// boolean addAll(Collection c)
			Collection c2 = new ArrayList(); 
			c2.add("小红");
			c2.add("小明");
			c2.add("小芳");
			c.addAll(c2);
			
			System.out.println(c);//[张三, 李四, 王五, 赵六, 小红, 小明, 小芳]
			
			// boolean remove(Object o) 
			System.out.println("remove: " + c.remove("张三"));//remove: true
			System.out.println(c);//[李四, 王五, 赵六, 小红, 小明, 小芳]
	//		 boolean removeAll(Collection<?> c);
	//		System.out.println("removeAll: " + c.removeAll(c2));//删除c里面的c2
	//		System.out.println(c);
			
			// void clear() 
	//		c.clear();//清空
	//		System.out.println(c);
			
			System.out.println(c.size());//6
			
			System.out.println("contains: " + c.contains("李四"));//是否有这个元素：true 
			System.out.println("contains: " + c.contains("曹操"));//false
			System.out.println("contains: " + c.contains(""));//false
			System.out.println("containsAll: " + c.containsAll(c2));//true
			System.out.println("isEmpty: " + c.isEmpty());//是否为空
			
			Collection c3 = new ArrayList();
	//		c3.add("张三");
	//		c3.add("李四");
	//		c3.add("王五");
	//		c3.add("赵六");
	//		c3.add("小红");
	//		c3.add("小明");
	//		c3.add("小芳");
	//		c3.add("小李");
			System.out.println(c);//[李四, 王五, 赵六, 小红, 小明, 小芳]
			System.out.println(c3);//[]
			System.out.println("retainAll:" + c.retainAll(c3));//retainAll:true
			System.out.println("c:" + c);//c:[]
			
		}
	
	}

集合的遍历


public class CollectionDemo02 {
	public static void main(String[] args) {
		// Object[] toArray() 
		Collection c = new ArrayList();
		c.add("希特勒");
		c.add("杨贵妃");
		c.add("貂蝉");
		c.add("赛西施");
//		c.add(c);
//		c.add(100);
		System.out.println(c);
//		Object[] objs = c.toArray();
//		for (Object oj : objs) {
//			String s = (String) oj;
//			System.out.println(s);
//		}
		
//		Iterator<E> iterator() 
//		获取迭代器对象
		Iterator it = c.iterator();
		
//		Object oj = it.next();
//		System.out.println(oj);
//		
//		oj = it.next();
//		System.out.println(oj);
//		
//		oj = it.next();
//		System.out.println(oj);
//		
//		oj = it.next();
//		System.out.println(oj);
//		
//		oj = it.next();
//		System.out.println(oj);
		
		while (it.hasNext()) {//it.hasNext()判断是否还有下一个元素
			Object oj = it.next();
			System.out.println(oj);
		}
		
	}
}
集合的并发修改异常

== java.util.ConcurrentModificationException==
产生原因: 表示在使用迭代器的同时,使用原集合修改了元素
解决办法:
1.只操作原集合
toArray
普通for
2.只操作迭代器
使用ListIterator
注意:
foreach遍历集合底层也是使用了迭代器不能够解决并发修改异常
修改异常小案例

		public static void main(String[] args) {
			Collection c = new ArrayList();
			c.add("希特勒");
			c.add("杨贵妃");
			c.add("貂蝉");
			c.add("赛西施");
			
	//		Iterator it = c.iterator();
	//		while (it.hasNext()) {
	//			Object oj = it.next();
	//			String s = (String) oj;
	//			if (s.equals("杨贵妃")) {
	//				c.remove("杨贵妃");
	//			}
	//		}
	//		Object[] objs = c.toArray();
	//		for (Object oj : objs) {
	//			String s = (String) oj;
	//			if (s.equals("杨贵妃")) {
	//				c.remove("杨贵妃");
	//			}
	//		}
			
	//		for (Object oj : c) {
	//			String s = (String) oj;
	//			if (s.equals("杨贵妃")) {
	//				c.remove("杨贵妃");
	//			}
	//		}
			
	//		for (Iterator iterator = c.iterator(); iterator.hasNext();)
	//		{
	//			Object oj = iterator.next();
	//			String s = (String)oj;
	//			if (s.equals("杨贵妃"))
	//				c.remove("杨贵妃");
	//		}
			
	//		for(Iterator iterator = c.iterator();iterator.hasNext();) System.out.println(iterator.next());
				
		}

泛型

泛型的概念

在编译时期就确定的类型的一种技术 ，泛型是一种参数化类型

泛型是JDK1.5之后引入的新特性，是一种将引用类型当做参数传递的参数化类型，在编译时期就已经确定了集合存储的元素类型

格式:
<数据类型> 这里的类型必须是引用类型
1. <>里面可以是任意的字母,一般泛型类会使用E,泛型方法会使用T
2. 这里只能够定义引用类型,不能够定义基本书类型
3. <>里面既可以定义一个泛型,也可以定义多个泛型

泛型的好处

1.提高了程序的安全性
3.在编译时期将类型确定，减少不必要的强转代码

泛型的应用

泛型根据放置的位置不同分为
泛型类
泛型接口
泛型方法
没有用泛型的案例

for (Iterator it = c.iterator(); it.hasNext(); ) {
    Object oj = it.next();
    if (oj instanceof String) {
        // 访问子类每一个元素所特有的方法
        String s = (String) oj;
        System.out.println("字符串的长度" + s.length());
    } else if (oj instanceof Integer) {
        Integer i = (Integer) oj;
        System.out.println("整数的值: " + i.intValue());
    } else if (oj instanceof Double) {
        Double d = (Double) oj;
        System.out.println("小数的值: " + d.doubleValue());
    }
}

用了泛型的案例

Collection<String> c = new ArrayList<String>();
		c.add("张三");
		c.add("李四");
		c.add("王五");
//		c.add(20);
//		c.add(2.5);
//		c.add(new Student("1001", "张三", 30));
Iterator<String> it = c.iterator();
while (it.hasNext()) {
    String s = it.next();
    System.out.println(s + "|" + s.length());
}
泛型类
	public class Test10 {
		public static void main(String[] args) {
			GenericClassTest<String> gc = new GenericClassTest<String>();
			gc.setE("哈哈");
	//		gc.setE(10);//设置一个数字会报错
			
			String s = gc.getE();
			System.out.println(s + "|" + s.length());
		}
	}
	
	class GenericClassTest<E> {
		private E e;
	
		public E getE() {
			return e;
		}
	
		public void setE(E e) {
			this.e = e;
		}
	}
泛型接口

实现类确定泛型类型

   // 1.实现类确定泛型类型
   class GenericInterfaceImpl implements GenericInterface<String, Integer> {
   
   	@Override
   	public void test(String e) {
   		System.out.println(e);
   	}
   
   	@Override
   	public Integer add(Integer t) {
   		return t;
   	}
   	
   }
  1. 实现类不确定泛型,在调用的时候确定泛型
   // 实现类不确定泛型
   class GenericInterfaceImpl<E,T> implements GenericInterface<E, T> {
   
   	@Override
   	public void test(E e) {
   		System.out.println(e);
   	}
   
   	@Override
   	public T add(T t) {
   		return t;
   	}
   	
   }

   // 在调用的时候确定泛型
   GenericInterface<String, Double> gi = new GenericInterfaceImpl<String, Double>();
   System.out.println(gi.add(2.5));
   gi.test("hello");
  1. 匿名内部类确定泛型类型
      GenericInterface<String, Boolean> gi = new GenericInterface<String, Boolean>(){
      
          @Override
          public void test(String e) {
              System.out.println(e);
          }
      
          @Override
          public Boolean add(Boolean t) {
              return t;
          }
      
      };
泛型方法

概念： 把泛型定义在方法上,泛型方法又可以理解为局部泛型。

泛型方法的特点：

1. 泛型方法独立于泛型类或者泛型接口
2. 泛型方法在方法调用的时候确定类型
3. 一个泛型接口或者泛型类中可以有多个泛型方法
4. 一个泛型方法也可以定义多个泛型

public class GenericDemo04 {
	public static void main(String[] args) {
		GenericMethod<String, Integer> gm = new GenericMethod<String, Integer>();
        // 2.泛型方法在方法调用的时候确定类型
		gm.show(20.5);
		
		Character c = gm.test('c');
		System.out.println(c);
		
		gm.method(25, 2.5);
	}
}

class GenericMethod<E,H> {
	
	private E e;
	private H h;
	
	// 1.泛型方法独立于泛型类或者泛型接口
	public <T> void show(T t) {
		System.out.println(t);
	}
	// 3.一个泛型接口或者泛型类中可以有多个泛型方法
	public <K> K test(K K) {
		return K;
	}
	// 4.一个泛型方法也可以定义多个泛型
	public <V, U> void method(V v, U u) {
		System.out.println(v);
		System.out.println(u);
	}
	
	public E getE() {
		return e;
	}
	public void setE(E e) {
		this.e = e;
	}
	public H getH() {
		return h;
	}
	public void setH(H h) {
		this.h = h;
	}
	
}

泛型限定符

概念： 用来限定泛型的符号

泛型限定符的常用格式：
1.？: 表示泛型可以是任意类型
2.？ extends E：表示泛型可以是E或者E的子类
3. ? super E：表示泛型可以是E或者E的父类

	public class GenericDemo05 {
		public static void main(String[] args) {
	        // Object并不是代表任意类型
			Collection<Object> c1 = new ArrayList<Object>();
	        // ？: 表示泛型可以是任意类型
			Collection<?> c2 = new ArrayList<Object>();
			Collection<?> c3 = new ArrayList<Fu>();
			Collection<?> c4 = new ArrayList<Daughter>();
			
	        // ？ `extends` E：表示泛型可以是E或者E的子类 
			Collection<? extends Fu> c5 = new ArrayList<Fu>();
			Collection<? extends Fu> c6 = new ArrayList<Daughter>();
			Collection<? extends Fu> c7 = new ArrayList<Son>();
			// Collection<? extends Fu> c8 = new ArrayList<Object>(); 编译报错
			
	        //  ? `super` E ：表示泛型可以是E或者E的父类
			Collection<? super Fu> c9 = new ArrayList<Fu>();
			// Collection<? super Fu> c10 = new ArrayList<Daughter>(); 编译报错
			// Collection<? super Fu> c11 = new ArrayList<Son>(); 编译报错
			Collection<? super Fu> c12 = new ArrayList<Object>();
		
		}
	}

泛型嵌套

泛型嵌套：泛型中可以包含泛型

有以下常见几种情况：

  1. Collection嵌套Collection集合
  2. Collection嵌套Map集合
  3. Map嵌套Collection集合
  4. Map嵌套Map集合
public class GenericDemo06 {
	public static void main(String[] args) {
		// 存储: 由内到外添加到集合中
		Collection<Student> class01 = new ArrayList<>();
		class01.add(new Student("1001", "张三", 30));
		class01.add(new Student("1002", "李四", 31));
		class01.add(new Student("1003", "王五", 32));
		
		Collection<Student> class02 = new ArrayList<>();
		class02.add(new Student("1001", "张三", 30));
		class02.add(new Student("1002", "李四", 31));
		class02.add(new Student("1003", "王五", 32));
		
		Collection<Student> class03 = new ArrayList<>();
		class03.add(new Student("1001", "张三", 30));
		class03.add(new Student("1002", "李四", 31));
		class03.add(new Student("1003", "王五", 32));
		
		Collection<Collection<Student>> school = new ArrayList<Collection<Student>>();
		school.add(class01);
		school.add(class02);
		school.add(class03);
		
		// 遍历: 由外到内
		int index = 1;
		for (Collection<Student> classList : school) {
			System.out.println(index + "班");
			for (Student s : classList) {
				System.out.println("\t" + s);
			}
			index ++;
		}
	}
}
swop_
关注
专栏目录
java获得集合的泛型类型_Java集合之泛型类和泛型接口
weixin_32512261的博客
02-28 879
1. 为什么要有泛型1.1 不使用泛型的问题当不使用泛型时，集合中是可以存放任意类型对象的，只要把对象存储集合后，那么他们都会被提升为Object类型。当我们在取出每一个对象，并且进行相应的操作，需要进行类型转换。观察下面代码：public static void main(String[] args) {Collection coll = new ArrayList();coll.add("ab...
集合与泛型
01-12
### 集合与泛型知识点总结 #### 泛型概览 - **引入原因**：在Java 1.5及之后的版本中，引入了泛型这一特性，旨在提高集合类使用的安全性与灵活性。主要解决的问题包括： - **元素存储的安全性问题**：在非泛型...
Java基础程序——集合和泛型
weixin_45890771的博客
04-14 930
目录 一、集合(Collection) 1.1、概述 1.2、集合继承关系图 1.3、集合的方法 二、迭代器 2.1、迭代器概述 2.1、迭代器的实现原理 2.3、集合迭代中的转型 三、增强for循环 3.1、增强for循环遍历数组 3.2、增强for循环遍历集合 四、泛型 4.1、泛型的定义和使用 4.2、擦拭法 4.3、泛型类 4.4、泛型方法 4.5、泛型的接口 4.6、泛型的好处 4.7、泛型的通配符 4.8、泛型的定 一、集合(Collectio...
C#集合与泛型
falsedewuxin的博客
04-08 812
C#集合（ArrayList、List、SortedList、Hashtable、Dictionary、Stack、Queue、BitArray）与泛型类、泛型方法、泛型委托、约束泛型
Java集合-泛型
Philanderers的博客
12-25 1264
1、Array(数组）、ArrayList和LinkedList的区别 Array(数组）是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。Array获取数据的时间复杂度是O(1),但是要删除数据却是开销很大，因为这需要重排数组中的所有数据,(因为删除数据以后, 需要把后面所有的数据前移)。缺点:数组初始化必须指定初始化的长度, 否则报错。 例如: int[] a = new int[4];//推荐使用int[] 这种方式初始化 ​ int
获取集合的泛型类型
m0_61050393的博客
11-22 391
获取集合的泛型类型
集合【泛型】
qq_48336929的博客
08-10 679
泛型 泛型部分知识思维导图 1、泛型介绍 1.1、为什么会出现泛型？ 集合中是可以存放任意对象的，只要把对象丢尽集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。 但是由于集合中什么类型的元素都可以存储。导致取出时，如果出现强转就会引发运行时 ClassCastException。 而因为集合存放的数据类型不固定，故网集合里面存放元素时，存在安全隐患，如果定义集合时，可以像定义数组一样指定数据类型，那么就可以解决该类安全问题。 JDK1.5
集合和泛型
weixin_45761101的博客
02-15 1402
四、泛型和集合 泛型（可以把他看成一种数据类型） 写在< >里面的数据类型，他是用来约束集合可以储存的数据类型。< > 只能是引用类型，不能是简单数据类型。 泛型参数可以有多个。 常见的有泛型类、泛型方法、泛型接口 泛型类： class A{}这里T可以为任意值，在使用的时候可以对其指定。 泛型接口： interface Generator{T next();} 泛型方法： class c{ public void test(string s){ return s; } } 把普通方
java集合之泛型
Walker_sis的博客
03-08 3699
泛型概述 java泛型是JDK1.5中引入的一个新特性，本质是参数化类型，把类型作为参数传递。 常见的形式由泛型类，泛型方法，泛型接口 语法：<T…>T称为类型占位符，表示一种引用类型。 好处： 提高代码的重用性 防止类型转换异常，提高代码的安全性。 3)规范类型 泛型的分类 泛型类 package genericedemo; /** * 定义的泛型类 */ public class GenericeClass<E,T> { //属性 private E
Java攻略集合之泛型
qq_57767445的博客
11-08 615
比较器排序：创建TreeSet对象的时候传递Comparator的实现类对象，重写compare方法，根据返回值进行排序。没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取，删除Set集合里的元素。>：表示元素类型未知的ArrayList，它的元素可以匹配任何的类型。此处T可以随便写为任意标识，常见的如T，E，K，V等形式的参数常用于表示泛型。在使用的时候，默认使用自然排序，当自然排序不满足现在的需求时，使用比较器排序。2、如果返回值为0，表示当前存入的元素跟集合中元素重复类，不存。
java的集合和泛型
qq_47360019的博客
10-24 525
第十一章
集合+泛型.docx
05-14
集合和泛型在 Java 中的应用 集合（Collection）是 Java 中的一种数据结构，用于存储和操作数据的集合。泛型（Generic）是 Java 5 中引入的一种特性，用于限制集合中元素的类型。 集合 集合是 Java 中的一种数据...
Java集合、泛型和枚举
最新发布
06-14
集合、泛型和枚举都是Java开发中常见的概念，它们在处理数据和编写代码时起到关键作用。 首先，Java集合是用于存储一组对象的容器。在Java中，集合分为两大类：`Collection`和`Map`。`Collection`接口是所有单一值...
JDBC与mysql
swop_的博客
05-24 2394
JDBC JDBC是"Java Database Connective"的缩写,表示使用Java去连接数据库进行数据操作的过程 Mysql的JDBC 使用Java连接Mysql需要先创建动态的wed项目(Dynamic wed Project),然后在导入驱动连接包 数据库连接代码 public class TestMysql { //连接地址 private static String UR...
注解 ，单元测试
swop_的博客
05-09 712
文章目录注解注解的概述注解的分类按照运行的机制分类按照来源分类:Java中常见的注解常见的元注解@Retention@Target自定义注解并且使用四种使用注解的方式通过反射解析注解常用的通过反射获取注解元素的相关方法单元测试 注解 注解的概述 1.Java提供了一种源程序中元素和任何信息或者元数据相关联的一种方法或者渠道 2.源程序中元素: Java文件 构造方法、成员变量、成员方法… 3.信...
Java static关键字，super关键字，继承
swop_的博客
04-19 496
文章目录@[toc]static关键字static的特点:static方法静态修饰方法的意义代码块继承什么时候使用继承继承的格式继承的特点继承的好处继承的缺点继承的注意事项super关键字this和super的区别super的特点 static关键字 针对某一个变量属于类而不属于某一个具体的对象的时候,我们可以考虑使用static关键字。 static的特点: 1.static修饰变量又称为共享变...
mybatis参数的传递
swop_的博客
07-14 430
mybatis的参数传递 #{}he${} mybatis的参数传递有两种方式,分别是使用#{}和${}这两种方式之间存在一些差异#{}会解析为一个JDBC预编译语句（PreparedStatement）的参数标记符,简单来说就是一个占位符?而传入的参数将会经过的强制类型检查和安全检查等处理，最后作为一个合法的字符串传入.${}这种方式只会做简单的字符串替换，在动态SQL解析阶段将会进行变量替换....
多态 ，抽象类 ，接口 ，final关键字
swop_的博客
04-20 362
文章目录final关键字多态多态的概述多态访问成员的特点多态的优点多态的缺点抽象类抽象类的概述接口接口的概念:接口的特点接口的好处接口和抽象类的区别 final关键字 表示最终的,可以修饰类，成员变量，成员方法 1.final修饰变量成为常量 修饰局部变量: 可以暂时不赋初始值,但是只能够赋值一次 修饰成员变量: 必须给出初始值 2.final修饰的方法不能够被子类重写和继承。 JDK1....
Java集合与泛型解析：理解集合问题和泛型应用
"Java集合存在的问题-集合与泛型 ppt" 在Java编程中，集合框架扮演着至关重要的角色，它提供了一种高效且灵活的方式来存储和管理数据。然而，早期的Java集合（例如在Java SE 1.4及更早版本）存在一些问题，主要体现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值