泛型和集合

于 2021-03-20 23:27:45 发布
阅读量100 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/my_superman/article/details/115036999
版权

目录

1. 泛型

2. 集合

1. 泛型

// 定义泛型类
class Test<T> {
	private T ob;

	public Test(T ob) {
		this.ob = ob;
	}

	public T getOb() {
		return ob;
	}

	public void setOb(T ob) {
		this.ob = ob;
	}

	public void showType() {
		System.out.println("T的实际类型是：" + ob.getClass().getName());
	}
}

public class TestDemo {
	public static void main(String[] args) {
		Test<Integer> intOb = new Test<Integer>(88);
		intOb.showType();
		int i = intOb.getOb();
		System.out.println("value = " + i);
		System.out.println("---------------------------");
		Test<String> strOb = new Test<String>("Hello World");
		strOb.showType();
		String str = strOb.getOb();
		System.out.println("value = " + str);
	}
}
// 简单使用泛型方法
package com.company;

class Animal {
	public Animal() {
		System.out.println("我是动物");
	}
}

class Dog extends Animal {
	public Dog() {
		System.out.println("我是狗");
	}
}

public class Main {
	public <T, S extends T> T testDemo(T t, S s) {
		System.out.println("我是 T 类型，我的类型是" + t.getClass().getName());
		System.out.println("我是 S 类型，我的类型是" + s.getClass().getName());
		return t;
	}

	public static void main(String[] args) {
		Main test = new Main();
		Dog dog = new Dog();
		Animal animal = new Animal();
		Animal newAnimal = test.testDemo(animal, dog);
		System.out.println("我是对象 newAnimal，我的类型是" + animal.getClass().getName());
	}
}

// 通过通配符定义泛型方法
package com.company;

import java.util.ArrayList;
import java.util.List;

class Animal {
	public Animal() {
		System.out.println("我是动物");
	}
}

class Dog extends Animal {
	public Dog() {
		System.out.println("我是狗");
	}
}

public class Main {
	public void testDemo(List<?> list) {
		for (Object obj : list) {
			System.out.println("我的类型是" + obj.getClass().getName());
		}
	}

	public static void main(String[] args) {
		Main test = new Main();
		Dog dog = new Dog();
		Animal animal = new Animal();

		List<Animal> list = new ArrayList<Animal>();
		list.add(dog);
		list.add(animal);
		test.testDemo(list);
	}
}

2. 集合

// ArrayList 测试
package com.company;

import java.util.*;

class Student {
	public String id;
	public String name;
	public Student(String id, String name) {
		this.id = id;
		this.name = name;
	}

	public String toString() {
		return "Student{" + "id=" + id +'\'' +
				", name=" + name + '\'' + '}';
	}
}

public class Main {
	public List<Student> students;

	public Main() {
		this.students = new ArrayList<Student>();
	}

	public void testAdd() {
		Student st1 = new Student("1", "张三");
		students.add(st1);

		Student temp = students.get(0);
		System.out.println("添加了学生：" + temp.id + ":" + temp.name);

		Student st2 = new Student("2", "李四");
		students.add(0, st2);

		Student temp2 = students.get(0);
		System.out.println("添加了学生：" + temp2.id + ":" + temp2.name);

		Student[] student = {new Student("3", "王五"),
							new Student("4", "马六")};
		students.addAll(Arrays.asList(student));
		Student temp3 = students.get(2);
		Student temp4 = students.get(3);
		System.out.println("添加了学生：" + temp3.id + ":" + temp3.name);
		System.out.println("添加了学生：" + temp4.id + ":" + temp4.name);

		Student[] students2 = {new Student("5", "周七"),
								new Student("6", "赵八")};

		students.addAll(2, Arrays.asList(students2));

		Student temp5 = students.get(2);
		Student temp6 = students.get(3);
		System.out.println("添加了学生：" + temp5.id + ":" + temp5.name);
		System.out.println("添加了学生：" + temp6.id + ":" + temp6.name);
	}

	public void testGet() {
		int size = students.size();
		for (int i = 0; i < size; i++) {
			Student st = students.get(i);
			System.out.println("学生：" + st.id + ":" + st.name);
		}
	}

