Java的泛型---（英雄联盟集合嵌套案例）

1

2

3

4

5

6

===========================

使用增强for遍历集合：

hello

world

java

bigdata

hadoop

从运行结果来看我们想要的输出效果实现了，但是如果进行遍历的集合为空呢？

所以我们在遍历之前需要判断一下是不是为null 。

参考代码2：

import java.util.ArrayList;

//将来能用增强for的时候，就用，可以消除黄色警告线

public class ForDemo1 {

public static void main(String[] args) {

//定义一个数组

int[] arr = {1,2,3,4,5,6};

//普通for循环

System.out.println(“使用普通for循环:”);

for (int i = 0;i < arr.length;i++){

System.out.println(arr[i]);

}

System.out.println(“===========================”);

//增强for循环

System.out.println(“使用增强for循环遍历：”);

for (int x : arr) {

System.out.println(x);

}

System.out.println(“===========================”);

//创建集合对象

ArrayList strings = new ArrayList<>();

//向集合中添加元素

strings.add(“hello”);

strings.add(“world”);

strings.add(“java”);

strings.add(“bigdata”);

strings.add(“hadoop”);

System.out.println(“使用增强for遍历集合：”);

//判断集合元素是否为null

if (strings!=null){

for (String s : strings) {

System.out.println(s);

}

}

}

}

输出结果：

使用普通for循环:

1

2

3

4

5

6

===========================

使用增强for循环遍历：

1

2

3

4

5

6

===========================

使用增强for遍历集合：

hello

world

java

bigdata

hadoop

增强for循环其实就是用来替代迭代器的，怎么去验证呢？

使用并发修改异常验证：

ConcurrentModificationException并发异常。

泛型类的测试

参考代码：

创建GenericTooll类：

/*

泛型类: 把泛型定义在类上

格式:public class 类名<泛型类型1,…>

注意:泛型类型必须是引用类型

这里的<>里面的内容仅仅表示的是一种参数数据类型，参数类型是一种变量，

既然是一种变量，就符合变量的命名规则，可以是任意符合标识符起名规则的名字。

*/

public class GenericTooll {

private T obj;

public T getObj() {

return obj;

}

public void setObj(T obj) {

this.obj = obj;

}

}

创建GenericTest1测试类：

不加泛型，默认是Object类型

必须要跟泛型类类型一致

/*

泛型类的测试

*/

public class GenericTest1 {

public static void main(String[] args) {

GenericTooll gt1 = new GenericTooll<>();

gt1.setObj(“java”);

String obj = gt1.getObj();

System.out.println(obj);

}

}

泛型方法的测试

参考代码：

创建GenericTool2类：

/*

泛型方法

把泛型定义在方法上

格式:public <泛型类型> 返回类型 方法名(泛型类型 .)

*/

public class GenericTool2 {

public void show(T t){

System.out.println(t);

}

}

创建GenericTest2测试类：

public class GenericTest2 {

public static void main(String[] args) {

//创建对象

GenericTool2 gt = new GenericTool2();

gt.show(“hadoop”);

gt.show(“23”);

gt.show(true);

}

}

输出结果：

hadoop

23

true

泛型接口的测试

创建GenericTool3接口：

public interface GenericTool3 {

public abstract void show(T t);

}

创建GenericTool3Impl接口类：

public class GenericTool3Impl implements GenericTool3{

@Override

public void show(T t) {

System.out.println(t);

}

}

创建GenericTest3测试类：

public class GenericTest3 {

public static void main(String[] args) {

GenericTool3Impl sgt1 = new GenericTool3Impl<>();

sgt1.show(“hadoop”);

}

}

输出结果：

hadoop

集合的嵌套遍历

在我们学泛型之前是创建方法来调用：

public class ArgsDemo {

public static void main(String[] args) {

//求两个数之和

int a = 10;

int b = 20;

// System.out.println(a+b);

sum(a, b);

//求三个数之和

int c = 30;

sum(a, b, c);

//求四个数之和

int d = 40;

sum(a, b, c, d);

}

public static void sum(int a, int b) {

System.out.println(a + b);

}

public static void sum(int a, int b, int c) {

System.out.println(a + b + c);

}

public static void sum(int a, int b, int c, int d) {

System.out.println(a + b + c + d);

}

}

输出结果：

30

60

100

假如说如果让我们做求和的数不确定呢？这个时候你怎么办呢？

根据我们的案例发现，方法名一样，参数列表中的数据类型一样，只是个数不一样，这时候，每增加一个参数，方法就要新写一个，非常麻烦，那怎么办呢？

java替我们考虑到了这一点，提供了一个技术给我们：可变参数

概述：定义方法的时候，参数不确定的时候使用

格式：修饰符 返回值的类型 方法名（数据类型…变量名）{}

注意：这里的变量其实是一个数组，如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

Arrays工具类中的一个方法

public static List List asList(T… a)

用Arrays工具类中的方法来进行代码的改进

使用可变参数的形式定义加法的方法：

