一步一步学JAVA(14)-集合框架

最新推荐文章于 2021-07-12 08:58:32 发布

千丈冰

最新推荐文章于 2021-07-12 08:58:32 发布

阅读量210

点赞数

分类专栏： java笔记文章标签：集合 Iterator List Set Map

本文链接：https://blog.csdn.net/abcjwg/article/details/89404081

版权

java笔记专栏收录该内容

19 篇文章 1 订阅

订阅专栏

集合框架：用于存储数据的容器。
特点：
1：对象封装数据，对象多了也需要存储。集合用于存储对象。
2：对象的个数确定可以使用数组，但是不确定怎么办？可以用集合。因为集合是可变长度的。
集合和数组的区别：
1：数组是固定长度的；集合可变长度的。
2：数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。
3：数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。
数据结构：就是容器中存储数据的方式。
对于集合容器，有很多种。因为每一个容器的自身特点不同，其实原理在于每个容器的内部数据结构不同。
集合容器在不断向上抽取过程中。出现了集合体系。
在使用一个体系时，原则：参阅顶层内容。建立底层对象。

--< java.util >-- Collection 接口：

Collection：
|--List：有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引。元素可以重复。
|--Set：无序(存入和取出顺序有可能不一致)，不可以存储重复元素。必须保证元素唯一性。
1，添加：
add(object)：添加一个元素
addAll(Collection) ：添加一个集合中的所有元素。
2，删除：
clear()：将集合中的元素全删除，清空集合。
remove(obj) ：删除集合中指定的对象。注意：删除成功，集合的长度会改变。
removeAll(collection) ：删除部分元素。部分元素和传入Collection 一致。
3，判断：
boolean contains(obj) ：集合中是否包含指定元素。
boolean containsAll(Collection) ：集合中是否包含指定的多个元素。
boolean isEmpty()：集合中是否有元素。
4，获取：
int size()：集合中有几个元素。
5，取交集：
boolean retainAll(Collection) ：对当前集合中保留和指定集合中的相同的元素。如果两个集合元素相同，返回flase；如果retainAll 修改了当前集合，返回true。
6，获取集合中所有元素：
Iterator iterator()：迭代器
7，将集合变成数组：
toArray();

--< java.util >-- Iterator 接口：
迭代器：是一个接口。作用：用于取集合中的元素。
boolean hasNext() 如果仍有元素可以迭代，则返回 true。
E next() 返回迭代的下一个元素。
void remove() 从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。
每一个集合都有自己的数据结构，都有特定的取出自己内部元素的方式。为了便于操作所有的容器，取出元素。将容器内部的取出方式按照一个统一的规则向外提供，这个规则就是Iterator 接口。
也就说，只要通过该接口就可以取出Collection 集合中的元素，至于每一个具体的容器依据自己的数据结构，如何实现的具体取出细节，这个不用关心，这样就降低了取出元素和具体集合的耦合性。
Iterator it = coll.iterator();//获取容器中的迭代器对象，至于这个对象是是什么不重要。这对象肯定符合一个规则Iterator 接口。

public static void main(String[] args) {
    Collection coll = new ArrayList();
    coll.add("abc0");
    coll.add("abc1");
    coll.add("abc2");
    //--------------方式1----------------------
    Iterator it = coll.iterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }
    //--------------方式2----------------------
    for(Iterator it = coll.iterator();it.hasNext(); ){
        System.out.println(it.next());
    }
}

--< java.util >-- List 接口：
List 本身是Collection 接口的子接口，具备了Collection 的所有方法。现在学习List 体系特有的共性方法，查阅方法发现List 的特有方法都有索引，这是该集合最大的特点。
List：有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引。元素可以重复。
|--ArrayList：底层的数据结构是数组,线程不同步，ArrayList 替代了Vector，查询元素的速度非常快。
|--LinkedList：底层的数据结构是链表，线程不同步，增删元素的速度非常快。
|--Vector：底层的数据结构就是数组，线程同步的，Vector 无论查询和增删都巨慢。
1，添加：
add(index,element) ：在指定的索引位插入元素。
addAll(index,collection) ：在指定的索引位插入一堆元素。
2，删除：
remove(index) ：删除指定索引位的元素。返回被删的元素。
3，获取：
Object get(index) ：通过索引获取指定元素。
int indexOf(obj) ：获取指定元素第一次出现的索引位，如果该元素不存在返回-1；
所以，通过-1，可以判断一个元素是否存在。
int lastIndexOf(Object o) ：反向索引指定元素的位置。
List subList(start,end) ：获取子列表。
4，修改：
Object set(index,element) ：对指定索引位进行元素的修改。