	public void testIterator() {
		Iterator<Student> iter = students.iterator();
		System.out.println("有如下学生（通过迭代器访问）：");
		while (iter.hasNext()) {
			Student st = iter.next();
			System.out.println("学生：" + st.id + ":" + st.name);
		}
	}

	public void testForEach() {
		System.out.println("有如下学生（通过foreach访问）：");
		for (Student obj : students) {
			Student st = obj;
			System.out.println("学生：" + st.id + ":" + st.name);
		}
		students.stream().sorted(Comparator.comparing(x -> x.id)).forEach(System.out::println);
	}

	public void testModify() {
		students.set(4, new Student("3", "吴酒"));
	}

	public void testRemove() {
		Student st = students.get(4);
		System.out.println("我是学生：" + st.id + ":" + st.name + "，我即将被删除");
		students.remove(st);
		System.out.println("成功删除学生");
		testForEach();
	}

	public static void main(String[] args) {
		Main test = new Main();
		test.testAdd();
		test.testGet();
		test.testIterator();
		test.testModify();
		test.testForEach();
		test.testRemove();
	}
}

// Map 测试
package com.company;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;

class Course {
	public String id;
	public String name;
	public Course(String id, String name) {
		this.id = id;
		this.name = name;
	}
}

public class Main {
	public Map<String, Course> courses;

	public Main() {
		this.courses = new HashMap<String, Course>();
	}

	public void testPut() {
		Scanner console = new Scanner(System.in);

		for (int i = 0; i < 3; i++) {
			System.out.println("请输入课程 ID:");
			String ID = console.next();

			Course course = courses.get(ID);
			if (course == null) {
				System.out.println("请输入课程名称: ");
				String name = console.next();
				Course newCourse = new Course(ID, name);
				courses.put(ID, newCourse);
				System.out.println("成功添加课程，" + courses.get(ID).name);
			}
			else {
				System.out.println("该课程 ID 已被占用");
			}
		}
	}

	public void testKeySet() {
		Set<String> keySet = courses.keySet();
		for (String courseID : keySet) {
			Course course = courses.get(courseID);
			if (course != null) {
				System.out.println("课程：" + course.name);
			}
		}
	}

	public void testRemove() {
		Scanner console = new Scanner(System.in);
		while (true) {
			System.out.println("请输入要删除的课程ID：");
			String ID = console.next();
			Course course = courses.get(ID);
			if (course == null) {
				System.out.println("该 ID 不存在！");
				continue;
			}
			courses.remove(ID);
			System.out.println("成功删除课程: " + course.name);
			break;
		}
	}

	public void testEntrySet() {
		Set<Entry<String, Course>> entrySet = courses.entrySet();
		for (Entry<String, Course> entry : entrySet) {
			System.out.println("取得键：" + entry.getKey());
			System.out.println("对应的值为：" + entry.getValue().name);
		}
	}

	public void testModify() {
		System.out.println("请输入要修改的课程ID：");
		Scanner console = new Scanner(System.in);
		while (true) {
			String ID = console.next();
			Course course = courses.get(ID);
			if (course == null) {
				System.out.println("该 ID 不存在！");
				continue;
			}
			System.out.println("当前该课程ID所对应的课程为：" + course.name);
			System.out.println("请输入新的课程名称：");
			String name = console.next();
			Course newCourse = new Course(ID, name);
			courses.put(ID, newCourse);
			System.out.println("修改成功！");
			break;
		}
	}

	public static void main(String[] args) {
		Main test = new Main();
		test.testPut();
		test.testKeySet();
		test.testRemove();
		test.testModify();
		test.testEntrySet();
	}
}

// Set 测试
package com.company;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
import java.util.List;
import java.util.Scanner;
import java.util.Arrays;

class Student {
	public String id;
	public String name;
	public Student(String id, String name) {
		this.id = id;
		this.name = name;
	}

	public String toString() {
		return "Student{" + "id=" + id + '\'' +
				", name=" + name + '\'' + '}';
	}
}

class PD {
	public String id;
	public String name;
	public Set<Student> students;
	public PD(String id, String name) {
		this.id = id;
		this.name = name;
		this.students = new HashSet<Student>();
	}
}

public class Main {
	public List<Student> students;

	public Main() {
		students = new ArrayList<Student>();
	}

