黑马程序员面试题集合1(ArrayList,LinkedList,Vector,Iterator,ListIterator，HashSet,TreeSet,JDK1.5新特性泛型)
2013-12-05 15:49
811 查看
--------- android培训、java培训、期待与您交流！---------
一.ArrayList
(1)ArrayList是List接口的一个子类。
(2)ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
(3)每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加.
二.Vector
(1)Vector非常类似ArrayList ，但是Vector是同步的。
(2)由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常.
三.LinkedList
(1)LinkedList实现了List接口，底层数据是链表数据结构 。
(2)允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
注意:inkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。
一种解决方法是在创建List时构造一个同步的List：List list = Collections.synchronizedList(new LinkedList(...));
四.Iterator
Iterator是java的一种设计模式：Iterator模式是用于遍历集合类的标准访问方法。
它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。
Iterator模式总是用同一种逻辑来遍历集合：
迭代器设计模式优势在于客户端自身不维护遍历集合的"指针"，所有的内部状态（如当前元素位置，是否有下一个元素）都由Iterator来维护，而这个Iterator由集合类通过工厂方法生成，因此，它知道如何遍历整个集合。
五.ListIterator和Iterator的区别和使用：
1、Iterator是ListIterator的父接口。
2、Iterator是单列集合(Collection)公共取出容器中元素的方式。对于List，Set，Map都通用。
而ListIterator是List集合的特有取出元素方式。
3、Iterator中具备的功能只有hashNext(),next()，remove();
ListIterator中具备着对被遍历的元素进行增删改查的方法，可以对元素进行逆向遍历。
之所以如此，是因为ListIterator遍历的元素所在的容器都有索引。
六Enumeration
(1)枚举是Vector特有的取出方式。
(2)枚举和迭代器是一样的。
(3)因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。
[java] view
plaincopy
class VectorDemo
{
public static void main(String[] args)
{
Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");
Enumeration en = v.elements(); //Iterator it = v.iterator();
while(en.hasMoreElements()) // while(it.hasNext())
{
System.out.println(en.nextElement()); //System.out.println(it.next());
}
}
}
六.HashSet
(1)底层数据结构是哈希表。是线程不安全的。不同步。
(2)HashSet是如何保证元素唯一性的呢？是通过元素的两个方法，hashCode和equals来完成。
如果元素的HashCode值相同，才会判断equals是否为true,如果元素的hashcode值不同，不会调用equals。
(3)注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
七.TreeSet
(1)底层数据结构是二叉树。
(2)TreeSet：可以对Set集合中的元素进行排序。
第一种排序方式：
让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。
也种方式也成为元素的自然顺序，或者叫做默认顺序。
第二种排序方式。当元素自身不具备比较性时，或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。
代码示例： 需求： 把学生对象Student存入到TreeSet集合中，（按年龄进行排序）
[java] view
plaincopy
class Student implements Comparable //首先定义一个学生对象，让学生对象Student实现Comparable接口
{
private String name;
private int age;
Student(String name,int age) //构造方法
{
this.name = name;
this.age = age;
}
public String getName() //获取姓名的方法
{
return name;
}
public int getAge()//获取年龄的方法
{
return age;
}
public int compareTo(Object obj) // 重写Comparable接口中的CompareTo方法 这样Student对象自身就实现了默认排序。
{
if(!(obj instanceof Student)) // 如果不是学生对象 直接抛出异常 不去比较。
throw new RuntimeException("不是学生对象 ");
Student s = (Student)obj; //把传入的对象强制转成Student引用类型。
if(this.age>s.age)
return 1;
if(this.age==s.age)
{
return this.name.compareTo(s.name); //先按年龄排序 当年龄也相同时 再按姓名进行排序。
}
return -1;
}
}
public class TreeSetDemo {
public static void main(String[] args)
{
TreeSet ts = new TreeSet(); //创建一个TreeSet集合 。
ts.add(new Student("zhangsan",34)); //存入TreeSet集合元素。
ts.add(new Student("wangliu",24));
ts.add(new Student("wangwu",23));
Iterator it = ts.iterator(); //用迭代器将Student元素取出。
while(it.hasNext())
{
System.out.println(it.next());
Student s = (Student)it.next();
System.out.println(s.getName()+".."+s.getAge());
}
}
}
class NameComparator implements Comparator // 定义一个姓名比较器 ，调用时直接将这个类传入TreeSet的构造函数中即可进行排序。
{
public int compare(Object o1,Object o2) //覆盖compare方法
{
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int num = s1.getName().compareTo(s2.getName());
if(num==0)
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())); //如果姓名一样 再按年龄排序。
return num;
}
}
八.泛型
1.泛型：JDK1.5以后出现的新特性，用于解决安全问题，是一个类型安全机制。
2.数组与集合
1)int[] arr = new int[3];
arr[o]=4;
arr[1] = 3.5;
此时编译就会报错，因为数组在初始化时就已经明确了元素类型。
ArrayList al = new ArrayList();
al.add("abc");
al.add(4);
此时编译不报错，运行时报ClassCastException,因为集合在初始化时没有明确元素的类型，这就是安全隐患。
3.泛型的好处：
1).将运行时期出现的问题ClassCastException,转移到了编译时期。方便于程序员解决问题，让运行时问题减少，更加安全。
4泛型使用
1).泛型格式：通过<>来定义要操作的引用数据类型。
2).在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，
只要见到<>就要定义泛型。
3).其实<>就是用来接收类型的。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
4)什么时候定义泛型类？
当类中操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在定义泛型来完成扩展
5.泛型类
class Worker
{
}
class Student
{
}
//泛型前做法（1.5版本以前）
class Tool
{
private Object obj;
public void setObject(Object obj)
{
this.obj = obj;
}
public Object getObject()
{
return obj;
}
}
//泛型后做法
class Utils<QQ>
{
private QQ q;
public void setObject(QQ q)
{
this.q = q;
}
public QQ getObject()
{
return q;
}
}
6.泛型方法
1).泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
2).为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。
3).集合全部是泛型类，泛型方法比泛型类更方便。
//泛型类
class Demo<T>
{
public void show(T t)
{
System.out.println("show:" + t);
}
public void print(T t)
{
System.out.println("print:" + t);
}
}
//泛型方法
class Demo
{
public <T> void show(T t)
{
System.out.println("show:" + t);
}
public <Q> void print(Q q)
{
System.out.println("print:" +t);
}
}
7.静态方法泛型
1).特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
2).静态方法的泛型也说明了静态要比非静态先加载进内存。
class Demo<T>
{
public void show(T t)
{
System.out.println("show:" + t);
}
public <Q> void print(Q q)
{
System.out.println("print:" +t);
}
public static <W> void method(W w)
{
System.out.println("method:"+w);
}
}
8.泛型接口:
泛型定义在接口上
interface Inter<T>
{
void show(T t);
}
class InterImpl<T> implements Inter<T>
{
public void show(T t)
{
System.out.println("show:" +t);
}
}
9.泛型限定
1).?通配符，也可以理解为占位符。
2).泛型的限定：
？ extends E: 可以接收E类型或者E的子类型。上限。
？ super E : 可以接收有类型或者E的父类型。下限。
3.限定举例（API文档）
eg1:TreeSet类中的TreeSet(Comparator<? super E> comparator)以及addAll(Collection<? extends E> c)方法
eg2:Collection中的addAll(Collection<? extends E> c),containsAll(Collection<?> c)
eg3:Comparable<? super E> Comparator<? super E>
4. 限定是扩展用的
TreeSet(Comparator<? super E> comparator)
1) E:只打印E类型
2) ?: 打印很多种类型
3)? extends E : 打印E及其子类型。
一.ArrayList
(1)ArrayList是List接口的一个子类。
(2)ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
(3)每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加.
二.Vector
(1)Vector非常类似ArrayList ，但是Vector是同步的。
(2)由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常.
三.LinkedList
(1)LinkedList实现了List接口，底层数据是链表数据结构 。
(2)允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
注意:inkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。
一种解决方法是在创建List时构造一个同步的List：List list = Collections.synchronizedList(new LinkedList(...));
四.Iterator
Iterator是java的一种设计模式：Iterator模式是用于遍历集合类的标准访问方法。
它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。
Iterator模式总是用同一种逻辑来遍历集合：
for(Iterator it = c.iterater(); it.hasNext(); ) { ... }迭代器设计模式优势在于客户端自身不维护遍历集合的"指针"，所有的内部状态（如当前元素位置，是否有下一个元素）都由Iterator来维护，而这个Iterator由集合类通过工厂方法生成，因此，它知道如何遍历整个集合。
五.ListIterator和Iterator的区别和使用：
1、Iterator是ListIterator的父接口。
2、Iterator是单列集合(Collection)公共取出容器中元素的方式。对于List，Set，Map都通用。
而ListIterator是List集合的特有取出元素方式。
3、Iterator中具备的功能只有hashNext(),next()，remove();
ListIterator中具备着对被遍历的元素进行增删改查的方法，可以对元素进行逆向遍历。
之所以如此，是因为ListIterator遍历的元素所在的容器都有索引。
六Enumeration
(1)枚举是Vector特有的取出方式。
(2)枚举和迭代器是一样的。
(3)因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。
[java] view
plaincopy
class VectorDemo
{
public static void main(String[] args)
{
Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");
Enumeration en = v.elements(); //Iterator it = v.iterator();
while(en.hasMoreElements()) // while(it.hasNext())
{
System.out.println(en.nextElement()); //System.out.println(it.next());
}
}
}
六.HashSet
(1)底层数据结构是哈希表。是线程不安全的。不同步。
(2)HashSet是如何保证元素唯一性的呢？是通过元素的两个方法，hashCode和equals来完成。
如果元素的HashCode值相同，才会判断equals是否为true,如果元素的hashcode值不同，不会调用equals。
(3)注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
七.TreeSet
(1)底层数据结构是二叉树。
(2)TreeSet：可以对Set集合中的元素进行排序。
第一种排序方式：
让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。
也种方式也成为元素的自然顺序，或者叫做默认顺序。
第二种排序方式。当元素自身不具备比较性时，或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。
代码示例： 需求： 把学生对象Student存入到TreeSet集合中，（按年龄进行排序）
[java] view
plaincopy
class Student implements Comparable //首先定义一个学生对象，让学生对象Student实现Comparable接口
{
private String name;
private int age;
Student(String name,int age) //构造方法
{
this.name = name;
this.age = age;
}
public String getName() //获取姓名的方法
{
return name;
}
public int getAge()//获取年龄的方法
{
return age;
}
public int compareTo(Object obj) // 重写Comparable接口中的CompareTo方法 这样Student对象自身就实现了默认排序。
{
if(!(obj instanceof Student)) // 如果不是学生对象 直接抛出异常 不去比较。
throw new RuntimeException("不是学生对象 ");
Student s = (Student)obj; //把传入的对象强制转成Student引用类型。
if(this.age>s.age)
return 1;
if(this.age==s.age)
{
return this.name.compareTo(s.name); //先按年龄排序 当年龄也相同时 再按姓名进行排序。
}
return -1;
}
}
public class TreeSetDemo {
public static void main(String[] args)
{
TreeSet ts = new TreeSet(); //创建一个TreeSet集合 。
ts.add(new Student("zhangsan",34)); //存入TreeSet集合元素。
ts.add(new Student("wangliu",24));
ts.add(new Student("wangwu",23));
Iterator it = ts.iterator(); //用迭代器将Student元素取出。
while(it.hasNext())
{
System.out.println(it.next());
Student s = (Student)it.next();
System.out.println(s.getName()+".."+s.getAge());
}
}
}
class NameComparator implements Comparator // 定义一个姓名比较器 ，调用时直接将这个类传入TreeSet的构造函数中即可进行排序。
{
public int compare(Object o1,Object o2) //覆盖compare方法
{
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int num = s1.getName().compareTo(s2.getName());
if(num==0)
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())); //如果姓名一样 再按年龄排序。
return num;
}
}
八.泛型
1.泛型：JDK1.5以后出现的新特性，用于解决安全问题，是一个类型安全机制。
2.数组与集合
1)int[] arr = new int[3];
arr[o]=4;
arr[1] = 3.5;
此时编译就会报错，因为数组在初始化时就已经明确了元素类型。
ArrayList al = new ArrayList();
al.add("abc");
al.add(4);
此时编译不报错，运行时报ClassCastException,因为集合在初始化时没有明确元素的类型，这就是安全隐患。
3.泛型的好处：
1).将运行时期出现的问题ClassCastException,转移到了编译时期。方便于程序员解决问题，让运行时问题减少，更加安全。
4泛型使用
1).泛型格式：通过<>来定义要操作的引用数据类型。
2).在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，
只要见到<>就要定义泛型。
3).其实<>就是用来接收类型的。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
4)什么时候定义泛型类？
当类中操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在定义泛型来完成扩展
5.泛型类
class Worker
{
}
class Student
{
}
//泛型前做法（1.5版本以前）
class Tool
{
private Object obj;
public void setObject(Object obj)
{
this.obj = obj;
}
public Object getObject()
{
return obj;
}
}
//泛型后做法
class Utils<QQ>
{
private QQ q;
public void setObject(QQ q)
{
this.q = q;
}
public QQ getObject()
{
return q;
}
}
6.泛型方法
1).泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
2).为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。
3).集合全部是泛型类，泛型方法比泛型类更方便。
//泛型类
class Demo<T>
{
public void show(T t)
{
System.out.println("show:" + t);
}
public void print(T t)
{
System.out.println("print:" + t);
}
}
//泛型方法
class Demo
{
public <T> void show(T t)
{
System.out.println("show:" + t);
}
public <Q> void print(Q q)
{
System.out.println("print:" +t);
}
}
7.静态方法泛型
1).特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
2).静态方法的泛型也说明了静态要比非静态先加载进内存。
class Demo<T>
{
public void show(T t)
{
System.out.println("show:" + t);
}
public <Q> void print(Q q)
{
System.out.println("print:" +t);
}
public static <W> void method(W w)
{
System.out.println("method:"+w);
}
}
8.泛型接口:
泛型定义在接口上
interface Inter<T>
{
void show(T t);
}
class InterImpl<T> implements Inter<T>
{
public void show(T t)
{
System.out.println("show:" +t);
}
}
9.泛型限定
1).?通配符，也可以理解为占位符。
2).泛型的限定：
？ extends E: 可以接收E类型或者E的子类型。上限。
？ super E : 可以接收有类型或者E的父类型。下限。
3.限定举例（API文档）
eg1:TreeSet类中的TreeSet(Comparator<? super E> comparator)以及addAll(Collection<? extends E> c)方法
eg2:Collection中的addAll(Collection<? extends E> c),containsAll(Collection<?> c)
eg3:Comparable<? super E> Comparator<? super E>
4. 限定是扩展用的
TreeSet(Comparator<? super E> comparator)
1) E:只打印E类型
2) ?: 打印很多种类型
3)? extends E : 打印E及其子类型。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 黑马程序员_集合1(ArrayList,LinkedList,Vector,Iterator,ListIterator)
- 黑马程序员_集合1_(ArrayList、LinkedList、Vector、Iterator、ListIterator)
- Java基础---集合框架---迭代器、ListIterator、Vector中枚举、LinkedList、ArrayList、HashSet、TreeSet、二叉树、Comparator
- Java基础---集合框架---迭代器、ListIterator、Vector中枚举、LinkedList、ArrayList、HashSet、TreeSet、二叉树、Comparator
- java集合（ArrayList,Vector,LinkedList,HashSet,TreeSet的功能详解）
- java集合（ArrayList,Vector,LinkedList,HashSet,TreeSet的功能详解）
- 浅析Java中的集合包(ArrayList,LinkedList,Vector, Stack,HashSet,TreeSet,HashMap,TreeMap)
- JAVA基础学习之String、StringBuffer、StringBuilder、基本数据类型的使用、整形进制转换、集合Collection、Vector、ArrayList、LinkedList、HashSet、TreeSet等（3）
- 黑马程序员：集合类：List（ArrayList、LinkedList、Vector）、Set（HashSet、TreeSet）介绍
- 黑马程序员_集合2(HashSet,TreeSet,JDK1.5新特性泛型)
- 2017 - 10 -22 集合框架 ArrayList Vector LinkedList 泛型 jdk5新特性
- 16 API-集合(List的子类(ArrayList_Vector_LinkedList,集合嵌套遍历),JDK5新特性(泛型,增强for循环,静态导入,可变参数)
- 黑马程序员_学习笔记：9) 集合框架1：Collection（List、Set）、Iterator、List（ArrayList、LinkedList、Vector）
- 黑马程序员_集合2_(HashSet、TreeSet、JDK1.5新特性泛型)
- java集合类，List和Set比较，各自的子类比较（ArrayList，Vector，LinkedList；HashSet，TreeSet），Map集合比较
- 集合类（常见的集合类：Collection、List、Set、ArrayList、linkedList、Vector、HashSet、TreeSet）
- 集合类：List（ArrayList、LinkedList、Vector）、Set（HashSet、TreeSet）介绍
- 【Java总结-集合】Java集合的Collection接口，ArrayList，LinkedList，HashSet，TreeSet
- List集合的子实现类的特点(ArrayList,Vector,LinkedList),JDK5以后提供的新特性
- ArrayList，LinkedList；TreeSet ，HashSet ,Map 集合知识的基础理解。