Skip to main content
 首页 » 编程设计

java中的数据结构

2022年07月19日136TianFang

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


本文参考链接：https://www.cnblogs.com/hellokitty2/p/10663078.html
  文章来源：
  https://www.itguest.com/post/gjd2b7.html
阅读延展