类集就是一个动态的对象数组
对象数组 ：可以保存多个对象在一个数组中 但是对象数组的大小固定 如果向对象数组中添加对象时 要考虑到数组的大小
类集：类集的大小不固定 可以任意的扩展和减少
l Java类集接口和框架 一下全部都是接口
·Conllection 元素的类集
·List(Conllection的子接口) 元素的序列 允许重复
·Set(Conllection的子接口) 没有重复元素的类集
·SortedSet 没有重复元素且排序的类集
·Map 元素为二元偶对的汇集 不能重复
·SortedMap 在 Map的基础上 加上排序的要求
·iterator 可遍历整个类集的对象
·ListIterator 可遍历一个序列List的对象
l 真正需要掌握的有三个核心接口
·Collection： 存放的是一个个对象,每次存放单个对象
·Map：每次存放一对值：key à value
·Iterator：输出接口 只要集合都要使用 Iterator输出
n Conllection接口：在一把开发中为了清楚的表现处理数据的存放 往往不直接使用Conllection接口
u 子接口：List list既然是一个接口 必须由其子类来实现 子类àArrayList 格式：List l = new ArrayList()
ArrayList：扩展了AbstractList并执行了List接口
ArrayList：动态数组，采用一部处理方式
? 向对象数组中加入对象
1. 顺序加入：l.add(Object obj)
2. 在指定位置加入：l.add(int index,Object obj) index为数组的下标位置 从0开始的
注：在对象数组中加入对象时 最好只加入一种对象
? 从对象数组中删除对象
remove(int index) 移除此列表中指定位置上的元素
public boolean remove (Object o) 删除指定的对象 返回的是布尔值 可以用来判断数组中是否存在该对象
import java.util.ArrayList; import java.util.List; class Person01 { private String name; public Person01(String name) { this.setName(name); } public String getName() { return name; } public void setName(String name) { this.name = name; } //覆写toString方法 public String toString() { return this.getName(); } } public class Demo01_ArrayList { public static void main(String[] args) { //List是接口 必须通过其子类来实现 List all = new ArrayList(); //添加对象 all.add("你"); all.add("是"); //注：在加入对象时 最好都加入一种类型的 all.add(new Person01("陈广志")); //数组下标从0开始 add(int index,Object obj)为在指定的位置加入对象 all.add(1, "就"); //删除指定位置的对象 all.remove(1); //删除指定的对象 返回的是布尔值 可以检查数组中是否存在该对象 System.out.println(all.remove("你"));//true //打印出的顺序 就是加入的顺序 System.out.println(all); } } |
? 打印数组中的元素
1. 使用for循环实现
//l.size() 求出对象数组的长度 l.get(i)获取每个对象数组元素 for(int i=0;i<l.size();i++) { System.out.println(l.get(i)); } l.size() 求出对象数组的长度 类似于数组中的lengh l.get(i) 取得对象数组中的每个元素 注：但在一般开发中 只要是集合就要用 iterator输出 |
2. 使用 iterator来遍历输出对象数组中的元素
//使用Iterator 来遍历输出对象数组中的元素 iter.haNext()判断是否有元素 iter.Next()返回迭代的下一个元素 Iterator iter = l.iterator(); while(iter.hasNext()) { Object object = iter.next(); System.out.println(object); } boolean hasNext() 如果仍有元素可以迭代，则返回 true E next() 返回迭代的下一个元素 重复调用此方法直到 hasNext() 方法返回 false |
3. 在使用对象数组时 一般只加入统一类型的对象 此时可以使用List<E> 来限制加入的对象只能为E
public class Demo03_AssignClass { public static void main(String[] args) { //List<E>限制加入对象数组中的对象类型必须为E List<String> list = new ArrayList<String>(); list.add("Hello"); list.add("Java"); Iterator<String> iter = list.iterator(); while(iter.hasNext()) { System.out.println(iter.next()); } } } |
u 子接口 Set 没有重复元素的类集 和List的用法很相似
·HashSet 扩展了AbstractSet和实现了Set接口
HashSet是无序（散列）的没有重复的对象存储数组
·TreeSet 有序的没有重复的对象存储数组
import java.util.*; public class Demo04_HashSetAndTreeSet { public static void main(String[] args) { //Set和 List的用法基本相同 但是hashset是无序的散列的存放 而且hashset不允许有相同的元素存在 即使添加了相同的元素 此类元素也只存放一个 //Set<String> hashSet = new HashSet<String>(); //TreeSet是有序的没有重复的存放数组对象 Set<String> treeSet = new TreeSet<String>(); treeSet.add("上海"); treeSet.add("北京"); treeSet.add("杭州"); treeSet.add("苏州"); treeSet.add("上海"); treeSet.add("上海"); Iterator<String> iterator = treeSet.iterator(); while(iterator.hasNext()) { System.out.println(iterator.next()); } } } |
v Set和 List的用法和相似 主要区别体现在是否会保留重复的对象
Set 不会保留重复的多余的对象 HashSet是无序的存储 TreeSet是有序的存储,TreeSet靠的是Compareable接口排序
List 允许保留重复的对象 ArrayList是有序的存储
l Map 存放元素为二元偶对的合集 不能重复
n HashMap采用散列表实现Map接口
HashMap是一种映射类 Key à Value
public class Demo05_HashMap { public static void main(String[] args) { //<>中指定输入的对象类型时 必须使用包装类名 Map<String, Integer> map = new HashMap<String, Integer>(); //map.put(Key,Value)存储对象 map.put("多弗明戈", 7878979); map.put("米霍克", 5654631); map.put("纽约特", 8328138); map.put("莱昂纳多", 362713); System.out.println(map);//{莱昂纳多=362713, 纽约特=8328138, 多弗明戈=7878979, 米霍克=5654631} //通过键值来查找 map.get(key) HashMap一般用于查找数据 System.out.println(map.get("米霍克"));//5654631 System.out.println(map.get("香克斯"));//null } } 1.map.put(Object key,Object Value) 向HashMap中添加对象 2.map.get(Object key)通过键来查找键值 HashMap类一般用来通过Key来查找数据 注： HashMap和HashSet一样也好似采用散列（无序）存储 |
★ Map主要用来作为查找 使用 而不是作为输出使用
Map接口的对象不能直接使用 iterator输出Map对象的内容 必须通过一下步骤
Map à Set à Iteratorà Map.Entry à getkey()、getValue()
public class Demo06_MapIterator { public static void main(String[] args) { Map<String,Integer> map = new HashMap<String,Integer>(); map.put("多弗明戈", 7878979); map.put("米霍克", 5654631); map.put("纽约特", 8328138); map.put("莱昂纳多", 362713); //将Map变为Set Set set = map.entrySet(); //遍历set中的元素 Iterator iter = set.iterator(); while(iter.hasNext()) { Map.Entry me = (Map.Entry)iter.next(); //getKey()获取键 getValue()获取键值 System.out.println("姓名："+me.getKey()+"--->"+"号码："+me.getValue()); } } } |
Map一般用于查找 用于输出的比较少
n TreeMap
TreeMap可以对数据进行排序
TreeMap可以快速的检索
用法和HashMap差不多 主要区别就是排序
l 枚举Enumeration 与Iterator的功能一致 都是用于输出集合中的内容 (Elements：元素)
| Enumeration | Iterator |
判断是否有下一个内容 | hasMoreElements() | hasNext() |
取值 | nextElement() | next() |
注：List和Set都不能使用Enumeration输出 而List的另外一个子类：Vector可以使用Enumeration输出 Vector的效率没有ArrayList高 其是较早的动态数组
l Vector (矢量) 较早的动态数组 和 ArrayList用法相似 但没有其效率高 Vector可以使用Enumeration和Iterator输出
Vector是同步的 ArrayList是异步的
public class Demo07_Vector { public static void main(String[] args) { //此处不能写成 List<E> v = new Vector<E> Enumeration值适合于 Vector不适合于List Vector<String> v = new Vector<String>(); v.add("上海"); v.add("北京"); v.add("苏州"); Enumeration<String> enu = v.elements(); while(enu.hasMoreElements()) { System.out.println(enu.nextElement()); } //Vector既可以用Enumeration输出又可以用Iterator输出 Iterator<String> ite = v.iterator(); while(ite.hasNext()) { System.out.println(ite.next()); } } } List只支持Iterator输出 Vector支持Enumeration和Iterator输出 |
Vector和Enumeration尽量不去使用 而去使用ArrayList和Iterator
l Stack( 栈) 栈就像一个胡同 先进的后出 后进的先出
s.push()往栈里压如对象（存放对象）
s.pop()往栈中弹出对象 即出栈
s.empty()判断栈内是否为空 为空则为true 不为空返回false
import java.util.Stack; //栈就像一个胡同 public class Demo08_Stack { public static void main(String[] args) { Stack<String> s = new Stack<String>(); //往栈里压对象 push:压 s.push("车厢一"); s.push("车厢二"); s.push("车厢三"); s.push("车厢四"); s.push("车厢五"); s.push("车厢尾"); //s.empty()当且仅当堆栈中不含任何项时返回 true；否则返回 false while(!s.empty()) { //s.pop()将栈内的内容弹出 即从最后开始一个个出栈 System.out.println(s.pop()); } //如果内容已全部弹出 则会出错 s.pop(); } } |
l HashTable 和HashMap用法类似 但HashTable是同步的 而HashMap 是异步的
HashTable 不支持迭代函数
public class Demo09_HashTable { public static void main(String[] args) { Hashtable<String, Integer> t = new Hashtable<String, Integer>(); t.put("哈维", 758934534); Set set = t.entrySet(); Iterator iter = set.iterator(); while(iter.hasNext()) { Map.Entry<String, Integer> me = (Map.Entry<String, Integer>)iter.next(); System.out.println("姓名："+me.getKey()+",电话号码："+me.getValue()); } } } |
l Properties
因为 Properties 继承于 Hashtable，所以可对 Properties 对象应用 put 和 putAll 方法。但强烈反对使用这两个方法，因为它们允许调用方插入其键或值不是 Strings 的项。相反，应该使用 setProperty 方法。如果在“有危险”的 Properties 对象（即包含非 String 的键或值）上调用 store 或 save 方法，则该调用将失败。
1. p.getProperty(String key)根据键来查找键值
2. p.getProperty(String key,String defaultValue)当找不到键值时 显示默认的内容
★ Properties只能用于字符串键值对
/* 因为 Properties 继承于 Hashtable，所以可对 Properties 对象应用 put 和 putAll 方法。 但强烈反对使用这两个方法，因为它们允许调用方插入其键或值不是 Strings 的项。相反，应该使用setProperty 方法。 如果在“有危险”的 Properties 对象（即包含非 String 的键或值）上调用 store 或 save 方法，则该调用将失败。 */ public class Demo10_Properties { public static void main(String[] args) { Properties p = new Properties(); p.setProperty("中国的首都","北京"); p.setProperty("日本的首都","东京"); p.setProperty("马来西亚的首都","吉隆坡"); System.out.println(p);//{日本的首都=东京, 马来西亚的首都=吉隆坡, 中国的首都=北京} //p.getProperty(String key)根据键来查找键值 System.out.println(p.getProperty("日本的首都")); //p.getProperty(String key,String defaultValue) System.out.println(p.getProperty("新加坡的首都","你要找的内容不存在")); } } |
★ 几点区别
1. ArrayList和Vector 的区别
1.vector是线程同步的，所以它也是线程安全的，而arraylist是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用arraylist效率比较高。(线程)
2.如果集合中的元素的数目大于目前集合数组的长度时，vector增长率为目前数组长度的100%,而arraylist增长率为目前数组长度的50%.如过在集合中使用数据量比较大的数据，用vector有一定的优势。 (处理大数据)
3.如果查找一个指定位置的数据，vector和arraylist使用的时间是相同的，都是o(1),这个时候使用vector和arraylist都 可 以。而如果移动一个指定位置的数据花费的时间为o(n-i)n为总长度，这个时候就应该考虑到使用linklist,因为它移动一个指定位置的数据所花费的时间为o(1),而查询一个指定位置的数据时花费的时间为o(i)。 (查找时间)
4.ArrayList只支持Iterator输出 而Vector支持Iterator和Enumeration输出 (输出