java中的数据结构

1.链表的使用

使用时需要import java.util.List 和 java.util.ArrayList

　　 //返回list中的元素个数
    int size();        
  
    //判断list中是否包含元素，如果不包含返回true
    boolean isEmpty();        
    
    //判断list中是否包含某个特定的对象
    boolean contains(Object o);    
    
    //以正确的顺序返回list中元素的迭代器    
    Iterator<E> iterator();
    
    //返回一个包含list中所有元素的数组，数组中元素的顺序和list中的顺序一样
    //这个方法可以当做array-based 和 collection-based API之间的桥梁
    Object[] toArray();        
    
    //返回一个包含list中所有元素的数组，数组中元素的顺序和list中的顺序一样
    //array数组的类型是确定的。如果指定的array大小不足，这个方法将会生成一个新的数组用于返回
    //新数组的类型和运行时的数组类型一样
    <T> T[] toArray(T[] a);
    
    //在list的末尾插入元素（实现类可以选择插入的位置）
    boolean add(E e);
    
    //如果指定元素存在list中，移除list中第一次出现的指定元素（实现类可以选择具体的实现）
    boolean remove(Object o);
    
    //判断list中是否包含某个集合
    boolean containsAll(Collection<?> c);
    
    //将指定集合中的所有元素加到list的末尾
    boolean addAll(Collection<? extends E> c);
    
    //在指定位置插入指定集合
    boolean addAll(int index, Collection<? extends E> c);
    
    //删除list中包含的Collection中的所有元素
    boolean removeAll(Collection<?> c);
    
    //保留list中包含的Collection中的所有元素
    boolean retainAll(Collection<?> c);
    
    //将该列表的每个元素替换为将该运算符应用于该元素的结果。
    default void replaceAll(UnaryOperator<E> operator);
    
    //对list中的元素排列
    default void sort(Comparator<? super E> c);
    
    //删除list中的所有元素
    void clear();
    
    boolean equals(Object o);
    
    int hashCode();
    
    //根据索引获取list中的元素
    E get(int index);
    
    //用指定元素替换指定位置上的元素
    E set(int index, E element);
    
    //在指定位置上增加指定元素
    void add(int index, E element);
    
    //删除指定索引上的元素
    E remove(int index);
    
    //获取对象的第一个索引
    int indexOf(Object o);
    
    //获取对象的最后一个索引
    int lastIndexOf(Object o);
    
    //返回list的list 迭代器
    ListIterator<E> listIterator();
    
    //从指定位置返回list的迭代器
    ListIterator<E> listIterator(int index);
    
    //返回list的子list
    List<E> subList(int fromIndex, int toIndex);
    
    //Creates a {@link Spliterator} over the elements in this list.
    default Spliterator<E> spliterator()

import java.util.ArrayList;
import java.util.List;

class Item {
    private int count;
    public Item(int count) {
        this.count = count;
    }
    public int getCount() {
        return count;
    }

}

class Meal {
    private ArrayList<Item> items = new ArrayList<Item>();

    void addItem(Item item) {
        items.add(item);
    }

    int sum_count() {
        int count =  0;
        for (Item i : items) {
            count += i.getCount();
        }
        return count;
    }

}

public class BuilderPatternDemo {
    public static void main(String args[]) {
        Item item1 = new Item(10);
        Item item2 = new Item(20);
        Item item3 = new Item(30);

        Meal meal1 = new Meal();

        meal1.addItem(item1);
        meal1.addItem(item2);
        meal1.addItem(item3);
        System.out.println("Sum=" + meal1.sum_count());
    }
}

error: List is abstract; cannot be instantiated
        List<Person> maleMeet = new List<Person>();
                                ^
应该修改为：List<Person> maleMeet = new ArrayList<Person>(); //List是个抽象类，ArrayList是List的实现子类。

参考：
https://www.cnblogs.com/cuglkb/p/7027907.html
https://www.cnblogs.com/Lxiaojiang/p/6231724.html

 

3.HashTable和HashMap

1.Hashtable简介
(1)Hashtable 是一个散列表，它存储的内容是键值对(key-value)映射。
(2)Hashtable 继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口。
(3)Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。

2.使用Demo(在遍历时使用是三种遍历方式来对其进行遍历)

package ThreeWeek;
 
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
 
public class HashTableTest {
 
        public static void main(String args[]){
                Hashtable<String, Integer> table = new Hashtable<String, Integer>();
                
                //[1]添加元素
                table.put("zhangsan", 22);
                table.put("lisi", 33);
                table.put("wangwu", 44);
                table.put("houliu", 55);
                
                //[2]toString()方式打印
                System.out.println(table.toString());
                
                //[3]Iterator遍历方式1--键值对遍历entrySet()
                Iterator<Entry<String, Integer>> iter = table.entrySet().iterator();
                while(iter.hasNext()){
                        Map.Entry<String, Integer> entry = (Map.Entry<String, Integer>)iter.next();
                        String key = entry.getKey();
                        int value = entry.getValue();
                        System.out.println("entrySet:"+key+" "+value);
                }
                
                System.out.println("====================================");
                
                //[4]Iterator遍历方式2--key键的遍历
                Iterator<String> iterator = table.keySet().iterator();
                while(iterator.hasNext()){
                        String key = (String)iterator.next();
                        int value = table.get(key);
                        System.out.println("keySet:"+key+" "+value);
                }
                
                System.out.println("====================================");
                
                //[5]通过Enumeration来遍历Hashtable
                Enumeration<String> enu = table.keys();
                while(enu.hasMoreElements()) {
                    System.out.println("Enumeration:"+table.keys()+" "+enu.nextElement());
                } 
                        
        }
}

/*
编译执行：
$ javac -d ./ HashTableTest.java
$ java ThreeWeek.HashTableTest

{houliu=55, zhangsan=22, lisi=33, wangwu=44}
entrySet:houliu 55
entrySet:zhangsan 22
entrySet:lisi 33
entrySet:wangwu 44
====================================
keySet:houliu 55
keySet:zhangsan 22
keySet:lisi 33
keySet:wangwu 44
====================================
Enumeration:java.util.Hashtable$Enumerator@120f0be houliu
Enumeration:java.util.Hashtable$Enumerator@199d4a86 zhangsan
Enumeration:java.util.Hashtable$Enumerator@2587b08d lisi
Enumeration:java.util.Hashtable$Enumerator@6f580c3a wangwu
*/

3.继承关系

java.lang.Object
    java.util.Dictionary<K, V>
        java.util.Hashtable<K, V>
 
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable { }

4.Hashtable和HashMap的区别
(1)基类不同：HashTable基于Dictionary类，而HashMap是基于AbstractMap。Dictionary是任何可将键映射到相应值的类的抽象父类，而AbstractMap是基于Map接口的骨干实现，它以最大限度地减少实现此接口所需的工作。
(2)null不同：HashMap可以允许存在一个为null的key和任意个为null的value，但是HashTable中的key和value都不允许为null。
(3)线程安全：HashMap只是单线程安全的，Hashtable是多线程安全的。
(4)遍历不同：HashMap仅支持Iterator的遍历方式，Hashtable支持Iterator和Enumeration两种遍历方式。

参考：
https://blog.csdn.net/jinhuoxingkong/article/details/52022999
http://www.importnew.com/24822.html