关闭

黑马程序员面试题集合1(ArrayList,LinkedList,Vector,Iterator,ListIterator,HashSet,TreeSet,JDK1.5新特性泛型)

标签: java基础面试题黑马程序员数据结构
742人阅读 评论(0) 收藏 举报
分类:

--------- 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模式总是用同一种逻辑来遍历集合:


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
  1. class VectorDemo   
  2. {  
  3.     public static void main(String[] args)   
  4.     {  
  5.         Vector v = new Vector();  
  6.   
  7.         v.add("java01");  
  8.         v.add("java02");  
  9.         v.add("java03");  
  10.         v.add("java04");  
  11.   
  12.         Enumeration en = v.elements(); //Iterator it = v.iterator();  
  13.    
  14.         while(en.hasMoreElements())   // while(it.hasNext())  
  15.         {  
  16.             System.out.println(en.nextElement()); //System.out.println(it.next());  
  17.         }  
  18.     }  
  19. }  

六.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
  1. class Student implements Comparable    //首先定义一个学生对象,让学生对象Student实现Comparable接口  
  2. {            
  3.     private String name;  
  4.     private int age;  
  5.     Student(String name,int age) //构造方法   
  6.     {  
  7.         this.name = name;  
  8.         this.age = age;  
  9.     }  
  10.     public String getName()  //获取姓名的方法  
  11.     {  
  12.             return name;  
  13.     }  
  14.     public int getAge()//获取年龄的方法  
  15.     {  
  16.                         return age;  
  17.                 }  
  18.     public int compareTo(Object obj)  //  重写Comparable接口中的CompareTo方法  这样Student对象自身就实现了默认排序。  
  19.     {  
  20.         if(!(obj instanceof Student))  // 如果不是学生对象 直接抛出异常 不去比较。  
  21.             throw new RuntimeException("不是学生对象 ");  
  22.           
  23.         Student s = (Student)obj;  //把传入的对象强制转成Student引用类型。  
  24.         if(this.age>s.age)       
  25.             return 1;  
  26.         if(this.age==s.age)  
  27.         {  
  28.             return this.name.compareTo(s.name);  //先按年龄排序  当年龄也相同时 再按姓名进行排序。  
  29.         }  
  30.         return -1;    
  31.     }  
  32. }  
  33.   
  34. public class TreeSetDemo {  
  35.   
  36.     public static void main(String[] args)  
  37.     {  
  38.         TreeSet ts = new TreeSet();        //创建一个TreeSet集合 。  
  39.         ts.add(new Student("zhangsan",34));     //存入TreeSet集合元素。  
  40.         ts.add(new Student("wangliu",24));  
  41.         ts.add(new Student("wangwu",23));  
  42.           
  43.         Iterator it = ts.iterator();        //用迭代器将Student元素取出。  
  44.         while(it.hasNext())  
  45.         {             
  46.             System.out.println(it.next());  
  47.             Student s = (Student)it.next();  
  48.             System.out.println(s.getName()+".."+s.getAge());  
  49.         }  
  50.     }  
  51. }  
  52. class NameComparator  implements Comparator // 定义一个姓名比较器 ,调用时直接将这个类传入TreeSet的构造函数中即可进行排序。  
  53. {  
  54.     public int compare(Object o1,Object o2)  //覆盖compare方法  
  55.     {  
  56.         Student s1 = (Student)o1;  
  57.         Student s2 = (Student)o2;  
  58.         int num = s1.getName().compareTo(s2.getName());  
  59.         if(num==0)  
  60.                  return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())); //如果姓名一样 再按年龄排序。  
  61.         return num;  
  62.     }  
  63. }  


八.泛型

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及其子类型。




0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:7203次
    • 积分:202
    • 等级:
    • 排名:千里之外
    • 原创:12篇
    • 转载:2篇
    • 译文:0篇
    • 评论:1条
    文章分类
    文章存档