5，获取所有元素：
ListIterator listIterator()：list 集合特有的迭代器。
List 集合支持对元素的增、删、改、查。
List 集合因为角标有了自己的获取元素的方式：遍历。

for(int x=0; x<list.size(); x++){
    sop("get:"+list.get(x));
}

在进行list 列表元素迭代的时候，如果想要在迭代过程中，想要对元素进行操作的时候，比如满足条件添加新元素。会发生.ConcurrentModificationException 并发修改异常。
导致的原因是：
集合引用和迭代器引用在同时操作元素，通过集合获取到对应的迭代器后，在迭代中，进行集合引用的元素添加，迭代器并不知道，所以会出现异常情况。
如何解决呢？
既然是在迭代中对元素进行操作,找迭代器的方法最为合适.可是Iterator 中只有hasNext,next,remove 方法.通过查阅的它的子接口,ListIterator,发现该列表迭代器接口具备了对元素的增、删、改、查的动作。
ListIterator 是List 集合特有的迭代器。
ListIterator it = list.listIterator;//取代Iterator it = list.iterator;
方法摘要
void add(E e) 将指定的元素插入列表（可选操作）。
boolean hasNext() 以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。
boolean hasPrevious() 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
E next() 返回列表中的下一个元素。
int nextIndex() 返回对 next 的后续调用所返回元素的索引。
E previous() 返回列表中的前一个元素。
int previousIndex() 返回对 previous 的后续调用所返回元素的索引。
void remove() 从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。
void set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。
可变长度数组的原理：
当元素超出数组长度，会产生一个新数组，将原数组的数据复制到新数组中，再将新的元素添加到新数组中。
ArrayList：是按照原数组的50%延长。构造一个初始容量为 10 的空列表。
Vector：是按照原数组的100%延长。

注意：对于list 集合，底层判断元素是否相同，其实用的是元素自身的equals 方法完成的。所以建议元素都要复写equals 方法，建立元素对象自己的比较相同的条件依据。
LinkedList：的特有方法。
addFirst();
addLast();
在jdk1.6 以后。
offerFirst();
offerLast();
getFirst():获取链表中的第一个元素。如果链表为空，抛出NoSuchElementException;
getLast();
在jdk1.6 以后。
peekFirst();获取链表中的第一个元素。如果链表为空，返回null。
peekLast();
removeFirst()：获取链表中的第一个元素，但是会删除链表中的第一个元素。如果链表为空，抛出NoSuchElementException
removeLast();
在jdk1.6 以后。
pollFirst();获取链表中的第一个元素，但是会删除链表中的第一个元素。如果链表为空，返回null。
pollLast();

