一、理论部分
1、栈
（1）栈是一种特殊的线性表，是一种后进先出的结构。（2）栈是限定仅在表尾进行插入和删除运算的线性表，表尾称为栈顶，表头称为栈底。（3）栈的物理存储可以用顺序存储结构，也可以用链式存储结构。2、队列（1）队列是限定所有的插入只能在表的一端进行，而所有的删除都在表的另一端进行的线性表。
（2）表中允许插入的一端称为队尾，允许删除的一端称为队头。
（3）队列的操作是按先进先出的原则进行的。
（4）队列的物理存储可以用顺序存储结构，也可以用链式存储结构。
3、散列表又称为哈希表。散列表算法的基本思想是：以结点的关键字为变量，通过一定的函数关系计算出对应的函数值，以这个值作为该结点存储在散列表中的地址。
4、JAVA的集合框架实现对各种数据结构的封装，以降低对数据管理与处理的难度。
5、所谓框架就是一个类库的集合，框架中包含很多超类，编程者创建这些超类的子类可较方便的设计设计程序所需的类。例如：Swing类包6、Java的集合类包含在java.util包中。
7、集合类的特点（1）只容纳对象。
（2）集合类容纳的对象都是Object类的实例，一旦把一个对象置入集合类中，它的类信息将丢失，这样设计的目的是为了集合类的通用性。
8、Vector类
（1）Vector类类似长度可变的数组。（2）Vector中只能存放对象。（3）Vector的元素通过下标进行访问。（4） Vector类关键属性：a.capacity表示集合最多能容纳的元素个数。b.capacityIncrement表示每次增加多少容量。c.size表示集合当前元素个数。9、Stack类是Vector的子类。10、Hashtable通过键来查找元素。Hashtable用散列码（hashcode）来确定键。所有对象都有一个散列码，可以通过Object类的hashCode()方法获得。
二、实验部分
1、实验目的与要求
(1) 掌握Vetor、Stack、Hashtable三个类的用途及常用API；
(2) 了解java集合框架体系组成；
(3) 掌握ArrayList、LinkList两个类的用途及常用API。
(4) 了解HashSet类、TreeSet类的用途及常用API。
(5)了解HashMap、TreeMap两个类的用途及常用API；
(6) 结对编程（Pair programming）练习，体验程序开发中的两人合作。
import java.util.Vector; class Cat { private int catNumber; Cat(int i) { catNumber = i; } void print() { System.out.println("Cat #" + catNumber); } } class Dog { private int dogNumber; Dog(int i) { dogNumber = i; } void print() { System.out.println("Dog #" + dogNumber); } } public class Test { public static void main(String[] args) { Vector cats = new Vector(); for (int i = 0; i < 7; i++) cats.addElement(new Cat(i)); cats.addElement(new Dog(7)); //cats.addElement(new Cat(7)); for (int i = 0; i < cats.size(); i++) { if(cats.elementAt(i) instanceof Cat) ( (Cat) cats.elementAt(i) ).print(); else( (Dog) cats.elementAt(i) ).print(); } } }
import java.util.*; public class Test1 { static String[] months = { "1", "2", "3", "4" }; public static void main(String[] args) { Stack stk = new Stack(); //构造一个新栈 for (int i = 0; i < months.length; i++) stk.push(months[i]); //1 2 3 4按顺序进栈 System.out.println(stk); System.out.println("element 2=" + stk.elementAt(2)); while (!stk.empty()) System.out.println(stk.pop()); //弹出并返回栈顶元素 } }
import java.util.*; class Counter { int i = 1; public String toString() { return Integer.toString(i)+"\n"; } } public class Test1 { public static void main(String[] args) { Hashtable ht = new Hashtable(); for (int i = 0; i < 10000; i++) { Integer r = new Integer((int)(Math.random() * 20)); if (ht.containsKey(r)) //判断r是否为ht中的值 ((Counter) ht.get(r)).i++; //累计r出现的次数 else ht.put(r, new Counter()); } System.out.println(ht); } }
import java.util.*; public class Test { public static void main(String[] argv) { ArrayList al = new ArrayList(); al.add(new Integer(11)); al.add(new Integer(12)); al.add(new Integer(13)); al.add(new String("hello")); //将11 12 13 hello加入al中 System.out.println("Retrieving by index:"); for (int i = 0; i < al.size(); i++) { System.out.println("Element " + i + " = " + al.get(i)); } } }
import java.util.*; public class Test { public static void main(String[] argv) { LinkedList l = new LinkedList(); l.add(new Object()); l.add("Hello"); l.add("zhangsan"); ListIterator li = l.listIterator(0);//列表迭代器 返回第一次调用next给定索引的元素 while (li.hasNext()) System.out.println(li.next()); if (l.indexOf("Hello") < 0) System.err.println("Lookup does not work"); //l中没有“hello”执行 else System.err.println("Lookup works"); } }
import java.util.*; public class Test { public static void main(String[] argv) { HashSet h = new HashSet(); //也可以 Set h=new HashSet() //构造一个空散列集 h.add("One"); h.add("Two"); h.add("One"); // 重复拥有相等的散列码 h.add("Three"); Iterator it = h.iterator(); while (it.hasNext()) { System.out.println(it.next()); } } }
import java.util.*; public class Test { public static void main(String[] argv) { HashMap h = new HashMap();//map 映射数据结构 存放键/值对 // The hash maps from company name to address. h.put("Adobe", "Mountain View, CA"); h.put("IBM", "White Plains, NY"); h.put("Sun", "Mountain View, CA"); String queryString = "Adobe"; String resultString = (String)h.get(queryString); //键Adobe 对应值为 "Mountain View, CA" System.out.println("They are located in: " + resultString); } } import java.util.*; /** * This program demonstrates operations on linked lists. * @version 1.11 2012-01-26 * @author Cay Horstmann */ public class LinkedListTest { public static void main(String[] args) { List<String> a = new LinkedList<>(); a.add("Amy"); a.add("Carl"); a.add("Erica"); List<String> b = new LinkedList<>(); b.add("Bob"); b.add("Doug"); b.add("Frances"); b.add("Gloria"); ListIterator<String> aIter = a.listIterator(); Iterator<String> bIter = b.iterator(); while (bIter.hasNext()) { if (aIter.hasNext()) aIter.next(); aIter.add(bIter.next()); } System.out.println("a:"+a); System.out.println("b:"+b); bIter = b.iterator(); System.out.println("b:"+b); while (bIter.hasNext()) { bIter.next(); // skip one element if (bIter.hasNext()) { bIter.next(); // skip next element bIter.remove(); // 执行删除操作 } } //删除b中 第二个第四个元素 System.out.println("b:"+b); // bulk operation: remove all words in b from a a.removeAll(b); //a中删除b的元素 System.out.println("a:"+a); } } import java.util.*; /** * This program uses a set to print all unique words in System.in. * @version 1.12 2015-06-21 * @author Cay Horstmann */ public class SetTest { public static void main(String[] args) { Set<String> words = new HashSet<>(); // HashSet implements Set long totalTime = 0; try (Scanner in = new Scanner(System.in)) { while (in.hasNext()) { String word = in.next(); long callTime = System.currentTimeMillis(); words.add(word); callTime = System.currentTimeMillis() - callTime; totalTime += callTime; } } Iterator<String> iter = words.iterator(); for (int i = 1; i <= 20 && iter.hasNext(); i++) System.out.println(iter.next()); System.out.println(". . ."); System.out.println(words.size() + " distinct words. " + totalTime + " milliseconds."); } } import java.util.*; /** * This program sorts a set of item by comparing their descriptions. * @version 1.12 2015-06-21 * @author Cay Horstmann */ public class TreeSetTest { public static void main(String[] args) { SortedSet<Item> parts = new TreeSet<>(); parts.add(new Item("Toaster", 1234)); parts.add(new Item("Widget", 4562)); parts.add(new Item("Modem", 9912)); System.out.println(parts); NavigableSet<Item> sortByDescription = new TreeSet<>( Comparator.comparing(Item::getDescription)); sortByDescription.addAll(parts); System.out.println(sortByDescription); } } import java.util.*; /** * An item with a description and a part number. */ public class Item implements Comparable<Item> { private String description; private int partNumber; /** * Constructs an item. * * @param aDescription * the item's description * @param aPartNumber * the item's part number */ public Item(String aDescription, int aPartNumber) { description = aDescription; partNumber = aPartNumber; } /** * Gets the description of this item. * * @return the description */ public String getDescription() { return description; } public String toString() { return "[description=" + description + ", partNumber=" + partNumber + "]"; } public boolean equals(Object otherObject) { if (this == otherObject) return true; if (otherObject == null) return false; if (getClass() != otherObject.getClass()) return false; Item other = (Item) otherObject; return Objects.equals(description, other.description) && partNumber == other.partNumber; } public int hashCode() { return Objects.hash(description, partNumber); } public int compareTo(Item other) { int diff = Integer.compare(partNumber, other.partNumber); return diff != 0 ? diff : description.compareTo(other.description); } }
转载于:https://www.cnblogs.com/2017xinghui/p/9930798.html
