Collection集合框架

Collection集合框架

在java中，有一个容器，专门用于存储对象，这个容器就是集合框架

数组可以存储对象，存储基本数据类型，集合只存储对象，不存储基本数据类型

数组的长度是固定的，集合的长度是可变的

Collection接口中的方法

向集合中存储一个对象 boolean add(参数 Object)

向集合中存储一批对象 boolean addAll(Collection c)将一个集合添加到另一个集合

清除集合中所有的对象void clear()

返回集合中存储对象的个数 int size()

判断集合中是否包含某个对象 boolean contains(Object o)对象全等

判断一个集合是否包含另一个集合boolean containAll(Collection c)

移除集合中的对象 boolean remove(Object o)

移除集合中的一批对象 boolean retainAll(Collection c)

获取两个集合的交集 boolean retainAll(Collection c)

两个集合中共同的对象 co2.retainAll(co3) 保存回co2中，co2没有变化，返回值就是false，co2中的对象发生变化，返回true

package cn.river.collection;import java.util.Collection;import java.util.*;/* * Collection接口中常用的方法 */public class CollectionDemo {public static void main(String[] args) {method_1();}public static void method_1(){Collection col = new ArrayList();col.add("river01");col.add("river02");col.add("river03");col.add("river04");Collection col2 = new ArrayList();col2.add("river01");col2.add("river2");col2.add("river03");/*//判断集合中是否包含某个对象boolean b = col.contains("river01");System.out.println(b);//判断一个集合是否包含另一个集合b = col.containsAll(col2);System.out.println(b);//移除集合中的对象b = col.remove("river01");System.out.println(b);System.out.println(col);//移除集合中的一批对象,移除col中有col2中也有的元素col.removeAll(col2);System.out.println(col);*///获取两个集合的交集boolean b = col.retainAll(col2);System.out.println(col);System.out.println(b);}public static void method(){Collection col = new ArrayList();//向集合中存储一个对象col.add("river01");col.add("river02");col.add("river03");boolean b = col.add("river04");System.out.println(col);System.out.println(b);Collection col2 = new ArrayList();//向集合中存储一批对象b = col2.addAll(col);System.out.println(col2);System.out.println(b);//清除集合中所有的对象col2.clear();System.out.println(col2);//返回集合中存储对象的个数System.out.println(col.size());System.out.println(col2.size());}}

迭代器

package cn.river.collection;import java.util.*;public class CollectionDemo2 {public static void main(String[] args) {method_1();}//集合存储自定义对象public static void method_1(){Collection col = new ArrayList();col.add(new Person("river01",21));col.add(new Person("river01",21));col.add(new Person("river03",23));col.add(new Person("river03",23));col.add(new Person("river05",25));System.out.println(col);Iterator it = col.iterator();while(it.hasNext()){System.out.println(it.next());}}public static void method(){Collection col = new ArrayList();col.add("river1");col.add("river2");col.add("river3");col.add("river4");Iterator it = col.iterator();while(it.hasNext()){String str = (String)it.next();if("river1".equals(str))it.remove();else System.out.println(str);}System.out.println(col);}}package cn.river.collection;public class Person {String name;int age;public Person(String name, int age) {super();this.name = name;this.age = age;}@Override//重写toString方法public String toString() {return "Person [name=" + name + ", age=" + age + "]";} }

List集合派系

List集合都有下标

List集合存储的对象是有序的

List集合允许存储重复对象

List集合常用方法:

 add(int index,Object o); 在指定的位置上插入元素

addAll(intindex,Collection c)在指定位置上插入另一个集合

E remove(intindex); 返回值,是要删除的那个对象

E set(int index,Object o)指定位置上,修改对象

List subList(intstart, int end)获取集合中的一部分,存储到新集合

package cn.river.list;import java.util.*;/* * List集合的方法 */public class ListDemo {public static void main(String[] args) {method();}public static void method(){List list = new LinkedList();list.add("river01");list.add("river03");list.add("river02");list.add("river04");System.out.println(list);//指定的位置上，修改对象,返回值是被修改的对象river04String str = (String)list.set(3, "haha");System.out.println(str);System.out.println(list);//获取集合中的一部分，存储到新集合list = list.subList(1, 3);System.out.println(list);/*//删除指定下标的元素返回值，是要删除的那个对象String s = (String)list.remove(2);System.out.println(s);//在指定的位置上，插入另一个集合List list1 = new ArrayList();list1.add("river001");list1.add("river002");list1.add("river003");list.add(2,list1);System.out.println(list);//在指定的位置上插入元素list.add(2, "river22");System.out.println(list);*/}}

List特有的的迭代器

所有List派系的集合都有这个方法listIterator() 返回的是List集合特有迭代器

使用List特有迭代器,可以在迭代过程中对集合的元素进行添加,删除,修改,进行逆向遍历

package cn.river.list;import java.util.ArrayList;import java.util.Iterator;import java.util.List;import java.util.ListIterator;/* * List集合的迭代器 */public class ListDemo2 {public static void main(String[] args) {method();}public static void method(){List list = new ArrayList<>();list.add("river01");list.add("river02");list.add("river03");list.add("river04");//System.out.println(list);/*//取出方式一Iterator it = list.iterator();while(it.hasNext()){System.out.println(it.next());}*//*//取出方式二for(int i=0; i<list.size(); i++){System.out.println(list.get(i));}*///取出方式三ListIterator li = list.listIterator();while(li.hasNext()){String s = (String)li.next();System.out.println(s);if("river01".equals(s))//li.add("river0000");//li.set("hahahahaha");li.remove();}System.out.println(list);/*//逆向遍历列表,逆向遍历列表前必须先正向遍历一次while(li.hasPrevious()){System.out.println(li.previous());}*/}}

List派系中的三个常用类

ArrayList

底层数据结构是数组,长度是可变的,变化率是每次增长50%,默认是10个长度数据

这个集合是线程不安全,里面的方法,都不是同步的,效率高

既然数据结构是数组结构,查询快,增删慢

案例:

去掉ArrayList集合中重复对象,依据对象中的equals方法

实现步骤

       遍历老集合

       遍历过程中,将老集合中元素,去新集合中比较,用的是新集合的contains方法

       新集合中,有这个元素,存

       新集合中,没有这个元素,将这个元素存储到新集合中

       返回新集合

集合中的方法contains,可以实现比较一个对象不在集合中

       contains如果如何判断对象在不在呢?通过调用对象中的equals方法来判断的

       字符串对象存储到集合后,contains方法,可以判断集合中有没有这个字符串对象

       原因在于String类继承Object,重写了equals方法

       自定义对象,必须重写equals()建立对象自己的比较方式

code:

package cn.river.list;import java.util.ArrayList;import java.util.Iterator;import cn.river.collection.Person;public class ArrayListDemo {public static void main(String[] args) {method();}public static void method(){ArrayList al = new ArrayList();al.add("river01");al.add("river02");al.add("river02");al.add("river04");al.add("river05");//字符串自己重写了equals方法System.out.println(method(al));al.clear();al.add(new Person("river01",21));al.add(new Person("river02",22));al.add(new Person("river02",22));al.add(new Person("river03",23));al.add(new Person("river03",23));System.out.println(al);//Person对象需要自己定义equals方法才能实现功能System.out.println(method(al));}//定义一个方法，返回一个集合,返回的集合就是去掉重复元素public static ArrayList method(ArrayList al){if(al==null) return al;ArrayList newal = new ArrayList();Iterator it = al.iterator();while(it.hasNext()){Object obj = it.next();if(!newal.contains(obj))newal.add(obj);}return newal;}} package cn.river.collection;public class Person {String name;int age;public Person(String name, int age) {super();this.name = name;this.age = age;}@Override//重写toString方法public String toString() {return "Person [name=" + name + ", age=" + age + "]";}/*public int hashCode(){return this.name.hashCode()+this.age*31;}*/public boolean equals(Object obj){if(obj==this)return true;if(obj instanceof Person){Person p = (Person)obj;return p.name.equals(this.name) && p.age == this.age;}return false;}}

Vector

出现在JDK1.0版本,从1.2版本开始java引入集合框架,将Vector划分好List派系

集合框架出现以前,Vector很重要,现在很少用

Vector类,底层也是数据结构,变化率是100%

package cn.river.list;import java.util.Enumeration;import java.util.Vector;/* * 枚举就是Vector特有的取出方式 * 发现枚举和迭代器很像 * 其实枚举和迭代器时一样的 * 因为枚举的名称以及方法的名称都过长 * 所以被迭代器取代了 */public class VectorDemo {public static void main(String[] args) {Vector v = new Vector();v.add("river1");v.add("river2");v.add("river3");v.add("river4");Enumeration en = v.elements();while(en.hasMoreElements()){System.out.println(en.nextElement());}}}

LinkedList

底层数据结构是链表结构

特点:增删快,查询慢

offerFirst()在列表头,插入元素

offerLast() 在列表尾,插入元素

peekFirst() 获取但不移除列表第一个元素

peekLast()获取但不移除列表最后一个元素

pollFirst() 获取但移除第一个元素

pollLast() 获取但移除最后一个元素

packagecn.river.list;

import java.util.*;/* * LinkedList中特有的方法 */public class LinkedListDemo {public static void main(String[] args) {method();}public static void method(){LinkedList link = new LinkedList();//link.addLast("river5");link.addFirst("river1");link.addFirst("river2");link.offer("XXX");link.addFirst("river3");link.addFirst("river4");link.offerFirst("river5");link.offerLast("XXX");//Object obj = link.pollFirst();//obj=link.pollLast();//Object obj = link.peekFirst();//obj = link.peekLast();//System.out.println(obj);System.out.println(link);}}

练习

package cn.river.list;import java.util.LinkedList;/* * 使用LinkedList模拟一个堆栈或者队列数据结构 * 堆栈：先进后出 * 队列：先进先出 *  */public class LinkedListDemo2 {public static void main(String[] args) {// TODO Auto-generated method stubDuiLie dl = new DuiLie();dl.myAdd("river1");dl.myAdd("river2");dl.myAdd("river3");dl.myAdd("river4");while(!dl.isEmpty())System.out.println(dl.myGet());}}package cn.river.list;import java.util.LinkedList;class DuiLie{private LinkedList link;DuiLie(){link = new LinkedList();}public void myAdd(Object obj){link.addFirst(obj);}public Object myGet(){//Object obj = link.removeLast();//队列Object obj = link.removeFirst();//堆栈return obj;}public boolean isEmpty(){return link.size()==0;}}

Set集合派系

集合中存储的对象是无序的(存储顺序和取出顺序)

集合中存储的对象时不允许重复的

这个排序没有索引

Set接口中的方法和Collection接口中的方法一致

Set集合体系中常用的类

HashSet

可以存储null这个元素

底层数据结构是哈希表

存储对象的依据是对象的哈希值

如果存储的两个对象的哈希值不同,开辟两个空间来存储这2个对象

如果存储的两个对象的哈希值相同

HashSet调用对象中的equals方法,当equals返回false,存起来,当equals返回真,判断同一对象,不存

线程不安全的

在使用HashSet的时候,不关注这个集合,关注的是集合中存储的对象

这个对象必须覆盖hashCode和equals方法,才能保证集合中对象的唯一

package cn.river.set;public class Person implements Comparable{String name;int age;public Person(String name, int age) {super();this.name = name;this.age = age;}@Override//重写toString方法public String toString() {return "Person [name=" + name + ", age=" + age + "]";}/*public int hashCode(){return this.name.hashCode()+this.age*31;}*//*public int hashCode(){return this.name.hashCode()+this.age*31;}public boolean equals(Object obj){if(obj==this)return true;if(obj instanceof Person){Person p = (Person)obj;return p.name.equals(this.name) && p.age == this.age;}return false;}*/@Overridepublic int compareTo(Object o) {Person p = (Person)o;int num = this.age - p.age;return num==0?p.name.compareTo(this.name):num;}}package cn.river.set;public class Person implements Comparable{String name;int age;public Person(String name, int age) {super();this.name = name;this.age = age;}@Override//重写toString方法public String toString() {return "Person [name=" + name + ", age=" + age + "]";}public int hashCode(){return this.name.hashCode()+this.age*31;}public boolean equals(Object obj){if(obj==this)return true;if(obj instanceof Person){Person p = (Person)obj;return p.name.equals(this.name) && p.age == this.age;}return false;}}

TreeSet

TreeSet集合,对于存储在这个集合内的对象,TreeSet会对存储的对象进行自然顺序的排序

既然要对存储在集合的对象排序,要求这个对象必须具备比较性

两种方式实现这种比较性

一,自定义的类实现Comparable接口,覆盖comparaTo()方法

二,自定义比较器,定义类实现Comparable接口,覆盖compare(Object o1,Object o2)方法

       TreeSet构造方法,传递一个比较器对象 Comparator 实现类对象就可以了

package cn.river.set;import java.util.*;public class TreeSetDemo {public static void main(String[] args) {method_1();}public static void method_1(){//TreeSet ts = new TreeSet();TreeSet ts = new TreeSet(new MyComparable());ts.add(new Person("river1",21));ts.add(new Person("river1",21));ts.add(new Person("river3",23));ts.add(new Person("river2",22));ts.add(new Person("river3",23));ts.add(new Person("river4",24));Iterator it = ts.iterator();while(it.hasNext()){System.out.println(it.next());}}public static void method(){TreeSet ts = new TreeSet();ts.add("river1");ts.add("qiver4");ts.add("wiver2");ts.add("aiver3");Iterator it = ts.iterator();while(it.hasNext()){System.out.println(it.next());}}} 

package cn.river.set;public class Person implements Comparable{String name;int age;public Person(String name, int age) {super();this.name = name;this.age = age;}@Override//重写toString方法public String toString() {return "Person [name=" + name + ", age=" + age + "]";}@Overridepublic int compareTo(Object o) {Person p = (Person)o;int num = this.age - p.age;return num==0?p.name.compareTo(this.name):num;}}

package cn.river.set;import java.util.Comparator;public class MyComparable implements Comparator{@Overridepublic int compare(Object o1, Object o2) {Person p1 = (Person)o1;Person p2 = (Person)o2;int num = p1.name.compareTo(p2.name);return num==0 ? p1.age-p2.age : num;}}

package cn.river.set;import java.util.TreeSet;/* * TreeSet案例  |-- 字符串排序，长度排序，不按照字段顺序来排序  |-- 如果长度一样，按照字典顺序排序 */public class TreeTest {public static void main(String[] args) {method();}public static void method(){TreeSet ts = new TreeSet(new StringLength());/*ts.add("jlksda");ts.add("fds");ts.add("gfsd");ts.add("fgdf");*/ts.add("斐迪南可怜");ts.add("斐迪怜");ts.add("斐怜");ts.add("斐南怜");System.out.println(ts);}}

package cn.river.set;import java.util.Comparator;public class StringLength implements Comparator {@Overridepublic int compare(Object o1, Object o2) {// TODO Auto-generated method stubString s1 = (String)o1;String s2 = (String)o2;int num = s1.length() - s2.length();return num==0?s1.compareTo(s2):num;//return 0;}}

哈希值

  |-- cn.itcast.list.Person@1afae45 哈希值

  |-- 哈希值通过一个方法，计算出来的，这个方法就是hashCode()方法，是Object类的方法

  |-- hashCode()方法，通过对象在内存中的实际地址，加上哈希算法计算出来的一个十进制数

      这个十进制数就是哈希值

  |-- 哈希值不是地址值，哈希值是JVM通过哈希算法计算出来的一个十进制数，这个数是一个供

      我们程序人员参考的一个十进制数，和实际对象在内存中的地址，没有关系

      虚拟的地址

 

  |-- 如果覆盖了hashCode()，不覆盖equals

    |-- 如果对象的hashCode()一样，equals不一定返回真

|-- 如果equals返回真，那么两个对象会拥有同样的hashCode()