--< java.util >-- Set 接口：
Set 接口中的方法和Collection 中方法一致的。Set 接口取出方式只有一种，迭代器。
|--HashSet：底层数据结构是哈希表，线程是不同步的。无序，高效；
HashSet 集合保证元素唯一性：通过元素的hashCode 方法，和equals 方法完成的。
当元素的hashCode 值相同时，才继续判断元素的equals 是否为true。
如果为true，那么视为相同元素，不存。如果为false，那么存储。
如果hashCode 值不同，那么不判断equals，从而提高对象比较的速度。
|--LinkedHashSet：有序，hashset 的子类。
|--TreeSet：对Set 集合中的元素的进行指定顺序的排序。不同步。TreeSet 底层的数据结构就是二叉树。
哈希表的原理：
1，对对象元素中的关键字(对象中的特有数据)，进行哈希算法的运算，并得出一个具体的算法值，这个值称为哈希值。
2，哈希值就是这个元素的位置。
3，如果哈希值出现冲突，再次判断这个关键字对应的对象是否相同。如果对象相同，就不存储，因为元素重复。如果对象不同，就存储，在原来对象的哈希值基础 +1 顺延。
4，存储哈希值的结构，我们称为哈希表。
5，既然哈希表是根据哈希值存储的，为了提高效率，最好保证对象的关键字是唯一的。
这样可以尽量少的判断关键字对应的对象是否相同，提高了哈希表的操作效率。
对于ArrayList 集合，判断元素是否存在，或者删元素底层依据都是equals 方法。
对于HashSet 集合，判断元素是否存在，或者删除元素，底层依据的是hashCode 方法和equals 方法。
TreeSet:
用于对Set 集合进行元素的指定顺序排序，排序需要依据元素自身具备的比较性。
如果元素不具备比较性，在运行时会发生ClassCastException 异常。
所以需要元素实现Comparable 接口，强制让元素具备比较性，复写compareTo 方法。
依据compareTo 方法的返回值，确定元素在TreeSet 数据结构中的位置。
TreeSet 方法保证元素唯一性的方式：就是参考比较方法的结果是否为0，如果return 0，视为两个对象重复，不存。
注意：在进行比较时，如果判断元素不唯一，比如，同姓名，同年龄，才视为同一个人。
在判断时，需要分主要条件和次要条件，当主要条件相同时，再判断次要条件，按照次要条件排序。
TreeSet 集合排序有两种方式，Comparable 和Comparator 区别：
1：让元素自身具备比较性，需要元素对象实现Comparable 接口，覆盖compareTo 方法。
2：让集合自身具备比较性，需要定义一个实现了Comparator 接口的比较器，并覆盖compare 方法，并将该类对象作为实际参数传递给TreeSet 集合的构造函数。
第二种方式较为灵活。
------------------------------------------------------------
Map 集合：
|--Hashtable：底层是哈希表数据结构，是线程同步的。不可以存储null 键，null 值。
|--HashMap：底层是哈希表数据结构，是线程不同步的。可以存储null 键，null 值。替代了Hashtable.
|--TreeMap：底层是二叉树结构，可以对map 集合中的键进行指定顺序的排序。
Map 集合存储和Collection 有着很大不同：
Collection 一次存一个元素；Map 一次存一对元素。
Collection 是单列集合；Map 是双列集合。
Map 中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。
特点：要保证map 集合中键的唯一性。
1，添加。
put(key,value)：当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null。
void putAll(Map);
2，删除。
void clear()：清空
value remove(key) ：删除指定键。
3，判断。
boolean isEmpty()：
boolean containsKey(key)：是否包含key
boolean containsValue(value) ：是否包含value
4，取出。
int size()：返回长度
value get(key) ：通过指定键获取对应的值。如果返回null，可以判断该键不存在。当然有特殊情况，就是在hashmap 集合中，是可以存储null 键null 值的。
Collection values()：获取map 集合中的所有的值。
5，想要获取map 中的所有元素：
原理：map 中是没有迭代器的，collection 具备迭代器，只要将map 集合转成Set 集合，可以使用迭代器了。
之所以转成set，是因为map 集合具备着键的唯一性，其实set 集合就来自于map，set 集合底层其实用的就是map 的方法。
★ 把map 集合转成set 的方法：
Set keySet();
Set entrySet();//取的是键和值的映射关系。
Entry 就是Map 接口中的内部接口；
为什么要定义在map 内部呢？entry 是访问键值关系的入口，是map 的入口，访问的是map 中的键值对。

取出map 集合中所有元素的方式一：keySet()方法。
可以将map 集合中的键都取出存放到set 集合中。对set 集合进行迭代。迭代完成，再通过get 方法对获取到的键进行值的获取。

Set keySet = map.keySet();
Iterator it = keySet.iterator();
while(it.hasNext()) {
    Object key = it.next();
    Object value = map.get(key);
    System.out.println(key+":"+value);
}