参考代码：

public class ArgsDemo {

public static void main(String[] args) {

//求两个数之和

int a = 10;

int b = 20;

// System.out.println(a+b);

sum(a, b);

//求三个数之和

int c = 30;

sum(a, b, c);

//求四个数之和

int d = 40;

sum(a, b, c, d);

sum(312,123,1,312,13,13,13,13,13,1,34,5,4,3,131,3);

}

//使用可变参数的形式定义加法的方法

public static void sum(int… ints){

int sum = 0;

// System.out.println(ints);

for(int i=0;i<ints.length;i++){

sum = sum + ints[i];

}

System.out.println(sum);

}

}

输出结果：

30

60

100

994

当方法定义的时候既有固定值，也有可变参数的数的时候，将可变参数的定义放在最后一个。

import java.util.Arrays;

import java.util.List;

public class ArgsDemo {

public static void main(String[] args) {

List strings = Arrays.asList(“hello”, “world”, “java”, “bigdata”);

for (String s : strings) {

System.out.println(s);

}

sum(“靓仔”,1998,10,21,2048);

}

public static void sum(String s,int… ints){

System.out.println(s);

int sum = 0;

for (int i = 0;i < ints.length;i++){

sum = sum + ints[i];

}

System.out.println(sum);

}

}

输出结果：

hello

world

java

bigdata

靓仔

4077

案例一

需求：获取10个1-20之间的随机数，要求不能重复

数组可以实现吗？由于长度不好确定，我们选择集合 。

需要导Random包

参考代码：

import java.util.ArrayList;

import java.util.Random;

public class RandomTest {

public static void main(String[] args) {

//创建随机数对象

Random random = new Random();

//创建集合对象存储随机数

ArrayList arr = new ArrayList<>();

//定义一个变量统计集合中是否有10个元素

int count = 0;

while (count < 10){

//产生随机数

int i = random.nextInt(20) + 1;

//判断集合中是否有该随机数

if (!arr.contains(i)){

//向集合中添加随机数

arr.add(i);

count++;

}

}

System.out.println(arr);

}

}

输出结果：

[10, 7, 14, 5, 18, 11, 19, 8, 20, 2]

[11, 5, 7, 16, 4, 1, 19, 9, 17, 10]

[13, 15, 3, 18, 4, 20, 5, 14, 6, 1]

案例二

需求：键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值。

参考代码：

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Iterator;

import java.util.Scanner;

/*

键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值

*/

public class ArrayListTest {

public static void main(String[] args) {

//创建键盘录入对象

Scanner sc = new Scanner(System.in);

//创建集合存储键盘输入的数据

ArrayList arr = new ArrayList<>();

while (true){

int num = sc.nextInt();

if (num==0){

break;

}else {

arr.add(num);

}

}

//Array工具类中有一个方法sort()

//集合转数组

Object[] objects = arr.toArray();

Arrays.sort(objects);

//第一个是最小值

Integer minNumber = (Integer) objects[0];

//最后一个是最大值

Integer maxNumber = (Integer)objects[objects.length - 1];

System.out.println(“最小值为：” + minNumber);

System.out.println(“最大值为：” + maxNumber);

}

}

输出结果：

23

343

13

3252

612

631

6143

642

16

7

1

675

0

最小值为：1

最大值为：6143

集合嵌套案例（英雄联盟案例）

需求：召唤师峡谷有红色方和蓝色方，红色方有很多英雄，蓝色方有很多英雄，每一位英雄都是一个召唤师对象，可以用一个集合表示召唤师峡谷有10位英雄。

红色方和蓝色方的召唤师都可以用集合表示：

红色方的英雄：ArrayList redList

蓝色方的英雄：ArrayListblueList

无论是红色方还是蓝色方，都是召唤师峡谷里的英雄

召唤师峡谷的召唤师也可以用集合表示：ArrayList<ArrayList> LOL

这样的现象叫做集合的嵌套。

参考代码：

创建Hero对象：

import java.util.Objects;

public class Hero {

private String name;//召唤师姓名

private String heroname;//英雄名

//定义无参的构造方法

public Hero() {

}

//定义有参的构造方法

public Hero(String name, String heroname) {

this.name = name;

this.heroname = heroname;

}

//定义getXxx()和setXxx()方法

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getHeroname() {

return heroname;

}

public void setHeroname(String heroname) {

this.heroname = heroname;

}

//重写toString方法

@Override

public String toString() {

return “Hero{” +

“name='” + name + ‘\’’ +

“, heroname='” + heroname + ‘\’’ +

‘}’;

}

//重写equals方法

@Override

public boolean equals(Object o) {

if (this == o) return true;

if (o == null || getClass() != o.getClass()) return false;

Hero hero = (Hero) o;

return Objects.equals(name, hero.name) &&

Objects.equals(heroname, hero.heroname);

}

}

创建LOLHero测试类：

import java.util.ArrayList;

import java.util.Iterator;

