java泛型与迭代器的关系

简介: java泛型与迭代器的关系

泛型

  本质上是类型参数化,解决了不确定对象的类型问题。泛型的使用,参考下面代码:

ArrayList<String> arrayList = new ArrayList();
arrayList.add("Java");

泛型的优点

  • 安全:不用担心程序运行过程中出现类型转换的错误。
  • 避免了类型转换:如果是非泛型,获取到的元素是 Object 类型的,需要强制类型转换。
  • 可读性高:编码阶段就明确的知道集合中元素的类型。

迭代器(Iterator)

1.为什么要用迭代器?

在迭代器(Iterator)没有出现之前,如果要遍历数组和集合,需要使用方法。

数组遍历,代码如下:

String[] arr = new String[]{"Java", "Java虚拟机", "Java面试题网"};
for (int i = 0; i < arr.length; i++) {
    String item = arr[i];
}

集合遍历,代码如下:

List<String> list = new ArrayList<String>() {{
    add("Java");
    add("Java虚拟机");
    add("Java面试题网");
}};
for (int i = 0; i < list.size(); i++) {
    String item = list.get(i);
}

而迭代器的产生,就是为不同类型的容器遍历,提供标准统一的方法。

迭代器遍历,代码如下:

Iterator iterator = list.iterator();
while (iterator.hasNext()) {
    Object object = iterator.next();
    // do something
}

总结:使用了迭代器就可以不用关注容器的内部细节,用同样的方式遍历不同类型的容器。

2.迭代器介绍

迭代器是用来遍历容器内所有元素对象的,也是一种常见的设计模式。包含以下四个方法。

  • hasNext():boolean —— 容器内是否还有可以访问的元素。
  • next():E —— 返回下一个元素。
  • remove():void —— 删除当前元素。
  • forEachRemaining(Consumer<? super E>):void —— JDK 8 中添加的,提供一个 lambda 表达式遍历容器元素。

3.迭代器使用

List<String> list = new ArrayList<String>() {{
    add("Java");
    add("Java虚拟机");
    add("Java面试题网");
}};
Iterator iterator =  list.iterator();
// 遍历
while (iterator.hasNext()){
    String str = (String) iterator.next();
    if (str.equals("Java面试题网")){
        iterator.remove();
    }
}
System.out.println(list);

程序执行结果:

[Java, Java虚拟机]

forEachRemaining 使用如下:

List<String> list = new ArrayList<String>() {{
    add("Java");
    add("Java虚拟机");
    add("Java面试题网");
}};
// forEachRemaining 使用
list.iterator().forEachRemaining(item -> System.out.println(item));

笔试面试题

1.为什么迭代器的 next() 返回的是 Object 类型?

答:因为迭代器不需要关注容器的内部细节,所以 next() 返回 Object 类型就可以接收任何类型的对象。

2.HashMap 的遍历方式都有几种?

答:HashMap 的遍历分为以下四种方式。

  • 方式一:entrySet 遍历
  • 方式二:iterator 遍历
  • 方式三:遍历所有的 key 和 value
  • 方式四:通过 key 值遍历

以上方式的代码实现如下:

Map<String, String> hashMap = new HashMap();
hashMap.put("name", "大冰");
hashMap.put("sex", "男");
// 方式一:entrySet 遍历
for (Map.Entry item : hashMap.entrySet()) {
  System.out.println(item.getKey() + ":" + item.getValue());
}
// 方式二:iterator 遍历  ,参考http://www.wityx.com/post/547_1_1.html
Iterator<Map.Entry<String, String>> iterator = hashMap.entrySet().iterator();
while (iterator.hasNext()) {
  Map.Entry<String, String> entry = iterator.next();
  System.out.println(entry.getKey() + ":" + entry.getValue());
}
// 方式三:遍历所有的 key 和 value
for (Object k : hashMap.keySet()) {
  // 循环所有的 key
  System.out.println(k);
}
for (Object v : hashMap.values()) {
  // 循环所有的值
  System.out.println(v);
}
// 方式四:通过 key 值遍历
for (Object k : hashMap.keySet()) {
  System.out.println(k + ":" + hashMap.get(k));
}

3.以下关于泛型说法错误的是?

A:泛型可以修饰类

B:泛型可以修饰方法

C:泛型不可以修饰接口

D:以上说法全错

答:选 C,泛型可以修饰类、方法、接口、变量。

例如:

public interface Iterable<T> {
}

4.以下程序执行的结果是什么?

List<String> list = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();
System.out.println(list.getClass() == list2.getClass());

答:程序的执行结果是 true。

题目解析:Java 中泛型在编译时会进行类型擦除,因此 List<String> listList<Integer> list2 类型擦除后的结果都是 java.util.ArrayList ,进而 list.getClass() == list2.getClass() 的结果也一定是 true

5. List 和 List<?> 有什么区别?

答:List<?> 可以容纳任意类型,只不过 List<?> 被赋值之后,就不允许添加和修改操作了;而 List<Object> 在赋值之后,可以进行添加和修改操作.

