java-基础-基本数据类型

引用原文：

http://www.cnblogs.com/zhenjing/archive/2013/04/25/java_Container.html

//http://blog.csdn.net/mad1989/article/details/26389541

线性表，链表，哈希表是常用的数据结构

Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap

Collection接口

　 　Collection是最基本的集合接口，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
　　 如何遍历Collection中的每一个元素：
　　　　Iterator it = collection.iterator(); // 获得一个迭代子
　　　　while(it.hasNext()) {
　　　　　　Object obj = it.next(); // 得到下一个元素
　　　　}

List接口

　　List是有序的Collection，List允许有相同的元素。
　 　除具有iterator()方法外，有listIterator()方法，返回一个 ListIterator接口多了一些add()之类的方法，允许添加，删除，设定元素， 还能向前或向后遍历。
　　实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

LinkedList类

　 　允许null元素。提供额外的get，remove，insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
　　注意没有同步方法。多个线程必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
　　List list = Collections.synchronizedList(new LinkedList(...));

ArrayList类

　　ArrayList实现了可变大小的数组。ArrayList没有同步。
　   每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并 没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。

Vector类

　 　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的 Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例 如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该 异常。

Stack 类

　　 Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。

Set接口

　　Set是一种不包含重复的元素的Collection
　　请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。

Map接口

　 　请注意，Map没有继承Collection接口，Map提供key到value的映射。

Hashtable类

　　Hashtable继承Map接口，实现一个key-value映射的哈希表。
　　添加数据使用put(key, value)，取出数据使用get(key)，时间开销为常数。
Hashtable 通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。
使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：
　　　　Hashtable numbers = new Hashtable();
　　　　numbers.put(“one”, new Integer(1));
　　　　numbers.put(“two”, new Integer(2));
　　　　numbers.put(“three”, new Integer(3));
　　要取出一个数，比如2，用相应的key：
　　　　Integer n = (Integer)numbers.get(“two”);
　　　　System.out.println(“two = ” + n);
　 　由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方 法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相 同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如 果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希 表的操作。
　　避免相同的对象有不同的hashCode：要同时复写equals方法和hashCode方法
　　Hashtable是同步的。

HashMap类

　 　HashMap和Hashtable类似，HashMap是非同步的，并且允许null，即null value和null key

WeakHashMap类

　　WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。

总结
　　如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。
　　如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。
　　要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
　　尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。

Map简单应用

