Java集合框架详解-优快云博客

一、理论部分

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

十一周