java学习——集合框架(Collection,List,Set)
集合类的由来：
对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定,就使用集合容器进行存储。
集合特点：
1，用于存储对象的容器。
2，集合的长度是可变的。
3，集合中不可以存储基本数据类型值。
集合容器因为内部的数据结构不同，有多种具体容器。
不断的向上抽取，就形成了集合框架。
框架的顶层Collection接口：java.util
Collection的常见方法：
1，添加。
boolean add(Object obj):
boolean addAll(Collection coll):
2，删除。
boolean remove(object obj):
boolean removeAll(Collection coll);
void clear();
3，判断：
boolean contains(object obj):
boolean containsAll(Colllection coll);
boolean isEmpty():判断集合中是否有元素。
package cn.itcast.p3.collection.demo; import java.util.ArrayList; import java.util.Collection; public class CollectionDemo { public static void main(String[] args) { Collection coll = new ArrayList(); show(coll); } public static void show(Collection coll){ //1,添加元素。add. coll.add("abc1"); coll.add("abc2"); coll.add("abc3"); System.out.println(coll); //2，删除元素。remove // coll.remove("abc2");//会改变集合的长度 //清空集合. // coll.clear(); System.out.println(coll.contains("abc3")); System.out.println(coll); } }
package cn.itcast.p3.collection.demo; import java.util.ArrayList; import java.util.Collection; public class CollectionDemo { /** * @param args */ public static void main(String[] args) { Collection coll = new ArrayList(); Collection c1 = new ArrayList(); Collection c2 = new ArrayList(); show(c1,c2); } public static void show(Collection c1,Collection c2){ //给c1添加元素。 c1.add("abc1"); c1.add("abc2"); c1.add("abc3"); c1.add("abc4"); //给c2添加元素。 c2.add("abc1"); c2.add("abc2"); c2.add("abc3"); c2.add("abc4"); c2.add("abc5"); System.out.println("c1:"+c1); System.out.println("c2:"+c2); //演示addAll // c1.addAll(c2);//将c2中的元素添加到c1中。 //演示removeAll // boolean b = c1.removeAll(c2);//将两个集合中的相同元素从调用removeAll的集合中删除。 // System.out.println("removeAll:"+b); //演示containsAll // boolean b = c1.containsAll(c2); // System.out.println("containsAll:"+b); //演示retainAll boolean b = c1.retainAll(c2);//取交集，保留和指定的集合相同的元素，而删除不同的元素。 //和removeAll功能相反 。 System.out.println("retainAll:"+b); System.out.println("c1:"+c1); } }
4，获取：
int size():
Iterator iterator():取出元素的方式：迭代器。
该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
所以该迭代器对象是在容器中进行内部实现的。
对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，
也就是iterator方法。
Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
其实就是抓娃娃游戏机中的夹子！
package cn.itcast.p3.collection.demo; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class IteratorDemo { public static void main(String[] args) { Collection coll = new ArrayList(); coll.add("abc1"); coll.add("abc2"); coll.add("abc3"); coll.add("abc4"); // System.out.println(coll); //使用了Collection中的iterator()方法。 调用集合中的迭代器方法，是为了获取集合中的迭代器对象。 // Iterator it = coll.iterator(); // while(it.hasNext()){ // System.out.println(it.next()); // } for(Iterator it = coll.iterator(); it.hasNext(); ){ System.out.println(it.next()); } } }
5，其他：
boolean retainAll(Collection coll);取交集。
Object[] toArray():将集合转成数组。
-------------------------------
Collection
|--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。
|--Set：元素不能重复,无序。
List:特有的常见方法：有一个共性特点就是都可以操作角标。
1，添加
void add(index,element);
void add(index,collection);
2，删除；
Object remove(index):
3，修改：
Object set(index,element);
4，获取：
Object get(index);
int indexOf(object);
int lastIndexOf(object);
List subList(from,to);
list集合是可以完成对元素的增删改查。
package cn.itcast.p4.list.demo; import java.util.ArrayList; import java.util.List; public class ListDemo { public static void main(String[] args) { List list = new ArrayList(); show(list); } public static void show(List list) { //添加元素 list.add("abc1"); list.add("abc2"); list.add("abc3"); System.out.println(list); //插入元素。 // list.add(1,"abc9"); //删除元素。 // System.out.println("remove:"+list.remove(2)); //修改元素。 // System.out.println("set:"+list.set(1, "abc8")); //获取元素。 // System.out.println("get:"+list.get(0)); //获取子列表。 // System.out.println("sublist:"+list.subList(1, 2)); System.out.println(list); } }
package cn.itcast.p4.list.demo; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.ListIterator; public class ListDemo2 { /** * @param args */ public static void main(String[] args) { List list = new ArrayList(); show(list); } public static void show(List list) { list.add("abc1"); list.add("abc2"); list.add("abc3"); list.add("abc4"); Iterator it = list.iterator(); while(it.hasNext()){ System.out.println("next:"+it.next()); } //list特有的取出元素的方式之一。 for(int x=0; x<list.size(); x++){ System.out.println("get:"+list.get(x)); } } }
public class ListDemo2 { public static void main(String[] args) { List list = new ArrayList(); list.add("abc1"); list.add("abc2"); list.add("abc3"); System.out.println("list:"+list); //Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。 ListIterator it = list.listIterator(); //获取列表迭代器对象 //它可以实现在迭代过程中完成对元素的增删改查。 //注意：只有list集合具备该迭代功能. while(it.hasNext()){ Object obj = it.next(); if(obj.equals("abc2")){ it.set("abc9"); } } // System.out.println("hasNext:"+it.hasNext()); // System.out.println("hasPrevious:"+it.hasPrevious()); //逆向遍历 while(it.hasPrevious()){ System.out.println("previous:"+it.previous()); } System.out.println("list:"+list); }
List:
|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！(不用了)
|--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。
|--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。
Vector举例：
public class VectorDemo { public static void main(String[] args) { Vector v = new Vector(); v.addElement("abc1"); v.addElement("abc2"); v.addElement("abc3"); v.addElement("abc4"); Enumeration en = v.elements(); while(en.hasMoreElements()){ System.out.println("nextelment:"+en.nextElement()); } //Enumeration接口与Iterator接口功能是重复的。 Iterator it = v.iterator(); while(it.hasNext()){ System.out.println("next:"+it.next()); } } }
LinkedList举例：查api
public class LinkedListDemo { public static void main(String[] args) { LinkedList link = new LinkedList(); link.addFirst("abc1"); link.addFirst("abc2"); link.addFirst("abc3"); link.addFirst("abc4"); // System.out.println(link); // System.out.println(link.getFirst());//获取第一个但不删除。 // System.out.println(link.getFirst()); // System.out.println(link.removeFirst());//获取元素但是会删除。 // System.out.println(link.removeFirst()); while(!link.isEmpty()){ System.out.println(link.removeLast()); } System.out.println(link); // Iterator it = link.iterator(); // while(it.hasNext()){ // System.out.println(it.next()); // } } }
ArrayList示例：
public class ArrayListTest { public static void main(String[] args) { Person p1 = new Person("lisi1",21); ArrayList al = new ArrayList(); al.add(p1); al.add(new Person("lisi2",22)); al.add(new Person("lisi3",23)); al.add(new Person("lisi4",24)); Iterator it = al.iterator(); while(it.hasNext()){ Person p = (Person) it.next(); System.out.println(p.getName()+"--"+p.getAge()); } } }
Set:
元素不可以重复，是无序。
Set接口中的方法和Collection一致。
|--HashSet: 内部数据结构是哈希表 ，是不同步的。
如何保证该集合的元素唯一性呢？
是通过对象的hashCode和equals方法来完成对象唯一性的。
如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。
记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
建立对象判断是否相同的依据。
示例：
package cn.itcast.p.bean; public class Person extends Object{ private String name; private int age; public Person() { super(); } public Person(String name, int age) { super(); this.name = name; this.age = age; } @Override public int hashCode() { // System.out.println(this+".......hashCode"); return name.hashCode()+age*27; } @Override public boolean equals(Object obj) { if(this == obj) return true; if(!(obj instanceof Person)) throw new ClassCastException("类型错误"); // System.out.println(this+"....equals....."+obj); Person p = (Person)obj; return this.name.equals(p.name) && this.age == p.age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String toString(){ return name+":"+age; } }
package cn.itcast.p4.hashset.test; import java.util.HashSet; import java.util.Iterator; import cn.itcast.p.bean.Person; /* * 往hashSet集合中存储Person对象。如果姓名和年龄相同，视为同一个人。视为相同元素。 */ public class HashSetTest { public static void main(String[] args) { HashSet hs = new HashSet(); /* * HashSet集合数据结构是哈希表，所以存储元素的时候， * 使用的元素的hashCode方法来确定位置，如果位置相同，在通过元素的equals来确定是否相同。 * */ hs.add(new Person("lisi4",24)); hs.add(new Person("lisi7",27)); hs.add(new Person("lisi1",21)); hs.add(new Person("lisi9",29)); hs.add(new Person("lisi7",27)); Iterator it = hs.iterator(); while(it.hasNext()){ Person p = (Person)it.next(); System.out.println(p); // System.out.println(p.getName()+"...."+p.getAge()); } } }
有序还唯一用子类：LinkedHashSet
|--TreeSet:可以对Set集合中的元素进行排序。是不同步的。
判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。
TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。
package cn.itcast.p.bean; public class Person implements Comparable { private String name; private int age; public Person() { super(); } public Person(String name, int age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String toString(){ return name+":"+age; } @Override public int compareTo(Object o) { Person p = (Person)o; //按年龄排序 int temp = this.age-p.age; return temp==0?this.name.compareTo(p.name):temp; //按姓名排序 // int temp = this.name.compareTo(p.name); // return temp==0?this.age-p.age:temp; } }
package cn.itcast.p5.treeset.demo; import java.util.Iterator; import java.util.TreeSet; import cn.itcast.p.bean.Person; public class TreeSetDemo { public static void main(String[] args) { TreeSet ts = new TreeSet(); ts.add(new Person("zhangsan",28)); ts.add(new Person("lisi",21)); ts.add(new Person("zhouqi",29)); ts.add(new Person("zhaoliu",25)); ts.add(new Person("wangu",24)); Iterator it = ts.iterator(); while(it.hasNext()){ Person p = (Person)it.next(); System.out.println(p.getName()+":"+p.getAge()); } } }
如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？
可以使用TreeSet集合第二种排序方式二：（常用）
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
将该类对象作为参数传递给TreeSet集合的构造函数。
package cn.itcast.p5.comparator; import java.util.Comparator; import cn.itcast.p.bean.Person; /** * 创建了一个根据Person类的name进行排序的比较器。 */ public class ComparatorByName implements Comparator { @Override public int compare(Object o1, Object o2) { Person p1 = (Person)o1; Person p2 = (Person)o2; int temp = p1.getName().compareTo(p2.getName()); return temp==0?p1.getAge()-p2.getAge(): temp; } }
package cn.itcast.p5.treeset.demo; import java.util.Iterator; import java.util.TreeSet; import cn.itcast.p.bean.Person; import cn.itcast.p5.comparator.ComparatorByName; public class TreeSetDemo { public static void main(String[] args) { TreeSet ts = new TreeSet(new ComparatorByName()); /* * 以Person对象年龄进行从小到大的排序。 * */ ts.add(new Person("zhangsan",28)); ts.add(new Person("lisi",21)); ts.add(new Person("zhouqi",29)); ts.add(new Person("zhaoliu",25)); ts.add(new Person("wangu",24)); Iterator it = ts.iterator(); while(it.hasNext()){ Person p = (Person)it.next(); System.out.println(p.getName()+":"+p.getAge()); } } }
package cn.itcast.p5.comparator; import java.util.Comparator; public class ComparatorByLength implements Comparator { @Override public int compare(Object o1, Object o2) { String s1 = (String)o1; String s2 = (String)o2; int temp = s1.length()-s2.length(); return temp==0? s1.compareTo(s2): temp; } }
package cn.itcast.p5.treeset.test; import java.util.Iterator; import java.util.TreeSet; import cn.itcast.p5.comparator.ComparatorByLength; /* * 对字符串进行长度排序。 * * "20 18 -1 89 2 67" */ public class TreeSetTest { public static void main(String[] args) { TreeSet ts = new TreeSet(new ComparatorByLength()); ts.add("aaaaa"); ts.add("zz"); ts.add("nbaq"); ts.add("cba"); ts.add("abc"); Iterator it = ts.iterator(); while(it.hasNext()){ System.out.println(it.next()); } } }
if(this.hashCode()== obj.hashCode() && this.equals(obj))
哈希表确定元素是否相同
1，判断的是两个元素的哈希值是否相同。
如果相同，在判断两个对象的内容是否相同。
2，判断哈希值相同，其实判断的是对象的hashCode的方法。判断内容相同，用的是equals方法。
注意：如果哈希值不同，是不需要判断equals。
完毕..
