-------android培训、java培训、期待与您交流! ----------
第一节 集合框架
一.概述:
1.面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式。
2.数组和集合类同是容器,有何不同:
数组虽然也可以存储对象,但长度是固定的,集合长度是可变的。
数组中可以存储基本数据类型,集合只能存储对象。
3.集合类的特点:集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象。
4.每一个容器对数据的存储方式都有不同。这个存储方式我们称之为数据结构。
二.集合中德共性方法。
1.增加:boolean add(E e) ; 添加元素方法。
2.删除:boolean remove(Object o) ;从集合中移除单个元素。
boolean removeAll(Collection<?> c); 移除一堆元素。
void clear(); 清空集合中的元素。
3.查:Iterator<E> iterator(); 返回在此collection的元素上进行迭代的迭代器。
4.长度: int size(); 返回集合中元素的大小。
5. Object[] toArray() ; 把集合转成数组。
注意:
add方法的参数类型是Object。以便于接收任意类型对象。
集合中存储的都是对象的引用(地址)
什么是迭代器呢?
其实就是集合的取出元素的方式。
因为每个容器的数据结构不一样,所以存取的方式也不一样。
对于取出这个动作,不足以用一个函数来表示。而是需要多个,所以就把这个动作提取为一个类。集合中存放着元素,你想要操作集合中的元素。所以把取出方式定义在集合的内部。这样取出方式就可以直接访问集合内容的元素。
那么取出方式就被定义成了内部类。而每一个容器的数据结构不同,所以取出的动作细节也不一样。但是都有共性内容判断和取出。那么可以将共性抽取。
那么这些内部类都符合一个规则。该规则是Iterator。如何获取集合的取出对象呢?通过一个对外提供的方法。iterator();
Collection:
|--List:元素是有序的,元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList :底层使用的是链表数据结构。特点:增删的速度很快,查询速度慢。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了.
|--Set:元素是无序的。元素不可以重复。
第二节 List集合
一.概述:
List:特有方法。凡是可以操作脚标的方法都是该体系特有的方法。
增: add(index,element);
addAll(index Collection)
删 : remove(index)
改 : set(index,elements);
查 : get(index);
subList(from,to);
listIterator();
方法演示示例代码:
package Collection;
import java.util.*;
public class CollectionDemo {
public static void main(String[] args){
method_2();
}
public static void method_2(){
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
ArrayList al2 = new ArrayList();
//添加元素
al2.add("java03");
al2.add("java04");
al2.add("java05");
al2.add("java06");
//取两个集合中的交集,al中只保留交集元素
// al.retainAll(al2);
// sop(al);
//移除两个集合交集的元素。
al.removeAll(al2);
sop(al);
}
public static void method_1(){
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
sop(al); //打印集合中的元素
sop("size:"+al.size()); //打印集合长度
al.remove("java01"); //删除元素
sop("size:"+al.size());
sop(al);
al.clear(); //清空集合中的元素。
sop(al);
}
public static void sop(Object o){
System.out.println(o);
}
}
在迭代时,不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。
所以在迭代时,只能用迭代器的方法操作元素,可是Iterator方法是有局限性的。只能对元素进行判断,取出,删除的操作。
如果想要其他的操作如添加,修改等,就需要使用其子接口:ListIterator。
该接口只能通过List集合的listIterator方法获取。
枚举就是Vector特有的取出方式。发现枚举和迭代器很像。
其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长,所以被迭代器取代了。
示例代码:
package Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class ListDemo {
public static void main(String[] args){
listIteratorMethod();
}
public static void addMethod(){
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
//原集合为:
sop(al);
//删除某个元素
//al.remove(1);
//sop(al);
//修改元素
al.set(2, "java09");
//两种方式获取元素。
for(int i=0;i<al.size();i++){
sop("al"+i+":"+al.get(i));
}
for( Iterator it = al.iterator(); it.hasNext();){
sop(it.next());
}
}
public static void sop(Object o){
System.out.println(o);
}
public static void listIteratorMethod(){
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
sop(al);
for(ListIterator lit = al.listIterator();lit.hasNext();){
Object obj = lit.next();
if(obj.equals("java01"))
//lit.add("java008"); // 在迭代的时候添加元素
//lit.set("java007"); //在迭代的时候修改元素
lit.remove(); //在迭代的时候移除元素
sop(obj);
}
sop(al);
}
}
LinkedList类:
特有方法:
增:
addFirst(E e); 将指定元素插入此列表的开头。
addLast(E e); 将指定元素添加到此列表的结尾。
删:
removeFirst() ;移除并返回此列表的第一个元素。若列表为空,则抛出NosuchElementException异常
removeLast(); 移除并返回此列表的最后一个元素。同上的异常
获取:
getFirst(); 返回此列表的第一个元素。 若列表为空,则抛出NosuchElementException异常
getLast(); 返回此列表的最后一个元素。
LinkedList升级后的方法:
增加 :
offerFirst();
offerLast();
获取:
peekFirst(); 若列表为空,返回null;
peekLast(); 若列表为空,返回null;
删除:
poolFirst(); 若列表为空,返回null;
poolLast(); 若列表为空,返回null;
第三节 Set集合
一.概述:
1.Set:元素是无序(存入和取出的顺序不一定一致),元素不可以重复。
|--HashSet:底层数据结构是哈希表。线程不同步
HashSet是如何保证元素的唯一性的呢?
是通过元素的两个方法,hashCode和equals来完成。
如果元素的HashCode值相同,才会判断equals是否为true。
如果元素的HashCode不同。就不会调用equals方法。
注意:对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashcode和equals方法。
|--TreeSet:底层数据结构是二叉树。保证元素唯一性的依据。
TreeSet排序的第一种方式:让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法。这种方式也成为元素的自然顺序,或者叫做默认顺序。
TreeSet的第二种排序方式。当元素自身不具备比较性时,或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时,就有了比较方式。
特点:可以对Set集合中的元素进行排序。
当两种排序都存在时,以比较起为主。
记住,当排序时,当主要条件相同时,一定要判断一下次要条件。
2.Set集合的功能和Collection是一致的。
3.Set集合取出方式只有一种就是迭代器。
二.哈希表:
1)哈希表是按照哈希值的大小进行排列的,如果两个哈希值不同,则大的值放后面;如果两个哈希值相同,则再用equals方法比较两个元素的对象是否相同,如果不同,则将第二个值顺延,两个值串起来,放在同一个位置上。
2)取值时是按照哈希值取出来的。
HashSet存储自定义对象:
示例代码:
package Collection;
import java.util.HashSet;
import java.util.Iterator;
public class HashSetDemo {
public static void main(String[] args){
HashSet hs = new HashSet();
hs.add(new Person("java01",11));
hs.add(new Person("java02",12));
hs.add(new Person("java01",11));
hs.add(new Person("java03",13));
for(Iterator it =hs.iterator();it.hasNext();){
Person p = (Person)it.next();
System.out.println(p.getName()+"......"+p.getAge());
}
}
}
class Person {
private String name;
private int age;
//定义构造方法,在学生创建时就赋予它基本信息(名字,成绩,总成绩)
Person(String name,int age){
this.name=name;
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
//重写hashCode方法
public int hashCode(){
System.out.println(this.name+".....hashcode");
return 60;
}
public boolean equals(Object o){
if(! (o instanceof Person))
return false;
Person p = (Person)o;
System.out.println(this.name+"equals"+p.name);
return this.name.equals(p.name)&&this.age==p.age;
}
}
TreeSet排序示例代码:
package Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class TreeSetDemo {
public static void main(String[] args){
//第二种排序方式。就是让集合具有可比性
TreeSet ts = new TreeSet(new Mycomparator());
ts.add(new Student("java01",40));
ts.add(new Student("java073",55));
ts.add(new Student("java02",20));
ts.add(new Student("java01",35));
ts.add(new Student("java013",55));
ts.add(new Student("java03",55));
for(Iterator it = ts.iterator();it.hasNext();){
Student s =(Student)it.next();
System.out.println(s.getName()+"........."+s.getAge());
}
}
}
//第一种排序方式。让元素自身实现可比性。
class Student implements Comparable{
private String name;
private int age;
Student(String name,int age){
this.name=name;
this.age=age;
}
Student(){
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
@Override
public int compareTo(Object o) {
if(!(o instanceof Student))
throw new RuntimeException("类型不匹配");
Student s = (Student)o;
int num = new Integer(this.age).compareTo(new Integer(s.getAge()));
if(num==0)
return this.name.compareTo(s.getName());
return num;
}
}
class Mycomparator implements Comparator{
@Override
public int compare(Object o1, Object o2) {
// TODO Auto-generated method stub
Student s = (Student)o1;
Student s2 = (Student)o2;
int num = new Integer(s.getAge()).compareTo(new Integer(s2.getAge()));
if(num==0)
return s.getName().compareTo(s2.getName());
return num;
}
}
泛型概述:
泛型:JDK1.5版本以后出现的新特性。用于解决安全问题,是一个类型安全机制。
好处:
1.将运行时期出现问题ClassCastException,转移到了编译时期。方便于程序员解决问题。让运行事情问题减少,安全。
2.避免了强制转换的麻烦。
泛型格式:通过< >来定义要操作的引用数据类型。
在使用java提供的对象时,什么时候写泛型呢?
通常在集合框架中很常见,只要见到< >就要定义泛型。
其实< >就是用来接收类型的。当使用集合时,将集合中要存储的数据类型作为参数传递到< >中即可。
泛型使用示例代码:
package Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class GenericDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
TreeSet<String> ts = new TreeSet<String>(new lengthComparator());
ts.add("abc");
ts.add("fdsf");
ts.add("obnjde");
ts.add("abd");
ts.add("abcde");
ts.add("obnjee");
//定义泛型的好处一: 在把元素添加进集合时,要是添加的不是String类型。编译器就会报错。
// ts.add(4);
for(Iterator<String> it =ts.iterator();it.hasNext();){
// String s = (String)it.next(); //好处二:没有泛型前这里需要强制类型转换。而有了泛型后不用强制转换了。
String s = it.next();
System.out.println(s);
}
}
}
class lengthComparator implements Comparator<String>{
@Override
public int compare(String o1, String o2) {
// TODO Auto-generated method stub
int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
if(num==0)
{
return o1.compareTo(o2);
}
return num;
}
}
泛型类:
什么时候定义泛型类?当类中要操作的引用数据类型不确定的时候,早期定义Object来完成扩展,现在定义泛型来完成扩展。
示例代码:
package Collection;
public class GenericDemo2 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// Tool t = new Tool();
// t.setObject(new Student());
// Student s = (Student)t.getObject();
//有个泛型这个特性后的做法
Utils<Student> ut = new Utils<Student>();
ut.setQQ(new Student());
Student s = ut.getQQ();
}
}
//没有出现泛型这个特性之前的做法
class Tool{
private Object o;
public void setObject(Object o){
this.o=o;
}
public Object getObject(){
return this.o;
}
}
class Utils<QQ>{
private QQ q;
public void setQQ(QQ q){
this.q=q;
}
public QQ getQQ(){
return q;
}
}
泛型方法:
泛型类定义的泛型,在整个类中有效。如果被方法使用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型,而且类型还不确定。
那么可以将泛型定义在方法上。
特殊之处:
静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。
示例代码:
package Collection;
import java.util.ArrayList;
import java.util.Iterator;
public class GenericDemo3 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<String> ts = new ArrayList<String>();
ts.add("abc");
ts.add("fdsf");
ts.add("obnjde");
ts.add("abd");
ts.add("abcde");
ts.add("obnjee");
iteratorMethod(ts);
ArrayList<Integer> ts2 = new ArrayList<Integer>();
ts2.add(18);
ts2.add(19);
ts2.add(20);
iteratorMethod(ts2);
}
//定义泛型可以为?,也可以为T
public static <T> void iteratorMethod(ArrayList<T> list){
for(Iterator<T > it =list.iterator();it.hasNext();){
System.out.println(it.next());
}
}
}
泛型定义在接口上。
泛型限定: ? Extends E :可以接收E类型或者E的子类型。上限。
? super E :可以接收E类型或者E的父类型。下限
? 通配符。也可以理解为占位符。
第四节 Map集合
一.概述:
1.特点:该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
2.常用方法:
1.添加:v put(k key , v value); 将数据以键值对的方式存进集合中。
void putAll(Map<? extends k,? extends v> m) ;从指定映射中将所有映射关系复制到此映射中
2.删除:void clear(); 清空集合
v remove(Object key); 将集合中的元素以键的形式移除。
3.判断:containsKey(Object key) 判断集合中是否有key。如果有,则返回true。
contaninValue(Object value) 判断集合中是否有value
4.查询:get(Object key);
size();
values();
entrySet();
keySet();
Map有三个常见子类:
|---Hashtable:此类实现一个哈希表,该哈希表将映射到相应的值。任何非null对象都可以用作键或值。该集合是线程同步的。 Jdk1.0 效率低
|--HashMap:底层是哈希表数据结构,允许使用null值和null键,该集合是不同步的。 Jdk1.2 效率高
|--TreeMap:底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。
和Set很像。
其实Set底层就是使用了Map集合。
注:如果添加相同的键,那么后添加的值会覆盖原来键对应值。
map集合的两种取出方式:
1.keySet:将map中所有的键存入到Set集合。因为set具备迭代器。所以可以用迭代的方式取出所有的键,在根据get方法。获取每一个键对应的值。
Map集合的取出原理:将map集合转成set集合。再通过迭代器取出。
2.Set<Map.Entry<k,v>> entrySet:将map集合中德映射关系存入到了set集合中,而这个关系的数据类型就是:map.entry.
Map.Entry 其实Entry也是一个接口,它是Map接口中的一个内部接口。
为何要定义在其内部呢?
原因:
a.Map集合中存的是映射关系这样的两个数据,是先有Map这个集合,才可有映射关系的存在,而且此类关系是集合的内部事务。
b.并且这个映射关系可以直接访问Map集合中的内部成员,所以定义在内部。
示例代码:
package Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.Map.Entry;
public class HashMapDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
entrySetMethod();
}
//利用keySet这个方法取出map集合中的值。
public static void keySetMethod(){
//创建一个HashMap集合,并添加了泛型。键值都是String类型的。
HashMap<String,String> hm = new HashMap<String,String>();
hm.put("01","zhangsan01");
hm.put("02","zhangsan02");
hm.put("03","zhangsan03");
hm.put("04","zhangsan04");
Set<String> keyset = hm.keySet();
for(Iterator<String> it =keyset.iterator();it.hasNext();){
String key =it.next();
String value = hm.get(key);
System.out.println("key: "+key+" "+"value:"+value);
}
}
public static void entrySetMethod(){
HashMap<String,String> hm = new HashMap<String,String>();
hm.put("01","zhangsan01");
hm.put("02","zhangsan02");
hm.put("03","zhangsan03");
hm.put("04","zhangsan04");
Set<Entry<String, String>> entry=hm.entrySet();
for(Iterator<Entry<String, String>> it =entry.iterator();it.hasNext();){
Entry<String, String> en = it.next();
System.out.println(en.getKey()+" "+en.getValue());
}
}
}
Map练习:
每一个学生都有对应的归属地。学生Student,地址String。学生属性:姓名,年龄。
注意:姓名和年龄相同的视为同一个学生。保证学生的唯一性。
思路:
1.描述学生。
2.定义map容器。将学生作为键,地址作为值。存入。
3.获取map集合中的元素。
示例代码:
package Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
entrySet();
}
//第一种取出方式keySet();
public static void keySet(){
HashMap<Students,String> hm = new HashMap<Students,String>();
hm.put(new Students("lisi1",21), "beijing");
hm.put(new Students("lisi1",21), "tianjing");
hm.put(new Students("lisi4",33), "nanjing");
hm.put(new Students("lisi8",44), "ganzhou");
hm.put(new Students("lisi5",80), "hengyang");
Set<Students> keyset =hm.keySet();
for(Iterator<Students> it = keyset.iterator();it.hasNext();){
Students key =it.next();
String addrv =hm.get(key);
System.out.println(key+":::"+addrv);
}
}
public static void entrySet(){
HashMap<Students,String> hm = new HashMap<Students,String>();
hm.put(new Students("lisi1",21), "beijing");
hm.put(new Students("lisi1",21), "tianjing");
hm.put(new Students("lisi4",33), "nanjing");
hm.put(new Students("lisi8",44), "ganzhou");
hm.put(new Students("lisi5",80), "hengyang");
Set<Map.Entry<Students, String>> entryset = hm.entrySet();
for(Iterator<Map.Entry<Students, String>> it =entryset.iterator();it.hasNext();){
Map.Entry<Students, String> entry = it.next();
Students s = entry.getKey();
String addr = entry.getValue();
System.out.println(s+":::"+addr);
}
}
}
练习2:
需求:对学生对象的年龄进行升序排序。
因为数据是以键值对形式存在的。所以要使用可以排序的Map集合TreeMap。
示例代码
package Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
public class MapTest2 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
TreeMap<Students,String> tm = new TreeMap<Students,String>(new myCom());
tm.put(new Students("lisi1",21), "beijing");
tm.put(new Students("lisi1",21), "tianjing");
tm.put(new Students("lisi4",33), "nanjing");
tm.put(new Students("lisi8",44), "ganzhou");
tm.put(new Students("lisi5",80), "hengyang");
Set<Students> set = tm.keySet();
Iterator<Students> it =set.iterator();
while(it.hasNext())
{
Students stu = it.next();
String addrv = tm.get(stu);
System.out.println(stu+":::"+addrv);
}
}
}
class myCom implements Comparator<Students>{
@Override
public int compare(Students o1, Students o2) {
// TODO Auto-generated method stub
int num = new Integer(o1.getAge()).compareTo(new Integer(o2.getAge()));
if(num==0)
return o1.getName().compareTo(o2.getName());
return num;
}
}
练习3:
“dsfdsfdsfrfew”获取该字符串中的字母出现的次数。
希望打印结果:a(1)c(2).........
通过结果发现,每一个字母都有对应的次数。说明字母和次数之间都有映射关系。
注意了,当发现有映射关系时,可以选择map集合。因为map集合中存放就是映射关系。
什么时候使用map集合呢?
当数据之间存在这映射关系时,就先要想map集合。
思路:
1.将字符串转换成字符数组。因为要对每一个字符进行操作。
2.定义一个map集合,因为打印结果的字母有顺序,所以使用treemap集合。
3.遍历字符数组,将每一个字符作为键去查map集合,如果返回null将该字母和1存入到map集合中。如果返回不是null,说明该字符在map集合已经存在并有对应的次数。那么就获取该次数并进行自增。然后将该字母和自增后的次数存入到map集合中。覆盖调用原键值对。
4.将map集合中的数据变成指定的字符串形式并返回。
示例代码:
package Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class Maptest3 {
public static void main(String[] args){
System.out.println(testMethod("abcaabddkeufdasda"));
}
public static String testMethod(String str){
char[] chs = str.toCharArray();
TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
StringBuilder sb = new StringBuilder();
int count=0;
for(int i=0;i<chs.length;i++){
Integer value = tm.get(chs[i]);
if(!(value==null))
count =value;
count++;
tm.put(chs[i], count);
count=0;
}
Set<Map.Entry<Character,Integer>> entry = tm.entrySet();
for(Iterator<Map.Entry<Character,Integer>> it =entry.iterator();it.hasNext();){
Map.Entry<Character,Integer> map = it.next();
Character ch = map.getKey();
Integer in = map.getValue();
sb.append(ch+"("+in+")");
}
return sb.toString();
}
}
Map扩展知识。
示例代码:
package Collection;
import java.util.*;
public class MapDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
hashMapMethod();
}
public static void hashMapMethod(){
HashMap<String,HashMap<String,String>> hm = new HashMap<String,HashMap<String,String>>();
HashMap<String,String> yure = new HashMap<String,String>();
HashMap<String,String> jiuye = new HashMap<String,String>();
hm.put("yureban", yure);
hm.put("jiuyeban", jiuye);
yure.put("01", "小明");
yure.put("09", "小华");
jiuye.put("01", "小分");
jiuye.put("09", "小康");
Set<String> set = hm.keySet();
Iterator<String> it = set.iterator();
while(it.hasNext()){
String roomname =it.next();
HashMap<String,String> room = hm.get(roomname);
entryRoomName(room);
}
}
public static void entryRoomName(HashMap<String,String> room){
Set<Map.Entry<String, String>> entry = room.entrySet();
for(Iterator<Map.Entry<String, String>> it = entry.iterator();it.hasNext();){
Map.Entry<String, String> map = it.next();
String num =map.getKey();
String name = map.getValue();
System.out.println("学号:"+num+"名字:"+name);
}
}
}