参考http://www.wityx.com/post/547_1_1.html

6.可以把 List 赋值给 List 吗?

答:不可以,编译器会报错.

7. List 和 List 的区别是什么?

答: ListList<Object> 都能存储任意类型的数据,唯一区别是,List 不会触发编译器的类型安全检查,比如把 List<String> 赋值给 List 是没有任何问题的,但赋值给 List<Object> 就不行,

8.以下程序执行的结果是?

List<String> list = new ArrayList<>();
list.add("Java");
list.add("Java虚拟机");
list.add("Java面试题网");
//http://www.wityx.com/post/539_1_1.html
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
    String str = (String) iterator.next();
    if (str.equals("Java面试题网")) {
        iterator.remove();
    }
}
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}
System.out.println("Over");

答:程序打印结果是 Over。

题目解析:因为第一个 while 循环之后,iterator.hasNext() 返回值就为 false 了,所以不会进入第二个循环,之后打印最后的 Over。

9.泛型的工作原理是什么?为什么要有类型擦除?

答:泛型是通过类型擦除来实现的,类型擦除指的是编译器在编译时,会擦除了所有类型相关的信息,比如 List 在编译后就会变成 List 类型,这样做的目的就是确保能和 Java 5 之前的版本(二进制类库)进行兼容。

相关文章
|
1月前
|
Java 编译器 API
如何在 Java 中避免使用迭代器
在Java中,为了避免使用迭代器,可以采用foreach循环来遍历集合或数组,简化代码,提高可读性。此外,Java 8引入的Stream API提供了更强大的功能,如filter、map等方法,能够以函数式编程风格处理数据,进一步减少对传统迭代器的依赖。
39 6
|
4月前
|
安全 Java 编译器
揭秘JAVA深渊:那些让你头大的最晦涩知识点,从泛型迷思到并发陷阱,你敢挑战吗?
【8月更文挑战第22天】Java中的难点常隐藏在其高级特性中,如泛型与类型擦除、并发编程中的内存可见性及指令重排,以及反射与动态代理等。这些特性虽强大却也晦涩,要求开发者深入理解JVM运作机制及计算机底层细节。例如,泛型在编译时检查类型以增强安全性,但在运行时因类型擦除而丢失类型信息,可能导致类型安全问题。并发编程中,内存可见性和指令重排对同步机制提出更高要求,不当处理会导致数据不一致。反射与动态代理虽提供运行时行为定制能力,但也增加了复杂度和性能开销。掌握这些知识需深厚的技术底蕴和实践经验。
92 2
|
4月前
|
存储 Java
Java学习笔记 List集合的定义、集合的遍历、迭代器的使用
Java学习笔记 List集合的定义、集合的遍历、迭代器的使用
|
2月前
|
Java API
[Java]泛型
本文详细介绍了Java泛型的相关概念和使用方法,包括类型判断、继承泛型类或实现泛型接口、泛型通配符、泛型方法、泛型上下边界、静态方法中使用泛型等内容。作者通过多个示例和测试代码,深入浅出地解释了泛型的原理和应用场景,帮助读者更好地理解和掌握Java泛型的使用技巧。文章还探讨了一些常见的疑惑和误区,如泛型擦除和基本数据类型数组的使用限制。最后,作者强调了泛型在实际开发中的重要性和应用价值。
35 0
[Java]泛型
|
2月前
|
存储 安全 Java
🌱Java零基础 - 泛型详解
【10月更文挑战第7天】本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!
18 1
|
2月前
|
设计模式 安全 Java
Java Iterator(迭代器)详解
在Java中,`Iterator`是一种设计模式,用于遍历如`List`、`Set`等集合,提供统一访问元素的方式而不暴露内部结构。它包括`hasNext()`、`next()`和`remove()`方法,通过集合的`iterator()`方法获取实例,可用于安全删除元素,避免`ConcurrentModificationException`。
40 14
|
3月前
|
Java 编译器 容器
Java——包装类和泛型
包装类是Java中一种特殊类,用于将基本数据类型(如 `int`、`double`、`char` 等)封装成对象。这样做可以利用对象的特性和方法。Java 提供了八种基本数据类型的包装类:`Integer` (`int`)、`Double` (`double`)、`Byte` (`byte`)、`Short` (`short`)、`Long` (`long`)、`Float` (`float`)、`Character` (`char`) 和 `Boolean` (`boolean`)。包装类可以通过 `valueOf()` 方法或自动装箱/拆箱机制创建。
44 9
Java——包装类和泛型
|
2月前
|
Java 语音技术 容器
java数据结构泛型
java数据结构泛型
27 5
|
2月前
|
存储 Java 编译器
Java集合定义其泛型
Java集合定义其泛型
19 1
|
2月前
|
存储 Java 编译器
【用Java学习数据结构系列】初识泛型
【用Java学习数据结构系列】初识泛型
22 2