1 集合概述:
1.1,为什么出现集合?
面向对象语言的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式。
1.2,数组和集合类同是容器,有何不同?
数组虽然也可以存储对象,但长度是固定的,集合长度是可变的数组中可以存储基本数据类型,集合只能存储对象,
1.3,集合类的特点:
集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象。
1.4,Collection的一些方法
Collection接口Collection接口是List和Set和Queue接口的父接口,该接口里定义的方法既可以 操作Set集合。
也可以用于操作List集合,所以我们要先学习一下Collection里的基本方法:
1、添加元素
add(Objectobj); //add方法的参数类型是Object。以便于接收任意类型对象。
2、删除元素
remove(Objectobj);
removeAll(另一集合);//调用者只保留另一集合中没有的元素。
clear();//清空集合
3、判断元素
contains(Objectobj);//判断是否存在obj这个元素
isEmpty();//是否为空
4、获取个数,集合长度
size();
5、取交集
retainAll(另一集合);//调用者只保留两集合的共性元素。
1.5集合元素的获取
当使用System.out的println方法来输出集合对象时,将输出[ele1,ele2,....]的形式,显然是因为所有的Collection实现类都重写了toString()方法但是如果想依次访问集合里的每一个元素,则需要使用某种方式来遍历集合对象,使用Iterator接口遍历集合对象或者使用foreach循环遍历集合元素。
注意:在没有限定泛型时,我们把一个对象放进集合里,集合会忘记这个对象的类型,集合会把所有的元素当成Object类的实例进行处理。
1,使用Iterator接口(在迭代时,只能用迭代器的方法操作元素)
Iterator接口里定义了3个方法。
boolean hasNext();判断集合是否有下一个元素
E next();返回集合的下一个元素
void remove();删除集合里上一次next方法返回的元素
class IteratorTest
{
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add("java01");//add(Object obj);
al.add("java02");
al.add("java03");
al.add("java04");
Iterator it = al.iterator();//获取迭代器,用于取出集合中的元素。
while(it.hasNext())
{
//it.next()方法返回的数据类型是Object类型。需要强制类型转换
String s = (String)it.next();
if(s.equals("java02"))
{
sop(s);
it.remove();
//s.remove("java02") ,使用Iterator迭代过程中,不可修改集合元素,否则引起java.util.ConcurrentModificationException异常。
}
}
}
}
Iterator仅用于遍历集合,Iterator本身并不提供盛装对象的能力,如果需要创建Iterator对象,则必须有一个被迭代的集合。
2使用foreach循环
class IteratorTest
{
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add("java01");//add(Object obj);
al.add("java02");
al.add("java03");
al.add("java04");
for(Object obj : al)
{
String s = (String)obj;
System.out.println(s);
if(s.equals("java02"))
{
//ad.remove(s);引发异常
}
}
}
}
2 List集合
2.1,List的特点:
|--List:元素是有序的,元素可以重复,因为该集合体系有索引。
|--ArrayList;底层的数据结构使用的是数组结构。特点:查询速度快,但是增删慢。线程不同步(默认长度10 )
|--LinkedList;底层使用的是链表数据结构。 特点:增删速度很快,查询稍慢。
|--Vector; 底层是数组数据结构 线程同步。被ArrayList替代了。
2.2,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
class ForTest
{
public static void main(String[] args)
{
ArrayList al = new ArrayList();
//1,添加元素。
al.add("java01");//add(Object obj);
al.add("java02");
al.add("java03");
al.add("java04");
for(int x= 0; x<al.size();x++)
{
System.out.println("al("+x+")="+al.get(x));
}
}
}
2.3,List_equals():
练习(List_equals复写):将自定义对象作为元素存到ArrayList集合中,并去除重复元素。
比如:存人对象。同姓名同年龄,视为同一个人。为重复元素。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;
System.out.println(this.name+"........"+p.name);
return this.name.equals(p.name) && this.age == p.age;
}
}
class ArrayListTest2
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add(new Person("lisi01",30));//al.add(Object obj);//Object obj = new Person("lisi01",30;)
al.add(new Person("lisi02",32));
al.add(new Person("lisi03",33));
al.add(new Person("lisi04",35));
//al = singleElements(al);
sop("remove 03:"+al.remove(new Person("lisi03",33)));//需要用到判断,所以要写equals()方法。返回true
Iterator it = al.iterator();
while(it.hasNext())
{
Person p = (Person)it.next();//做强制转换。it.next是Object类型的,不认识getName()方法。所以要做强制转化
sop(p.getName()+"::"+p.getAge());
}
}
public static ArrayList singleElements(ArrayList al)
{
//定义一个临时容器。
ArrayList newal = new ArrayList();
Iterator it = al.iterator();
while(it.hasNext())
{
Object obj = it.next();
if(!newal.contains(obj))//底层自动调用equals()方法,obj调用自身的equals的方法,和newal的各个元素进行比较
newal.add(obj);
}
return newal;
}
}
2.4,List_listIterator()
->boolean hasPrevious(); 返回该迭代器关联的集合是否有上一个元素。
->Object previous();返回该迭代器的上一个元素。
->void add();在指定位置插入一个元素。
2.5,linkedList
addFirst();
addLast();
getFirst();
getLast();
removeFirst();
removeLast();
在JDK1.6出现了替代方法。
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素,并删除元素。如果集合中没有元素,会返回null
pollFirst();
pollLast();
2.练习(LinkedList)
import java.util.*;
class DuiLie
{
private LinkedList link;
DuiLie()
{
link = new LinkedList();
}
public void myAdd(Object obj)
{
link.addFirst(obj);
}
public Object myGet()
{
return link.removeLast();
}
public boolean isNull()
{
return link.isEmpty();
}
}
class LinkedListTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
DuiLie dl = new DuiLie(); dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");
while(!dl.isNull())
{
sop(dl.myGet());
}
}
}
3 Set集合
3.1Set集合特点
|--Set:元素师无序(存入和取出的顺序不一定一致),元素不可以重复。元素值可以是null(只有一种取出方式迭代器。)
|--HashSet:底层数据结构是哈希表。线程不是同步的。|--TreeSet:底层数据结构是二叉树。可以对Set集合中的元素进行排序。
3.2HashSet
元素的唯一性是通过元素的两个方法,hashCode和equals来完成。
1,如果元素的HashCode(存放位置)值相同,才会判断equals(对象本身)是否为true
2,如果元素的Hashcode值不同,不会调用equals。
hashcode()一样,equals()不一样也存得进去。(在同一个位置,以链的方式存储)
练习:HashSet_HashCode() and equals()
姓名和年龄相同视为同一个人,重复元素。
class HashSetTest
{
public static void main(String[] args)
{
HashSet hs = new HashSet();
hs.add(new Person("a1",11));
hs.add(new Person("a2",12));
hs.add(new Person("a3",13));
hs.add(new Person("a2",12));
//先算一下new Person("a1",12);的hashcode值,和hs里的a2一样,就调用自身的equals()方法。
hs.remove(new Person("a3",13));
Iterator it = hs.iterator();
while(it.hasNext())
{
Person p =(Person)it.next();
sop(p.getName()+":;"+p.getAge());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
class Person
{
private String name;
private int age;
Person(String name, int age)
{
this.name = name;
this.age = age;
}
public int hashCode()//复写哈希值使equals运行。
{
System.out.println(this.name+" .....hashcode")
return name.hashCode()+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;
System.out.println(this.name+"....equals...."+p.name);
/*
a2...equals..a1
a3...equals..a2
a3...equals..a1
a2...equals..a3
a2...equals..a2
*/
return this.name.equals(p.name) && this.age==p.age;
}
}
3.3TreeSet
3.3.1TreeSer排序的第一种方式:
元素需要实现Comparable接口,覆盖compareTo方法。
这种方式也称为元素的自然顺序,或者默认顺序。
3.3.2TreeSet的第二种排序方式。
当元素自身不具备比较性,或者具备的比较性不是所需要的,这时就需要让集合自身具备比较性,在集合初始化时,就有了比较性。练习(TreeSet排序):往TreeSet存入自定义对象学生。
想按照学生的年龄进行排序。(往TreeSet存储的对象都要具备计较性。)
记住:排序时,当主要条件相同时,一定要判断一下次要条件。
class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
//将自定义的比较器传给TreeSet的构造器
//TreeSet ts = new TreeSet(new MyCompare());
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi07",20));//07存进来的时候,调用自己的compareTo和02比较
//没有实现comparable接口会Student cannot be cast to java.lang.Comparable
ts.add(new Student("lisi09",19));//09存进来的时候,调用自己的compareTo分别和02,07比较。
ts.add(new Student("lisi01",40));
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"....."+stu.getAge());
}
}
}
class Student implements Comparable //该接口强制让学生具备比较性。
{
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 s = (Student)obj;
if(this.age>s.age)
return 1;
if(this.age==s.age)
{
return this.name.compareTo(s.name);
}
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age
}
}
//当元素自身不具备比较性,或者具备的比较性不是所需要的。
//这时需要让容器自身具备比较性。
//定义了比较器,实现Comparator接口,覆盖compare方法,将比较器对象作为参数传递给TreeSet集合的构造函数
class MyCompare implements Comparator//两个对象被集合比。。
{
public int compare(Object o1,Object o2)
{
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int num = s1.getName().compareTo(s2.getName());//(String已经实现了Comparator)
if(num==0)//主条件相同判断次要条件。
{
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
}
return num;
}
}
4Map集合
4.1Map集合特点
|--Hashtable:底层是哈希表数据结构,不可以存入null键null值集合式线程同步的。
用作键的对象必须实现equals()和hashcode()方法。
|--HashMap:底层是哈希表数据结构,并允许使用null值和null值,该集合是不同步的。
|--TreeMap:底层是二叉树数据结构。线程是不同步。可以用于给Map集合中的键排序。
4.2Map接口常用方法。
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集合
5,,两个关于取出的方法
Set<Map.Entry<K,V>>entrySet();返回该Map中所有key组成的Set集合。
Set<K> keySet();返回该Map中包含的key-value对所组成的Set集合,每个集合元素都是Map.Entry对象。
注:HashMap集合可以通过get()方法的返回值来判断一个键是否存在,通过返回null来判断。
所以可以通过迭代方式取出所有的键,再根据get方法。获取每一个键对应的值。
而这个关系的数据类型就是:Map.Entry
练习(map_keySet and entrySet):
两种方法的用法:
class MapDemo2
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
map.put("002","zhangsan2");
map.put("003","zhangsan3");
map.put("001","zhangsan1");
map.put("004","zhangsan4");
public static void mehod_1(HashMap<String,String> map)
{
//将map集合中的映射关系取出,存入到Set集合中,
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);
}
}
public static void method_2(HashMap<String,String> map)
{
//先获取map集合中的所有键的Set集合,keyset();
Set<String> keySet = map.keySet();
//有了Set集合就可以获取其迭代器了。
Iterator<String> it = keySet.iterator();
while(it.hasNext())
{
String key = it.next();
// 有了键就可以通过map集合的get方法获取其对应的值。
String value = map.get(key);
System.out.println("key:"+key+",valur:"+value);
}
}
}
}
练习(Map):
"sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。希望打印结果:a(1)c(2).......
import java.util.*;
class MapTest3
{
public static void main(String[] args)
{
String s = charCount("sdfgzxcvasdfxcvdf");
System.out.println(s);
}
public static String charCount(String str)
{
char[] chs = str.toCharArray();
TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
int count = 0;
for(int x=0; x<chs.length; x++)
{
if(!(chs[x]>='a'&& chs[x]<='z'|| chs[x]>='A'&& chs[x]<='Z'))
continue;
Integer value = tm.get(chs[x]);//返回值
if(value!=null)
count = value;
count++;
tm.put(chs[x],count);
count = 0;
StringBuilder sb = new StringBuilder();
Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<Character,Integer> me = it.next();
Character ch = me.getKey();
Integer value = me.getValue();
sb.append(ch+"("+value+")");
}
return sb.toString();
}
}