public static void main(String[] args){        //Map<String,String> pets=new HashMap<String, String>();        Map<String,String> pets=new TreeMap<String, String>();        pets.put("1","张三");        pets.put("2","李四");        pets.put("3","王五");        if (pets.containsKey("1")){            System.out.println("已存在键1");        }        if (pets.containsValue("张三")){            System.out.println("已存在值张三");        }        Set<String> sets=pets.keySet();        Set<Map.Entry<String , String>> entrySet= pets.entrySet();        Collection<String> values=  pets.values();        for (String value:values){            System.out.println(value+";");        }       for (String key:sets){           System.out.print(key+";");       }        for (Map.Entry entry:entrySet){            System.out.println("键："+entry.getKey());            System.out.println("值："+entry.getValue());        }    }

String、StringBuffer、StringBuilder区别

String类是不可变类，任何对String的改变都 会引发新的String对象的生成；

StringBuffer则是可变类，任何对它所指代的字符串的改变都不会产生新的对象。StringBufferd支持并发操作，线性安全的，适合多线程中使用

StringBuilder类不是线程安全的，但其在单线程中的性能比StringBuffer高。

基本应用示例

package com.scalalearn.java.main.JavaContainer;/** * Created by hjw on 17/5/19. */import java.lang.String;import java.util.*;//http://www.cnblogs.com/zhenjing/archive/2013/04/25/java_Container.html//http://blog.csdn.net/mad1989/article/details/26389541public class ContainerLearn {    public static void main(String[] args) throws Exception {        System.out.println("\n============StringBuffer====StringBuilder============");        {            //StringBuffer常用方法（StringBuffer和StringBuilder在使用上几乎一样）            //------初始化-----            StringBuilder s = new StringBuilder();            //分配了长度512字节的字符缓冲区。            StringBuilder sb1 = new StringBuilder(512);            //创建带有内容的StringBuilder对象，在字符缓冲区中存放字符串“how are you?”            StringBuilder sb2 = new StringBuilder("how are you?");            //-------append方法            //该方法的作用是追加内容到当前StringBuilder对象的末尾，类似于字符串的连接，调用该方法以后，StringBuilder对象的内容也发生改 变，例如：            StringBuilder sb3 = new StringBuilder("abc");            //则对象sb3的值将变成”abcappend”            sb3.append("append");            //装成最后所用的字符串            sb3.toString();            // ------deleteCharAt方法            //该方法的作用是删除指定位置的字符，然后将剩余的内容形成新的字符串。例如：            StringBuilder sb = new StringBuilder("KMing");            sb. deleteCharAt(1);            //该代码的作用删除字符串对象sb中索引值为1的字符，也就是删除第二个字符，剩余的内容组成一个新的字符串。所以对象sb的值变 为”King”。            System.out.println(sb);            //-------delete方法：            //public StringBuffer delete(int start,int end)            //该方法的作用是删除指定区间以内的所有字符，包含start，不包含end索引值的区间。例如：            StringBuilder sb4 = new StringBuilder("TestString");            //该代码的作用是删除索引值1(包括)到索引值4(不包括)之间的所有字符，剩余的字符形成新的字符串。则对象sb的值是”TString”。             System.out.println(sb4.delete (1,4));            // ----insert方法            //public StringBuffer insert(int offset, boolean b),            // 该方法的作用是在StringBuilder对象中插入内容，然后形成新的字符串。例如：            StringBuilder sb5 = new StringBuilder("TestString");            // 该示例代码的作用是在对象sb的索引值4的位置插入false值，形成新的字符串，则执行以后对象sb的值是”TestfalseString”。            System.out.println(sb5.insert(4,false));            //---reverse方法            //该方法的作用是将StringBuilder对象中的内容反转，然后形成新的字符串。例如：            StringBuilder sb6 = new StringBuilder("abc");            //经过反转以后，对象sb中的内容将变为”cba”。            System.out.println(sb6.reverse());;            //-----setCharAt方法            //该方法的作用是修改对象中索引值为index位置的字符为新的字符ch,返回值为void。例如：            StringBuilder sb7 = new StringBuilder("abc");            //则对象sb的值将变成”aDc”。            sb7.setCharAt(1,'D');            System.out.println(sb7);            // -----trimToSize方法            //    public void trimToSize()            //    该方法的作用是将StringBuffer对象的中存储空间缩小到和字符串长度一样的长度，减少空间的浪费，和String的trim()是一样的作用            //   sb.capacity方法            //   该方法的作用是获取字符串的容量。            StringBuilder sb8 = new StringBuilder(8);            sb8.append("abc");            System.out.println("sb8.capacity:" + sb8.capacity() + "\tsb8.length:" + sb8.length());            //sb8.capacity:8   sb8.length:3            sb8.trimToSize();            System.out.println("sb8.capacity:" + sb8.length());            //sb8.capacity:3           // -----setlength方法           //    该方法的作用是设置字符串缓冲区大小。           //    sb.ensureCapacity(32); //预先设置sb的容量为32,该方法的作用是重新设置字符串容量的大小。            StringBuilder sb9=new StringBuilder("abcd");            // 如果用小于当前字符串长度的值调用setlength()方法，则新长度后面的字符将丢失。            sb9.setLength(3);            System.out.println(sb9);            //abc                        // ----getChars方法            //    该方法的作用是将字符串的子字符串复制给数组。            //    getChars(int start,int end,char chars[],int charStart);             StringBuffer sb10 = new StringBuffer("I love You");            int begin = 0;            int end = 5;            //    //注意ch字符数组的长度一定要大于等于begin到end之间字符的长度            //    //小于的话会报ArrayIndexOutOfBoundsException            //    //如果大于的话，大于的字符会以空格补齐            char[] ch  = new char[end-begin];            sb10.getChars(begin, end, ch, 0);            System.out.println(ch);            //I lov        }                // Interfaces:        // Interface Iterator: hasNext(),  next(), remove() ---- 所有容器通用的遍历方式。        // Interface Collection：add(E e)，remove(Object o), clear(), isEmpty(), size(), iterator(), toArray() ---- 所有单值容器(map除外)的公共接口。        // Interface Map: put(K key, V value), get(Object key), remove(Object key), clear()，isEmpty()，size(), keySet(), entrySet(), values()  ---- 所有K-V容器的公共接口，常见class: HashMap, Hashtable, IdentityHashMap, LinkedHashMap, ConcurrentHashMap        // Interface Map.Entry: getKey(), getValue(), setValue(V value) ---- 用于遍历Map容器。        // ============Arrays============        {            System.out.println("\n============Arrays============");            String[] array = new String[] { "a", "b", "c" };            //-----转List            List list = Arrays.asList(array);            //List.size            for (int i = 0; i < list.size(); i++) {                System.out.print(list.get(i) + ";");            }            //foreach            System.out.println();            for (Object val : array) {                System.out.print( val + ";");            }        }        // ============ArrayList============        {            System.out.println("============ArrayList============");            ArrayList arraylist = new ArrayList();            /*            add()直接添加到最后            add(index,value)在index位置添加元素,该位置及之后的原值依次后移,当index>目前的length抛出异常IndexOutOfBoundsException            set(index,value)更改index位置处的元素             */            arraylist.add(0, "end");//指定索引加入值            for (int i = 0; i < 2; i++) {                arraylist.add(i, String.valueOf(i));            }            System.out.println(arraylist);            //[0, 1, end]            System.out.println("ArrayList's lastIndexOf(\"end\") is " + arraylist.lastIndexOf("end"));            System.out.println("ArrayList's lastIndexOf(\"0\") is " + arraylist.lastIndexOf("0"));            System.out.println("ArrayList's lastIndexOf(\"1\") is " + arraylist.lastIndexOf("1"));            System.out.println();            //  ArrayList's lastIndexOf("end") is 2            //  ArrayList's lastIndexOf("0") is 0            //  ArrayList's lastIndexOf("1") is 1            arraylist.add("2");            System.out.println(arraylist);            //  [0, 1, end, 2]            System.out.println("ArrayList's lastIndexOf(\"2\") is " + arraylist.lastIndexOf("2"));            //  ArrayList's lastIndexOf("2") is 3            //  arraylist.add(5,"3");            //  java.lang.IndexOutOfBoundsException: Index: 5, Size: 4            arraylist.add(3,"3");            // [0, 1, end, 3, 2]            System.out.println(arraylist);            arraylist.set(3,"4");            System.out.println(arraylist);            // [0, 1, end, 4, 2]            System.out.print("ArrayList遍历1:");            for (Object val : arraylist) {                System.out.print( val + ";");            }            System.out.println();            System.out.print("ArrayList遍历2:");            for (int i = 0; i < arraylist.size(); i++) {                System.out.print(arraylist.get(i) + ";");            }        }         // ============Vector============        {            System.out.println("\n============Vector============");            Vector vector = new Vector();            vector.add(0, "b");            vector.add("a");            vector.addElement("d");            vector.add("c");            System.out.println(vector);            vector.set(2, "h");//替换掉指定索引的元素            System.out.println(vector);            Object[] str = vector.toArray();            for (int i = 0; i < str.length; i++) {                System.out.print(str[i] + ";");            }            vector.setSize(2);//重新设置大小为2            System.out.println(" " + vector);        }        // ============LinkedList============        {            System.out.println("\n============LinkedList============");            LinkedList linkedlist = new LinkedList();//自由使用是它的特色            linkedlist.add("a");            linkedlist.add(1, "c");            linkedlist.addLast("b");            linkedlist.addFirst("d");            System.out.println(" LinkedList:");            System.out.println(linkedlist);            // linkedlist.clear();//该方法清空容器            // linkedlist.remove(0);//删除索引为0的元素            // linkedlist.remove("d");//删除值为d的元素            // linkedlist.removeFirst();//删除第一个元素            // linkedlist.removeLast();//删除最后一个元素            for (int i = 0; i < linkedlist.size(); i++) {                System.out.print(linkedlist.get(i) + ";");            }            System.out.println("\n");        }        // ============Stack============        {            System.out.println("\n============Stack============");            Stack stack = new Stack();//堆栈            stack.add("b");            stack.add(0, "c");            stack.push("d");            stack.add("e");            stack.push("a");            System.out.println(stack);            //[c, b, d, e, a]            System.out.println("peek:" + stack.peek());            //peek:a            System.out.print("遍历(是从底开始的):");            Enumeration enumeration = stack.elements();            while (enumeration.hasMoreElements()) {                System.out.print(enumeration.nextElement() + ";");            }            //遍历(是从底开始的):c;b;d;e;a;            // 后进先出            System.out.println("\npop:" + stack.pop());            //pop:a            //是否包含该元素            System.out.println(stack.contains("d") + ";" + stack.contains("a"));            //检索是从栈顶开始(栈顶index=0)            System.out.println(stack.search("c"));            System.out.println("\n");        }        // ============Collections============        {            System.out.println("\n============Collections============");            String[] array = new String[] { "a", "b", "c" };            List list = Arrays.asList(array);            //Collections.fill            Collections.fill(list, "Fill");//用Fill填充全部元素            for (int i = 0; i < list.size(); i++) {                System.out.print(list.get(i) + ";");            }            //Collections.copy            array = new String[] { "1", "2", "3" };            List list2 = Arrays.asList(array);            Collections.copy(list, list2);//拷贝list2的数据进list            System.out.println(" " + list);            //Collections.swap            Collections.swap(list, 2, 1);//调换索引为1和2的元素的位置            System.out.println(list);            //============Collections============            //Fill;Fill;Fill; [1, 2, 3]            //[1, 3, 2]        }          // ============HashMap=====LinkedHashMap====TreeMap===        {            System.out.println("\n============HashMap============");            HashMap hashmap = new HashMap();//一个速度最快的容器            hashmap.put("0", "c");            hashmap.put("1", "a");            System.out.println(hashmap);//该容器有其内部的排序方式            System.out.println(hashmap.containsKey("1"));//是否包含这个键            System.out.println(hashmap.containsValue("c"));//是否包含值            Set set = hashmap.keySet();//获取全部键            System.out.println("\nHashMap: K-V");            Iterator iterator = set.iterator();            while (iterator.hasNext()) {                Object key = iterator.next();                System.out.print(key+":"+hashmap.get(key) + ";");            }            System.out.println("\nHashMap(Entry): K-V");            Set<Map.Entry> kvSet = hashmap.entrySet();            Iterator<Map.Entry> it = kvSet.iterator();            while (it.hasNext()){                Map.Entry entry = it.next();                System.out.print( entry.getKey()+":" + entry.getValue() +";");            }            System.out.println();            for (Map.Entry entry:(Set<Map.Entry>)hashmap.entrySet()){                System.out.print("键："+entry.getKey());                System.out.print("-值："+entry.getValue() + " ;");            }            System.out.println("\n");        }        // ============HashSet====LinkedHashSet=====TreeSet===        {            System.out.println("\n============HashSet============");            HashSet hashset = new HashSet();//一个绝对不能重复的类型            hashset.add("c");            hashset.add("b");            hashset.add("a");            hashset.add("a");            hashset.add("b");            System.out.println(hashset);            Iterator iterator = hashset.iterator();//取出元素            while (iterator.hasNext()) {                System.out.print(iterator.next() + ";");            }            System.out.println("\n");        }        // Hashtable        {            System.out.println("\n============Hashtable============");            Hashtable hashtable = new Hashtable();//线程同步的            hashtable.put("0", "c");            hashtable.put("1", "a");            hashtable.put("3", "c");            hashtable.put("2", "b");            Enumeration enumeration = hashtable.elements();//获取元素，Enumeration已经不是主流，Iterator是它的下一代替代品            while (enumeration.hasMoreElements()) {                System.out.print(enumeration.nextElement() + ";");            }            System.out.println("\n");        }    }}