取出map 集合中所有元素的方式二：entrySet()方法。

Set entrySet = map.entrySet();
Iterator it = entrySet.iterator();
while(it.hasNext()) {
    Map.Entry me = (Map.Entry)it.next();
    System.out.println(me.getKey()+"::::"+me.getValue());
}

使用集合的技巧：
看到Array 就是数组结构，有角标，查询速度很快。
看到link 就是链表结构：增删速度快，而且有特有方法。addFirst； addLast； removeFirst()； removeLast()；getFirst()；getLast()；
看到hash 就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖hashCode，equals 方法。
看到tree 就是二叉树，就要想到排序，就想要用到比较。
比较的两种方式：
一个是Comparable：覆盖compareTo 方法；
一个是Comparator：覆盖compare 方法。
LinkedHashSet，LinkedHashMap:这两个集合可以保证哈希表有存入顺序和取出顺序一致，保证哈希表有序。
集合什么时候用？
当存储的是一个元素时，就用Collection。当存储对象之间存在着映射关系时，就使用Map 集合。
保证唯一，就用Set。不保证唯一，就用List。

Collections：它的出现给集合操作提供了更多的功能。这个类不需要创建对象，内部提供的都是静态方法。
静态方法：
Collections.sort(list);//list 集合进行元素的自然顺序排序。
Collections.sort(list,new ComparatorByLen());//按指定的比较器方法排序。

class ComparatorByLen implements Comparator<String>{
    public int compare(String s1,String s2){
        int temp = s1.length()-s2.length();
        return temp==0?s1.compareTo(s2):temp;
    }
}

Collections.max(list); //返回list 中字典顺序最大的元素。
int index = Collections.binarySearch(list,"zz");//二分查找，返回角标。
Collections.reverseOrder();//逆向反转排序。
Collections.shuffle(list);//随机对list 中的元素进行位置的置换。
将非同步集合转成同步集合的方法：Collections 中的 XXX synchronizedXXX(XXX);
List synchronizedList(list);
Map synchronizedMap(map);
原理：定义一个类，将集合所有的方法加同一把锁后返回。
Collection 和 Collections 的区别：
Collections 是个java.util 下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。
Collection 是个java.util 下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set 和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。

Arrays：
用于操作数组对象的工具类，里面都是静态方法。
asList 方法：将数组转换成list 集合。
String[] arr = {"abc","kk","qq"};
List<String> list = Arrays.asList(arr);//将arr 数组转成list 集合。
将数组转换成集合，有什么好处呢？用aslist 方法，将数组变成集合；
可以通过list 集合中的方法来操作数组中的元素：isEmpty()、contains、indexOf、set；
注意（局限性）：数组是固定长度，不可以使用集合对象增加或者删除等，会改变数组长度的功能方法。比如add、remove、clear。（会报不支持操作异常UnsupportedOperationException）；
如果数组中存储的引用数据类型，直接作为集合的元素可以直接用集合方法操作。
如果数组中存储的是基本数据类型，asList 会将数组实体作为集合元素存在。
集合变数组：用的是Collection 接口中的方法：toArray();
如果给toArray 传递的指定类型的数据长度小于了集合的size，那么toArray 方法，会自定再创建一个该类型的数据，长度为集合的size。
如果传递的指定的类型的数组的长度大于了集合的size，那么toArray 方法，就不会创建新数组，直接使用该数组即可，并将集合中的元素存储到数组中，其他为存储元素的位置默认值null。
所以，在传递指定类型数组时，最好的方式就是指定的长度和size 相等的数组。
将集合变成数组后有什么好处？限定了对集合中的元素进行增删操作，只要获取这些元素即可。

