面试常见问题
ArrayList和LinkedList的联系和区别
1. ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2. 对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3. 对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据
Vector和ArrayList的联系和区别
1.Vector是多线程安全的，而ArrayList不是，这个可以从源码中看出，Vector类中的方法很多有synchronized进行修饰，这样就导致了Vector在效率上无法与ArrayList相比。
2.两个都是采用的线性连续空间存储元素，但是当空间不足的时候，两个类的增加方式是不同的，很多网友说Vector增加原来空间的一倍，ArrayList增加原来空间的50%，其实也差不多是这个意思，不过还有一点点问题可以从源码中看出，一会儿从源码中分析。
3.Vector可以设置增长因子，而ArrayList不可以。
在说集合前我们不得不说一下数组
数组的作用：存放一组相同的数据类型(基本或对象)的数据，从而实现对数据的管理
优势：可以快速的通过下标对数组元素进行访问，效率高
劣势：容量实现定义好了，不能随着需求变化而扩容
因此出现了更好的集合框架
一、数组和集合的比较
数组不是面向对象的，存在明显的缺陷，集合弥补了数组的缺点，比数组更灵活更实用，而且不同的集合框架类可适用不同场合。如下：
1：数组能存放基本数据类型和对象，而集合类存放的都是对象的引用，而非对象本身！
2：数组容易固定无法动态改变，集合类容量动态改变。
3：数组无法判断其中实际存有多少元素，length只告诉了数组的容量，而集合的size()可以确切知道元素的个数
4：集合有多种实现方式和不同适用场合，不像数组仅采用顺序表方式
5：集合以类的形式存在，具有封装、继承、多态等类的特性，通过简单的方法和属性即可实现各种复杂操作，大大提高了软件的开发效率
二、java集合主要由两个接口派生：Collection和Map，是集合框架的根接口。
collection的子接口：Set:接口 ---实现类： HashSet、LinkedHashSet
set的子接口SortedSet接口---实现类：TreeSet
List:接口---实现类： LinkedList,Vector,ArrayList
List:有序列表，允许存放重复的元素；
实现类：
ArrayList：数组实现，查询快，增删慢，轻量级；(线程不安全)
LinkedList：双向链表实现，增删快，查询慢 (线程不安全)
Vector：数组实现，重量级 (线程安全、使用少)
Set:无序集合，不允许存放重复的元素；允许使用null元素
HashSet 的后台有一个HashMap;初始化后台容量；只不过生成一个HashSet的话，系统只提供key的访问； 如果有两个Key重复，那么会覆盖之前的；
实现类
HashSet：equals返回true，hashCode返回相同的整数；哈希表；存储的数据是无序的。
LinkedHashSet：此实现与 HashSet 的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。存储的数据是有序的。
哈希表详解http://www.bianceng.cn/Programming/sjjg/200705/1126.htm
http://blog.csdn.net/feixiaoxing/article/details/6885657
http://blog.csdn.net/jdh99/article/details/8490704
子接口SortedSet,对Set排序实现类 :TreeSet：使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序；二叉树实现的；
二叉树详解：http://blog.csdn.net/luckyxiaoqiang/article/details/7518888/
http://blog.csdn.net/pony_maggie/article/details/38390513
Map的实现类：HashMap、TreeMap、LinkedHashMap、Hashtable等
HashMap：键值对，key不能重复，但是value可以重复；key的实现就是HashSet；value对应着放；允许null的键或值；
Hashtable：线程安全的，不允许null的键或值；
Properties:：key和value都是String类型，用来读配置文件；
TreeMap：对key排好序的Map; key 就是TreeSet, value对应每个key; key要实现Comparable接口或TreeMap有自己的构造器；
LinkedHashMap： 此实现与 HashMap 的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。存储的数
据是有序的。
接口 |
简述 |
实现 |
操作特性 |
成员要求 |
Set |
成员不能重复 |
HashSet |
外部无序地遍历成员 |
成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。 |
TreeSet |
外部有序地遍历成员；附加实现了SortedSet, 支持子集等要求顺序的操作 |
成员要求实现caparable接口，或者使用 Comparator构造TreeSet。成员一般为同一类型。 |
||
LinkedHashSet |
外部按成员的插入顺序遍历成员 |
成员与HashSet成员类似 |
||
List |
提供基于索引的对成员的随机访问 |
ArrayList |
提供快速的基于索引的成员访问，对尾部成员的增加和删除支持较好 |
成员可为任意Object子类的对象 |
LinkedList |
对列表中任何位置的成员的增加和删除支持较好，但对基于索引的成员访问支持性能较差 |
成员可为任意Object子类的对象 |
||
Map |
保存键值对成员，基于键找值操作，compareTo或compare方法对键排序 |
HashMap |
能满足用户对Map的通用需求 |
键成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。 |
TreeMap |
支持对键有序地遍历，使用时建议先用HashMap增加和删除成员，最后从HashMap生成TreeMap；附加实现了SortedMap接口，支持子Map等要求顺序的操作 |
键成员要求实现caparable接口，或者使用Comparator构造TreeMap。键成员一般为同一类型。 |
||
LinkedHashMap |
保留键的插入顺序，用equals 方法检查键和值的相等性 |
成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。 |
||
IdentityHashMap |
使用== 来检查键和值的相等性。 |
成员使用的是严格相等 |
||
WeakHashMap |
其行为依赖于垃圾回收线程，没有绝对理由则少用 |
|
三、Collection常见方法
add(E e); addAll(Collection c);clear();contains(Obj o);返回是否包含指定的元素(true false)
containsAll(Collection c)是否包含c中所有元素 isEmpty(); iterator();remove();size();toArray();返回
collection中所有元素的数组
四、集合的遍历
1、增强for循环 for(Obj o:c){syso(o)}
2、使用iterator ， Iterator it=c.iterator;
while(it.hasNext()){Object o = it.next()}
3、普通循环：for(Iterator it=c.iterator();it.hasNext();){it.next() }
五、代码实例
import java.util.ArrayList;
/**
*
* 关于ArrayList的基本操作
* 其它操作感兴趣的读者可以自己结合源码实现一下
*
*/
public class ListTest {
public static void main(String[] args) {
/* 新建一个ArrayList */
ArrayList<String> list = new ArrayList<String>();
System.out.println("初始化大小:" + list.size());
/* 添加元素 */
list.add("zzz");
list.add("egg");
list.add("hell");
list.add("child");
System.out.println("当前容量:" + list.size());
/* 将ArrayList的大小和实际所含元素的大小设置一致 */
list.trimToSize();
/* 遍历 */
for (String string : list) {
System.out.println(string);
}
/* 在指定位置插入元素 */
list.add(2, "zhu");
for (String string : list) {
System.out.println(string);
}
System.out.println("--------------");
/* 清空list */
list.clear();
/* 遍历 */
for (String string : list) {
System.out.println(string);
}
System.out.println("--------------");
}
}
2、LinkedList
import java.util.LinkedList;
public class LinkedListTest {
public static void main(String[] args) {
/* 新建一个list */
LinkedList<Integer> list = new LinkedList<Integer>();
System.out.println(list.size());
/* 向list中添加元素 */
list.add(222);
list.add(111);
list.add(0);
list.add(3333);
list.add(8888);
System.out.println(list.size());
/* 遍历list */
for (Integer integer : list) {
System.out.println(integer);
}
/* 获取第一个元素 ,即header的next域*/
System.out.println("第一个元素是:" + list.getFirst());
/*获取最后一个元素,即header的previous域*/
System.out.println("最后一个元素是:"+list.getLast());
}
}
3、hashset
public static void main(String[] args) {
Set set = new HashSet();
set.add("a");
set.add("b");
System.out.println(set);
Student stu= new Student(18, "小名", 60);
set.add(stu);//调用第一个对象的hashcode方法 调 equals
set.add(new Student(19, "小明", 60));
set.add(new Student(19, "小明", 60));
set.add(new Student(20, "小明", 61));
System.out.println(set);
}
4、treeset
import java.util.ArrayList;
import java.util.HashSet;
import java.util.TreeSet;
/**
* 使用treeset存放一组学生成绩
* 1、可以自动排序(系统类 自然排序)
* 2、不可重复(去重)
* 3、只能存放一种数据类型
* ---存放到 treeset中的元素必须要具有比较能力
* 调用compareTo() 如果得到的结果为0 ， 两个元素相等
* 1 ---》排到后面
* -1 --->排到前面
*
* hashset:-->hashtable(哈希表)
* treeset:-->二叉树，红黑树算法
* 每存入一个元素就会调用一次compareTo方法
* @author Administrator
*
*/
import java.util.Comparator;
/**
* 外部比较器，当系统类提供的比较规则满足不了需求时使用
* 1、自己创建一个比较器 实现 Comprator接口 ，添加一个泛型（需要比较的数据类型）
* 2、重写comprae方法,用来比较，参数是两个需要比较的对象
* @author Administrator
*
*/
public class MyStrCompartor implements Comparator<String>{
@Override
public int compare(String o1, String o2) {
//按照字符串长度排序
return o1.length() - o2.length();
}
}
public class TestTreeSet02 {
public static void main(String[] args) {
//使用外部比较器，
//1 拿到比较器的对象
MyStrCompartor mcom = new MyStrCompartor();
//2在创建集合时，调用有参的构造方法，把比较器传进去
//3、在treeset中添加元素时，会优先调用自定义比较器的方法
//treeset专用
TreeSet ts = new TreeSet(mcom);
// ts.add(20);//自动装箱
// ts.add(1);
// ts.add(100);
// ts.add(7);
// ts.add(8);
// ts.add(100);
System.out.println(ts);
//需求：不希望按照系统的排序来排列
//自己创建一个比较规则
ts.add("xiaomi32313");
ts.add("zhangliguo5");
ts.add("asima1");
ts.add("baibaibai4");
ts.add("sansan2");
// ts.add(new Student("yushen", 19, 19));
// ts.add(new Student("xiaoming", 19, 19));
// ts.add(new Student("axiaoming1", 19, 18));
System.out.println(ts);
}
}
5、hashmap
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* HashMap的使用
* @author erqing
*
*/
public class MapTest {
public static void main(String[] args) {
/* 初始化map */
Map<String, Integer> map = new HashMap<String, Integer>();
System.out.println("HashMap的初始值:" + map.size());
System.out.println("HashMap是否为空:" + (map.isEmpty() ? "是" : "否"));
/* 想map中添加元素 */
map.put("erqing", 1);
map.put("niuniu", 2);
map.put("egg", 3);
System.out.println(map.size());
;
System.out.println("HashMap是否为空:" + (map.isEmpty() ? "是" : "否"));
/* 遍历HashMap中的元素 */
Set<String> set = map.keySet();
for (String s : set) {
System.out.println(s + " " + map.get(s) + " " + "hashcode:"
+ s.hashCode());
}
/*检测是否含有某个Key*/
System.out.println(map.containsKey("egg"));
/*检测是否含有某个Value*/
System.out.println(map.containsValue(2));
/*打印hashCode*/
System.out.println(map.hashCode());
}
}
/*
输出：
HashMap的初始值:0
HashMap是否为空:是
3
HashMap是否为空:否
niuniu 2 hashcode:-1045196352
egg 3 hashcode:100357
erqing 1 hashcode:-1294670850
true
true
1955200455
*/
6、treemap
public static void main(String[] args) {
SortedMap<String, Integer> map = new TreeMap<String, Integer>();
map.put("zgg", 1);
map.put("erqing", 3);
map.put("niu", 0);
map.put("abc", 2);
map.put("aaa", 5);
// map.put(1004, new Student("04",18 ,1004));
// map.put(1005, new Student("05",18 ,1005)); 也能存new
Set<String> keySet = map.keySet();
for (String string : keySet) {
System.out.print(map.get(string)+" ");
}
}
//输出：5 2 3 0 1
更多内容：http://blog.csdn.net/zhangerqing/article/details/8122075