Collection接口：
说出ArrayList,Vector, LinkedList的存储性能和特性
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
List, Set, Map是否继承自Collection接口?
List，Set是，Map不是
测试addAll与containsAll：
import java.util.ArrayList;
import java.util.Collection;
public class testAddAllandContaintsAll {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Collection c1 = new ArrayList<String>();
c1.add("java");
c1.add("C++");
c1.add("php");
System.out.println(c1);
Collection c2 = new ArrayList<String>();
c2.addAll(c1);
System.out.println(c2);
Collection c3 = new ArrayList<String>();
c3.add("java");
c3.add("php");
System.out.println(c1.containsAll(c3)); //true
}
}
使用Iterator的hasNext方法，next方法遍历集合，还有remove删除：
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* iterator用法演示代码
* @author 小宇
*/
public class IteratorDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Collection<String> col = new ArrayList<String>();
col.add("令狐冲");
col.add("乃是");
col.add("豪杰之士");
//返回Iterator接口实现
Iterator<String> iter = col.iterator();
System.out.println("删除: 乃是");
while(iter.hasNext())
{
String s = iter.next();
System.out.print(s);
if(s == "乃是")
iter.remove();
}
System.out.println();
Object[] ss = col.toArray();
System.out.println("删除之后的内容");
for(int i = 0; i <ss.length;i++ )
System.out.print(ss[i]);
}
}
新的循环方法：
import java.util.ArrayList;
import java.util.Collection;
public class XinXunhuan {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Collection<String> c = new ArrayList<String>();
c.add("sb张磊");
c.add("2b林卓俊");
c.add("都是傻逼");
for(String str:c){
System.out.println(str);
}
}
}
Collection与Collections的区别：
Collection是集合类的上级接口，继承与他的接口主要有Set 和List。
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
List接口：
包括get(),set(),插入，移除，subList(),数组与list的转换
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class testList {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
List<String> list = new ArrayList<String>();
list.add("古德里安");
list.add("邓尼茨");
list.add("曼施坦因");
list.add("隆美尔");
//get方法遍历list
for(int i = 0; i < list.size(); i++){
System.out.println(list.get(i).toUpperCase());
}
String value = list.set(1, "元首");
System.out.println(value);
System.out.println(list);
//交换一和三上的元素
list.set(1,list.set(3, list.get(1)));
System.out.println(list);
//插入和移除数据
list.add(2,"阿道夫");
System.out.println(list);
list.remove(2);
System.out.println(list);
//subList
List<String> subList = list.subList(2, 4);
System.out.println(subList);
//将list转换为数组
String[] strArr = list.toArray(new String[]{});
System.out.println(Arrays.toString(strArr));
//将数组转换为List
String[] strArr0 = {"a","b","c"};
List<String> list0 = Arrays.asList(strArr0);
System.out.println(list0);
}
}
Collections.sort()实现排序：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
public class testSort {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
List<Integer> list = new ArrayList<Integer>();
Random r = new Random(1);
for(int i = 0; i < 10; i++){
list.add(r.nextInt(100));
}
System.out.println(list);
Collections.sort(list);
System.out.println(list);
}
}
Comparator设置比较条件可以给对象元素排序
Queue：
import java.util.LinkedList;
import java.util.Queue;
public class testQueue {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Queue<String> queue = new LinkedList<String>();
queue.offer("a");
queue.offer("b");
queue.offer("c");
System.out.println(queue );
String str = queue.peek();
System.out.println(str);
while(queue.size() > 0){
str= queue.poll();
System.out.println(str +" ");
}
}
}
Deque:
import java.util.Deque;
import java.util.LinkedList;
public class testStack {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Deque<String> stack = new LinkedList<String>();
stack.push("a");
stack.push("b");
stack.push("c");
System.out.println(stack);
String str = stack.peek();
System.out.println(str);//c
while(stack.size() > 0){
str = stack.pop();
System.out.print(str + " ");
}
}
}
Map:
put():
get():
containsKey():
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class testHashMap
{
public static void main(String[] args)
{
String str = "ab=43,de=56,er=8,yu=12,sd=35";
String[] arr = str.split("[,=]");
Map<String,Integer> map = new HashMap<String,Integer>();
for(int i = 0; i < arr.length; i += 2)
{
if(!map.containsKey(arr[i]) ||
Integer.parseInt(arr[i + 1]) > map.get(arr[i]))
{
map.put(arr[i], Integer.parseInt(arr[i + 1]));
}
}
System.out.println(map);
//使用迭代key的方式遍历集合map
Set<String> keys = map.keySet();
for(String key:keys)
{
System.out.println(key + ":" + map.get(key));
}
}
}Hashtable与HashMap区别：
第一个不同主要是历史原因。Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。
也许最重要的不同是Hashtable的方法是同步的，而HashMap的方法不是。这就意味着，虽然你可以不用采取任何特殊的行为就可以在一个多线程的应用程序中用一个Hashtable，但你必须同样地为一个HashMap提供外同步。一个方便的方法就是利用Collections类的静态的synchronizedMap()方法，它创建一个线程安全的Map对象，并把它作为一个封装的对象来返回。这个对象的方法可以让你同步访问潜在的HashMap。这么做的结果就是当你不需要同步时，你不能切断Hashtable中的同步（比如在一个单线程的应用程序中），而且同步增加了很多处理费用。
第三点不同是，只有HashMap可以让你将空值作为一个表的条目的key或value。HashMap中只有一条记录可以是一个空的key，但任意数量的条目可以是空的value。这就是说，如果在表中没有发现搜索键，或者如果发现了搜索键，但它是一个空的值，那么get()将返回null。如果有必要，用containKey()方法来区别这两种情况。