增强for 循环：foreach 语句，foreach 简化了迭代器。
格式：// 增强for 循环括号里写两个参数，第一个是声明一个变量，第二个就是需要迭代的容器
for( 元素类型变量名 : Collection 集合 & 数组 ) {
…

}
高级for 循环和传统for 循环的区别：
高级for 循环在使用时，必须要明确被遍历的目标。这个目标，可以是Collection 集合或者数组，如果遍历Collection 集合，在遍历过程中还需要对元素进行操作，比如删除，需要使用迭代器。
如果遍历数组，还需要对数组元素进行操作，建议用传统for 循环因为可以定义角标通过角标操作元素。如果只为遍历获取，可以简化成高级for 循环，它的出现为了简化书写。
高级for 循环可以遍历map 集合吗？不可以。但是可以将map 转成set 后再使用foreach 语句。
1)、作用：对存储对象的容器进行迭代：数组 collection map
2)、增强for 循环迭代数组：

String [] arr = {"a", "b", "c"};//数组的静态定义方式，只试用于数组首次定义的时候
for(String s : arr) {
    System.out.println(s);
}

3)、单列集合 Collection：

List list = new ArrayList();
list.add("aaa");
// 增强for 循环, 没有使用泛型的集合能不能使用增强for 循环迭代？能
for(Object obj : list) {
    String s = (String) obj;
    System.out.println(s);
}

4)、双列集合 Map：

Map map = new HashMap();
map.put("a", "aaa");
// 传统方式：必须掌握这种方式
Set entrys = map.entrySet(); // 1.获得所有的键值对Entry 对象
iter = entrys.iterator(); // 2.迭代出所有的entry
while(iter.hasNext()) {
    Map.Entry entry = (Entry) iter.next();
    String key = (String) entry.getKey(); // 分别获得key 和value
    String value = (String) entry.getValue();
    System.out.println(key + "=" + value);
}
// 增强for 循环迭代：原则上map 集合是无法使用增强for 循环来迭代的，因为增强for 循环只能针对实现了Iterable 接口的集合进行迭代；Iterable 是jdk5 中新定义的接口，就一个方法iterator 方法，只有实现了Iterable 接口的类，才能保证一定有iterator 方法，java 有这样的限定是因为增强for 循环内部还是用迭代器实现的，而实际上，我们可以通过某种方式来使用增强for 循环。
for(Object obj : map.entrySet()) {
    Map.Entry entry = (Entry) obj; // obj 依次表示Entry
    System.out.println(entry.getKey() + "=" + entry.getValue());
}

5）、集合迭代注意问题：在迭代集合的过程中，不能对集合进行增删操作（会报并发访问异常）；可以用迭代器的方法进行操作（子类listIterator：有增删的方法）。
6)、增强for 循环注意问题：在使用增强for 循环时，不能对元素进行赋值；

int[] arr = {1,2,3};
for(int num : arr) {
    num = 0; //不能改变数组的值
}
System.out.println(arr[1]); //2

可变参数（...）：用到函数的参数上，当要操作的同一个类型元素个数不确定的时候，可是用这个方式，这个参数可以接受任意个数的同一类型的数据。
和以前接收数组不一样的是：
以前定义数组类型，需要先创建一个数组对象，再将这个数组对象作为参数传递给函数。现在，直接将数组中的元素作为参数传递即可。底层其实是将这些元素进行数组的封装，而这个封装动作，是在底层完成的，被隐藏了。所以简化了用户的书写，少了调用者定义数组的动作。
如果在参数列表中使用了可变参数，可变参数必须定义在参数列表结尾(也就是必须是最后一个参数，否则编译会失败。)。
如果要获取多个int 数的和呢？可以使用将多个int 数封装到数组中，直接对数组求和即可。
---------------------------------------------------
静态导入：导入了类中的所有静态成员，简化静态成员的书写。
import static java.util.Collections.*; //导入了Collections 类中的所有静态成员
---------------------------------------------------
枚举：关键字 enum
问题：对象的某个属性的值不能是任意的，必须为固定的一组取值其中的某一个；
解决办法：
1）、在setGrade 方法中做判断，不符合格式要求就抛出异常；
2）、直接限定用户的选择，通过自定义类模拟枚举的方式来限定用户的输入，写一个Grade 类，私有构造函数，对外提供5 个静态的常量表示类的实例；
3)、jdk5 中新定义了枚举类型，专门用于解决此类问题；
4)、枚举就是一个特殊的java 类，可以定义属性、方法、构造函数、实现接口、继承类；
------------------------------------------------------------------------------
自动拆装箱：java 中数据类型分为两种：基本数据类型引用数据类型(对象)在 java 程序中所有的数据都需要当做对象来处理，针对8 种基本数据类型提供了包装类，如下：