	public void testAdd() {
		Student st1 = new Student("1", "张三");
		students.add(st1);

		Student st2 = new Student("2", "李四");
		students.add(st2);

		Student[] student = {new Student("3", "王五"),
							new Student("4", "马六")};
		students.addAll(Arrays.asList(student));

		Student[] student2 = {new Student("5", "周七"),
							new Student("6", "赵八")};
		students.addAll(Arrays.asList(student2));
	}

	public void testForEach() {
		System.out.println("有如下学生（通过foreach）：");
		for (Object obj : students) {
			Student st = (Student)obj;
			System.out.println(st.toString());
		}
	}

	public void testForEachForSet(PD pd) {
		for (Student s : pd.students) {
			System.out.println("选择了学生：" + s.id + ":" + s.name);
		}
	}

	public static void main(String[] args) {
		Main st = new Main();
		st.testAdd();
		st.testForEach();
		PD pd = new PD("1", "张老师");
		System.out.println("请" + pd.name + "选择小组成员！");

		Scanner console = new Scanner(System.in);

		for (int i = 0; i < 3; i++) {
			System.out.println("请输入学生 ID");
			String studentID = console.next();
			for (Student s : st.students) {
				if (s.id.equals(studentID)) {
					pd.students.add(s);
				}
			}
		}
		st.testForEachForSet(pd);
		console.close();
	}
}
// Collections 测试
package com.company;

import java.util.ArrayList;
import java.util.List;
import java.util.Collections;

public class Main {
	public static void printList(List<Integer> list, String str) {
		System.out.print(str + "：");
		list.forEach(v ->System.out.print(v + "\t"));
		System.out.println();
	}

	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();

		list.add(3);
		list.add(5);
		list.add(7);
		list.add(9);
		list.add(12);
		printList(list, "初始顺序");

		Collections.shuffle(list);
		printList(list, "打乱顺序");

		Collections.swap(list, 0, list.size() - 1);
		printList(list, "交换第一位和最后一位后");

		Collections.sort(list);
		printList(list, "Sort排序后");

		System.out.println("二分查找数值7的位置为：" + (1 + Collections.binarySearch(list, 7)));

		List<Integer> synchronizedList = Collections.synchronizedList(list);
	}
}

 

