黑马程序员 七、集合框架(1)

    xiaoxiao2025-09-24  86

    Java帮帮-IT资源分享网  七、黑马程序员—集合框架(1)  第七篇 集合框架(1)  1、集合类 & 容器 为什么出现集合类? 面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就要 对对象进行存储,集合就是存储对象最常用的一种方式。 数组和集合类同是容器,有何不同? 数组虽然也可以存储对象,但长度是固定的;集合长度是可变的。数组中可以存储任意 数据类型,集合只能存储对象。 集合类的特点 集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象。 我的总结:集合类比数组强大,类似于包装类与基本数据类型! 集合框架的构成及分类   两大接口 Java 集合类主要由两个接口派生出来: Collection Set :不能存放重复对象 List :可存放重复对象,有序 Queue :队列 SortedSet:可对集合数据排序 Map SortedMap :可对集合数据排序   2、Collection 接口 方法: boolean add(Object o):该方法用于向集合里面添加一个元素,若集合对象被添加操作改变了, 返回 true. boolean addAll(Collection c):把集合 c 里面的所有元素添加到指定集合里面去,如果集合对象 被添加操作改变了返回 true. void clear():清除集合里面的所有元素,将集合长度变为 0。 boolean contains(Object o):返回集合里是否包含指定的元素。 boolean containsAll(Collection c):返回集合里是否包含集合 c 内所有的元素。 boolean isEmpty():返回集合是否为空(长度是否为 0)。 Iterator iterator():返回一个 Iterator 对象,用于遍历集合里的元素。 boolean remove(Object o):删除集合中指定元素 o。 boolean removeAll(Collection c):从集合中删除集合 c 里面的元素。若删除一个或以上返回 true。 boolean retainAll(Collection c):从集合中删除集合 c 里不包含的元素。 int size():得到集合元素的个数。 Object[] toArray():把集合转成一个数组,所有集合元素编程数组元素。 Eg: public class Demo10 { public static void main(String[] args) { Collection<String> c = new ArrayList<String>(); c.add("A"); c.add("A"); c.add("A"); c.add("A"); //c.add(new Date());上面写了泛型,这个语句就是错误的了,因为泛型规定 了加进来的类型! System.out.println(c); } }   3、Iterator 接口 Iterator 主要遍历 Collection 集合中的元素,也有称为迭代器或迭代精灵。 boolean hasNext():若被迭代的集合元素还没有被遍历,返回 true. Object next():返回集合的下一个元素. void remove():删除集合上一次 next()方法返回的元素。(若集合中有多个相同的元素,都可以 删掉) iterator 对于集合才能用,for 不同,只要是循环都可用。 迭代是取出集合中元素的一种方式。 因为 Collection 中有 iterator 方法,所以每一个子类集合对象都具备迭代器。 迭代器在 Collcection 接口中是通用的,它替代了 Vector 类中的 Enumeration(枚举)。迭代器 的 next 方法是自动向下取元素,要避免出现 NoSuchElementException。 迭代器的 next 方法返回值类型是 Object,所以要记得类型转换。(学到泛型就可以消除强转!) Eg:Iterator iter = l.iterator(); while(iter.hasNext()){ System.out.println(iter.next()); }   4、集合遍历输出方式 Iterator:迭代输出 一旦操作集合的遍历输出,首选 Iterator 接口; ListIterator:Iterator 子接口,专门输出 List 中的元素; Enumeration:古老的输出方式,迭代 Vector 元素,被 Iterator 取代; foreach:可输出数组和 Iterable 对象; 我的总结: 集合遍历输出方式: 1. Iterable 接口(迭代遍历) 注:优先选择 Iterator 接口,遍历 Collection 里所有元素, 也称为迭代器和迭代精灵;迭代是取出集合中元素的一种推荐方式。 2. Foreach 循环 注:可以直接用,使用场合:数组和 Iterable 对象! 3. For 循环 注:在()内实例化 Iterable 对象,进行遍历! 4. 先用 toArray 方法输出成为数组,再用 Foreach 循环! 第一个和第三个很类似,第二个和第四个很类似! 很好 Eg: package july7; //遍历输出的四种方式 import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Demo11 { public static void main(String[] args) { List<String> l = new ArrayList(); l.add("1"); l.add("2"); l.add("3"); l.add("4"); System.out.println(l); /** * 遍历输出:四种方式 */ // 1、推荐使用的Iterator对象,迭代输出! Iterator it = l.iterator(); while (it.hasNext()) { System.out.println("迭代输出:" + it.next()); } // 2、对集合进行fore循环! for (String str : l) { System.out.println("fore集合迭代输出:" + str); } // 3、for循环迭代,在for方法体内部实例化Iterator对象! int i = 0;// for方法体内定义项不能出现多种不同类型 for (Iterator iter = l.iterator(); i < l.size(); i++) { System.out.println("for循环迭代实例化输出:" + iter.next()); } // 4、先将集合转换为数组,再利用数组的遍历输出; Object[] o = l.toArray(); for (Object object : o) { System.out.println("转换数组迭代输出:" + object); } } }   5、Set 接口(元素不可以重复) Set 是 Collection 子接口; Set 和 Collection 基本上一样,一点除外: Set 无法记住添加的顺序,不允许包含重复的元素。 当试图添加两个相同元素进 Set 集合,添加操作失败,add()方法返回 false。 Set 判断两个对象是否相等用 equals,而不是使用==。 也就是说两个对象 equals 比较返回 true,Set 集合是不会接受这个两个对象的。 常用子类: HashSet:散列存放 TreeSet:有序存放 hashCode 方法对于 HashSet 的作用 HashSet 类是 Set 接口最常用的实现类,采用 hash 算法存储数据,具有良好的存储和查找功能。 散列存储:不记录添加顺序;排列顺序时,顺序有可能发生变化; 线程不安全的,多个线程访问一个 HashSet 要使用同步代码; HashSet 集合元素值允许是 null,但是最多只能有一个;//因为 Set 集合就不可以装重复的对象! hash(翻译为哈希,或散列)算法的功能: 保证通过一个对象快速找到另一个对象; 其算法价值体现在速度,可以保证查询快速执行; 当从 HashSet 中访问元素时,HashSet 先计算该元素的 hashCode(也就是该对象的 hashCode 方 法返回值),然后直接到该 HashCode 对应的位置取出该元素; 在这里对象的 hashCode 就好比是数组里的索引,但是不是索引; HashSet 元素添加 当向 HashSet 集合中存入一个元素时,HashSet 会调用该对象的 hashCode()方法来得到该对 象的 hashCode 值,判断已经存储在集合中的对象的 hashCode 值是否与添加的对象的 hashCode 值一致:若不一致:直接添加进去;若一致,再进行 equals 方法比较,equals 方法如果返 回 true,表明对象已经添加进去了,就不会再添加新的对象了,否则添加进去; 如果我们重写了 equals 方法,也要重写 hashCode 方法,反之亦然;。 HashSet 集合判断两个元素相等的标准是两个对象通过 equals 方法比较相等,并且两个对象 的 hashCode 方法返回值也相等。 如果需要某个类的对象保存到 HashSet 集合中,覆写该类的 equals()和 hashCode()方法,应 该尽量保证两个对象通过 equals 比较返回 true 时,他们的 hashCode 返回也相等。 我的总结: 很重要的一点:理解!往 HashSet 集合里面存入数据,要先后调用两个方法:hashCode 方法和 equals 方法!!! 备注:使用 eclipse 添加这两个方法。 Eg: package july7; //hashset方法和equals方法判断输入的对象是否重复! import java.util.HashSet; import java.util.Set; class PersonDemo{ private String name; public PersonDemo(String name) { super(); this.name = name; } @Override public String toString() { return "name= " + name ; } //没有覆写hashcode和equals方法前,显示三次(一样的)。覆写后,只剩下一个 了!说明覆写后方法起作用了,重复的输入不进去! @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; PersonDemo other = (PersonDemo) obj; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } } public class Demo12 { public static void main(String[] args) { Set s = new HashSet(); s.add(new PersonDemo("章泽天")); s.add(new PersonDemo("章泽天")); s.add(new PersonDemo("章泽天")); System.out.println(s); } }   6、TreeSet TreeSet 是 SortedSet 接口唯一的实现,与 HashSet 相比额外的方法有: Comparator comparator():返回当前 Set 使用的 Comparator,若返回 null,表示以自然顺序排序。 Object first() 返回此 set 中当前第一个(最低)元素。 Object last() 返回此 set 中当前最后一个(最高)元素。 SortedSet subSet(Object fromElement, E toElement) 返回此 set 的部子集,其元素从 fromElement(包括)到 toElement(不包括)。 SortedSet headSet(Object toElement)返回此 set 的部分子集,其元素严格小于 toElement。 SortedSet tailSet(Object fromElement) 返 回 此 set 的 部 分 子 集 , 其 元 素 大 于 等 于 fromElement。 TreeSet 的排序之自然排序 TreeSet 会调用元素的 compareTo(Object o)方法来比较元素之间的大小关系,然后将集合里的 元素按升序排列 .此时需要排序元素的类 必须实现 Compareble 接口,并覆写其 int compareTo(Object o)方法; 该方法用于比较对象,若:obj1,compareTo(obj2),返回 0,表示两个对象相等,若返回一个正整数, 表示 obj1 大于 obj2,若返回一个负整数,表示 obj1 小于 obj2; 对于 TreeSet 集合而言,判断两个对象相等的标准是: compareTo()方法比较返回 0; package july7; //TreeSet可以自动进行排序!最简单的情况 import java.util.Set; import java.util.TreeSet; public class Demo13 { public static void main(String[] args) { Set<Integer> s = new TreeSet<Integer>(); s.add(1); s.add(192); s.add(123); s.add(56); s.add(13); s.add(96); System.out.println(s);//[1, 13, 56, 96, 123, 192] } } 稍复杂点的 package july7; //TreeSet的自然排序,升序 import java.util.Set; import java.util.TreeSet; class Student implements Comparable{//必须实现接口 private Integer age; public Student(Integer age) { super(); this.age = age; } @Override public int compareTo(Object o) {//比较的规则,运用泛型可以消除强转! if(o instanceof Student){ Student s = (Student)o; return this.age.compareTo(s.age); } return 0; } @Override public String toString() { return age+"" ; } } public class Demo14 { public static void main(String[] args) { Set<Student> s = new TreeSet(); s.add(new Student(140)); s.add(new Student(15)); s.add(new Student(11)); s.add(new Student(63)); s.add(new Student(96)); System.out.println(s);//[11, 15, 63, 96, 140] } } TreeSet 的排序之定制排序 TreeSet 的自然排序是根据元素的大小进行升序排序的,若想自己定制排序,比如降序排序,就 可以使用 Comparator 接口了: 该接口包含 int compare(Object o1,Object o2)方法,用于比较两个对象的大小,比较结果和 compareTo 方法一致; 要实现定制排序,需要在创建 TreeSet 集合对象时,提供一个一个 Comparator 对象,该对象里 负责集合元素的排序逻辑; TreeSet(Comparator comparator) Eg: package july7; //定制排序的话,必须在创建TreeSet集合对象的时候提供一个Comparator方法 import java.util.Comparator; import java.util.Set; import java.util.TreeSet; class Student1{ private Integer age; public Student1(Integer age) { super(); this.age = age; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } @Override public String toString() { return age + ""; } } class MyComparator implements Comparator{ @Override public int compare(Object o1, Object o2) { if(o1 instanceof Student1 & o2 instanceof Student1){ Student1 s1 = (Student1)o1; Student1 s2 = (Student1)o2; if(s1.getAge() > s2.getAge()){ return -1; }else if(s1.getAge() < s2.getAge()){ return 1; } } return 0; } } public class Demo15 { public static void main(String[] args) { Set<Student1> s = new TreeSet(new MyComparator()); /** * 要 实 现 定 制 排序 , 需 要 在 创 建 TreeSet 集 合 对 象 时 , 提 供 一 个 一 个 Comparator对象, * 该对象里负责集合元素的排序逻辑; */ s.add(new Student1(140)); s.add(new Student1(15)); s.add(new Student1(11)); s.add(new Student1(63)); s.add(new Student1(96)); System.out.println(s); } }   7、List 接口 Collection 子接口; List 是有序的集合,集合中每个元素都有对应的顺序序列。List 集合可使用重复元素,可以 通过索引来访问指定位置的集合元素(顺序索引从 0 开始),List 集合默认按元素的添加顺 序设置元素的索引,比如第一个元素的索引就是 0,好似数组。 List 作为 Collection 子接口当然拥有其所有方法,同时也有自己的方法: void add(int index,Object e):将元素 e 添加到 List 集合中的 index 处; boolean addAll(int index,Collection c):将集合 c 所包含的所有元素都插入在 List 集合的 index 处; Object get(int index):返回集合 index 索引处的元素; int indexOf(Object o):返回对象 o 在 List 集合中第一次出现位置的索引; int lastIndexOf(object o):返回对象 o 在 List 集合中最后一次出现的位置索引; Object remove(int index):删除并返回 index 索引处的元素; Object set(int index,Object e):把集合 index 处的元素替换为 e 对象,返回以前在指定位置的元 素; List subList(int fromIndex,int toIndex):返回从所有 fromIndex(包括)到 toIndex(不包括)处所有 集合元素的子集合。 ListIterator Iterator 的子接口,专门用于操作 List 集合的输出; List 自己还有一个 listIterator()方法,该方法返回 ListIterator 对象,ListIterator 继承了 Iterator 接口,提供了专门操作 List 的方法。在 Iterator 上额外增加的方法: 支持双向输出: boolean hasPrevious():返回该迭代器关联集合是否还有上一个元素; Object previous():返回该迭代器的上一个元素; 我的总结:这是相对更加特殊的一个接口,只用于 List 集合,可以完成逆序输出! Eg: package july7; import java.util.ArrayList; import java.util.List; import java.util.ListIterator; public class Demo16 { public static void main(String[] args) { List<Integer> l = new ArrayList<Integer>(); l.add(12); l.add(24); l.add(36); l.add(23); l.add(37); System.out.println(l); ListIterator<Integer> it = l.listIterator(); while(it.hasNext()){ System.out.println("正序:"+it.next()); } System.out.println("=================================="); //使用向前迭代前必须将游标(指针)移动到后边! while(it.hasPrevious()){ System.out.println("逆序:"+it.previous()); } } } 输出: [12, 24, 36, 23, 37] 正序:12 正序:24 正序:36 正序:23 正序:37 ================================== 逆序:37 逆序:23 逆序:36 逆序:24 逆序:12   8、List 接口中常用类 Vector:线程安全,但速度慢,已被 ArrayList 替代。 ArrayList:线程不安全,查询速度快。 LinkedList:链表结构,增删速度快。取出 List 集合中元素的方式: get(int index):通过脚标获取元素。 iterator():通过迭代方法获取迭代器对象。 ArrayList 和 Vector 类都是基于数组实现的 List 类,Vector 比较古老,被 ArrayList 取代了; ArrayList 是线程不安全的,而 Vector 是线程安全的,但是即使这样,也不推荐使用 Vector,因为 Collections 有方法可以得到线程安全的 ArrayList 对象; Collections 类: static List synchronizedList(List list) 返回指定列表支持的同步(线程安全的) 列表。 Queue 接口 继承 Collection 接口 模拟队列:先进先出(FIFO); void add(Object e):将 e 插入到队列尾部; Object element():获取队列头部的元素; boolean offer(Object e):将 e 插入到队列的尾部,当使用有容量限制的队列时,此方法比 add(Object e)方法更好。 Object peek():获取队列头部的元素。如果此双端队列为空,则返回 null。 Object poll():获取并删除队列头部的元素。如果此双端队列为空,则返回 null。 Object remove():获取并删除队列头部的元素。 Eg:练习:List 的使用 设计 Department 和 Employee 对象类(按照开发的样式没有写在一个文件里面) //一个员工只可以有一个部门,所以按照普通的写法 //一个部门可以有许多员工,所以按照集合的写法; //员工 package re538.Department; public class Emp { private Dept dept;//一个员工只可以有一个部门,所以按照普通的写法 private String name; public Dept getDept() { return dept; } public void setDept(Dept dept) { this.dept = dept; } public Emp(String name) { super(); this.name = name; } public String toString(){//覆写toString方法 return this.name+""; } } //部门 package re538.Department; import java.util.List; public class Dept { private String name; private List emp;//一个部门可以有许多员工,所以按照集合的写法;部门里的 属性,员工! public Dept(String name) { super(); this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } public List getEmp() { return emp; } public void setEmp(List emp) { this.emp = emp; } private Dept parent;//一个部门只有一个直接主管部门,所以普通写法 private List children;//但是一个部门可以管理很多部门,充当很多部门的直 接主管部门,所以使用集合 public Dept getParent() { return parent; } public void setParent(Dept parent) { this.parent = parent; } public List getChildren() { return children; } public void setChildren(List children) { this.children = children; } public String toString(){ return this.name.toString(); } } //测试类,主方法! package re538.Department; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class TestDemo { public static void main(String[] args) { Emp e1 = new Emp("刘亦菲"); Emp e2 = new Emp("章泽天"); Emp e3 = new Emp("张月娟"); Emp e4 = new Emp("王二五"); Emp e5 = new Emp("刘昭"); List list = new ArrayList();//把员工丢尽集合去 list.add(e1); list.add(e2); list.add(e3); list.add(e4); list.add(e5); for (Object object : list) {//把员工给遍历出来,使用的是直接的 foreach(四种方法之一) System.out.println("----->"+object); } System.out.println("-------------------"); Dept d = new Dept("部门");//定义出一个部门来接收员工 d.setEmp(list);//把员工这个集合丢到部门去。 Dept d1 = new Dept("itcast"); Dept cditcast = new Dept("成都传智播客"); Dept gzitcast = new Dept("广州传智播客"); Dept d4 = new Dept(""); System.out.println(d4); List children = new ArrayList(); children.add(cditcast); children.add(gzitcast); d1.setChildren(children);//定义直接被主管部门(集合) d1.setParent(d4);//定义直接主管部门 Iterator it = children.iterator();//运用到了迭代遍历,四种之一! while(it.hasNext()){ System.out.println(it.next()); } } }   9、Map 接口 映射关系,也有人称为字典,Map 集合里存在两组值,一组是 key,一组是 value。Map 里的 key 不允许重复。通过 key 总能找到唯一的 value 与之对应。 Map 里的 key 集存储方式和对应的 Set 集合中的元素存储方式一致; 学生都有一个学号,我们能点学号就能找到某个学生,好比这个学号就是 key,学生就是 value。 Map.Entry 是 Map 接口的内部接口,专门用来保存 key-value 内容: Map 常用方法 void clear():删除该 Map 对象中所有的 key-value 对。也就是清理该集合; boolean containsKey(Object key):查询 Map 中是否包含指定的 key; boolean containsValue(Object value):查询 Map 中是否包含至少一个 value; Set entrySet():返回Map所包含的key-value对所组成的Set集合,每个集合元素都是Map.Entry 对象(Entry 是 Map 内部类); Object get(Object key):返回指定 key 所对应的 value,若此 Map 中不包含该 key,返回 null; boolean isEmpty():判断 Map 集合是否为空; Set keySet():返回该 Map 中所有 key 所组成的 Set 集合; Object put(Object key,Object value):添加一个 key-value 对,若 Map 中已有与 key 相等的 key-value 对,则新的 key-value 对覆盖原来的 key-value 对; void putAll(Map m):将 m 中的 key-value 赋值到调用该方法的 Map 对象中; Object remove(Object key):删除指定 key 所对应的 key-value 对,返回本删除 key 所关联的 value,若 key 不存在,返回 null; int size():返回该 Map 里面 key-value 对的个数; Collection values():返回 Map 里所有 value 组成的 Collection。 Eg:package july7; import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; public class Demo17 { public static void main(String[] args) { Map m = new HashMap(); m.put(1, "jack"); m.put(2, "rose"); m.put(3, "lucy"); System.out.println(m);//{1=jack, 2=rose, 3=lucy} Set s = m.entrySet(); System.out.println(s);//[1=jack, 2=rose, 3=lucy] s = m.keySet(); System.out.println(s);//[1, 2, 3] for (Object key : s) { System.out.println(key);//Key System.out.println(m.get(key));//Value } Collection c = m.values(); System.out.println(c); } } Map.Entry Entry 是 Map 接口里面的一个内部接口. 该接口用于封装 key- value,有 3 个方法: Object getKey();返回 Entry 里包含的 key 值 Object getValue();返回 Entry 里包含的 value 值 Object setValue(Object value):设置 Entry 里包含的 value 值,并返回新设置的 value 值; Map 集合的输出 按照最正统的做法,所有的 Map 集合的内容都要依靠 Iterator 输出,以上虽然是完成了输出, 但是完成的不标准,Map 集合本身并不能直接为 Iterator 实例化,如果此时非要使用 Iterator 输出 Map 集合中内容的话,则要采用如下的步骤: 方法一: 1.通过 entrySet 方法变成 Set 对象 2.调用 Set 的 Iterator 方法,此时每个 Iterator 对象是 Map.Entry 对象 3.对 Map.Entry 分离出 key - value 方法二: 1.通过 keySet 得到 Map 集合多有 key 的 Set 集合 2.调用 Set 的 Iterator 方法,此时每个 Iterator 对象是 key 值 3.通过 Map 的 getValue(key)得到 value 值 Eg: package july7; //把Map中的元素取出来 import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import java.util.Set; public class Demo18 { public static void main(String[] args) { Map<Integer, String> m = new HashMap<Integer, String>(); m.put(1, "jack"); m.put(2, "rose"); m.put(3, "lucy"); //第一种方法 Set s = m.entrySet(); Iterator it = s.iterator(); while(it.hasNext()){ Map.Entry me = (Entry) it.next(); System.out.println(me.getKey()+" "+me.getValue()); } //第二种方法 s = m.keySet();//得到的是key的集合 it = s.iterator();//然后将key迭代出来 while(it.hasNext()){ int i = (int)it.next(); System.out.println(i+" "+m.get(i)); } } } Java帮帮-IT资源分享网
    最新回复(0)