int --> Integer
byte --> Byte
short --> Short
long --> Long
char --> Character
double --> Double
float --> Float
boolean --> Boolean

jdk5 以前基本数据类型和包装类之间需要互转：
基本---引用 Integer x = new Integer(x);
引用---基本 int num = x.intValue();
1)、Integer x = 1; x = x + 1; 经历了什么过程？装箱 拆箱 装箱；
2)、为了优化，虚拟机为包装类提供了缓冲池，Integer 池的大小 -128~127 一个字节的大小；
3)、String 池：Java 为了优化字符串操作提供了一个缓冲池；
----------------------------------------------------------
泛型：jdk1.5 版本以后出现的一个安全机制。表现格式：< >
好处：
1：将运行时期的问题ClassCastException 问题转换成了编译失败，体现在编译时期，程序员就可以解决问题。
2：避免了强制转换的麻烦。
只要带有<>的类或者接口，都属于带有类型参数的类或者接口，在使用这些类或者接口时，必须给<>中传递一个具体的引用数据类型。
泛型技术：其实应用在编译时期，是给编译器使用的技术，到了运行时期，泛型就不存在了。
为什么? 因为泛型的擦除：也就是说，编辑器检查了泛型的类型正确后，在生成的类文件中是没有泛型的。
在运行时，如何知道获取的元素类型而不用强转呢？
泛型的补偿：因为存储的时候，类型已经确定了是同一个类型的元素，所以在运行时，只要获取到该元素的类型，在内部进行一次转换即可，所以使用者不用再做转换动作了。
什么时候用泛型类呢？
当类中的操作的引用数据类型不确定的时候，以前用的Object 来进行扩展的，现在可以用泛型来表示。这样可以避免强转的麻烦，而且将运行问题转移到的编译时期。

泛型在程序定义上的体现：

//泛型类：将泛型定义在类上。
class Tool<Q> {
    private Q obj;
    public void setObject(Q obj) {
        this.obj = obj;
    }
    public Q getObject() {
        return obj;
    }
}

//当方法操作的引用数据类型不确定的时候，可以将泛型定义在方法上。

public <W> void method(W w) {
    System.out.println("method:"+w);
}

//静态方法上的泛型：静态方法无法访问类上定义的泛型。如果静态方法操作的引用数据类型不确定的时候，
必须要将泛型定义在方法上。

public static <Q> void function(Q t) {
    System.out.println("function:"+t);
}

//泛型接口.

interface Inter<T> {
    void show(T t);
}
class InterImpl<R> implements Inter<R> {
    public void show(R r) {
        System.out.println("show:"+r);
    }
}

泛型中的通配符：可以解决当具体类型不确定的时候，这个通配符就是 ? ；当操作类型时，不需要使用类型的具体功能时，只使用Object 类中的功能。那么可以用 ? 通配符来表未知类型。
泛型限定：
上限：？extends E：可以接收E 类型或者E 的子类型对象。
下限：？super E：可以接收E 类型或者E 的父类型对象。
上限什么时候用：往集合中添加元素时，既可以添加E 类型对象，又可以添加E 的子类型对象。为什么？因为取的时候，E 类型既可以接收E 类对象，又可以接收E 的子类型对象。
下限什么时候用：当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。
泛型的细节：
1）、泛型到底代表什么类型取决于调用者传入的类型，如果没传，默认是Object 类型；
2）、使用带泛型的类创建对象时，等式两边指定的泛型必须一致；
原因：编译器检查对象调用方法时只看变量，然而程序运行期间调用方法时就要考虑对象具体类型了；
3）、等式两边可以在任意一边使用泛型，在另一边不使用(考虑向后兼容)；

