java面试题-Java基础部分-基础语法 57-70

向右看齐 2022-01-21 05:25 292阅读 0赞

**基础语法 57-70**

57 、介绍 Collection  框架的结构

58 、Collection  框架中实现比较要实现什么接口

59 、ArrayList 和 和 Vector  的区别

60 、HashMap 和 和 Hashtable  的区别

61 、List  和 Map  区别?

62 、List, Set, Map  是否继承自 Collection  接口?

63 、List 、Map 、Set  三个接口，存取元素时，各有什么特点？

64 、说出 ArrayList,Vector, LinkedList  的存储性能和特性

65 、去掉一个 Vector  集合中重复的元素

66 、Collection  和 Collections 的 的区别。 区别。

67 、Set  里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还 还是 是 equals()? 它们有何区别?

68 、你所知道的集合类都有哪些？主要方法？

69 、两个对象值相同(x.equals(y) == true) ，但却可有不同的 hash code，这句 ，这句话对不对 话对不对?

70 、TreeSet 里面放对象，如果同时放入了父类和子类的实例对象，那比较时使 里面放对象，如果同时放入了父类和子类的实例对象，那比较时使用的是父类的 用的是父类的 compareTo  方法，还是使用的子类的 compareTo 方法，还是抛 方法，还是抛异常！ 异常！

--------------------

### 57 、介绍 Collection  框架的结构   ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70][] ###

### 58 、Collection  框架中实现比较要实现什么接口 ###

Comparable和Comparator接口  
如果一个类的不同对象需要比较大小，那么就需要实现这两个接口，根据业务需求定义规则。  
使用区别:  
(1)Comparable接口  
需要比较的类实现自己实现

例如：定义的Student类需要比较,需要Student类自己实现这个接口，实现ComParaTo()方法。  
(2)Comparator接口  
自己定义一个比较容器，去实现这个接口（实现compare方法），然后在集合生成的时候，用一个比较对象做参数，跟集合绑定。  
例：  
Class A implements Comparator\{\}//定义比较容器，实现compare方法  
A a = new A();//生成比较对象  
Set set = new TreeSet(a);//构造集合对象时，传入比较器。

###    59 、ArrayList 和 和 Vector  的区别 ###

List接口是有序的Collection，使用该接口能精确控制每个元素的插入位置，可以使用索引来访问List中的元素，跟数组是很类似的。并且List中允许有重复元素，当然有些List的实现类不允许重复元素的存在。

List中有iterator()方法，还有listIterator方法，返回一个ListIterator接口，这个接口比标准的Iterator接口相比，多了一些add之类的方法，允许添加、删除、设置元素值以及向前或者向后遍历等。

List下有几个常用类:LinkedList、ArrayList和Vector以及Stack。

1.  ArrayList类：实现了可变大小的数组。它允许包含所有元素，包括null。每个ArrayList实例都有一个容量，即用于存储元素的数组的大小，这个容量可以随着不断添加新元素而自动增加，但增长算法没有定义，当插入大量元素时，插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
2.  LinkedList类：允许null元素，提供额外的get，remove和insert方法，这使得LinkedList可以用作stack、queue或双向队列。它可以再List的中间插入和移除，在这方面比ArrayList有效，但是在随机访问方面就没有ArrayList有效了。                        如果多个线程同时访问一个List，则必须自己实现访问同步，一种解决方法是在创建List时构造一个同步的List：List list = Collection.synchronizedList(new LinkedList(……))；
3.  Vector类：Vector跟ArrayList非常类似，但是Vector是同步的，由Vector创建的Iterator，虽然和ArrayList创建的 Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。
4.  Stack类：继承自Vector，实现一个后进先出的栈。提供了几个基本方法，push、pop、peak、empty、search等。

*  **List**：元素是有序的，元素可以重复。因为该集合体系有索引。
 *   *  **ArrayList**：底层的数据结构使用的是数据结构。
     *   *  查询速度很快。
         *  增删稍慢。
         *  线程不同步。
         *  默认长度为10增长率为50%。
     *  **LinkedList**：底层使用的链表数据结构。
     *   *  增删速度很快。
         *  查询稍慢。
     *  **Vector**：底层是数组数据结构。1.0出现
     *   *  线程同步
         *  被ArrayList替代了。
         *  长度增长率100%。

