------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
第一讲 集合
一、集合类存在的意义
Java是面向对象的,而一般都是对对多个对象进行一起处理,这样为了方便对多个对象同时进行操作维护等,就需要集合来存储对象然后集中来处理。
二、数组和集合类二者区别
集合的长度是可变的,而数组则是固定的另外集合只可以存储对象,而
数组则还可以存方基本数据类型,
第二讲 Collection
集合框架中的常用接口就是Collection。继承他的还有两个子接口:List,Set。
List:元素能够重复并且有序,满足这点的原因就是其有索引。
Set:不同于list有索引,set是没有索引的,因此是不可重复的。
一、Collection接口中的一般操作
a、添加元素
add(Objectobj); //为了能够收任意类型对象,add函数的参是上帝object。
b、删除元素
remove(Objectobj);
clear();——集合晴空函数
c、判断元素
contains(x);确定x元素是否存在
isEmpty();是不是空集合
d、集合长度大小函数 size()
二、迭代概述
a、迭代一般方法
hasNext();判断是否有下一个元素
next();/获得下一元素
注意:调用next方法一下应该用hasnext确认一下。
使用:
集合创建 ArrayList a=newArrayList()
; Iterator diedai=a.iterator();
打印方法一:
for(Iterator iter = a.iterator();iter.hasNext(); )
{
System.out.println(iter.next());
}
打印方法二:
Iterator iter = a.iterator();
while(iter.hasNext())
{
System.out.println(iter.next());
}
c、迭代小提醒
· 迭代器代替了枚举在集合借口中是普遍应用。
· 迭代器的取下一个元素是自动的,所以要注意NoSuchElementException异常。
· 迭代器获取下一个元素返回值类型是Object,不要忘了进行类型转换。
第三讲 List
一、List
组成
List:元素是有序的,元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的是链表数据结构。特点:增删速度很快,查询稍慢。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。
二、List的特有方法
凡是可以操作角标的方法都是该体系特有的方法。
1、增
booleanadd(index,element);//指定位置添加元素
BooleanaddAll(index,Collection);//在指定位置增加给定集合中的所有元素,若省略位置参数,则在当前集合的后面依次添加元素
2、删
Booleanremove(index);//删除指定位置的元素
3、改
set(index,element);//修改指定位置的元素。
4、查
get(index);//通过角标获取元素
subList(from,to);//获取部分对象元素
5、其他
listIterator();//List特有的迭代器
indexOf(obj);//获取元素第一次出现的位置,如果没有则返回-1
注:List集合判断元素是否相同,移除等操作,依据的是元素的equals方法。
三、ListIterator
1、概述
ListIterator是List集合特有的迭代器,是Iterator的子接口。
在迭代时,不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以在迭代器时,只能用迭代器的方法操作元素。可是Iterator方法是有限的,只能对元素进行判断,取出,删除的操作。如果想要其他的操作,如添加、修改等,就需要使用其子接口:ListIterrator。该接口只能通过List集合的ListIterator方法获取。
2、ListIterator特有的方法
add(obj);//增加
set(obj);//修改为obj
hasPrevious();//判断前面有没有元素
previous();//取前一个元素
四、枚举Enumeration
枚举:
就是Vector特有的取出方式。Vector有三种取出方式。
其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。
特有方法:
addElement(obj);//添加元素,相当于add(obj);
Enumerationelements();//Vector特有取出方式(枚举)
hasMoreElements();//相当于Iterator的hasNext()方法
nextElements();//相当于Iterator的next()方法
例:
Vector v=new Vector();
for(Enumeration e=v.elements();e.hasMoreElements();)
{
System.out.println(e.nextElements());
}
Vector v=new Vector(); for(Enumeration e=v.elements();e.hasMoreElements();){ System.out.println(e.nextElements());}
五、LinkedList
LinkedList:底层使用的是链表数据结构。特点:增删速度很快,查询稍慢。
特有方法:
1、增
addFirst();
addLast();
2、获取
//获取元素,但不删除元素。如果集合中没有元素,会出现NoSuchElementException
getFirst();
getLast();
3、删
//获取元素,并删除元素。如果集合中没有元素,会出现NoSuchElementException
removeFirst();
removeLast();
在JDK1.6以后,出现了替代方法。
1、增
offFirst();
offLast();
2、获取
//获取元素,但是不删除。如果集合中没有元素,会返回null。
peekFirst();
peekLast();
3、删
//获取元素,并删除元素。如果集合中没有元素,会返回null。
pollFirst();
pollLast();
示例:
/*
使用LinkedList模拟一个堆栈或者队列数据结构。
堆栈:先进后出 如同一个杯子。
列:先进先出 First in First out FIFO 如同一个水管。
.
*/
import java.util.*;
class LinkedListTest
{
public static void main(String[] args)
{
LinkedList l=new LinkedList();
l.addFirst("java01");
l.addFirst("java02");
l.addFirst("java03");
l.addFirst("java04");
l.addFirst("java05");
.
//堆栈输出
// stack(l);
//队列输出
queue(l);
}
//堆栈
public static void stack(LinkedList l)
{
while (!l.isEmpty())
{
sop(l.removeFirst());
}
}
//队列
public static void queue(LinkedList l)
{
while(!l.isEmpty())
{
sop(l.removeLast());
}
}
//输出
public static void sop(Object obj)
{
System.out.println(obj);
}
}
第四讲 Set
一、概述
Set:元素是无序(存入和取出的顺序不一定一致),元素不可以重复。
|--HashSet:底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理:判断元素的hashCode值是否相同。如果相同,还会继续判断元素的equals方法,是否为true。
|--TreeSet:可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据:compareTo方法return 0。
Set集合的功能和Collection是一致的。
二、HasSet
HashSet:线程不安全,存取速度快。
可以通过元素的两个方法,hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同,才会判断equals是否为true。如果元素的hashCode值不同,不会调用equals。
注意:HashSet对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashCode和equals方法。
示例:
[java] view plaincopyprint?
/*
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人,重复元素。去除重复元素
思路:1、对人描述,将人的一些属性等封装进对象
2、定义一个HashSet容器,存储人对象
3、取出
*/
import java.util.*;
//人描述
class Person
{
private String name;
private int age;
Person(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 Person))
return false;
Person p=(Person)obj;
return this.name.equals(p.name)&&this.age==p.age;
}
public int hashCode()
{
return this.name.hashCode()+this.age;
}
}
class HashSetTest
{
public static void main(String[] args)
{
HashSet h=new HashSet();
h.add(new Person("shenm",10));
h.add(new Person("shenm2",6));
h.add(new Person("shenm1",30));
h.add(new Person("shenm0",10));
h.add(new Person("shenm0",10));
getOut(h);
}
//取出元素
public static void getOut(HashSet h)
{
for (Iterator it=h.iterator(); it.hasNext(); )
{
Person p=(Person)it.next();
sop(p.getName()+"..."+p.getAge());
}
}
//打印
public static void sop(Object obj)
{
System.out.println(obj);
}
}
public static void sop(Object obj) { System.out.println(obj); }}
三、TreeSet
1、特点
a、底层的数据结构为二叉树结构(红黑树结构)
b)可对Set集合中的元素进行排序,是因为:TreeSet类实现了Comparable接口,该接口强制让增加到集合中的对象进行了比较,需要复写compareTo方法,才能让对象按指定需求(如人的年龄大小比较等)进行排序,并加入集合。
java中的很多类都具备比较性,其实就是实现了Comparable接口。
注意:排序时,当主要条件相同时,按次要条件排序。
二叉树示意图
c、保证数据的唯一性的依据:通过compareTo方法的返回值,是正整数、负整数或零,则两个对象较大、较小或相同。相等时则不会存入。
2、Tree排序的两种方式
1)第一种排序方式:自然排序
让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法。这种方式也被称为元素的自然顺序,或者叫做默认顺序。
示例:
import java.util.*;
//学生类
class Student implements Comparable
{
private String name;
private int age;
Student(String name,int age)
{
this.name=name;
. this.age=age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
//复写hashCode以便HashSet集合调用
public int hashCode()
{
return name.hashCode()+age;
}
//复写equals以便HashSet集合和集合中一些比较方法调用
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
throw new RuntimeException();
Student s = (Student)obj;
return this.name.equals(s.name)&&this.age==s.age;
}
//复写compareTo以便TreeSet集合调用
public int compareTo(Object obj)
{
Student s=(Student)obj;
if(this.age==s.age)
return this.name.compareTo(s.name);
return this.age-s.age;
//return new Integer(this.age).compareTo(new Integer(s.age));
}
}
class TreeSetTest
{
public static void main(String[] args)
{
TreeSet<Student> t=new TreeSet<Student>();
t.add(new Student("wo1",12));
t.add(new Student("wosj",2));
t.add(new Student("wo1sdj",12));
t.add(new Student("wo6sd",12));
t.add(new Student("wo",22));
for (Iterator<Student> it=t.iterator(); it.hasNext(); )
{
Student s=it.next();
System.out.println(s.getName()+"....."+s.getAge());
}
}
}
2)第二种方式:比较器
当元素自身不具备比较性时,或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时,就有了比较方式。定义一个比较器,将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器构造方式:定义一个类,实现Comparator接口,覆盖compare方法。
当两种排序都存在时,以比较器为主。
示例:
/*
需求:
往TreeSet集合中存储自定义对象学生。
想按照学生的年龄进行排序。
*/
import java.util.*;
//学生类
class Student implements Comparable
. {
private String name;
private int age;
Student(String name,int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
//复写hashCode以便HashSet集合调用
public int hashCode()
{
return name.hashCode()+age;
}
//复写equals以便HashSet集合和集合中一些比较方法调用
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
throw new RuntimeException();
Student s = (Student)obj;
return this.name.equals(s.name)&&this.age==s.age;
}
//复写compareTo以便TreeSet集合调用
public int compareTo(Object obj)
{
Student s=(Student)obj;
if(this.age==s.age)
return this.name.compareTo(s.name);
return this.age-s.age;
//return new Integer(this.age).compareTo(new Integer(s.age));
}
}
class TreeSetTest
{
public static void main(String[] args)
{
TreeSet<Student> t=new TreeSet<Student>(new LenCompare());
t.add(new Student("wo1",12));
. t.add(new Student("wosj",2));
t.add(new Student("wo1sdj",12));
t.add(new Student("wo6sd",12));
t.add(new Student("wo",22));
. for (Iterator<Student> it=t.iterator(); it.hasNext(); )
{
Student s=it.next();
System.out.println(s.getName()+"....."+s.getAge());
}
}
}
//定义一个比较器,以姓名长度为主要比较
class LenCompare implements Comparator<Student>
{
. public int compare(Student s1,Student s2)
{
int num=new Integer(s1.getName().length()).compareTo(new Integer(s2.getName().length()));
if (num==0)
{
return new Integer(s1.getAge()).compareTo(s2.getAge());
}
return num;
}
}
第五讲 Map集合
一、概述
1、简述:
Map<K,V>集合是一个接口,和List集合及Set集合不同的是,它是双列集合,并且可以给对象加上名字,即键(Key)
2、特点:
1)该集合存储键值对,一对一对往里存
2)要保证键的唯一性。
二、Map集合的子类
Map
|--Hashtable:底层是哈希表数据结构,不可以存入null键null值。该集合是线程同步的。JDK1.0,效率低。
|--HashMap:底层是哈希表数据结构。允许使用null键null值,该集合是不同步的。JDK1.2,效率高。
|--TreeMap:底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。
Map和Set很像。其实Set底层就是使用了Map集合。
三、Map集合的常用方法
1、添加
Vput(K key,V value);//添加元素,如果出现添加时,相同的键,那么后添加的值会覆盖原有键对应值,并put方法会返回被覆盖的值。
voidputAll(Map <? extends K,? extends V> m);//添加一个集合
2、删除
clear();//清空
Vremove(Object key);//删除指定键值对
3、判断
containsKey(Objectkey);//判断键是否存在
containsValue(Objectvalue)//判断值是否存在
isEmpty();//判断是否为空
4、获取
Vget(Object key);//通过键获取对应的值
size();//获取集合的长度
Collection<V>value();//获取Map集合中所以得值,返回一个Collection集合
还有两个取出方法,接下来会逐个讲解:
Set<Map.Entry<K,V>>entrySet();
Set<K> keySet();
注:HashMap集合可以通过get()方法的返回值来判断一个键是否存在,通过返回null来判断。
四、Map集合的两种取出方式
Map集合的取出原理:将Map集合转成Set集合。再通过迭代器取出。
1、Set<K> keySet():将Map中所以的键存入到Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所以键的值,再通过get方法。获取每一个键对应的值。
示例:
[java] view plaincopyprint?
/*
每一个学生都有对应的归属地。
学生Student,地址String。
学生属性:姓名,年龄。
注意:姓名和年龄相同的视为同一个学生。
保证学生的唯一性。
思路:1、描述学生类
2、定义一个Map集合,存储学生对象和地址值
. 3、获取Map中的元素
*/
import java.util.*;
//描述学生类
class Student implements Comparable<Student>
{
private String name;
private int age;
Student(String name,int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
//复写hashCode
public int hashCode()
{
return name.hashCode()+age*33;
}
//复写equals,比较对象内容
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
throw new ClassCastException("类型不匹配");
Student s=(Student)obj;
return this.name.equals(s.name)&&this.age==s.age;
}
//复写compareTo,以年龄为主
public int compareTo(Student c)
{
int num=new Integer(this.age).compareTo(new Integer(c.age));
if(num==0)
{
return this.name.compareTo(c.name);
}
return num;
}
//复写toString,自定义输出内容
. public String toString()
{
return name+"..."+age;
}
}
class HashMapTest
. {
public static void main(String[] args)
{
HashMap<Student,String > hm=new HashMap<Student,String >();
hm.put(new Student("zhangsan",12),"beijing");
hm.put(new Student("zhangsan",32),"sahnghai");
hm.put(new Student("zhangsan",22),"changsha");
hm.put(new Student("zhangsan",62),"USA");
hm.put(new Student("zhangsan",12),"tianjing");
keyset(hm);
}
//keySet取出方式
public static void keyset(HashMap<Student,String> hm)
{
Iterator<Student> it=hm.keySet().iterator();
while(it.hasNext())
{
Student s=it.next();
String addr=hm.get(s);
System.out.println(s+":"+addr);
}
}
}
2、Set<Map.Entry<K,V>> entrySet():将Map集合中的映射关系存入到Set集合中,而这个关系的数据类型就是:Map.Entry
其实,Entry也是一个接口,它是Map接口中的一个内部接口。
interface Map
{
public static interface Entry
{
public abstract Object getKey();
public abstract Object getValue();
}
}
interface Map { public static interface Entry { public abstract Object getKey(); public abstract Object getValue(); } }
示例:
同上面示例的学生类----
class HashMapTest
{
public static void main(String[] args)
{
HashMap<Student,String > hm=new HashMap<Student,String >();
hm.put(new Student("zhangsan",12),"beijing");
hm.put(new Student("zhangsan",32),"sahnghai");
hm.put(new Student("zhangsan",22),"changsha");
hm.put(new Student("zhangsan",62),"USA");
hm.put(new Student("zhangsan",12),"tianjing");
entryset(hm);
}
//entrySet取出方式
public static void entryset(HashMap<Student,String> hm)
{
Iterator<Map.Entry<Student,String>> it=hm.entrySet().iterator();
while(it.hasNext())
{
Map.Entry<Student,String> me=it.next();
Student s=me.getKey();
String addr=me.getValue();
System.out.println(s+":::"+addr);
}
}
}
l
关于Map.Entry:
Map是一个接口,其实,Entry也是一个接口,它是Map的子接口中的一个内部接口,就相当于是类中有内部类一样。为何要定义在其内部呢?
原因:a、Map集合中村的是映射关系这样的两个数据,是先有Map这个集合,才可有映射关系的存在,而且此类关系是集合的内部事务。
b、并且这个映射关系可以直接访问Map集合中的内部成员,所以定义在内部。
五、Map集合的应用及扩展
1、何时使用Map集合:当量数据之间存在着映射关系的时候,就应该想到使用Map集合。
2、示例:
获取该字符串中的字母出现的次数,如:"sjokafjoilnvoaxllvkasjdfns";希望打印的结果是:a(3)c(0).....
通过结果发现,每个字母都有对应的次数,说明字母和次数之间有映射关系。代码如下:
. /*
思路:1、将字符串转换为字符数组
2、定义一个TreeMap集合,用于存储字母和字母出现的次数
3、用数组去遍历集合,如果集合中有该字母则次数加1,如果集合中没有则存入
4、将TreeMap集合中的元素转换为字符串
*/
class CharCount {
public static void main(String[] args)
{
String s="sdfgzxcvasdfxcvdf";
System.out.println("s中各字母出现的次数:"+charCount(s));
}
//定义一个方法获取字符串中字母出现的次数
public static String charCount(String str)
{
char[] cha=str.toCharArray();//转换为字符数组
//定义一个TreeMap集合,因为TreeMap集合会给键自动排序
TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
int count=0;//定义计数变量
for (int x=0;x<cha.length ;x++ )
{
if(!(cha[x]>='a'&&cha[x]<='z'||cha[x]>='A'&&cha[x]<='Z'))
continue;//如果字符串中非字母,则不计数
Integer value=tm.get(cha[x]);//获取集合中的值
if(value!=null)//如果集合中没有该字母,则存入
count=value;
count++;
tm.put(cha[x],count);//存入键值对
count=0;//复位计数变量
}
StringBuilder sb=new StringBuilder();//定义一个容器
//遍历集合,取出并以题目格式存入容器中
for(Iterator<Character> it=tm.keySet().iterator();it.hasNext();)
{
Character ch=it.next();
Integer value=tm.get(ch);
sb.append(ch+"("+value+")");
}
return sb.toString();//返回字符串
}
}