---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流! ----------------------
1集合框架(体系概述)
为什么会出现这么多的容器呢?
因为每一个容器对数据的存储方式都有不同,这个存储方式可以称之为:数据结构--数据在内存中的存储方式。
2集合框架(共性方法)
引入的包:import java.util.*;
创建一个集合容器,使用Collection接口的子类ArrayList
ArrayList aL=new ArrayList();
添加元素:aL.add(“java01”);
获取集合长度:aL.size();
打印集合:System.out.println(aL);
删除元素:aL.remove(“java02”);
aL.clear();
判断元素:aL.contains(“java03”);//是否包含
aL.isEmpty();//集合是否为空
取交集:aL1.retainAll(aL2);
取差集:aL1.removeAll(aL2);
注:add方法的参数类型是Object,以便于接收任意类型对象,集合中存储的都是对象的引用。
3集合框架(迭代器)
什么是迭代器?
其实就是集合的取出元素的方式。
把取出方式定义在了集合的内部,这样取出方式就可以直接访问每个集合内容的元素,那么取出方式就被定义成了内部类。而每一个容器的数据结构不同,所以取出的动作细节也不一样,但是都有共性内容:判断和取出,那么可以将这些共性抽取。那么这些内部类都符合一个规则Iterator,如何获取集合的取出对象呢?通过一个对外提供的方法iterator();
代码:
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList<String> aL=new ArrayList<String>();
aL.add("java01");
aL.add("java02");
aL.add("java03");
Iterator it=aL.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
4集合框架(List结合共性方法)
Collection
|---List:元素是有序的,元素可以重复,因为该集合体系有索引
|---Set:元素是无序的,元素不可以重复,没有索引
List集合特有方法:凡是可以操作角标的方法都是该体系特有的方法。
增加元素:add(index,element)
addAll(index,Collection)
删除元素:remove(index);
修改元素:set(indext,element)
查找元素:get(index)
subList(from,to)
ListIterator();
获取所有元素
方式1:for(int i=0;i<aL.size();i++)
{System.out.println(aL.get(i));}
方式2:
Iterator it=aL.iterator();
while(it.hasNext())
{System.out.println(it.next());}
获取对象的位置:aL.indexOf(“java02”);
5集合框架(ListIterator)
代码:
//在迭代过程中,准备添加或者删除元素
ArrayList aL=new ArrayList();
aL.add("java02");
aL.add("java03");
Iterator it=aL.iterator();
while(it.hasNext())
{
Object obj=it.next();
if(obj.equals("java02"))
it.remove();
}
System.out.println(obj);
List集合特有的迭代器,ListIterator是Iterator的子接口,在迭代时,不可以通过集合对象的方法操作集合中的元素,因为会发生并发修改异常,所以,在迭代时,只能用迭代器的方法操作元素,可是Iterator方法是有限的,只能对元素进行判断,取出,删除的操作,如果想要其他的操作,如添加,修改等就需要使用其子接口,ListIterator,该接口只能通过List集合的ListIterator方法获取。
代码:
ArrayList aL=new ArrayList();
aL.add("java02");
aL.add("java03");
ListIterator it=aL.listIterator();
Object obj=null;
while(it.hasNext())
{
obj=it.next();
if(obj.equals("java02"))
it.add("java009");
}
System.out.println(aL);
判断有没有前一个元素:it.hasPrevious();
判断有没有后一个元素:it.hasNext();
获取前一个元素:it.previous();
6集合框架(List集合具体对象的特点)
Collection
|--List:元素是有序的,元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的链表数据结构。特点:增删速度很快,查询稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
ArrayList 默认长度为10,超过10,再添加,就会new一个新的数组,50%延长,把原来的添加到新数组中来,再向后添加。
Vector 默认长度为10,超过10,100%延长。
一般使用ArrayList,Vector的效率低。
7集合框架(Vector中的枚举)
枚举就是Vector特有的取出方式。发现枚举和迭代器很像。其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。枚举郁郁而终了。
代码:
class VectorDemo
{
public static void main(String[] args)
{
Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");
Enumeration en = v.elements();
while(en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}
8集合框架(LinkedList)
LinkedList:特有方法:
addFirst();
addLast();
getFirst();
getLast();
获取元素,但不删除元素。如果集合中没有元素,会出现NoSuchElementException
removeFirst();
removeLast();
获取元素,但是元素被删除。如果集合中没有元素,会出现NoSuchElementException
在JDK1.6出现了替代方法。
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素,但不删除元素。如果集合中没有元素,会返回null。不抛出异常
pollFirst();
pollLast();
获取元素,但是元素被删除。如果集合中没有元素,会返回null。不抛出异常
9集合框架(LinkedList练习)
使用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.removeFirst();
}
public boolean isNull()
{
return link.isEmpty();
}
}
10集合框架(ArrayList练习1)
代码:
去除ArrayList集合中的重复元素。
注:迭代时,it.next()取一次,就用it.hasNext()判断一次。
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList aL=new ArrayList();
aL.add("java01");
aL.add("java01");
System.out.println(singleElement(aL));
}
public static List singleElement(ArrayList aL)
{
ArrayList temp=new ArrayList();
Iterator it=aL.iterator();
while(it.hasNext())
{
Object obj=it.next();
if(!temp.contains(obj))
temp.add(obj);
}
return temp;
}
}
11集合框架(ArrayList练习2)
将自定义对象作为元素存到ArrayList集合中,并去除重复元素。
比如:存人对象。同姓名同年龄,视为同一个人。为重复元素。
思路:
1,对人描述,将数据封装进人对象。
2,定义容器,将人存入。
3,取出。
注:List集合判断元素是否相同,依据是元素的equals方法。equals方法默认比较的是地址值,我们要让它按照我们的方式比较,需要重写equals方法。
代码:
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList aL=new ArrayList();
aL.add(new Person("zhangsan",34));
aL.add(new Person("lisi",34));
aL.add(new Person("wangwu",33));
aL.add(new Person("wangwu",33));
aL.add(new Person("wangwu",33));
aL.add(new Person("wangwu",33));
aL=singleElement(aL);
Iterator it=aL.iterator();
while(it.hasNext())
{
Person p=(Person)it.next();
System.out.println(p.getName()+" "+p.getAge());
}
System.out.println(aL.remove(new Person("wangwu",33)));
}
public static ArrayList singleElement(ArrayList aL)
{
ArrayList temp=new ArrayList();
Iterator it=aL.iterator();
while(it.hasNext())
{
Object obj=it.next();
if(!temp.contains(obj))
temp.add(obj);
}
return temp;
}
}
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = 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 String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
注意:调用contains(),contais()调用的是equals();
remove底层也调用了equals();
12集合框架(HashSet)
set:元素无序,不可重复。
HashSet:底层数据结构是哈希表
Set集合的功能和Collection功能一致。
代码:
import java.util.*;
class Test
{
public static void main(String[] args)
{
HashSet hs=new HashSet();
hs.add("java01");
hs.add("java02");
hs.add("java03");
hs.add("java04");
hs.add("java03");
Iterator it=hs.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
13集合框架(HashSet存储自定义对象)
往HashSet集合中存入自定义的对象,姓名和年龄相同为同一个人。
代码:
import java.util.*;
class Test
{
public static void main(String[] args)
{
HashSet hs=new HashSet();
hs.add(new Person("java01",22));
hs.add(new Person("java02",22));
hs.add(new Person("java02",22));
Iterator it=hs.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
class Person
{
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;
}
public int hashCode()
{
return this.name.hashCode()+age*17;
}
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);
}
}
HashSet是如何保证元素唯一性的呢?
是通过元素的两个方法,hashCode和equals来完成。
如果元素的HashCode值相同,才会判断equals是否为true。
如果元素的hashcode值不同,不会调用equals。
13集合框架(HashSet判断和删除的依据)
hs.contains(new Person("java01",22));
hs.remove(new Person("java01",22))
注意:对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashcode和equals方法。
14集合框架(TreeSet)
Set:无序,不可以重复元素。
|--HashSet:数据结构是哈希表。线程是非同步的。
保证元素唯一性的原理:判断元素的hashCode值是否相同。
如果相同,还会继续判断元素的equals方法,是否为true。
|--TreeSet:可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据:
compareTo方法return 0.
代码:
import java.util.*;
class Test
{
public static void main(String[] args)
{
TreeSet ts=new TreeSet();
ts.add("java01");
ts.add("java06");
ts.add("java02");
ts.add("java08");
ts.add("java00");
Iterator it=ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
15集合框架(TreeSet存储自定义对象)
往TreeSet集合中存储自定义对象,学生,想按照学生的年龄进行排序。
记住:排序时,当主要条件相同时,一定要判断一下次要条件。
代码:
import java.util.*;
class Test
{
public static void main(String[] args)
{
TreeSet ts=new TreeSet();
ts.add(new Student("zhangsan",23));
ts.add(new Student("zhangsan",19));
ts.add(new Student("zhangsan",33));
ts.add(new Student("zhangsan",11));
ts.add(new Student("zhangsan1",11));
Iterator it=ts.iterator();
while(it.hasNext())
{
Student s=(Student)it.next();
System.out.println(s.getName()+" "+s.getAge());
}
}
}
class Student implements Comparable
{
private String name;
private int age;
public 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;
else if(this.age<s.age)
return -1;
else return this.name.compareTo(s.getName());
}
public String getName()
{
return this.name;
}
public int getAge()
{
return this.age;
}
}
实现Comparable接口,并复写CompareTo(Object obj)方法,Student类才具有比较性。
16集合框架(二叉树)
元素怎么存进去就怎么取出来
public int compareTo(Object obj)
{return 1;}
注:|--TreeSet:可以对Set集合中的元素进行排序。底层数据结构是二叉树。保证元素唯一性的依据:compareTo方法return 0.
TreeSet排序的第一种方式:让元素自身具备比较性。
元素需要实现Comparable接口,覆盖compareTo方法。
也种方式也成为元素的自然顺序,或者叫做默认顺序。
17集合框架(实现comparator方式排序)
TreeSet的第二种排序方式。
当元素自身不具备比较性时,或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。
在集合初始化时,就有了比较方式。
代码:
import java.util.*;
class Test
{
public static void main(String[] args)
{
TreeSet ts=new TreeSet(new MyCompare());
ts.add(new Student("java04",22));
ts.add(new Student("java02",25));
ts.add(new Student("java01",21));
Iterator it=ts.iterator();
while(it.hasNext())
{
Student s=(Student)it.next();
System.out.println(s.getName()+" "+s.getAge());
}
}
}
class Student implements Comparable
{
private String name;
private int age;
public Student(String name,int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return this.name;
}
public int getAge()
{
return this.age;
}
public int compareTo(Object obj)
{
Student s=(Student)obj;
int num=new Integer(this.getAge()).compareTo(new Integer(s.getAge()));
if(num==0)
{
return this.getName().compareTo(s.getName());
}
return num;
}
}
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());
if(num==0)
{
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
}
return num;
}
}
18集合框架(TreeSet练习)
按照字符串的长度排序:使用比较器
import java.util.*;
class Test
{
public static void main(String[] args)
{
TreeSet ts=new TreeSet(new StringLengthComparator());
ts.add("aaaa");
ts.add("cbaa");
ts.add("e9");
Iterator it=ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
class StringLengthComparator implements Comparator
{
public int compare(Object o1,Object o2)
{
String s1=(String)o1;
String s2=(String)o2;
int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num==0)
return s1.compareTo(s2);
return num;
}
}
19集合框架(泛型概述)
泛型:JDK1.5版本以后出现新特性。用于解决安全问题,是一个类型安全机制。
好处
1.将运行时期出现问题ClassCastException,转移到了编译时期。,
方便于程序员解决问题。让运行时问题减少,安全。,
2,避免了强制转换麻烦。
代码:
ArrayList<String> aL=new ArrayList<String>();
aL.add("java01");
aL.add("java02");
Iterator<String> it=aL.iterator();
while(it.hasNext())
{
String s=it.next();
System.out.println(s);
}
20集合框架(泛型使用)
泛型格式:通过<>来定义要操作的引用数据类型。
在使用java提供的对象时,什么时候写泛型呢?
通常在集合框架中很常见,
只要见到<>就要定义泛型。
其实<> 就是用来接收类型的。
当使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可。
泛型比较器代码:
import java.util.*;
class Test
{
public static void main(String[] args)
{
TreeSet<String> ts=new TreeSet<String>(new StringLengthComparator());
ts.add("java02");
ts.add("java01");
ts.add("java001");
Iterator<String> it=ts.iterator();
while(it.hasNext())
{
String s=it.next();
System.out.println(s);
}
}
}
class StringLengthComparator 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;
}
}
21集合框架(泛型类)
泛型类代码:
class Test
{
public static void main(String[] args)
{
Tool<Student> tL=new Tool<Student>();
tL.setObject(new Student());
Student s=tL.getObject();
}
}
class Student
{
}
class Worker
{
}
class Tool<QQ>
{
private QQ q;
public void setObject(QQ q)
{
this.q=q;
}
public QQ getObject()
{
return this.q;
}
}
当类中要操作的引用数据类型不确定的时候,使用泛型类,早期使用的是Object来完成扩展,容易在运行时期强制类型转换出错。
22集合框架(泛型方法)
泛型类定义的泛型,在整个类中有效。如果被方法使用,
那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型,而且类型还不确定。
那么可以将泛型定义在方法上。
代码:
class Test
{
public static void main(String[] args)
{
Demo d=new Demo ();
d.show(4);
d.print("haha");
}
}
class Demo
{
public<T> void show(T t)
{
System.out.println("show"+t);
}
public<T> void print(T t)
{
System.out.println("print"+t);
}
}
23集合框架(静态方法泛型)
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。
public static <W> method(W w)
24集合框架(泛型接口)
在实现接口的时候知道操作的是什么类型:
class Test
{
public static void main(String[] args)
{
InterImple in=new InterImple();
in.show("hello");
}
}
interface Inter<T>
{
public void show(T t);
}
class InterImple implements Inter<String>
{
public void show(String str)
{
System.out.println(str);
}
}
在实现接口的时候不知道操作什么类型,在实例化的时候才知道。
class Test
{
public static void main(String[] args)
{
InterImple<Integer> in=new InterImple<Integer>();
in.show(5);
}
}
interface Inter<T>
{
public void show(T t);
}
class InterImple<T> implements Inter<T>
{
public void show(T t)
{
System.out.println(t);
}
}
25集合框架(泛型限定)
? 通配符。也可以理解为占位符。
泛型的限定;
? extends E: 可以接收E类型或者E的子类型。上限。
? super E: 可以接收E类型或者E的父类型。下限
? extends E示例代码:
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList<Person> aL=new ArrayList<Person>();
aL.add(new Person("aaa1"));
aL.add(new Person("aaa2"));
aL.add(new Person("aaa3"));
print(aL);
ArrayList<Student> aL1=new ArrayList<Student>();
aL1.add(new Student("aaa-01"));
aL1.add(new Student("aaa_02"));
aL1.add(new Student("aaa-03"));
print(aL1);
}
public static void print(ArrayList<? extends Person> aL)
{
Iterator<? extends Person> it=aL.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
}
class Person
{
private String name;
public Person(String name)
{
this.name=name;
}
public String getName()
{
return this.name;
}
}
class Student extends Person
{
public Student(String name)
{
super(name);
}
}
? super E示例代码:
import java.util.*;
class Test
{
public static void main(String[] args)
{
TreeSet<Student> ts=new TreeSet<Student>(new Comp());
ts.add(new Student("abc04"));
ts.add(new Student("abc01"));
ts.add(new Student("abc03"));
Iterator<Student> sit=ts.iterator();
while(sit.hasNext())
{
System.out.println(sit.next().getName());
}
TreeSet<Worker> tss=new TreeSet<Worker>(new Comp());
tss.add(new Worker("wabc-03"));
tss.add(new Worker("wabc-01"));
tss.add(new Worker("wabc-04"));
Iterator<Worker> wit=tss.iterator();
while(wit.hasNext())
{
System.out.println(wit.next().getName());
}
}
}
class Comp implements Comparator<Person>
{
public int compare(Person p1,Person p2)
{
return p1.getName().compareTo(p2.getName());
}
}
class Person
{
private String name;
public Person(String name)
{
this.name=name;
}
public String getName()
{
return this.name;
}
}
class Student extends Person
{
public Student(String name)
{
super(name);
}
}
class Worker extends Person
{
public Worker(String name)
{
super(name);
}
}
26集合框架(Map概述)
Map集合:该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
1,添加。
put(K key, V value)
putAll(Map<? extends K,? extends V> m)
2,删除。
clear()
remove(Object key)
3,判断。
containsValue(Object value)
containsKey(Object key)
isEmpty()
4,获取。
get(Object key)
size()
values()
entrySet()
keySet()
27集合框架(Map子类对象的特点)
Map
|--Hashtable:底层是哈希表数据结构,不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
|--HashMap:底层是哈希表数据结构,允许使用 null 值和 null 键,该集合是不同步的。将hashtable替代,jdk1.2.效率高。
|--TreeMap:底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。
和Set很像。
其实大家,Set底层就是使用了Map集合。
注意:添加元素,添加元素,如果出现添加时,相同的键。那么后添加的值会覆盖原有键对应值。
System.out.println("put:"+map.put("01","zhangsan1"));
System.out.println("put:"+map.put("01","wnagwu"));
28集合框架(Map_keySet)
map集合的两种取出方式:
Set<k> keySet:将map中所有的键存入到Set集合。因为set具备迭代器。所有可以迭代方式取出所有的键,在根据get方法。获取每一个键对应的值。
代码:
import java.util.*;
class Test
{
public static void main(String[] args)
{
Map<String,String> map=new HashMap<String,String>();
map.put("01","zhangsan01");
map.put("02","zhangsan02");
map.put("03","zhangsan03");
map.put("04","zhangsan04");
Set<String> keys=map.keySet();
Iterator<String> it=keys.iterator();
while(it.hasNext())
{
String key=it.next();
String value=map.get(key);
System.out.println(key+"="+value);
}
}
}
注意:Map集合的取出原理:将map集合转成set集合。在通过迭代器取出。
29集合框架(Map-entrySet)
Set<Map.Entry<k,v>> entrySet:将map集合中的映射关系存入到了set集合中,而这个关系的数据类型就是:Map.Entry
Entry其实就是Map中的一个static内部接口。
为什么要定义在内部呢?
因为只有有了Map集合,有了键值对,才会有键值的映射关系。关系属于Map集合中的一个内部事物。而且该事物在直接访问Map集合中的元素。
代码:
import java.util.*;
class Test
{
public static void main(String[] args)
{
Map<String,String> map=new HashMap<String,String>();
map.put("01","zhangsan01");
map.put("02","zhangsan02");
map.put("03","zhangsan03");
map.put("04","zhangsan04");
Set<Map.Entry<String,String>> entry=map.entrySet();
Iterator<Map.Entry<String,String>> it=entry.iterator();
while(it.hasNext())
{
Map.Entry<String,String> me=it.next();
String key=me.getKey();
String value=me.getValue();
System.out.println(key+"="+value);
}
}
}
30集合框架(Map练习)
练习要求:
每一个学生都有对应的归属地。学生Student,地址String。学生属性:姓名,年龄。
注意:姓名和年龄相同的视为同一个学生。保证学生的唯一性。
1,描述学生。
2,定义map容器。将学生作为键,地址作为值。存入。
3,获取map集合中的元素。
import java.util.*;
class Test
{
public static void main(String[] args)
{
HashMap<Student,String> hm=new HashMap<Student,String>();
hm.put(new Student("lisi1",22),"tianjing");
hm.put(new Student("lisi1",22),"beijing");
hm.put(new Student("lisi2",26),"shanghai");
hm.put(new Student("lisi3",23),"nanjing");
hm.put(new Student("lisi4",26),"wuhan");
//第一种取出方式
Set<Student> keys=hm.keySet();
Iterator<Student> it=keys.iterator();
while(it.hasNext())
{
Student stu=it.next();
String address=hm.get(stu);
System.out.println(stu+" "+address);
}
//第二种取出方式
Set<Map.Entry<Student,String>> entry=hm.entrySet();
Iterator<Map.Entry<Student,String>> iter=entry.iterator();
while(iter.hasNext())
{
Map.Entry<Student,String> me=iter.next();
Student stu=me.getKey();
String address=me.getValue();
System.out.println(stu+"-------"+address);
}
}
}
class Student implements Comparable<Student>
{
private String name;
private int age;
public Student(String name,int age)
{
this.name=name;
this.age=age;
}
public int hashCode()
{
return this.name.hashCode()+this.age*37;
}
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.getAge();
}
public int compareTo(Student s)
{
int num=this.name.compareTo(s.getName());
if(num==0)
{
return new Integer(this.age).compareTo(new Integer(s.getAge()));
}
return num;
}
public String getName()
{
return this.name;
}
public int getAge()
{
return this.age;
}
public String toString()
{
return this.name+" "+this.age;
}
}
31集合框架(TreeMap练习)
利用treeMap存入学生对象:
import java.util.*;
class Test
{
public static void main(String[] args)
{
TreeMap<Student,String> hm=new TreeMap<Student,String>(new StuCom());
hm.put(new Student("lisi1",22),"tianjing");
hm.put(new Student("lisi1",22),"beijing");
hm.put(new Student("lisi2",26),"shanghai");
hm.put(new Student("lisi3",23),"nanjing");
hm.put(new Student("lisi4",26),"wuhan");
Set<Map.Entry<Student,String>> entry=hm.entrySet();
Iterator<Map.Entry<Student,String>> iter=entry.iterator();
while(iter.hasNext())
{
Map.Entry<Student,String> me=iter.next();
Student stu=me.getKey();
String address=me.getValue();
System.out.println(stu+"-------"+address);
}
}
}
class StuCom implements Comparator<Student>
{
public int compare(Student s1,Student s2)
{
int num=new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
if(num==0)
return s1.getName().compareTo(s2.getName());
return num;
}
}
class Student implements Comparable<Student>
{
private String name;
private int age;
public Student(String name,int age)
{
this.name=name;
this.age=age;
}
public int hashCode()
{
return this.name.hashCode()+this.age*37;
}
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.getAge();
}
public int compareTo(Student s)
{
int num=this.name.compareTo(s.getName());
if(num==0)
{
return new Integer(this.age).compareTo(new Integer(s.getAge()));
}
return num;
}
public String getName()
{
return this.name;
}
public int getAge()
{
return this.age;
}
public String toString()
{
return this.name+" "+this.age;
}
}
32集合框架(TreeMap练习-字母出现的次数)
根据给定的字符串,统计各个字母出现的次数。
代码:
import java.util.*;
class Test
{
public static void main(String[] args)
{
System.out.println(charCount("rrrrdldlk"));
}
public static String charCount(String str)
{
char[] chs=str.toCharArray();
TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
for(int i=0;i<chs.length;i++)
{
Integer value=tm.get(chs[i]);
if(value==null)
{
value=0;
}
tm.put(chs[i],value+1);
}
StringBuilder sb=new StringBuilder();
Set<Map.Entry<Character,Integer>> entry=tm.entrySet();
Iterator<Map.Entry<Character,Integer>> it=entry.iterator();
while(it.hasNext())
{
Map.Entry<Character,Integer> me=it.next();
Character c=me.getKey();
Integer count=me.getValue();
sb.append(c+"("+count+")");
}
return sb.toString();
}
}
33集合框架(Map扩展)
代码示例1:
import java.util.*;
class Test
{
public static void main(String[] args)
{
HashMap<String,String> yure=new HashMap<String,String>();
HashMap<String,String> jiuye=new HashMap<String,String>();
HashMap<String,HashMap<String,String>> czbk=new HashMap<String,HashMap<String,String>>();
yure.put("01","zhangsan1");
yure.put("02","zhangsan2");
jiuye.put("01","lisi1");
jiuye.put("02","lisi2");
czbk.put("jiuye",jiuye);
czbk.put("yure",yure);
Set<String> keys=czbk.keySet();
Iterator<String> it=keys.iterator();
while(it.hasNext())
{
String key1=it.next();
HashMap<String,String> hs=czbk.get(key1);
System.out.println(key1);
Set<String> ks=hs.keySet();
Iterator<String> iter=ks.iterator();
while(iter.hasNext())
{
String key=iter.next();
String value=hs.get(key);
System.out.println(key+" "+value);
}
}
}
}
代码示例2:
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList<Student> list=new ArrayList<Student>();
list.add(new Student("01",23));
list.add(new Student("02",22));
list.add(new Student("03",33));
list.add(new Student("04",33));
HashMap<String,ArrayList<Student>> czbk=new HashMap<String,ArrayList<Student>>();
czbk.put("jiuye",list);
czbk.put("yure",list);
Set<String> keys=czbk.keySet();
Iterator<String> it=keys.iterator();
while(it.hasNext())
{
String key=it.next();
System.out.println(key);
ArrayList<Student> value=czbk.get(key);
for(int i=0;i<list.size();i++)
{
System.out.println(list.get(i).getName()+" "+list.get(i).getAge());
}
}
}
}
class Student
{
private String name;
private int age;
public Student(String name,int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return this.name;
}
public int getAge()
{
return this.age;
}
}
34 集合(Collections工具类)
排序:Collections.sort(list,new StrLenCom());
最大值:Collections.max(list,new StrLenCom());
这版查找:Collections.binarySearch(list,”aaa”,new StrLenCom());
将集合中的元素全都替换成它:Collections.fill(list,”pp”);
集合中元素替换:Collections.replaceAll(list,”oldValue”,”newValue”)
集合中元素反转:Collections.reverse(list)
强行逆转指定比较器顺序:Collections.reverseOrder(new StrLenCom());
强行逆转实现Comparable接口的对象collection的自然顺序:Collections.reverseOrder();
把元素随机排放:Collections.shuffle(list)
元素换位置:Collections.swap(list,1,2)
将非同步的变成同步的:Collections.synchronizedList(list)
示例代码:
import java.util.*;
class Test
{
public static void main(String[] args)
{
ArrayList<String> list=new ArrayList<String>();
list.add("sddd");
list.add("dkjld");
list.add("dkdk");
Collections.sort(list,new StrLenCom());
String max=Collections.max(list,new StrLenCom());
System.out.println(list);
System.out.println(max);
}
}
class StrLenCom 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;
}
}
35 集合(Arrays工具类)
Arrays:用于操作数组的工具类。
将数组变成字符串:Arrays.toString(arr)
将数组变成List集合:Arrays.asList(arr);(不可以使用集合的增删方法)
*高级for循环
格式:
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{
}
对集合进行遍历。只能获取集合元素。但是不能对集合进行操作。
迭代器除了遍历,还可以进行remove集合中元素的动作。
如果是用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。
传统for和高级for有什么区别呢?
高级for有一个局限性。必须有被遍历的目标。
建议在遍历数组的时候,还是希望是用传统for。因为传统for可以定义脚标。
*可变参数。
例如:
public static void show(String str,int... arr)
{System.out.println(arr.length);}
---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流! ----------------------