接着才说 ArrayList 与 Vector 的区别，这主要包括两个方面：.  
（1）同步性：  
Vector 是线程安全的，也就是说是它的方法之间是线程同步的，而 ArrayList 是线程序不安全的，它的方法之间是线程不同步的。

如果只有一个线程会访问到集合，那最好是使用 ArrayList，因为它不考虑线程安全，效率会高些；

如果有多个线程会访问到集合，那最好是使用 Vector，因为不需要我们自己再去考虑和编写线程安全的代码。  
  
（2）数据增长： Vector 增长原来的一倍，ArrayList 增加原来的0.5倍。

###    60 、HashMap 和 和 Hashtable  的区别 ###

HashMap 是 Hashtable 的轻量级实现（非线程安全的实现），他们都完成了 Map 接口，主要区别在于 HashMap 允许空（null）键值（key）,由于非线程安全，在只有一个线程访问的情况下，效率要高于 Hashtable。

HashMap 允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。  
HashMap 把 Hashtable 的 contains 方法去掉了，改成 containsvalue 和 containsKey。  
Hashtable 继承自 Dictionary 类，而 HashMap 是 Java1.2引进的 Map interface 的一个实现。

Hashtable 的方法是 Synchronize 的，而 HashMap 不是，在多个线程访问Hashtable 时，不需要自己为它的方法实现同步，而 HashMap 就必须为之提供外同步。  
Hashtable 和 HashMap 采用的 hash/rehash 算法都大概一样，所以性能不会有很大的差异。

就 HashMap 与 HashTable 主要从三方面来说。

1.  历史原因:Hashtable 是基于陈旧的 Dictionary 类的，HashMap 是 Java 1.2引进的 Map接口的一个实现
2.  同步性:Hashtable 是线程安全的，也就是说是同步的，而 HashMap 是线程序不安全的，不是同步的
3.  值：只有 HashMap 可以让你将空值作为一个表的条目的 key 或 value

###    61 、List  和 Map  区别? ###

一个是存储单列数据的集合，另一个是存储键和值这样的双列数据的集合，

List 中存储的数据是有顺序，并且允许重复；

Map 中存储的数据是没有顺序的，其键是不能重复的，它的值是可以有重复的。

###    62 、List, Set, Map  是否继承自 Collection  接口? ###

List，Set 是，Map 不是

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 5][]

###    63 、List 、Map 、Set  三个接口，存取元素时，各有什么特点？ ###

首先，List 与 Set 具有相似性，它们都是单列元素的集合，所以，它们有一个功共同的父接口，叫 Collection。Set 里面不允许有重复的元素，所谓重复，即不能有两个相等（注意，不是仅仅是相同）的对象，即假设 Set 集合中有了一个 A 对象，现在我要向 Set 集合再存入一个 B 对象，但 B 对象与 A 对象 equals 相等，则 B 对象存储不进去，所以，Set 集合的add 方法有一个 boolean 的返回值，当集合中没有某个元素，此时 add 方法可成功加入该元素时，则返回 true，当集合含有与某个元素 equals 相等的元素时，此时 add 方法无法加入该元素，返回结果为 false。Set 取元素时，没法说取第几个，只能以 Iterator 接口取得所  
有的元素，再逐一遍历各个元素。

List 表示有先后顺序的集合，当我们多次调用 add(Obj e)方法时，每次加入的对象就像火车站买票有排队顺序一样，按先  
来后到的顺序排序。有时候，也可以插队，即调用 add(int index,Obj e)方法，就可以指定当前对象在集合中的存放位置。一个对象可以被反复存储进 List 中，每调用一次 add 方法，这个对象就被插入进集合中一次，其实，并不是把这个对象本身存储进了集合中，而是在集合中用一个索引变量指向这个对象，当这个对象被 add 多次时，即相当于集合中有多个索引指向了这个对象，如图 x 所示。List 除了可以以 Iterator 接口取得所有的元素，再逐一遍历各个元素之外，还可以调用 get(index i)来明确说明取第几个。  
Map 与 List 和 Set 不同，它是双列的集合，其中有 put 方法，定义如下：put(objkey,objvalue)，每次存储时，要存储一对 key/value，不能存储重复的 key，这个重复的规则也是按 equals 比较相等。取则可以根据 key 获得相应的 value，即 get(Object key)返回值为 key 所对应的 value。另外，也可以获得所有的 key 的结合，还可以获得所有的 value的结合，还可以获得 key 和 value 组合成的 Map.Entry 对象的集合。