咸蛋超人1号
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java泛型和集合
04-22
Java Generics and Collections 英文版，详细描述java 泛型技术
集合和泛型
qq_58631644的博客
08-04 705
在向 HashSet 集合中增加元素时，会先计算此元素的 hashcode 值，如果 HashSet 集合中没有此 hashcode 值，那么此元素就可以插入。如果 hashcode 值与 HashSet 集合中的某个元素的 hashcode 值相同，HashSet 就会继续调用 euqals() 方法进一步判断它们的内容是否相同，如果相同就忽略这个新增的元素，如果不同才能把它增加到 HashSet 集合中。......
Redis-基础
NeilNiu
03-14 230
罪魁祸首——关系型数据库 性能瓶颈：磁盘IO性能低下（CPU数据交换是和高速缓存cache，cache的数据交换和谁做，和内存。内存的数据交换和谁做，和磁盘做，这些基础数据存在硬盘上，一层层往上传递。数据库是保存在磁盘上的） 扩展瓶颈：数据关系复杂，扩展性差，不便于大规模集群 解决思路 降低磁盘IO次数，越低越好 ------内存存储 这样就出现NoSQL 内存型数据库...
泛型和泛型集合
dcujcivw769565的博客
06-30 97
泛型：通过参数化类型来实现在同一份代码上操作多种数据类型。利用“参数化类型”将类型抽象化，从而实现灵活的复用。 using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.Web.UI; using System.Web.UI.WebC...
Java泛型和集合]-英文版
11-24
Java泛型和集合]-英文版
[Java泛型和集合].
10-02
[Java泛型和集合].(Java.Generics.and.Collections).Maurice.Naftalin&Philip.Wadler.文字版.pdf
泛型和集合案例.7z
08-08
结合https://blog.csdn.net/weixin_46168350/article/details/107755203学习
集合与泛型
shujuboke的博客
07-22 2652
集合与泛型 一、集合：就像是一种容器。用于存储、获取、操作对象的容器。 1. 数组的弊端 ①数组的长度不可变     ②数组没有提供可以查看有效元素个数的方法 2. 集合的特点 ①集合的长度是可变的 ②集合可以存储任意类型的对象 ③集合只能存储对象 3. 集合框架 java.util.Collection : 集合层次的根接口  
泛型与集合类型
见证大牛成长之路的专栏
02-06 782
泛型与集合类型   说起泛型时,就不得不说到泛型集合类型,因为使用反省能够极大的提高集合类型的性能和安全性.   为了看看使用泛型能为集合类型带来什么好处,先看看不用泛型时集合类型的表现.最典型的非泛型集合类型就是ArrayList了,这里便以它为例作为介绍,考虑一下下面的代码: ArrayList list = new ArrayList();
16 集合与泛型
Elon Zero的博客
08-02 315
目录 Collection.sort() 存储自定义对象 　泛型 泛型的类 泛型的方法 所以就知道哪里有问题了…Song类必须实现Comparable Comparator接口 处理重复 对象的等价 HashSet如何检查重复：hashCode()与equals() TreeSets与排序 现在来看Map 回到泛型 泛型的万用字符 目录 页码：529-58...
最全泛型和集合框架讲解（知识点+方法+示例）
weixin_42507474的博客
07-28 2233
一、认识集合 在开始之前我们先认识一下集合。 开发应用程序时，如果想存储多个类型的数据可以使用数组来实现；但是使用数组存在一些明显的缺陷 数组长度固定不变，不能很好的适应元素数量动态变化的情况 可以通过数组名.length来获取数组的长度，却无法直接获取数组中实际存储的元素个数 数组采用在内存中分配连续空间的存储方式存储，根据元素信息查找时效率比较低，需要多次比较 针对这些缺陷，java结合框架提供了一套性能优良、使用方便的接口和类，即在这里我们即将讲解的内容。 二、List接口 Collection接
泛型与集合
DeftTOT的博客
08-11 250
泛型与集合 泛型 本篇博客主要参考码出高效-Java开发手册 泛型的基本概念 泛型的定义和本质 泛型指的是可以将类型作为参数进行传递，其本质上就是类型参数化，泛型只会存在于编译期，在运行期会进行参数擦除。关于泛型的擦除，如果泛型没有设置类型上限，则泛型会转化为Object类型，如果设置上限则会转化为设置的上限。最后再进行类型的强转，转化为我们需要的类型。 除了基本类型之外，其他的都可以都可以作为泛型。泛型可以定义在类、接口、方法中，编译器通过尖括号和尖括号中的字母来解析泛型，有些字母是约定俗成的：
JAVA 泛型，集合使用方法
风吹草低见牛羊
06-28 4417
工作内容： 1.集合学习 2.泛型学习 学习分享： 1.典型泛型集合List，HashMap 常用定义泛型集合： List list = new ArrayList(); 【存储类型必须是T类型，可以用Object,来使用这样就可以存储所有类型对象，拿出来时需要强制转型】 Map map = new HashMap(); 【K是键值(Key)，V是值(Values)，可以通过ma
集合和泛型的关系
qq_42742861的博客
05-29 443
1 List 、 List 、 List<?>的区别 List：可以在集合中装入任何对象。但是在正常情况下，一般集合中只存放一种元素。 List: 可以将任意对象装入List集合中，简单的可以看成和第一种是一样的。 List<?>: 问号在正则表达式中可以匹配任何字符，List< ?>称为通配符集合。可以接受任何类型的集合引用赋值，不能 添加 任何元素，但...
JAVA复习笔记02
DCBA11223344的博客
06-11 126
16、interface中的成员变量默认为public static final类型，方法只能是public（默认为public） 17、内部类访问外部类成员： Outer.this.num; 18、一道有趣的题目 　　使用内部类实现该程序。（答案附在本文末尾） interface Inter { void show(); } clas...
泛型与集合500字
最新发布
05-29
泛型是Java中的一个非常重要的特性，它可以让我们在编写代码时更加灵活...总之，泛型和集合是Java中非常重要的特性，它们可以帮助我们更加灵活和安全地编写代码。我们需要在实践中不断学习和总结，提高自己的编程能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值