《集合与泛型》

最新推荐文章于 2023-07-13 16:45:45 发布

皓狗今天更新了么

最新推荐文章于 2023-07-13 16:45:45 发布

阅读量112

点赞数 1

分类专栏： Java高级

本文链接：https://blog.csdn.net/lhlh980312/article/details/103717172

版权

Java高级专栏收录该内容

6 篇文章 0 订阅

订阅专栏

day15

课程

part1.不带泛型的集合

List集合

使用Arraylist类来实现

List list=new ArrayList();

因为list类是接口，所以需要Arraylist类来实现接口，这里使用了多态的创建方式

list.add(1);
list.add("xiaoye");
list.add("yang");
list.add(true);
User user=new User("liushuai",16);
list.add(user)

使用add()方法，将数据传入到集合内，这里因为没有用到泛型，所以数据类型为object类,笔者另定义了一个User类与它的带参构造方法，即证明对象也能存入集合中

list.add(1,100);

此处add方法的作用是在下标为1的位置插入一个类型为integer的100的值

for(int i=0;i<list.size();i++){
  Object object=list.get(i);
  System.out.println(object);
 }

使用size()方法查看集合长度,get(i)方法是取出下标为i的元素,上面的代码是遍历集合的第一种方式（普通for循环）

for(Object obb:list){
  System.out.println(obb);
 }

笔者在上一篇文章中做过加强型for循环的演示，故不在多做解释（加强型for循环）

Iterator iterator=list.iterator();
while(iterator.hasNext()){
Object object=iterator.next();
system.out.println(object);
}

这种方法是利用迭代器遍历集合,也是本章难点，需熟练掌握其用法

int index=list.indexOf(true);

indexof()方法的作用是查找指定元素的下标

list.remove(2);
list.remove(user);

remove()方法的作用是删除以2为下标的元素，或者是直接删除user元素

使用LinkList来实现

如果使用LinkList类来实现List接口，那么它的集合内的元素一样是有序的，但是它的元素不能重复，如果重复，后面输入的元素会覆盖掉前面输入的元素

LinkedList link=new LinkedList();

这里因为处于学习阶段，需要调用LinkList独有的方法，所以直接定义LinkList类的对象，而不是使用多态继承

link.add("yang");
link.add("liu");
link.add(13);
link.add("ma");

同样的添加元素的方式

link.addFirst(16);
link.addLast(88);

使用LinkedList类独有的addFirst()与addLast()方法向集合最前面与最后面插入元素,类型依然为Object

link.remove(0);

删除下标为0的元素

link.removeFirst();
link.removeLast();

这两个方法的作用是删除最前面和最后面的元素

System.out.println(link);
[liu, 13, ma]

着重介绍这种输出方法，直接输出link集合,结果如上图第二行所显示，十分实用

Set集合

使用HashSet类实现

Set set=new HashSet();

这里只介绍多态的方法创建对象，其他方法和集合的遍历写法与List接口类似，不多做赘述
值得注意的不同点为：
Set集合
1.Set是一个接口，创建对象的时候常用HashSet
2.Set集合是无序的，没有下标
3.Set集合存储的值是唯一的

Map集合

使用HashMap类实现

Map map=new HashMap();

多态方式创建对象

map.put("yang1", new User("yang1",20));
map.put("yang2", new User("yang2",30));
map.put("yang3", new User("yang3",40));
map.put("yang4", new User("yang4",44));

Map集合与其他两种集合不同的点就在于它使用的是键值对结构，键必须唯一，值可以重复，put()方法是像集合内输入一个键值对

Object object=map.get("yang3");

这里get()方法的作用是取得键值为"yang3"的值

map.remove("yang2");

在这里remove()的方法是删除键值为"yang2"的键值对

Set set=map.keySet();
 //获取迭代器
 Iterator iterator=set.iterator();
 while(iterator.hasNext()){
  Object key=iterator.next();
  //根据键获取值
  Object object2=map.get(key);
  User user2=(User)object2;
  System.out.println(user2);
 }

Map集合中使用迭代器遍历的方式为重中之重,具体为先使用KeySet()方法取得map中所有的键，然后使用一个Object对象依次获取每一个键，最后用Map集合中的get()方法将键对应的值依次放入另一个Object对象中，最后依次输出

part2.使用泛型的集合

首先附上泛型需遵守的规则：
自定义泛型类:语法格式：修饰符 class 类名<T,E,M>

1.泛型类注入的实际是变量，或方法，或方法返回值的数据类型
2.泛型类定义完成以后，在创建对象的时候需要给泛型类型注入值,这个值表示的就是数据类型
3.如果没有给定泛型的类型则默认是Object
4.当一个类继承一个泛型类的时候，当前类必须是泛型类，而且必须带上父类的泛型参数

