package pan;
import com.sun.tools.javac.util.List;
import pan.Entity.UpdateStu;
import java.util.*;
public class Main {
/** 常用集合类的继承关系
* Java.lang.Object 包括:
* Map:
* HashMap
* TreeMap
* Collection:
* Set:
* HashSet
* TreeSet
* List:
* ArrayList
* LinkedList
*/
/** Collection 接口的常用方法
* add(E e)
* remove(Object o)
* isEmpty()
* iterator()
* size()
*/
public static void iteratorTraversal(){
Collection<Character> list = new ArrayList<Character>();
for (char c = 'a'; c <= 'z'; c ++){
list.add(c);
}
Iterator<Character> iterator = list.iterator();
while (iterator.hasNext()){
char c = iterator.next();
System.out.println(c);
}
}
/** List 集合中的元素允许重复，各元素的顺序就是对象插入的顺序。
* 用户可以使用索引来访问集合中的元素
*
* get(int index);
* set(int index, Object obj);
*
*/
public static void listTest(){
ArrayList<String> stringArrayList = new ArrayList<String>();
stringArrayList.add("Tom");
stringArrayList.add("Micheal");
stringArrayList.add("Kangkang");
int i = (int)(Math.random() * stringArrayList.size());
System.out.println("随机获取数组中的元素:" + stringArrayList.get(i));
stringArrayList.remove(2);
for (String s: stringArrayList) {
System.out.println(s);
}
}
/** Set 集合
* Set集合中的队形不按特定的方式排序，不能包括重复对象
*
* HashSet 不保证 Set 的迭代顺序，可以有 null 元素
* TreeSet 实现了 Java.util.SortedSet 接口，按照自然顺序递增排序，也可以按照指定比较器排序
* TreeSet 新增方法：
* first();
* last();
* comparator(); // 返回对此 Set 中的元素进行排序的比较器。
* 如果此 Set 使用自然排序，则返回 null
* headSet(E toElement); // 返回一个新的 Set 集合，
* 新集合是 toElement(不包含）之前的所有对象
* subSet(E fromElement, E fromElement) // 返回一个新的 Set 集合，
* 是 fromElement（包含）与 fromElement（不包含）之间的所有对象
*/
public static void setTest(){
UpdateStu stu1 = new UpdateStu("李小龙", 01011);
UpdateStu stu2 = new UpdateStu("陈建斌", 01021);
UpdateStu stu3 = new UpdateStu("王刚", 01051);
UpdateStu stu4 = new UpdateStu("马云", 01012);
/** 注意：存入 TreeSet 类实现的 Set 结婚必须实现 Comparable 接口，
* 该接口中的 compareTo(Object o)方法比较此对象与制定队形的顺序。
*
*/
TreeSet<UpdateStu> treeSet = new TreeSet<>();
treeSet.add(stu1);
treeSet.add(stu2);
treeSet.add(stu3);
treeSet.add(stu4);
Iterator<UpdateStu> iterator = treeSet.iterator();
System.out.println("Set 集合中的所有元素：");
while (iterator.hasNext()){ // 遍历集合
UpdateStu updateStu = (UpdateStu)iterator.next();
System.out.println("学号：" + updateStu.getId() + ", 名字：" + updateStu.getName());
}
// 截取排在 stu2 对象之前的对象
iterator = treeSet.headSet(stu2).iterator();
System.out.println("\n截取前面部分的集合：");
while (iterator.hasNext()){
UpdateStu updateStu = (UpdateStu)iterator.next();
System.out.println("学号：" + updateStu.getId() + ", 名字：" + updateStu.getName());
}
// 截取排在 sut2 与 stu3 之间的对象
iterator = treeSet.subSet(stu2, stu3).iterator();
System.out.println("\n截取中间部分的集合：");
while (iterator.hasNext()){
UpdateStu updateStu = (UpdateStu)iterator.next();
System.out.println("学号：" + updateStu.getId() + ", 名字：" + updateStu.getName());
}
}
/** Map
* Key/Value 映射机制
* Map 集合中允许对象是 null，而且没有个数限制
*
* 建议使用 HashMap，添加和删除映射关系效率更高
* TreeMap 适合按顺序排列对象
*
*/
public static void mapTest(){
Map<String, String> map = new HashMap<>();
map.put("01", "小李子");
map.put("02", "小邓子");
Set<String> set = map.keySet();
Iterator<String> iterator = set.iterator();
System.out.println("Key 集合中的元素：");
while (iterator.hasNext()){
String id = iterator.next();
String name = (String)map.get(id);
System.out.println("id:" + id + " Value:" + id);
}
Collection<String> collection = map.values();
iterator = collection.iterator();
System.out.println("\nName 集合中的元素：");
while (iterator.hasNext()){
System.out.println(iterator.next());
}
// 创建 TreeMap 集合对象
TreeMap<String, String> treeMap = new TreeMap<>();
treeMap.putAll(map); // 向集合添加对象
Iterator<String> iterator1 = treeMap.keySet().iterator();
System.out.println("\nTreeMap 类实现的 Map 集合，键对象升序：");
while (iterator.hasNext()){
String id = (String)iterator1.next();
String name = (String)treeMap.get(id);
System.out.println("id:" + id + " Name:" + name);
}
}
public static void main(String[] args) {
// write your code here
// iteratorTraversal();
// listTest();
// setTest();
mapTest();
}
}
向量与哈希表
package pan;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Set;
import java.util.Vector;
public class Main {
/**
* 向量和数组相似，都可以保存一组数据（数据列表）。
* 但是数组的大小是固定的，一旦指定，就不能改变，而向量却提供了一种类似于“动态数组”的功能，
* 向量与数组的重要区别之一就是向量的容量是可变的。
* 向量和数组分别适用于不同的场合，一般来说，下列场合更适合于使用向量：
1.如果需要频繁进行对象的插入和删除工作，或者因为需要处理的对象数目不定。
2.列表成员全部都是对象，或者可以方便的用对象表示。
3.需要很快确定列表内是否存在某一特定对象，并且希望很快了解到对象的存放位置。
*
* 向量只能存储对象，不能直接存储简单数据类型
*/
public static void VectorTest(){
Vector vector = new Vector(); // 创建空向量，初始大小为 10
vector = new Vector(8); // 大小为 8，超过后翻倍增量
vector = new Vector(8,10);// 增量为 10
vector.add(new Object());
vector.add(new Object());
int size = vector.size();
System.out.println(size);
}
public static void hashTableTest(){
// 哈希表三种构造方法
Hashtable hashtable = new Hashtable(); // 默认构造函数，初始容量为 101，最大填充因子为 0.75
hashtable = new Hashtable(100);
hashtable = new Hashtable(10, 8);
hashtable.put("one", new Integer(1));
hashtable.put("two", new Integer(2));
hashtable.put("three", new Integer(3));
hashtable.put("four", new Double(12.3));
Set set = hashtable.keySet();
for (Iterator<String> iterator = set.iterator();iterator.hasNext();){
System.out.println(hashtable.get(iterator.next()));
}
}
public static void main(String[] args) {
// write your code here
// VectorTest();
hashTableTest();
}
}
网友评论