List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value 值，value 可多值。  
HashSet 按照 hashcode 值的某种运算方式进行存储，而不是直接按 hashCode 值的大小进行存储。

LinkedHashSet 按插入的顺序存储，那被存储对象的 hashcode 方法还有什么作用呢？学员想想!hashset 集合比较两个对象是否相等，首先看hashcode 方法是否相等，然后看 equals 方法是否相等。new 两个 Student 插入到 HashSet中，看 HashSet 的 size，实现 hashcode 和 equals 方法后再看 size。同一个对象可以在 Vector 中加入多次。往集合里面加元素，相当于集合里用一根绳子连接到了目标对象。往 HashSet 中却加不了多次的。

###    64 、说出 ArrayList,Vector, LinkedList  的存储性能和特性 ###

ArrayList 和 Vector 都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector 由于使用了 synchronized 方法（线程安全），通常性能上较 ArrayList 差，而 LinkedList 使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。LinkedList 也是线程不安全的，LinkedList 提供了一些方法，使得 LinkedList 可以被当作堆 可以被当作堆栈和队列来使用。

###    65 、去掉一个 Vector  集合中重复的元素 ###

Vector newVector = new Vector();
    For (int i=0;i<vector.size();i++)
    {
        Object obj = vector.get(i);
        if(!newVector.contains(obj);
            newVector.add(obj);
    }

###    66 、Collection  和 Collections 的 的区别。 区别。 ###

Collection 是集合类的上级接口，继承与他的接口主要有 Set 和 List.  
Collections 是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、  
排序、线程安全化等操作。

###    67 、Set  里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还 还是 是 equals()? 它们有何区别? ###

Set 里的元素是不能重复的，元素重复与否是使用 equals()方法进行判断的。  
equals()和==方法决定引用值是否指向同一对象 equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

###    68 、你所知道的集合类都有哪些？主要方法？ ###

最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。  
Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作"键"和"值"），其中每个键映射到一个值。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 6][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 7][]

### 69 、两个对象值相同(x.equals(y) == true) ，但却可有不同的 hash code，这句 ，这句话对不对 话对不对? ###

对。  
如果对象要保存在 HashSet 或 HashMap 中，它们的 equals 相等，那么，它们的 hashcode值就必须相等。  
如果不是要保存在HashSet或HashMap，则与hashcode没有什么关系了，这时候hashcode不等是可以的，

### 70 、TreeSet 里面放对象，如果同时放入了父类和子类的实例对象，那比较时使 里面放对象，如果同时放入了父类和子类的实例对象，那比较时使用的是父类的 用的是父类的 compareTo  方法，还是使用的子类的 compareTo 方法，还是抛 方法，还是抛   异常！ 异常！ ###

当前的 add 方法放入的是哪个对象，就调用哪个对象的 compareTo 方法，至于这个 compareTo 方法怎么做，就看当前这个对象的类中是如何编写这个方法的  
实验代码：

public class Parent implements Comparable {
        private int age = 0;
        public Parent(int age){
        this.age = age;
    }
    
    public int compareTo(Object o){
        System.out.println("method ofparent");
        Parent o1 = (Parent)o;
        return age>o1.age?1:age<o1.age?-1:0;
    }
    }
    public class Child extends Parent {
        public Child(){
            super(3);
        }
        public int compareTo(Object o){
            System.out.println("methodof child");
            return 1;
        }
    }
    public class TreeSetTest {
    
        public static voidmain(String[] args) {
            TreeSet set = new TreeSet();
            set.add(newParent(3));
            set.add(new Child());
            set.add(newParent(4));
            System.out.println(set.size());
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70]: /images/20220121/b5bd84532ae0471e87cd28d28e37a9ed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 1]: /images/20220121/5795fcbc8266414fbd0dac9de8162480.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 2]: /images/20220121/9da8ad5afda446989eb2e1fd1a0e7987.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 3]: /images/20220121/829b55193eb343168e4d127534e8779c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 4]: /images/20220121/be6fa246e2de46f990409bccedd8fb09.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 5]: /images/20220121/b80ddabe1ca942f8abcbb36110b3bddd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 6]: /images/20220121/49d10043679d4c91a9748fcc7f324bbb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpbmd5aXdpbg_size_16_color_FFFFFF_t_70 7]: /images/20220121/de01a310428e4f8788de124042dfedd9.png