----------------------
ASP.Net+Android+IO开发S、
.Net培训、期待与您交流! ----------------------
集合框架
概述
为什么出现集合类:
面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式。
数组和集合类同是容器,有何不同:
数组虽然也可以存储对象,但长度是固定的,集合长度是可变的,数组中可以存储基本数据类型,集合只能存储对象。
集合类的特点
集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象。
数据结构:集合框架中有很多种容器类型,每一个容器对数据的存储方式都不同,这个存储方式称为数据结构。
Collection
Collection 层次结构 中的根接口。Collection 表示一组对象,这些对象也称为 collection 的元素。一些 collection 允许有重复的元素,而另一些则不允许。一些 collection 是有序的,而另一些则是无序的。JDK 不提供此接口的任何直接 实现:它提供更具体的子接口(如 Set 和 List)实现。此接口通常用来传递 collection,并在需要最大普遍性的地方操作这些 collection。
方法的使用:见例1.
迭代器
定义:其实就是集合的取出元素的方式。
方法:
boolean hasNext()
如果仍有元素可以迭代,则返回 true。
E next()
返回迭代的下一个元素。
void remove()
从迭代器指向的 collection 中移除迭代器返回的最后一个元素(可选操作)。
内部设计方式:
集合把取出元素的方式定义在其内部,这样取出方式就可以直接访问集合内部的元素,取出方式就被定义成了内部类。而每一个容器的数据结构不同,所以取出的动作细节也不一样,但是都有共性内容:判断和取出。那么就可以将这些共性抽取。这些内部类都符合一个规则:Iterator。通过一个对外提供的方法:iterator();供外部调用。
注意:在迭代时循环中next调用一次就需要hasNext判断一次。
例1:
import java.util.*;
public class APITest
{
public static void main(String[] ags)
{
public static void sop(Object obj)
{
System.out.println(obj);
}
//建立一个集合容器,使用Collection接口的子类。ArrayList
ArrayList al1 = new ArrayList();
//添加元素
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");
/**/
ArrayList al2 = new ArrayList();
al2.add("java01");
al2.add("java02");
al2.add("java05");
al2.add("java06");
//获取元素个数,集合长度。编译会有提示,可以不用管。
sop("size:"+al1.size());
//删除元素。
al1.remove("java02");
//清空集合
al1.clear();
//判断元素
sop("java03是否存在:"+al1.contains("java03"));
sop("集合是否为空?"+al1.isEmpty());
//打印集合
sop(al1);
//取交集。al1中只会保留和al2中相同的元素。
al1.retainAll(al2);
sop("al1与al2的交集:"+al1);
//取非交集。al1中会删除和al2中相同的元素。
al1.removeAll(al2);
sop("al1与a2的非交集:"+al1);
//迭代器。
Iterator it = al1.iterator();
while(it.hasNext())//指针后还有元素,it.hasNext()的值为true。
{
sop(it.next());//it.next()迭代取出集合中元素。
}
}
}
Conllection
|--List :元素是有序的,元素可以重复,因为该集合体系有索引。
|---- |--ArrayList 底层的数据结构使用的是数组结构。特点:查询速度快,但是增删较慢。1.2版本开始使用。线程不同步,效率高。
|---- |--LinkedList 底层使用的是链表数据结构。特点:增删较快,但是查询较慢。
| ----|--Vector 底层是数组数据结构。1.0版本开始使用。线程同步,效率低。
|
|
|--Set: 元素是无序的,元素不可以重复。
List-------------------
特有方法:凡是可以操作角标的方法都是该体系特有的方法。
增
add(index, element);
addAll(index, Collection);
删
remove(index);
改
set(index, element);
查
get(index);
subList(from,to);
listIterator();
List集合特有的迭代器:
ListIterator是Iterator的子接口。
在迭代时,不可以通过集合对象的方法操作集合中的元素。因为会发生并发异常。所以在迭代器时,只能用迭代器的方法操作元素。可是Iterator方法是有限的,只能对元素进行判断,取出,删除的操作。如果想要其他的操作,就需要使用其子接口:ListIterator。该接口只能通过List集合的listIterator方法获取。
例2:列表迭代器
ArrayList a1 = new ArrayList();
a1.add("java01");
a1.add("java02");
a1.add("java03");
ListIterator li = a1.listIterator();
while(li.hasNext());
{
object obj = li.next();
if(obj.equals("java02"))
li.add("java008");//增加
li.set("java009");//修改
}
li.hasPrevious();//判断指针前有没有元素,有则为true无则为false。
Vector枚举
枚举就是Vector特有的取出方式,枚举和迭代是一样的。由于枚举的名称以及方法的名称过长,所以被迭代器所取代。
LinkedList-----
特有方法。
void addFirst(E e)
将指定元素插入此列表的开头。
void addLast(E e)
将指定元素添加到此列表的结尾。
┏━E getFirst()
┃ 返回此列表的第一个元素。
┣━E getLast()
┃ 返回此列表的最后一个元素。
┃
┣━E removeFirst()
┃ 移除并返回此列表的第一个元素。
┣━E removeLast()
┃ 移除并返回此列表的最后一个元素。
┗━▶在集合为空的时候,会出现NoSuchElementException异常。
在JDK1.6出现了替代方法。
boolean offerFirst(E e)
在此列表的开头插入指定的元素。
boolean offerLast(E e)
在此列表末尾插入指定的元素。
E peekFirst()
获取但不移除此列表的第一个元素;如果此列表为空,则返回 null。
E peekLast()
获取但不移除此列表的最后一个元素;如果此列表为空,则返回 null。
E pollFirst()
获取并移除此列表的第一个元素;如果此列表为空,则返回 null。
E pollLast()
获取并移除此列表的最后一个元素;如果此列表为空,则返回 null。
Set---------------------------
┣━HashSet:底层数据结构是哈希表。线程是非同步的。 ┃┗━TreeSet:可以对set集合中的元素进行排序。底层数据结构是二叉树。
特点
Set集合中元素是无序(存入和去除的顺序不一定一致),元素不可以重复。
Set集合的功能和Collection是一致的。
HashSet------
例:
HashSet hs = new HashSet();
hs.add("java01");//返回值是true,存入成功。
hs.add("java01");//返回值是false,存入失败。
hs.add("java02");
hs.add("java03");
hs.add("java03");
hs.add("java04");
HashSet储存自定义对象的方法------
HashSet如何保证元素唯一性的?
是通过元素的两个方法:hashCode和equals来完成。如果元素的HashCode值相同,才会判断equals是否为true。如果不同,就不会调用equals。
例:
/*
姓名年龄相同,则视为同一个人。
*/
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public int hashCode()//复写hashCode()方法。
{
//姓名和年龄相同,则返回相同的哈希值。27的作用:避免姓名的哈希值与年龄的哈希值相加出现相同值情况。
return this.name.hashCode()+age*27;
}
public boolean equals(Object obj)//复写equals方法。
{
if(!(obj instanceof Person))//需要判断obj对象是否指向Person。
return false;
Person p = (Person) obj;//因为所用到的name与age等参数不是Object中的成员,所以需要转型。
return this.name.equals(p.name)&&this.age == p.age;
}
}
注意:判断元素是否存在以及删除等操作,都依赖元素的hashCode和equals方法。先是判断哈希值是否相同,然后通过equals比较元素,最后才可以确认此元素,并进行对应的操作。
TreeSet------
保证元素唯一性的依据:compareTo方法return 0.
注意:当主要条件相同时,一定要判断一下次要条件。
TreeSet排序------
第一种排序方式:让元素自身具备比较性。元素需要实现comparable接口,并复写compareTo方法。
TreeSet存储自定义元素,需要复写compareTo方法。注意:当主要条件相同时,一定要判断一下次要条件。
int compareTo(T o)
比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象,则分别返回负整数、零或正整数。
例:
class Student implements Comparable//该接口强制使Student具备比较性。
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
if(!(obj instanceof Student))
throw new RuntimeException("非Student对象");
Student s = (Student)obj;
if(this.age == s.age)
{return this.name.compareTo(s.name);}
return (this.age - s.age);
}
}
第二种排序方式:当元素自身不具备比较性时,或者具备的比较性不是所需要的。这时需要让集合自身具备比较性。在集合初始化时就有了比较方式。定义一个比较器,将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器定义方法:定义一个类,实现comparator旧口,覆盖compare方法。
注意:当两种排序方法都存在时,以比较器为主。
例:
//定义比较器。
class MyCompare implements Comparator
{
public int compare(Object obj1,Object obj2)
{
Student s1 = (Student)obj1;
Student s2 = (Student)obj2;
int num;
num = s1.getName().compareTo(s2.getName());
if(num == 0)
return (new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())));
return num;
}
}
class TreeSetTest
{
public static void main(String[] args)
{
//将比较器对象作为参数传递给TreeSet集合的构造函数
TreeSet ts = new TreeSet(new MyCompare());
}
}
泛型------
JDK1.5版本以后出现的新特性,用于解决安全问题,是一个安全机制。
好处:
1.将运行时期出现问题ClassCastException转移到了编译时期。方便于程序员解决问题,让运行时期问题减少,安全。
2.避免了强制转换麻烦。
泛型格式:
通过<>来定义要操作的引用数据类型。
在使用java提供的对象时,什么时候写泛型呢?
通常在集合框架中很常见,只要见到<>就要定义泛型。
其实<>就是用来接收类型的。当使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可。
例:
ArrayList<String> al = new ArrayList<String>();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
Iterator<String> i = hs.iterator();
while (i.hasNext())
{
String s = i.next();//不用强制转换类型。也可以使用length方法。
System.out.println(s + ":"+s.length());
}
接口 Comparator<T>------
类型参数:
T - 此 Comparator 可以比较的对象类型
public interface Comparator<T>
强行对某个对象 collection 进行整体排序 的比较函数。
例:
class MyComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num == 0)
{
return s1.compareTo(s2);
}
return num;
}
}
泛型类------
什么时候使用泛型类?
当类中要操作的引用数据类型不确定的时候,早期定义Object来扩展,现在定义泛型来扩咱。
例:
//非泛型类的定义
class Utils<Object obj>
{
private Object obj;
public void setObject(Object obj)
{
this.obj = obj;
}
public void getObject()
{
return obj;
}
}
//建立对象以及方法调用
Utils u = new Utils();
u.setObject(new Worker());//当传入的对象不是指向Worker类的,编译通过,但运行失败。
Worker w = (Worker)u.getObject();//必须强转类型。
//泛型类的定义。
class Utils<QQ>
{
private QQ q;
public void setObject(QQ q);
{
this.q = q;
}
public void getObject()
{
return q;
}
}
//建立对象以及方法调用
Utils<Worker> u = new Utils<Worker>();
u.setObject(new Worker());//当传入的对象不是指向Worker类的,编译不能通过,将错误转到编译时期。
Worker w = u.getObject();//不用强转类型。
泛型方法------
泛型类定义的泛型,在整个类中有效,如果被方法使用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了,存在局限性。
例:
class Demo<String>
{
public void show()
{
}
}
class GenericDemo
{
Demo<String> d = new Demo<String>();
d.show("java");//传入String型参数,编译通过。
d.show(2);//传入int型参数,编译失败。
}
为了让不同方法可以操作不同类型,而且类型不确定,可以将泛型定义在方法上。
例:
class Demo
{
public <T> void show(T t)
{
}
}
class GenericDemo
{
Demo d = new Demo();
d.show("java");//传入String型参数,编译通过。
d.show(2);//传入int型参数,编译通过。但是当Demo是泛型类,且定义为:Demo<T>时,则编译失败。
}
特殊之处:
静态方法不可以访问类上定义的泛型。如果静态方法的参数类型不确定,可以将泛型定义在方法上。
例:
class Demo<T>
{
public static <W> show(W w)
{
}
}
泛型接口------
interface Inter<>
{
}
class InterImpl<T> implements Inter<T t>
{
}
?通配符,也可以理解为占位符。
例:
public void show(ArrayList<?> al)
{
}
<?>与<T t>形式的区别:用<?>不可以操作参数,用<T t>形式可以操作参数t。
泛型的限定:
? extends E 可以接受E类型或者E的子类型。上限。
? super E 可以接受E类型或者E的父类型。下限。
例:
public static void show(ArrayList<? extends E> al)//接收上限是E类型。可以接收E类型以及其子类型集合,不可以接收其父类型集合。
{
}
public static void show1(ArrayList<? super E> al)//接收下限是E类型,可以接收E类型以及其父类型集合,不可以接收其子类型集合。
{
}
Map集合------
|---Hashtable: 底层是哈希表数据结构,不可以存入null键null值。该集合是线程同步的。jdk1.0 效率低
|---HashMap 底层是哈希表数据结构,可以存入null键null值。该集合是不同步的。jdk1.2 效率高
|---TreeMap 底层是二叉树数据结构,线程不同步。可以用于给map集合中的键进行排序。
结构和Set很像。其实Set底层就是使用了Map集合。
Map<K,V>
类型参数:K - 此映射所维护的键的类型V - 映射值的类型
特点:该集合存储键值对。一对一对往里存,而且要保证键的唯一性。
主要方法:
1.添加
V put(K key, V value)
将指定的值与此映射中的指定键关联(可选操作)。
添加元素,添加元素,如果出现添加时,相同的键。那么后添加的值会覆盖原有键对应值。并且put方法会返回被覆盖之前的值。
void putAll(Map<? extends K,? extends V> m)
从指定映射中将所有映射关系复制到此映射中(可选操作)。
2.删除
void clear()
从此映射中移除所有映射关系(可选操作)。
V remove(Object key)
如果存在一个键的映射关系,则将其从此映射中移除(可选操作)。
3.判断
boolean containsKey(Object key)
如果此映射包含指定键的映射关系,则返回 true。
boolean containsValue(Object value)
如果此映射将一个或多个键映射到指定值,则返回 true。
boolean equals(Object o)
比较指定的对象与此映射是否相等。
boolean isEmpty()
如果此映射未包含键-值映射关系,则返回 true。
4.获取
V get(Object key)
返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回 null。
int hashCode()
返回此映射的哈希码值。
int size()
返回此映射中的键-值映射关系数。
Collection<V> values()
返回此映射中包含的值的 Collection 视图。
* Set<Map.Entry<K,V>> entrySet()
返回此映射中包含的映射关系的 Set 视图。
* Set<K> keySet()
返回此映射中包含的键的 Set 视图。
Set<K> keySet() ------
将map中所有的键存入到Set集合,因为set具备迭代器,所有可以迭代方式取出所有的键,再根据get方法,获取每一个键对应的值。
Map集合的取出原理:将map集合转成set集合,再通过迭代器取出。
例:
Map<String,String> map = new HashMap<String,String>();
map.put("01", "java01");
Set<String> keySet = map.keySet();
Iterator<String> it = keySet.iterator();
while(it.hasNext())
{
String key = it.next();
String value = map.get(key);
System.out.println("key:"+key+"...value:"+value);
}
Set<Map.Entry<K,V>>entrySet()------
将map中所有的键与值的关系:Map.Entry 存入到Set集合,就可以通过迭代方式取出所有的关系对象Map.Entry,再通过Map.Entry接口的getKey与getValue方法获取每一个关系中的键与对应的值。
Map.Entry:其实Entry也是一个接口,它是Map接口中的一个内部接口。
例:
Map<String,String> map = new HashMap<String,String>();
map.put("01", "java01");
Set<Map.Entry<String,String>> entrySet = map.entrySet();
Iterator<Map.Entry<String,String>> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<String,String> me = it.next();
String key = me.getKey();
String value = me.getValue();
System.out.println(key+"::"+value);
}
Collections------
主要方法:
static <T extends Comparable<? super T>> void sort(List<T> list)
根据元素的自然顺序 对指定列表按升序进行排序。
例:Collections.sort(list);
static <T> void sort(List<T> list, Comparator<? super T> c)
根据指定比较器产生的顺序对指定列表进行排序。
例:Collections.sort(list,new SortComparator());
static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
根据元素的自然顺序,返回给定 collection 的最大元素。
例:Collections.max(list);
static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定比较器产生的顺序,返回给定 collection 的最大元素。
例:Collections.max(list,new MaxComparator());
static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
使用二分搜索法搜索指定列表,以获得指定对象。
例:Collections.binarySearch(list,"aaa");
static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
使用二分搜索法搜索指定列表,以获得指定对象。
例:Collections.binarySearch(list,"aaa",new BSComparator()):
static <T> void fill(List<? super T> list, T obj)
使用指定元素替换指定列表中的所有元素。
例:Collections.fill(list,"qq");
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
使用另一个值替换列表中出现的所有某一指定值。
例:Collections.replaceAll(list,"aaa","qqq");
static void reverse(List<?> list)
反转指定列表中元素的顺序。
例:Collections.reverse(list);
static <T> Comparator<T> reverseOrder()
返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
例:TreeSet ts = new TreeSet(Collections.reverseOrder());
static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
返回一个比较器,它强行逆转指定比较器的顺序。
例:TreeSet ts = new TreeSet(Collections.reverseOrder(new TsComparator()));
static void swap(List<?> list, int i, int j)
在指定列表的指定位置处交换元素。
例:Collections.swap(list,1,2);
static void shuffle(List<?> list)
使用默认随机源对指定列表进行置换。
例:Collections.shuffle(list);
Arrays------
主要方法
static <T> List<T> asList(T... a)
返回一个受指定数组支持的固定大小的列表。
例:List<String> li = Arrays.asList(arr);
List<int[]> li = Arrays.asList(arr);
注意:将数组变成集合,不可以使用集合的增删方法。因为数组的长度是固定的。
如果数组中的元素都是对象,那么变成集合时,数组中的对象就转成集合中的元素,如果数组中的元素都是基本数据类型,那么就会将该数组作为集合中的元素存在。
集合变数组------
<T> T[] toArray(T[] a)
返回包含此 collection 中所有元素的数组;返回数组的运行时类型与指定数组的运行时类型相同。
例:String[] arr = al.toArray(new String[0]);
注:1.指定类型的数组到底要定义多长?
当制定类型的数组长度小于集合的size,那么该方法内部会创建一个新的数组,长度为集合的size。
当指定类型的数组长度大于集合的size,就不会新创建了数组,而是使用了传递进来的数组。
所以创建一个刚刚好的数组最优。
2.为什么要将集合变成数组?
为了限定对元素的操作。不需要进行增删。
高级for循环------
格式:
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{
}
对集合进行遍历,只能获取元素,但是不能对集合进行操作。
迭代器除了遍历,还可以进行remove集合中元素的动作。
例:
for(int i:arr)
{
System.out.println(i);
}
传统for循环和高级for循环的区别:
1.高级for有一个局限性,必须有被遍历的目标。
建议在遍历数组的时候,还是希望使用传统for,因为传统for有脚标。
可变参数------jdk1.5
其实就是一种简写形式,它隐式将参数封装成数组。
格式:T...a
例:
show(int...arr){}//定义
show(2,4,5,6);//调用
使用时注意:可变参数一定要定义在参数列表的最后。
StaticImport 静态导入------
静态导入,导入的是类中的所有静态成员。
例:
import static java.util.Arrays.*;
sort(arr);//此时就不用加前缀:Arrays.
注:
当类名重名时,需要指定具体的包名。
当方法重名时,指定具备所属的对象或者类。
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流! ----------------------详细请查看:http://edu.csdn.net