Java之集合初探(二)Iterator(迭代器),collections,打包/解包(装箱拆箱),泛型(Generic),comparable接口

Iterator(迭代器)

所有实现了Collection接口的容器都有一个iterator方法, 用来返回一个实现了Iterator接口的对象 Iterator对象称作迭代器, 用来方便的实现对容器内的元素的遍历

迭代器是一种设计模式,它是一个对象,它可以遍历并选择序列中的对象,而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象,因为创建它的代价小。

  Java中的Iterator功能比较简单,并且只能单向移动:

  (1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时,它返回序列的第一个元素。注意:iterator()方法是java.lang.Iterable接口,被Collection继承。

  (2) 使用next()获得序列中的下一个元素。

  (3) 使用hasNext()检查序列中是否还有元素,如果迭代具有更多的元素,则返回true 。换句话说,如果next()返回一个元素而不是抛出一个异常,则返回true

  (4) 使用remove()将迭代器新返回的元素删除。

  Iterator是Java迭代器最简单的实现,为List设计的ListIterator具有更多的功能,它可以从两个方向遍历List,也可以从List中插入和删除元素。

for循环与迭代器比较  例子  :

 1 package collectionTest;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collection;
 5 import java.util.HashMap;
 6 import java.util.Iterator;
 7 import java.util.List;
 8 import java.util.Map;
 9 import java.util.Set;
10 
11 public class test {
12     public static void main(String[] args) {
13         List list=new ArrayList();
14         list.add("aaa");
15         list.add("ccc");
16         list.add("vvv");
17         list.add("bbb");
18         list.add("nnn");
19         for (int i = 0; i < list.size(); i++) {
20             System.out.println(list.get(i));
21         }
22         //foreach循环遍历,没有下标,需要的话可以自己定义
23         for(Object s:list){
24             System.out.println(s);
25         }
26         Iterator iter=list.iterator();
27         while(iter.hasNext()){//判断有没有下一个
28             System.out.println(iter.next());
29         }
30         Map map=new HashMap();
31         map.put("aa", 1);
32         map.put("bb", 2);
33         map.put("cc", 3);
34         map.put("dd", 4);
35         
36         Set set=map.keySet();//返回Set集合,存放map的键的值
37         for(Object o:set){
38             System.out.println(o);//输出对象的键
39             System.out.println(map.get(o));//输出对象的值,无序
40         }
41         Iterator iter2=set.iterator();
42         while(iter2.hasNext()){//遍历
43             System.out.println(map.get(iter2.next()));
44         }
45         Collection c=map.values();//返回Collection
46         Iterator iter3=c.iterator();
47         while(iter3.hasNext()){
48             System.out.println(iter3.next());
49         }
50     }
51 }

collections

是一个包装类。它包含有各种有关集合操作的静态多态方法。直接调用,简单实用。此类不能实例化,就像一个工具类,服务于Java的Collection框架。

  • 此类仅由静态方法组合或返回集合。 它包含对集合进行操作的多态算法,“包装器”,返回由指定集合支持的新集合,以及其他一些可能的和最终的。 如果提供给它们的集合或类对象为null,则此类的方法都抛出一个NullPointerException 。 该类中包含的多态算法的文档通常包括实现的简要说明 。 这些描述应被视为实施说明 ,而不是说明书的一部分 。 只要规范本身得到遵守,实现者就可以随意替代其他算法。 (例如,sort使用的算法不一定是一个mergeesort,但它必须是稳定的 。)
 1 package collectionTest;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collections;
 5 import java.util.List;
 6 
 7 public class test1 {
 8     public static void main(String[] args) {
 9         List list=new ArrayList();
10         list.add("aaa");
11         list.add("ccc");
12         list.add("vvv");
13         list.add("bbb");
14         list.add("nnn");
15         Collections.sort(list);//排序,如果是字母按照字母表排序
16         System.out.println(list);
17         Collections.shuffle(list);//随机乱序
18         System.out.println(list);
19         Collections.reverse(list);//逆序
20         System.out.println(list);
21         List list2=new ArrayList();
22         //Collections.copy(list2, list);//复制集合,前提是size相同
23         Collections.fill(list, new Person());
24         System.out.println(list);
25         Collections.binarySearch(list, 2);//二分搜索法,使用要先排序
26         
27     }
28 }
29 class Person{
30     
31 }

自动打包/解包(装箱拆箱)

这里的装箱应该理解为 封装对象 ,即把基础数据类型(如 int)转换成基础类型封装类的对象(如 new Integer()) 拆箱就是装箱的反过程,即把基础类型封装类的对象(如 new Integer())转换为基础数据类型(如 int)。

    Integer a = new Integer() ;//装箱
    a = 100 ;  
    int b = new Integer(100) ;  //拆箱

自动装箱拆箱

//自动装箱拆箱

执行上面那句代码的时候,系统执行了:Integer i = new Integer(100);

这就是基本数据类型的自动装箱功能。

泛型(Generic)(1.5之后才有泛型)

泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。

1, 装入集合的类型都被当作Object对待, 从而失去了自己的实际类型 2, 集合中取出来的时候需要转型, 效率低, 易出错 好处: 增强程序的可读性和稳定性

 1 package collectionTest;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 public class Test3 {
 7 
 8     public static void main(String[] args) {
 9         // TODO Auto-generated method stub
10         List<String> list=new ArrayList<String>();
11         List<Person2> list2=new ArrayList<Person2>();
12         
13         list2.add(new Student());//父类的引用指向子类的对象
14     }
15 
16 }
17 class Person2{
18     
19 }
20 class Student extends Person2{
21     
22 }

注意:泛型里不能写基础数据类型,因为 基础数据类型不能为 null,引用类型可以

comparable接口

  • 该接口对实现它的每个类的对象强加一个整体排序。 这个排序被称为类的自然排序 ,类的compareTo方法被称为其自然比较方法Collections.sort (和Arrays.sort )可以自动对实现此接口的对象进行列表(和数组)排序。 实现该接口的对象,可以使用如在键sorted map或作为在元件sorted set ,而不需要指定一个comparator 。 一类C的自然顺序被说成是与equals一致当且仅当e1.compareTo(e2) == 0对每一个e1和C类e2相同的布尔值e1.equals(e2)。 请注意, null不是任何类的实例, e.compareTo(null)应该抛出一个NullPointerException即使e.equals(null)返回false 。 强烈建议(尽管不需要)自然排序与等于一致。 这是因为,当没有显式比较器的排序集(和排序映射)与其自然排序与equals不一致的元素(或键)一起使用时会“奇怪地”。 特别地,这种排序集合(或排序映射)违反了根据equals方法定义的集合(或映射)的一般合同。

只有一个方法

compareTo(To)

将此对象与指定的对象进行比较以进行排序。 

 1 package com.hanqi;
 2 
 3 public class Student implements Comparable<Student>{//实现接口时也要泛型
 4     
 5     private String name;
 6     private Integer age;
 7     
 8     public Student() {
 9         super();
10     }
11     
12     public Student(String name, Integer age) {
13         super();
14         this.name = name;
15         this.age = age;
16     }
17     
18     public String getName() {
19         return name;
20     }
21     public void setName(String name) {
22         this.name = name;
23     }
24     
25     public Integer getAge() {
26         return age;
27     }
28     public void setAge(Integer age) {
29         this.age = age;
30     }
31 
32     @Override
33     public String toString() {
34         return "Student ["+ name + ","+age+"]";
35     }
36 
37     @Override
38     //通过年龄来比较,从大到小排列
39     public int compareTo(Student o) {
40         // TODO Auto-generated method stub
41         if(this.age<o.age){
42             return 1;
43         }else if(this.age>o.age){
44             return -1;
45         }else{
46             return this.age.compareTo(o.age);
47         }
48     }
49     
50     
51 }

总结:

集合是数组的一种延伸, 与数组相比有很多好处和优点, 1, 可以存放不同的类型 2, 长度可变 3, 随时存放和获取 六个接口和一个类: List Map Set Iterator Collection Comparable

Collections类

选择一种集合类型是一件非常痛苦的事 在以后的编程中要考虑读取和修改的效率问题, 数据的存取在以后的使用过程中, Collection是主要的载体, Array: 读快改慢 Linked: 读慢改快 Hash: 介于两者之间的

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏北京马哥教育

一篇搞定Python正则表达式

1. 正则表达式语法 1.1 字符与字符类     1 特殊字符:.^$?+*{}[]()|       以上特殊字符要想使用字面值,必须使用进行转义    ...

3436
来自专栏机器学习从入门到成神

C/C++学习之路(一)

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/sinat_35512245/articl...

3572
来自专栏和蔼的张星的图像处理专栏

c++ primer2 变量和基本类型。

这四种初始化方式c++11都是支持的。c++11中用花括号来初始化变量得到了全面应用。

1191
来自专栏WindCoder

Java漫谈-数组

在Java语言中,数组是对象(An object is a class instance or an array.),而且是动态创建的。

1771
来自专栏黑泽君的专栏

java基础学习_基础语法(下)01_day05总结

============================================================================= ==...

971
来自专栏小詹同学

程序员面试必备之排序算法汇总(下)

希望小小詹同学学习同时能便于他人~ ---- 本文用Python实现了快速排序、插入排序、希尔排序、归并排序、堆排序、选择排序、冒泡排序共7种排序算法。上篇已...

34810
来自专栏aCloudDeveloper

const特性总结(不断更新)

作者:bakari  时间:2012.6.5 1、指向const对象的指针---const int *cptr; i、在此,cptr是指向int类型的const...

1988
来自专栏机器学习实践二三事

Python基础----数据变量和变量

整数 Python可以处理任意大小的整数,当然包括负整数,在程序中的表示方法和数学上的写法一模一样,例如:1,100,-8080,0,等等。 计算机由于使用...

2025
来自专栏微信公众号:Java团长

Java泛型详解——绝对是对泛型方法讲解最详细的,没有之一!

ArrayList可以存放任意类型,例子中添加了一个String类型,添加了一个Integer类型,再使用时都以String的方式使用,因此程序崩溃了。为了解决...

1051
来自专栏塔奇克马敲代码

第 14 章 重载运算与类型转换

2486

扫码关注云+社区

领取腾讯云代金券