public class LOLHero {

public static void main(String[] args) {

//定义红色方召唤师的集合

ArrayList redList = new ArrayList<>();

//定义蓝色方召唤师的集合

ArrayList blueList = new ArrayList<>();

//定义召唤师峡谷集合

ArrayList<ArrayList> LOL = new ArrayList<>();

//将红色方和蓝色方英雄放到召唤师峡谷中

LOL.add(redList);

LOL.add(blueList);

//创建红色方英雄对象

Hero h1 = new Hero(“TheShay”, “暗裔剑魔”);

Hero h2 = new Hero(“麻辣香锅”, “永恒梦魇”);

Hero h3 = new Hero(“大魔王”, “影流之主”);

Hero h4 = new Hero(“UZI”, “暗夜猎手”);

Hero h5 = new Hero(“刘青松”, “蒸汽机器人”);

//将红色方英雄放入召唤师峡谷中

redList.add(h1);

redList.add(h2);

redList.add(h3);

redList.add(h4);

redList.add(h5);

//创建蓝色方英雄对象

Hero h6 = new Hero(“圣枪哥”, “圣枪游侠”);

Hero h7 = new Hero(“大司马”, “虚空掠夺者”);

Hero h8 = new Hero(“硬币哥”, “离群之刺”);

Hero h9 = new Hero(“德莱文”, “文森特”);

Hero h10 = new Hero(“青蛙”, “魂锁典狱长”);

//将蓝色方英雄放入召唤师峡谷中

blueList.add(h6);

blueList.add(h7);

blueList.add(h8);

blueList.add(h9);

blueList.add(h10);

//迭代器遍历

Iterator<ArrayList> LOLhero = LOL.iterator();

while (LOLhero.hasNext()){

ArrayList heros = LOLhero.next();

Iterator LOLheros = heros.iterator();

while (LOLheros.hasNext()){

Hero heros1 = LOLheros.next();

System.out.println(heros1);

}

}

}

}

输出结果：

Hero{name=‘TheShay’, heroname=‘暗裔剑魔’}

Hero{name=‘麻辣香锅’, heroname=‘永恒梦魇’}

Hero{name=‘大魔王’, heroname=‘影流之主’}

Hero{name=‘UZI’, heroname=‘暗夜猎手’}
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总目录展示

该笔记共八个节点（由浅入深），分为三大模块。

高性能。 秒杀涉及大量的并发读和并发写，因此支持高并发访问这点非常关键。该笔记将从设计数据的动静分离方案、热点的发现与隔离、请求的削峰与分层过滤、服务端的极致优化这4个方面重点介绍。

一致性。 秒杀中商品减库存的实现方式同样关键。可想而知，有限数量的商品在同一时刻被很多倍的请求同时来减库存，减库存又分为“拍下减库存”“付款减库存”以及预扣等几种，在大并发更新的过程中都要保证数据的准确性，其难度可想而知。因此，将用一个节点来专门讲解如何设计秒杀减库存方案。

高可用。 虽然介绍了很多极致的优化思路，但现实中总难免出现一些我们考虑不到的情况，所以要保证系统的高可用和正确性，还要设计一个PlanB来兜底，以便在最坏情况发生时仍然能够从容应对。笔记的最后，将带你思考可以从哪些环节来设计兜底方案。

---

篇幅有限，无法一个模块一个模块详细的展示（这些要点都收集在了这份《高并发秒杀顶级教程》里），麻烦各位转发一下（可以帮助更多的人看到哟！）

由于内容太多，这里只截取部分的内容。
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
中…(img-o3tUiBnP-1713449660956)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总目录展示

该笔记共八个节点（由浅入深），分为三大模块。

高性能。 秒杀涉及大量的并发读和并发写，因此支持高并发访问这点非常关键。该笔记将从设计数据的动静分离方案、热点的发现与隔离、请求的削峰与分层过滤、服务端的极致优化这4个方面重点介绍。

一致性。 秒杀中商品减库存的实现方式同样关键。可想而知，有限数量的商品在同一时刻被很多倍的请求同时来减库存，减库存又分为“拍下减库存”“付款减库存”以及预扣等几种，在大并发更新的过程中都要保证数据的准确性，其难度可想而知。因此，将用一个节点来专门讲解如何设计秒杀减库存方案。

高可用。 虽然介绍了很多极致的优化思路，但现实中总难免出现一些我们考虑不到的情况，所以要保证系统的高可用和正确性，还要设计一个PlanB来兜底，以便在最坏情况发生时仍然能够从容应对。笔记的最后，将带你思考可以从哪些环节来设计兜底方案。

---

篇幅有限，无法一个模块一个模块详细的展示（这些要点都收集在了这份《高并发秒杀顶级教程》里），麻烦各位转发一下（可以帮助更多的人看到哟！）

[外链图片转存中…(img-0VLBdTbd-1713449660958)]

[外链图片转存中…(img-ggFhyrhN-1713449660959)]

由于内容太多，这里只截取部分的内容。
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！