泛用型类

class FanXin<T>{
 public T name;
    //定义返回值是泛型的方法
 public T getName() {
  return name;
 }
    //定义形参是泛型的方法
 public void setName(T name) {
  this.name = name;
 }
}

class Fan<T,E> extends FanXin<T>{
 public E age;
}

这里介绍的是泛用型方法的继承
泛用型方法的调用基本与其他方法相同，与其不同的是泛用型方法可以指定数据类型

泛型List集合

List<String> list=new ArrayList<String>();

泛用型集合List创建对象的方式，用ArrayList类实现

list.add("ppx");
list.add("ppg");
list.add("ppm");

泛型集合添加元素的方法与非泛型集合类似，只是规定了元素的数据类型
泛型集合有关for的遍历方式基本与非泛型集合相同，故不多做示范

Iterator<String> iterator=list.iterator();
 while(iterator.hasNext()){
  String hkhk=iterator.next();
  System.out.println(hkhk);
 }

需要注意的是如果使用Iterator来遍历数组，Iterator类的后面也应加上数据类型

泛型Set集合

Set<User> set=new HashSet<User>();

这是泛型集合Set创建对象的方式，利用HashSet类对接口Set进行实例化

set.add(new User("yang1",20));
set.add(new User("yang2",50));
set.add(new User("yang3",70));
set.add(new User("yang4",205));
set.add(new User("yang6",2550));

泛型集合Set添加元素的方式也与非泛型集合类似，这里添加的元素是笔者从创建的User类中创建出的对象

Iterator<User> iterator=set.iterator();
 while(iterator.hasNext()){
 User user2=iterator.next();
 System.out.println(user2);
 }

Set集合以Iterator方式遍历数组，需注意的东西也是Iterator类型元素类型的限定

泛型Map集合

Map<String, User> map=new HashMap<String, User>();

泛型Map集合比较特殊，因为是键值对的特殊集合，所以设定数据类型的时候需要输入两个限制条件

map.put("liu1", new User("lu4",11));
map.put("liu2", new User("lu5",116));
map.put("liu3", new User("lu3",16));
map.put("liu5", new User("lu1",18));
map.put("liu6", new User("lu6",186));

Map集合对象调用方法的时候也与其他两个集合不同，是使用put()方法进行元素的插入,先插入键，再插入值

Set<String> set=map.keySet();
 Iterator<String> iterator=set.iterator();
 while(iterator.hasNext()){
  String qqString=iterator.next();
  System.out.println(qqString+"\t");
  System.out.println(map.get(qqString));
 }

Map集合的Iterator遍历方式依旧是难点，建议多练增加熟练度

练习

1

public static void main(String[] args) {
List<Maker> list=new ArrayList<Maker>();
list.add(new Maker("1","汽车","lh"));
list.add(new Maker("2","高考","ls"));
System.out.println(list.size());
for(Maker maker:list){
  System.out.println(maker);
 }
}

这题考察的是将自己创建的对象填入List集合中

public static void main(String[] args) {
 List<String> list=new ArrayList<String>();
 list.add("欧欧");
 list.add("亚亚");
 list.add("菲菲");
 list.add("美美");
 List<String> list2=new ArrayList<String>();
 list2.add("雪纳瑞");
 list2.add("拉布拉多");
 list2.add("拉布拉多");
 list2.add("雪纳瑞");
 System.out.println("总计有四条狗狗");
 System.out.println("分别是");
 Iterator<String> iterator=list.iterator();
 Iterator<String> iterator2=list2.iterator();
 while(iterator.hasNext()){
  String qqString=iterator.next();
  String kkString=iterator2.next();
  System.out.print(qqString+"\t");
  System.out.println(kkString);
  
 }
 }

总计有四条狗狗
分别是
欧欧 雪纳瑞
亚亚 拉布拉多
菲菲 拉布拉多
美美 雪纳瑞

这题实现的结果如下，具体是使用了两个list集合，分别调出

public static void main(String[] args) {
 Set<Maker> set=new HashSet<Maker>();
 set.add(new Maker("欧欧", "雪纳瑞", null));
 set.add(new Maker("亚亚", "拉布拉多", null));
 set.add(new Maker("菲菲", "拉布拉多", null));
 set.add(new Maker("美美", "雪纳瑞", null));
 System.out.println("共计有"+set.size()+"条狗狗。");
 System.out.println("分别是");
 Iterator<Maker> iterator=set.iterator();
 while(iterator.hasNext()){
  Maker maker=iterator.next();
  System.out.print(maker.id+"\t");
  System.out.println(maker.name);
 }
}