Collection 笔记
一、 Collection
所有集合共用的方法:
[list]
[*]************************增************************
[*]boolean add(Object obj):添加一个元素
[*]boolean addAll(Collection collection):添加一个集合里面的所有元素
[*]************************删************************
[*]void clear():清空集合内所有元素
[*]boolean remove(Object obj):删除一个指定元素
[*]boolean removeAll(Collection collection):删除与另外一个集合相同的所有元素
[*]************************改************************
[*]boolean retainAll(Collection collection):保留与另外一个集合相同的所有元素,即做交集
[*]************************查************************
[*]int size():获得集合的长度
[*]************************判断************************
[*]boolean contains(Object obj):判断一个元素是否存在集合中
[*]boolean containsAll(Collection collection):判断一个集合是否包含另外一个集合的所有元素
[*]boolean isEmpty():判断一个集合是否为空
[*]************************迭代器************************
[*]Iterator iterator():获得迭代器
[/list]
二、 List 特点:有序可重复
List独有方法:
[list]
[*]************************增************************
[*]boolean add(int index, Object obj):在指定位置添加一个元素
[*]boolean addAll(int index, Collection collection):添加一个集合里面的所有元素
[*]************************删************************
[*]boolean remove(int index):根据索引删除一个元素
[*]************************改************************
[*]Object set(int index, Object obj):设置索引处的元素值
[*]************************查************************
[*]Object get(int index):获得指定位置元素
[*]int indexOf(Object obj):获得相应元素的位置
[*]************************迭代************************
[*]ListIterator listIterator():获得ListIterator
[/list]
三、 ArrayList(数组存储结构)
独有方法:
Object clone():复制ArrayList实例
四、 LinkList(链表存储结构)
独有方法:
[list]
[*]boolean addFirst(Object obj):在集合第一个添加一个元素
[*]boolean addLast(Object obj):在集合最后一个添加一个元素
[*]Object getFirst():获得第一个元素
[*]Object getLast():获得最后一个元素
[*]Object removeFirst():删除第一个元素
[*]Object removeLast():删除最后一个元素
[/list]
新的替代方法:
[list]
[*]boolean offerFirst(Object obj):在集合第一个添加一个元素
[*]boolean offerLast(Object obj):在集合最后一个添加一个元素
[*]Object peekFirst():获得第一个元素
[*]Object peekLast():获得最后一个元素
[*]Object pollFirst():删除第一个元素
[*]Object pollLast():删除最后一个元素
[/list]
/*在List里面,元素之间的比较使用equals()方法*/
五、 HashSet(哈希表存储) 特点:无序不可重复
检验HashSet里面元素比较方法:先调用HashCode()计算Hash值,再调用equals()方法比较Hash值一样的元素
程序运行结果:
yuan01..equals..yuan01
yuan02..equals..yuan01
yuan03..equals..yuan02
yuan03..equals..yuan01
yuan04..equals..yuan03
yuan04..equals..yuan02
yuan04..equals..yuan01
可以看出由于所有的Hash值是相等的,所以相互之间进行比较,因此以后再使用HashSet的时候就需要重写hashCode()与equals()方法。
六、 TreeSet(二叉树又称红黑树存储) 特点:有序不可重复
若要向TreeSet里面存入自定义元素,则自定义类必须实现Comparable接口,重写compareTo()方法。如果有类里面有多个元素则在判断父元素后,还要判断子元素。
七、 使用比较器进行比较(实际中应用较多)
如果不想使用已经定义好的比较方法,可以自定义比较器,即实现Comparator接口,重写compare()方法,实例化一个类对象,当作参数传入TreeSet的构造方法中。
如果两种比较都有的时候,以比较器为主。
八、 泛型
泛型在比较器中的使用:
自定义泛型类(当自定义类中,使用对象的类型不确定的时候,早期使用Object,现在使用泛型)
当只定义泛型类的时候,一个类难以操作多个不同类型的变量,而定义泛型方法可以做一个类操作多个不同对象。
特殊之处:静态方法不可以访问类上定义的泛型,如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。而且泛型的标记<T>等应该放在方法返回类型的前面,修饰词的后面。
九、 泛型的高级应用
当方法里面的参数类型不确定的时候,可以使用通配符?代替不明确的参数,与使用其它符号如<T>等不同的是,使用通配符,不能取出相应的元素,而使用其它符号可以,例如:T t = it.next();其中T就是明确的了。
如果当要操作的对象有继承关系的时候,子类对象不能向父类对象转换,例子如下:
编译时,报错说无法通过方法调用转换将实际参数ArrayList<Teacher>转换为ArrayList<People>,那么怎样修改呢 ?可以使用通配符<? extends People>代替即可解决问题,这个叫作泛型的上限。修改后例子如下:
泛型的下限:<? super E>可以接受E的所有父类型。
十、 Map(存储键值对)
[list]
[*]void clear():清空元素
[*]boolean containsKey(Object obj):判断是否存在键
[*]boolean containsValue(Object value):判断是否存在值
[*]Object get(Object key):根据键获得值
[*]Set keySet():获得所有键所组成的Set集合
[*]Object put(Key key , Value value):存储元素
[*]Collection values():获得Collection
[/list]
|--Hashtable:是哈希表数据结构。不允许存储null键null值,是线程同步的,
|--HashMap:是只哈希表数据结构。允许存储null键null值,不是线程同步的。
|--TreeMap:是二叉树数据结构,是线程不同步的。可用Map中的键进行排序。
十一、 Map中获取键值的方法
第一种:values()获取所有的值,返回的对象是Collection类型
第二种:keySet()方法获得所有的键,再通过键获取所有的值
第三种:entrySet()方法,获取所有的键值关系,存入Set<Map.Entry<key,value>>里面,通过getKey()和getValue()方法获得相应的键和值。
十二、 TreeMap的应用
当自定义的对象要存入Hash存储结构的集合中时,需要重写hashCode()和equals()方法,当要存入二叉树数据结构时,要实现Comparable接口或者自定义比较器实现Comparator接口,并当参数传入相应集合的构造方法中。
*******#***反向旋转比较器Comparator<Student> cmp = Collections.reverseOrder();*************
一、 Collection
所有集合共用的方法:
[list]
[*]************************增************************
[*]boolean add(Object obj):添加一个元素
[*]boolean addAll(Collection collection):添加一个集合里面的所有元素
[*]************************删************************
[*]void clear():清空集合内所有元素
[*]boolean remove(Object obj):删除一个指定元素
[*]boolean removeAll(Collection collection):删除与另外一个集合相同的所有元素
[*]************************改************************
[*]boolean retainAll(Collection collection):保留与另外一个集合相同的所有元素,即做交集
[*]************************查************************
[*]int size():获得集合的长度
[*]************************判断************************
[*]boolean contains(Object obj):判断一个元素是否存在集合中
[*]boolean containsAll(Collection collection):判断一个集合是否包含另外一个集合的所有元素
[*]boolean isEmpty():判断一个集合是否为空
[*]************************迭代器************************
[*]Iterator iterator():获得迭代器
[/list]
二、 List 特点:有序可重复
List独有方法:
[list]
[*]************************增************************
[*]boolean add(int index, Object obj):在指定位置添加一个元素
[*]boolean addAll(int index, Collection collection):添加一个集合里面的所有元素
[*]************************删************************
[*]boolean remove(int index):根据索引删除一个元素
[*]************************改************************
[*]Object set(int index, Object obj):设置索引处的元素值
[*]************************查************************
[*]Object get(int index):获得指定位置元素
[*]int indexOf(Object obj):获得相应元素的位置
[*]************************迭代************************
[*]ListIterator listIterator():获得ListIterator
[/list]
三、 ArrayList(数组存储结构)
独有方法:
Object clone():复制ArrayList实例
四、 LinkList(链表存储结构)
独有方法:
[list]
[*]boolean addFirst(Object obj):在集合第一个添加一个元素
[*]boolean addLast(Object obj):在集合最后一个添加一个元素
[*]Object getFirst():获得第一个元素
[*]Object getLast():获得最后一个元素
[*]Object removeFirst():删除第一个元素
[*]Object removeLast():删除最后一个元素
[/list]
新的替代方法:
[list]
[*]boolean offerFirst(Object obj):在集合第一个添加一个元素
[*]boolean offerLast(Object obj):在集合最后一个添加一个元素
[*]Object peekFirst():获得第一个元素
[*]Object peekLast():获得最后一个元素
[*]Object pollFirst():删除第一个元素
[*]Object pollLast():删除最后一个元素
[/list]
/*在List里面,元素之间的比较使用equals()方法*/
五、 HashSet(哈希表存储) 特点:无序不可重复
检验HashSet里面元素比较方法:先调用HashCode()计算Hash值,再调用equals()方法比较Hash值一样的元素
import java.util.*;
class HashSetDemo
{
public static void main(String[] args)
{
HashSet hs = new HashSet();
hs.add(new Student("yuan01",17));
hs.add(new Student("yuan01",17));
hs.add(new Student("yuan02",21));
hs.add(new Student("yuan03",23));
hs.add(new Student("yuan04",32));
for(Iterator it = hs.iterator(); it.hasNext();) {
Student st = (Student)it.next();
sop(st.getName() + "..." + st.getAge());
}
}
public static void sop(Object obj) {
System.out.println(obj);
}
}
class Student
{
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public boolean equals(Object obj) {
if(!(obj instanceof Student)) {
return false;
}
Student st = (Student)obj;
System.out.println(this.name + "..equals.." + st.name);
return this.age == st.age && this.name.equals(st.name);
}
public int hashCode() {
//System.out.println(this.name + "hashCode()");
return 100;
//return name.hasCode + age * 20;
}
}
程序运行结果:
yuan01..equals..yuan01
yuan02..equals..yuan01
yuan03..equals..yuan02
yuan03..equals..yuan01
yuan04..equals..yuan03
yuan04..equals..yuan02
yuan04..equals..yuan01
可以看出由于所有的Hash值是相等的,所以相互之间进行比较,因此以后再使用HashSet的时候就需要重写hashCode()与equals()方法。
六、 TreeSet(二叉树又称红黑树存储) 特点:有序不可重复
若要向TreeSet里面存入自定义元素,则自定义类必须实现Comparable接口,重写compareTo()方法。如果有类里面有多个元素则在判断父元素后,还要判断子元素。
import java.util.*;
class TreeSetDemo1
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(new Person("yuan01", 20));
ts.add(new Person("yuan02", 17));
ts.add(new Person("yuan03", 19));
ts.add(new Person("yuan04", 20));
for(Iterator it = ts.iterator(); it.hasNext();) {
Person st = (Person)it.next();
System.out.println(st.getName() + "..." + st.getAge());
}
}
}
class Person implements Comparable
{
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}//重写compareTo()方法
public int compareTo(Object obj) {
Person ps = (Person)obj;
if(this.age > ps.age)
return 1;
if(this.age == ps.age) {
return this.name.compareTo(ps.name);
}
return -1;
}
}
七、 使用比较器进行比较(实际中应用较多)
如果不想使用已经定义好的比较方法,可以自定义比较器,即实现Comparator接口,重写compare()方法,实例化一个类对象,当作参数传入TreeSet的构造方法中。
import java.util.*;
class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new myCompare());
ts.add("asdf");
ts.add("afggf");
ts.add("aasdfasdf");
ts.add("asd");
ts.add("acd");
for(Iterator it = ts.iterator(); it.hasNext();) {
String str = (String)it.next();
System.out.println(str);
}
}
}
class myCompare implements Comparator {
public int compare(Object o1, Object o2) {
String s1 = (String)o1;
String s2 = (String)o2;
//System.out.println(s1 + "..compare.." + s2);
int l1 = s1.length();
int l2 = s2.length();
if(l1 > l2)
return 1;
if(l1 == l2)
return s1.compareTo(s2);//当长度一样的时候,还要比较内容
return -1;
}
}
如果两种比较都有的时候,以比较器为主。
八、 泛型
import java.util.*;
class GenericDemo
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("yuan01");
al.add("yuan02");
al.add("yuan03");
al.add("yuan04");
for(Iterator<String> it = al.iterator(); it.hasNext();) {
String str = it.next();
System.out.println(str);
}
}
}
泛型在比较器中的使用:
import java.util.*;
class GenericDemo2
{
public static void main(String[] args)
{
TreeSet<String> ts = new TreeSet<String>(new StrComparator());
ts.add("java0");
ts.add("java02");
ts.add("java");
for(Iterator<String> it = ts.iterator(); it.hasNext();) {
String str = it.next();
System.out.println(str);
}
}
}
class StrComparator implements Comparator<String>
{
public int compare(String s1 , String s2) {
int num = ((Integer)s2.length()).compareTo((Integer)s1.length());
if(num == 0)
return s2.compareTo(s1);
return num;
}
}
自定义泛型类(当自定义类中,使用对象的类型不确定的时候,早期使用Object,现在使用泛型)
class GenericDemo3
{
public static void main(String[] args)
{
Tool<String> tool = new Tool<String>();
tool.setObject("loveyuan");
System.out.println(tool.getObject());
}
}
class Tool<T>
{
private T t;
public void setObject(T t) {
this.t = t;
}
public T getObject() {
return t;
}
}
当只定义泛型类的时候,一个类难以操作多个不同类型的变量,而定义泛型方法可以做一个类操作多个不同对象。
class GenericDemo4
{
public static void main(String[] args)
{
Demo<String> d = new Demo<String>();
d.show("love");
d.print(new Integer(1));
d.print("yuan");
}
}
class Demo<T>
{
public void show(T t) {
System.out.println("show" + t);
}
public <Q> void print(Q q) {
System.out.println("print" + q);
}
}
特殊之处:静态方法不可以访问类上定义的泛型,如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。而且泛型的标记<T>等应该放在方法返回类型的前面,修饰词的后面。
九、 泛型的高级应用
当方法里面的参数类型不确定的时候,可以使用通配符?代替不明确的参数,与使用其它符号如<T>等不同的是,使用通配符,不能取出相应的元素,而使用其它符号可以,例如:T t = it.next();其中T就是明确的了。
import java.util.*;
class GenericDemo6
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("java1");
al.add("java2");
al.add("java3");
ArrayList<Integer> al1 = new ArrayList<Integer>();
al1.add(1);
al1.add(2);
al1.add(3);
print(al);
}
public static void print(ArrayList<?> al) {
for(Iterator<?> it = al.iterator(); it.hasNext();) {
System.out.println(it.next());
}
}
}
如果当要操作的对象有继承关系的时候,子类对象不能向父类对象转换,例子如下:
import java.util.*;
class People
{
private String name;
public People(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
class Teacher extends People
{
public Teacher(String name) {
super(name);
}
}
class GenericDemo7
{
public static void main(String[] args)
{
ArrayList<Teacher> al = new ArrayList<Teacher>();
al.add(new Teacher("java1"));
al.add(new Teacher("java2"));
al.add(new Teacher("java3"));
printAll(al);
}
public static void printAll(ArrayList<People> al) {
for(Iterator<People> it = al.iterator(); it.hasNext();) {
System.out.println(it.next().getName());
}
}
}
编译时,报错说无法通过方法调用转换将实际参数ArrayList<Teacher>转换为ArrayList<People>,那么怎样修改呢 ?可以使用通配符<? extends People>代替即可解决问题,这个叫作泛型的上限。修改后例子如下:
public static void printAll(ArrayList<? extends People> al) {
for(Iterator<? extends People> it = al.iterator(); it.hasNext();) {
System.out.println(it.next().getName());
}
}
泛型的下限:<? super E>可以接受E的所有父类型。
class GenericDemo7
{
public static void main(String[] args)
{
ArrayList<People> al = new ArrayList<People>();
al.add(new People("java--1"));
al.add(new People("java--2"));
al.add(new People("java--3"));
printAll(al);
}
public static void printAll(ArrayList<? super Teacher> al) {
for(Iterator<? super Teacher> it = al.iterator(); it.hasNext();) {
System.out.println(it.next());
}
}
}
十、 Map(存储键值对)
[list]
[*]void clear():清空元素
[*]boolean containsKey(Object obj):判断是否存在键
[*]boolean containsValue(Object value):判断是否存在值
[*]Object get(Object key):根据键获得值
[*]Set keySet():获得所有键所组成的Set集合
[*]Object put(Key key , Value value):存储元素
[*]Collection values():获得Collection
[/list]
|--Hashtable:是哈希表数据结构。不允许存储null键null值,是线程同步的,
|--HashMap:是只哈希表数据结构。允许存储null键null值,不是线程同步的。
|--TreeMap:是二叉树数据结构,是线程不同步的。可用Map中的键进行排序。
十一、 Map中获取键值的方法
第一种:values()获取所有的值,返回的对象是Collection类型
import java.util.*;
class MapDemo1
{
public static void main(String[] args)
{
Map<String , String> map = new HashMap<String, String>();
map.put("01","java01");
map.put("02","java02");
map.put("03","java03");
System.out.println(map.values());
}
}
第二种:keySet()方法获得所有的键,再通过键获取所有的值
import java.util.*;
class MapDemo2
{
public static void main(String[] args)
{
Map<String ,String> map = new HashMap<String , String>();
map.put("01","java1");
map.put("02","java2");
map.put("03","java3");
Set<String> set = map.keySet();
for(Iterator<String> it = set.iterator();it.hasNext();) {
String key = it.next();
String value = map.get(key);
System.out.println(key + "=" + value);
}
}
}
第三种:entrySet()方法,获取所有的键值关系,存入Set<Map.Entry<key,value>>里面,通过getKey()和getValue()方法获得相应的键和值。
import java.util.*;
class MapDemo3
{
public static void main(String[] args)
{
Map<String , String> map = new HashMap<String , String>();
map.put("01","java1");
map.put("02","java2");
map.put("03","java3");
Set<Map.Entry<String,String>> set = map.entrySet();
for(Iterator<Map.Entry<String,String>> it = set.iterator();it.hasNext();) {
Map.Entry<String,String> me = it.next();
String key = me.getKey();
String value = me.getValue();
System.out.println(key + "=" + value);
}
}
}
十二、 TreeMap的应用
import java.util.*;
class MapDemo4
{
public static void main(String[] args)
{
TreeMap<Student, String> map = new TreeMap<Student, String>();
map.put(new Student("java17",20),"beijing");
map.put(new Student("java13",20),"shanghai");
map.put(new Student("java16",20),"wuhan");
map.put(new Student("java12",20),"nanjing");
Set<Map.Entry<Student,String>> set = map.entrySet();
for(Iterator<Map.Entry<Student,String>> it = set.iterator();it.hasNext();) {
Map.Entry<Student,String> me = it.next();
Student st = me.getKey();
String addr = me.getValue();
System.out.println(st + "=" + addr);
}
}
}
class Student implements Comparable<Student>
{
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public int hashCode() {
return name.hashCode() + age * 23;
}
public boolean equals(Object obj) {
if(!(obj instanceof Student))
throw new ClassCastException("类型不匹配!");
Student st = (Student)obj;
return this.name.equals(st.name) && this.age == st.age;
}
public int compareTo(Student st) {
int num = ((Integer)this.age).compareTo((Integer)st.age);
if(num == 0)
return this.name.compareTo(st.name);
return num;
}
public String toString() {
return this.name + ":" + this.age;
}
}
当自定义的对象要存入Hash存储结构的集合中时,需要重写hashCode()和equals()方法,当要存入二叉树数据结构时,要实现Comparable接口或者自定义比较器实现Comparator接口,并当参数传入相应集合的构造方法中。
*******#***反向旋转比较器Comparator<Student> cmp = Collections.reverseOrder();*************