ArrayList<String> al = new ArrayList<Object>(); //错
//要保证左右两边的泛型具体类型一致就可以了，这样不容易出错。
ArrayList<? extends Object> al = new ArrayList<String>();
al.add("aa"); //错
//因为集合具体对象中既可存储String，也可以存储Object 的其他子类，所以添加具体的类型对象不合适，类型检查会出现安全问题。 ？extends Object 代表Object 的子类型不确定，怎么能添加具体类型的对象呢？
public static void method(ArrayList<? extends Object> al) {
al.add("abc"); //错
//只能对al 集合中的元素调用Object 类中的方法，具体子类型的方法都不能用，因为子类型不确定。

论坛里一个问题：

利用LinkedList和ArrayList的相关知识，分别编程实现如下功能：
（1）初始化链表list，存放字符串数据“Java”、“真”、“有趣”、“！”；
（2）用迭代器方法和for-get方法遍历输出list中的全部数据；
（3）比较不同遍历方法的运行时间；
（4）编写main方法，测试上述代码的功能。

代码实现如下：

package com.qzb.test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class TestList {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 初始化LinkedList
		List<String> linkedList = new LinkedList<String>();
		linkedList.add("Java");
		linkedList.add("真");
		linkedList.add("有趣");
		linkedList.add("！");
		// 初始化ArrayList
		List<String> arrayList = new ArrayList<String>();
		arrayList.add("Java");
		arrayList.add("真");
		arrayList.add("有趣");
		arrayList.add("！");
		// 比较运行时间
		compareRunTime(linkedList, arrayList);
	}

	/**
	 * 遍历list 使用Iterator
	 * 
	 * @param list
	 */
	@SuppressWarnings("rawtypes")
	public static void traverseListIterator(List<String> list) {
		for (Iterator iterator = list.iterator(); iterator.hasNext();) {
			String string = (String) iterator.next();
			System.out.print(string);
		}
	}

	/**
	 * 遍历list 使用for
	 * 
	 * @param list
	 */
	public static void traverseListFor(List<String> list) {
		for (int i = 0; i < list.size(); i++) {
			String string = list.get(i);
			System.out.print(string);
		}
	}

	/**
	 * 比较运行时间
	 * 
	 * @param linkedList
	 * @param arrayList
	 */
	public static void compareRunTime(List<String> linkedList, List<String> arrayList) {
		long beginTime1 = System.currentTimeMillis();
		traverseListIterator(linkedList);
		long endTime1 = System.currentTimeMillis();
		System.out.println("迭代器方式遍历LinkedList运行耗时：" + (endTime1 - beginTime1));
		
		long beginTime2 = System.currentTimeMillis();
		traverseListFor(linkedList);
		long endTime2 = System.currentTimeMillis();
		System.out.println("for循环方式遍历LinkedList运行耗时：" + (endTime2 - beginTime2));
		
		long beginTime3 = System.currentTimeMillis();
		traverseListIterator(arrayList);
		long endTime3 = System.currentTimeMillis();
		System.out.println("迭代器方式遍历ArrayList运行耗时：" + (endTime3 - beginTime3));
		
		long beginTime4 = System.currentTimeMillis();
		traverseListFor(arrayList);
		long endTime4 = System.currentTimeMillis();
		System.out.println("for循环方式遍历ArrayList运行耗时：" + (endTime4 - beginTime4));
	}
}

输出结果如下：

Java真有趣！迭代器方式遍历LinkedList运行耗时：1
Java真有趣！for循环方式遍历LinkedList运行耗时：1
Java真有趣！迭代器方式遍历ArrayList运行耗时：1
Java真有趣！for循环方式遍历ArrayList运行耗时：0

千丈冰

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
一步一步学JAVA(14)-集合框架

集合框架：用于存储数据的容器。特点：1：对象封装数据，对象多了也需要存储。集合用于存储对象。2：对象的个数确定可以使用数组，但是不确定怎么办？可以用集合。因为集合是可变长度的。集合和数组的区别：1：数组是固定长度的；集合可变长度的。2：数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。3：数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。数...
复制链接

扫一扫

专栏目录