10、集合类（集合框架）
10.1为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式
10.2数组和集合类同是容器，有何不同？
数组虽然也可以存储对象，当长度是固定的：集合长度时可变的
数组中可以存储基本数据类型，集合只能存储对象
10.3集合类的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
10.4集合框架的构成及分类
10.4.1为什么会出现这么多容器呢
因为每一个容器对数据的存储方式都有不同。这个存储方式称之为：数据结构。
集合中存放的不是对象的实体，而是对象的首地址
10.5Collection定义了集合框架的共性功能
10.5.1添加
add(e);
addAll(collection);
10.5.2删除
remove(e);
removeAll(collection);
clear();
10.5.3判断
contains(e);
isEmpty();
10.5.4获取
iterator();
size();
10.5.5获取交集
retainAll();
10.5.6集合变数组
toArray();
10.5.7注意：
1，add方法的参数类型是Object。以便于接收任意类型对象。
2，集合中存储的都是对象的引用(地址)
接口型引用只能指向自己的子类对象，而此对象是通过集合类的方法获取出来的。
例如：Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。
10.6什么是迭代器呢
其实就是集合取出元素的方式。
如同抓娃娃游戏机中的夹子。
迭代器是取出方式，会直接访问集合中的元素。
所以将迭代器通过内部类的形式来进行描述。
通过容器的iterator()方法获取该内部类的对象。
import java.util.*;
class CollectionDemo
{
public static void main(String[] args)
{
method_get();
}
public static void method_get()
{
ArrayList al = new ArrayList();
//1，添加元素。
al.add("java01");//add(Object obj);
al.add("java02");
al.add("java03");
al.add("java04");
/*while循环迭代元素
Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。
while(it.hasNext())//如果还有元素可以迭代则返回真
{
sop(it.next());//返回迭代的下一个元素。
}
*/
//for循环迭代元素，使得内存更加优化
for(Iterator it = al.iterator(); it.hasNext() ; )
{
sop(it.next());
}
}
public static void method_2()
{
ArrayList al1 = new ArrayList();
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");
ArrayList al2 = new ArrayList();
al2.add("java03");
al2.add("java04");
al2.add("java05");
al2.add("java06");
al1.retainAll(al2); //取交集，al1中只会保留和al2中相同的元素。
al1.removeAll(al2);//去除al1中，他们相同的部分
sop("al1:"+al1);
sop("al2:"+al2);
}
public static void base_method()
{
//创建一个集合容器。使用Collection接口的子类。ArrayList
ArrayList al = new ArrayList();
//1，添加元素。
al.add("java01");//add(Object obj);添加的是父类对象
al.add("java02");
al.add("java03");
al.add("java04");
//打印原集合。
sop("原集合:"+al);//封装成中括号里的元素表现形式
//3，删除元素。
//al.remove("java02");
//al.clear();//清空集合。打印后的结果为一组中括号。
//4，判断元素。
sop("java03是否存在:"+al.contains("java03"));
sop("集合是否为空？"+al.isEmpty());
//2，获取个数。集合长度。
sop("size:"+al.size());
//打印改变后的集合。
sop(al);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
10.7 Collection的子集
Collection JDK1.2
|--List:元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。JDK1.2
|--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。增删查该都很慢。被ArrayList替代了。因为效率低。JDK1.0（开发很少用）
|--Set：元素是无序，元素不可以重复。因为该集合体系没有索引。
10.7.0可变长度数组
ArrayList构造一个初始化容量为10的空列表。当超过容量时，其数组的长度会加长，会以50%的延长。把原来数组中的元素复制到新数组中，在把新元素添加到后面去。而Vector默认初始化长度也为10，当超过10的时候是100%延长，比较浪费空间。
10.7.1List
特有方法。凡是可以操作脚标的方法都是该体系特有的方法。
增加
add(index,element);
addAll(index,Collection);
删除
remove(index);
修改
set(index,element);
查询
get(index):
subList(from,to);//含头不含尾
listIterator();
int indexOf(obj):获取指定元素的位置。
ListIterator listIterator();
10.7.2List集合特有的迭代器
ListIterator是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常（并发修改异常）。
所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作，如果想要其他的操作如添加，修改等，就需要使用其子接口：ListIterator。
该接口只能通过List集合的listIterator方法获取。实现了在集合中遍历的增、删、改、查。
*/
import java.util.*;
class ListDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void method()
{
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
sop("原集合是："+al);
//在指定位置添加元素。
al.add(1,"java09");//脚标位1时添加“java09”
//删除指定位置的元素。
//al.remove(2);//根据脚标位置
//修改元素。
//al.set(2,"java007");
//通过角标获取元素。
sop("get(1):"+al.get(1));
sop(al);
//获取所有元素。操作脚标都是数组元素，遍历
for(int x=0; x<al.size(); x++)
{
System.out.println("al("+x+")="+al.get(x));
}
//使用迭代器遍历
Iterator it = al.iterator();
while(it.hasNext())
{
sop("next:"+it.next());
}
//通过indexOf获取对象的位置。
sop("index="+al.indexOf("java02"));
List sub = al.subList(1,3);
sop("sub="+sub);
}
public static void main(String[] args)
{
//演示列表迭代器。
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
sop(al);
ListIterator li = al.listIterator();
//sop("hasPrevious():"+li.hasPrevious());
while(li.hasNext())
{
Object obj = li.next();
if(obj.equals("java02"))
//li.add("java009");
li.set("java006");
}
while(li.hasPrevious())
{
sop("pre::"+li.previous());
}
//sop("hasNext():"+li.hasNext());
//sop("hasPrevious():"+li.hasPrevious());
sop(al);
/*
//在迭代过程中，准备添加或者删除元素。可以有判断、添加、删除、无添加
Iterator it = al.iterator();
while(it.hasNext())//判断
{
Object obj = it.next();//取出
if(obj.equals("java02"))
//al.add("java008");
it.remove();//将java02的引用从集合中删除了。但未删除其内存中的变量，Obj对象还在引用。
sop("obj="+obj);//所以删除后的元素还在引用
}
sop(al);//集合中的元素是不存在的
*/
}
}
10.8枚举
/*
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。枚举郁郁而终了。
IO对象当中会用。
*/
import java.util.*;
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());
}
}
}
10.9LinkedList
10.9.1 LinkedList以前特有方法：
10.9.1.1添加
addFirst();
addLast();
10.9.1.2获取
getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException（没有这个元素异常）
10.9.1.3删除
removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException（没有这个元素异常）
10.9.2LinkedList:在JDK1.6出现了替代方法（没有异常抛出）
10.9.2.1添加
offerFirst();
offerLast();
10.9.2.2获取
peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。
10.9.2.3获取并删除
pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。
10.9.2.4示例代码：
import java.util.*;
class LinkedListDemo
{
public static void main(String[] args)
{
LinkedList link = new LinkedList();
link.addLast("java01");
link.addLast("java02");
link.addLast("java03");
link.addLast("java04");
//sop(link);
// sop(link.getFirst());//打印java01
// sop(link.getFirst());//打印java01
//sop(link.getLast());//打印java04
//sop(link.removeFirst());//打印java01
//sop(link.removeFirst());//打印java02
//sop("size="+link.size());//打印4
while(!link.isEmpty())
{
sop(link.removeLast());//取出并删除
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
10.9.3LinkedList:模拟堆栈和队列（必须会）
使用LinkedList模拟一个堆栈或者队列数据结构。
堆栈：先进后出 如同一个杯子。
队列：先进先出 First in First out FIFO 如同一个水管。
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();
}
}
class LinkedListTest
{
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())
{
System.out.println(dl.myGet());
}
}
}
10.9.4ArrayList:字符串中无重复元素
/*
去除ArrayList集合中的重复元素。
*/
import java.util.*;
class ArrayListTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java03");
/*
在迭代时循环中next调用一次，就要hasNext判断一次。
Iterator it = al.iterator();
while(it.hasNext())
{
sop(it.next()+"...."+it.next());
}
*/
/**/
sop(al);
al = singleElement(al);
sop(al);
}
public static ArrayList singleElement(ArrayList al)
{
//定义一个临时容器。
ArrayList newAl = new ArrayList();
Iterator it = al.iterator();
while(it.hasNext())
{
Object obj = it.next();
if(!newAl.contains(obj))
newAl.add(obj);
}
return newAl;
}
}
10.9.5ArrayList:自定义对象的存入取出
将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。
思路：
1，对人描述，将数据封装进人对象。
2，定义容器，将人存入。
3，取出。
List集合判断元素是否相同，依据是元素的equals方法。其他不同。
数据结构的不同依赖的方法是不同的。ArrayList和LinkedList都是依赖的equals方法。包括包含和删除依赖的都是这个方法。
import java.util.*;
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;
//System.out.println(this.name+"....."+p.name);
return this.name.equals(p.name) && this.age == p.age;
}
/**/
public String getName()
{
return name;
}
public int getAge()
{
return 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 Demo());
al.add(new Person("lisi01",30));
//al.add(Object obj);//Object obj = new Person("lisi01",30);迭代器返回的都是Object类型
//al.add(new Person("lisi02",32));
al.add(new Person("lisi02",32));
al.add(new Person("lisi04",35));
al.add(new Person("lisi03",33));
//al.add(new Person("lisi04",35));
//al = singleElement(al);
sop("remove 03 :"+al.remove(new Person("lisi03",33)));//remove方法底层也是依赖于元素的equals方法。
Iterator it = al.iterator();
while(it.hasNext())
{
Person p = (Person)it.next();
sop(p.getName()+"::"+p.getAge());
}
}
public static ArrayList singleElement(ArrayList al)
{
//定义一个临时容器。
ArrayList newAl = new ArrayList();
Iterator it = al.iterator();
while(it.hasNext())
{
Object obj = it.next();
if(!newAl.contains(obj)) // contains方法底层也是依赖于元素的equals方法
newAl.add(obj);
}
return newAl;
}
}
10.10contains方法
10.10.1声明
public boolean contains(Object o)
如果此列表中包含指定的元素，则返回 true。更确切地讲，当且仅当此列表包含至少一个满足 (o==null ? e==null : o.equals(e)) 的元素 e 时，则返回 true。
指定者：
接口 Collection<E> 中的contains
指定者：
覆盖：
类 AbstractCollection<E> 中的contains
参数：
o - 测试此列表中是否存在的元素
返回：
如果此列表包含特定的元素，则返回 true
10.10.2LinkedList、ArrayList比较
取到的元素很多，频繁的增删操作，使用LinkedList
涉及到的增删操作不频繁，使用LinkedList或者ArrayList
涉及增删，同时查询，建议使用ArrayList最常使用容器
10.11Set子集
|--Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。
|--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成。
如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashcode值不同，不会调用equals。
注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
equals()方法中的参数必须写，Object类型，没有泛型，必须转换。
|--TreeSet：
Set集合的功能和Collection是一致的。
10.11.1验证数据的存入无序和不可重复
import java.util.*;
class HashSetDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
HashSet hs = new HashSet();
sop(hs.add("java01"));//打印结果为true，存入成功
sop(hs.add("java01"));//打印结果为false，存入失败，相同
hs.add("java02");
hs.add("java03");
hs.add("java03");
hs.add("java04");
Iterator it = hs.iterator();//哈希表的取值方式只有一种就是迭代器。
while(it.hasNext())
{
sop(it.next());//打印结果无序
}
}
}
10.11.2HashSet应用举例:往hashSet集合中存入自定义对象
姓名和年龄相同为同一个人，重复元素。
import java.util.*;
class HashSetTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
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));
// hs.add(new Person("a4",14));
//sop("a1:"+hs.contains(new Person("a2",12)));
// hs.remove(new Person("a4",13));
Iterator it = hs.iterator();
while(it.hasNext())
{
Person p = (Person)it.next();
sop(p.getName()+"::"+p.getAge());
}
}
}
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public int hashCode()//复写父类的hashCode方法，返回一个哈希值，并通过此值判断，其对象的哈希值的
{
System.out.println(this.name+"....hashCode");
return name.hashCode()+age*37;
}
public boolean equals(Object obj)//此方法的Object对象必须写
{
if(!(obj instanceof Person))//判断对象
return false;
Person p = (Person)obj;//必须强转，不可使用泛型，使用泛型就不是复写父类方法。
System.out.println(this.name+"...equals.."+p.name);
return this.name.equals(p.name) && this.age == p.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
10.12TreeSet
/*
Set:无序，不可以重复元素。
|--HashSet：数据结构是哈希表。线程是非同步的。
保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。
|--TreeSet：特点：可以对Set集合中的元素进行排序。（ASCII码表）
底层数据结构是二叉树。
保证元素唯一性的依据：compareTo方法return 0.
10.12.1TreeSet排序方式
TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也成为元素的自然顺序，或者叫做默认顺序。
TreeSet的第二种排序方式。当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。
当两种都存在时，按比较器优先。
需求：
往TreeSet集合中存储自定义对象学生。想按照学生的年龄进行排序。
记住，排序时，当主要条件相同时，一定判断一下次要条件。
*/
import java.util.*;
class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
//ts.add(new Student("lisi007",20));
//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());
}
}
}
要求自定义一个对象：
自定义一个学生对象，实现一个Compareable接口，可以存放在HashSet和TreeSet之中，
定义一个hashCode和equals方法
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)
{
//return 1;//怎么存怎么取，原序
//return -1;//倒序 比较只与结果有关
//return 0;//只存一个，只取一个
if(!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
System.out.println(this.name+"....compareto....."+s.name);
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;
}
}
10.12.2TreeSet的第二种排序方式（常用）
/*
当元素自身不具备比较性，或者具备的比较性不是所需要的。这时需要让容器自身具备比较性。定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
当两种排序都存在时，以比较器为主。
定义比较器步骤：
定义一个类，实现Comparator接口，覆盖compare方法。
*/
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 int compareTo(Object obj)
{
//return 0;
if(!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
//System.out.println(this.name+"....compareto....."+s.name);
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;
}
}
class TreeSetDemo2
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi02",21));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi06",18));
ts.add(new Student("lisi06",18));
ts.add(new Student("lisi007",29));
//ts.add(new Student("lisi007",20));
//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 MyCompare implements Comparator //java比较器
{
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()));
/*
if(s1.getAge()>s2.getAge())
return 1;
if(s1.getAge()==s2.getAge())
return 0;
return -1;
*/
}
return num;
}
}
10.12.3TreeSet练习：按照字符串长度排序
/*
练习：按照字符串长度排序。
字符串本身具备比较性。但是它的比较方式不是所需要的。
这时就只能使用比较器。
*/
import java.util.*;
class TreeSetTest
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new StrLenComparator());
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("z");
ts.add("hahaha");
Iterator it = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
class StrLenComparator implements Comparator
{
public int compare(Object o1,Object o2)
{
String s1 = (String)o1;
String s2 = (String)o2;
/*
if(s1.length()>s2.length())
return 1;
if(s1.length()==s2.length())
return 0;
*/
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num==0)
return s1.compareTo(s2);
return num;
}
}
10.12.4TreeSet练习：将字符串中的数值排序
/*
"90 -7 0 18 2 45 4"
将字符串中的数值进行排序。使用TreeSet完成。
思路
1，将字符串切割。
2，可以将这些对象存入TreeSet集合。因为TreeSet自身具备排序功能。
*/
import java.util.*;
class TreeSetTest2
{
public static void main(String[] args)
{
ArrayList al = new ArrayList();
String str = "90 -7 0 18 2 45 4";
String[] arr = str.split(" ");
TreeSet ts = new TreeSet();
for(int x=0; x<arr.length; x++)
{
//ts.add(new Integer(arr[x]));
ts.add(Integer.parseInt(arr[x]));//
}
System.out.println(ts);
}
}
10.13集合框架中的常用接口
Collection接口有两个子接口：
List（列表），Set（集）
List：可存放重复元素，元素存取是有序的
Set：不可以存放重复元素，元素存取是无序的
10.14List接口中的常用类
Vector：线程安全，但速度慢，以被ArrayList替代。
ArrayList：线程不安全，查询速度快
LinkedList：链表结构，增删速度快
取出List集合中元素的方式：
get(int index)：通过脚标获取元素
iterator():通过迭代方法获取迭代器对象
10.15迭代
迭代是取出集合中元素的一种方式
因为Collection中由iterator方法，所以每一个子类集合对象都具有迭代器。
迭代注意事项：
迭代器在Collection接口中是通用的，他替代了Vector类中的Enumeration（枚举）。
迭代器的next方法是自动向下去元素，要避免出现NoSuchElementException。
迭代器的next方法返回值类型是Object，所以要记得类型转换
思考：为什么next方法的返回值类型是Object的呢？
10.16Set接口中常用的类
HashSet：线程不安全，存取速度快
它是如何保证元素唯一性的呢？通过equals方法和hashCode方法来保证元素的唯一性。
TreeSet：线程不安全，可以对Set集合中的元素进行排序。它的排序是如何进行的呢？通过compareTo或者compare方法中的来保证元素的唯一性。元素是以二叉树的形式存放的。
10.17泛型
JDK1.5以后出现的机制
泛型出现的原因
泛型出现的好处
泛型的书写格式
自定义泛型类
10.17.1泛型的特点
提高了程序的安全性
将运行期遇到的问题转移到了编译期
省去了类型强转的麻烦
泛型类的出现优化了程序设计
泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。
10.17.2好处
1.将运行时期出现问题ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行时问题减少，安全。
2，避免了强制转换麻烦。
泛型格式：通过<>来定义要操作的引用数据类型。
在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，只要见到<>就要定义泛型。
其实<> 就是用来接收类型的。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
10.17.3泛型演示一
import java.util.*;
class GenericDemo
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc01");
al.add("abc0991");
al.add("abc014");
//al.add(4);//al.add(new Integer(4));
//编译通过，运行时类型转换异常
Iterator<String> it = al.iterator();
while(it.hasNext())
{
String s = it.next();
System.out.println(s+":"+s.length());
}
}
}
10.17.4泛型演示二：比较器
import java.util.*;
class GenericDemo2
{
public static void main(String[] args)
{
TreeSet<String> ts = new TreeSet<String>(new LenComparator());//字符串类型
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("z");
ts.add("hahaha");
Iterator<String> it = ts.iterator();//迭代器
while(it.hasNext())
{
String s = it.next();
System.out.println(s);
}
}
}
class LenComparator implements Comparator<String>//比较器
{
public int compare(String o1,String o2)
{
int num = new Integer(o2.length()).compareTo(new Integer(o1.length()));//倒序比较只将对象名字互反。
if(num==0)
return o2.compareTo(o1);
return num;
}
}
10.17.5自定义类中使用泛型
/*
class Tool
{
private Worker w;
public void setWorker(Worker w)
{
this.w = w;
}
public Worker getWorker()
{
return w;
}
}
*/
class Worker
{
}
class Student
{
}
//泛型前做法。需要强转
class Tool
{
private Object obj;
public void setObject(Object obj)
{
this.obj = obj;
}
public Object getObject()
{
return obj;
}
}
10.17.6什么时候定义泛型类
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展。
现在定义泛型来完成扩展。
*/
class Utils<QQ>
{
private QQ q;
public void setObject(QQ q)
{
this.q = q;
}
public QQ getObject()
{
return q;
}
}
class GenericDemo3
{
public static void main(String[] args)
{
Utils<Worker> u = new Utils<Worker>();
u.setObject(new Worker ());
Worker w = u.getObject();;
/*
Tool t = new Tool();
t.setObject(new Student());
Worker w = (Worker)t.getObject();
*/
}
}
10.17.7方法中使用泛型
/*
class Demo<T>
{
public void show(T t)
{
System.out.println("show:"+t);
}
public void print(T t)
{
System.out.println("show:"+t);
}
}
*/
泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。
特殊之处：
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
*/
class Demo<T>//泛型类
{
public void show(T t)//跟从泛型类的方法
{
System.out.println("show:"+t);
}
public <Q> void print(Q q)//泛型方法，可以跟从类和方法
{
System.out.println("print:"+q);
}
public static <W> void method(W t)// 静态泛型方法，跟从方法，不从类，因为静态先加载，后使用对象。
{
System.out.println("method:"+t);
}
}
class GenericDemo4
{
public static void main(String[] args)
{
Demo <String> d = new Demo<String>();
d.show("haha");
//d.show(4);
d.print(5);
d.print("hehe");
Demo.method("hahahahha");
/*
Demo d = new Demo();
d.show("haha");
d.show(new Integer(4));
d.print("heihei");
*/
/*
Demo<Integer> d = new Demo<Integer>();
d.show(new Integer(4));
d.print("hah");
Demo<String> d1 = new Demo<String>();
d1.print("haha");
d1.show(5);
*/
}
}
10.17.8泛型定义在接口上
interface Inter<T>//定义的接口是泛型
{
void show(T t);
}
/*
class InterImpl implements Inter<String>//实现接口时操作String类型
{
public void show(String t)
{
System.out.println("show :"+t);
}
}
*/
class InterImpl<T> implements Inter<T>//实现接口时操作泛型
{
public void show(T t)
{
System.out.println("show :"+t);
}
}
class GenericDemo5
{
public static void main(String[] args)
{
InterImpl<Integer> i = new InterImpl<Integer>();
i.show(4);
//InterImpl i = new InterImpl();
//i.show("haha");
}
}
10.17.9泛型的限定
? 通配符。也可以理解为占位符。
泛型的限定；
？ extends E: 可以接收E类型或者E的子类型。上限。
？ super E: 可以接收E类型或者E的父类型。下限
*/
import java.util.*;
class GenericDemo6
{
public static void main(String[] args)
{
/*
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
ArrayList<Integer> al1 = new ArrayList<Integer>();
al1.add(4);
al1.add(7);
al1.add(1);
printColl(al);
printColl(al1);
*/
ArrayList<Person> al = new ArrayList<Person>();
al.add(new Person("abc1"));
al.add(new Person("abc2"));
al.add(new Person("abc3"));
//printColl(al);
ArrayList<Student> al1 = new ArrayList<Student>();
al1.add(new Student("abc--1"));
al1.add(new Student("abc--2"));
al1.add(new Student("abc--3"));
printColl(al1); //ArrayList<? extends Person> al = new ArrayList<Student>();error
}
public static void printColl(Collection<? extends Person> al)
{
Iterator<? extends Person> it = al.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
/*
public static void printColl(ArrayList<?> al)//ArrayList al = new ArrayList<Integer>();error
{
Iterator<?> it = al.iterator();
//public static <T> void printColl(ArrayList<T> al)//可以用变量T指代
// Iterator<T> it = al.iterator();
while(it.hasNext())
{
//T t = it.next();
//System.out.println(t);
//System.out.println(it.next().length());//不可以使用类型的特有方法
//System.out.println(it.next().toString());//可以,因为所有类型都具备
}
}
*/
}
class Person
{
private String name;
Person(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}
/*
class Student implements Comparable<Person>//<? super E>
{
public int compareTo(Person s)
{
this.getName()
}
}
*/
class Comp implements Comparator<Person>
{
public int compare(Person s1,Person s2)
{
//Person s1 = new Student("abc1");
return s1.getName().compareTo(s2.getName());
}
}
TreeSet<Student> ts = new TreeSet<Student>(new Comp());
ts.add(new Student("abc1"));
ts.add(new Student("abc2"));
ts.add(new Student("abc3"));
import java.util.*;
class GenericDemo7
{
public static void main(String[] args)
{
TreeSet<Student> ts = new TreeSet<Student>(new Comp());
ts.add(new Student("abc03"));
ts.add(new Student("abc02"));
ts.add(new Student("abc06"));
ts.add(new Student("abc01"));
Iterator<Student> it = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
ts1.add(new Worker("wabc--03"));
ts1.add(new Worker("wabc--02"));
ts1.add(new Worker("wabc--06"));
ts1.add(new Worker("wabc--01"));
Iterator<Worker> it1 = ts1.iterator();
while(it1.hasNext())
{
System.out.println(it1.next().getName());
}
}
}
/*
class StuComp implements Comparator<Student>
{
public int compare(Student s1,Student s2)
{
return s1.getName().compareTo(s2.getName());
}
}
class WorkerComp implements Comparator<Worker>
{
public int compare(Worker s1,Worker s2)
{
return s1.getName().compareTo(s2.getName());
}
}
*/
class Comp implements Comparator<Person>
{
public int compare(Person p1,Person p2)
{
return p2.getName().compareTo(p1.getName());
}
}
class Person
{
private String name;
Person(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public String toString()
{
return "person :"+name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}
class Worker extends Person
{
Worker(String name)
{
super(name);
}
}
10.17.10练习
import java.util.*;
class GenericTest
{
public static void main(String[] args)
{
/*
ArrayList al = new ArrayList();
al.add(new Person("heihei"));
ArrayList al1 = new ArrayList();
al1.add("haha1");
al1.add("haha2");
al.addAll(al1);
System.out.println(al);int.next().getName();
*/
/**/
ArrayList<Person> al = new ArrayList<Person>();
al.add(new Person("ahah"));
ArrayList<Student> al1 = new ArrayList<Student>();
al1.add(new Student("haha"));
al.addAll(al1);
Iterator<Person> it = al.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
}
class Person
{
private String name;
Person(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public String toString()
{
return "person :"+name;
}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
}
/*
Person p = new PErson();
p.equals("haha");
Demo d = new Demo();
d.equals(p);
*/
//泛型搞定：泛型的使用。对于集合类中的泛型会用即可。可以看得懂上限下限，泛型类和泛型方法定义。
10.18Map集合
Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
10.18.1常用方法
10.18.1.1添加。
put(K key, V value) //返回此键对应的原来的值，若没有则返回null。
putAll(Map<? extends K,? extends V> m)
10.18.1.2删除。
clear()
remove(Object key)
10.18.1.3判断。
containsValue(Object value)
containsKey(Object key)
isEmpty()
10.18.1.4获取。
get(Object key)
size()
values()
entrySet()
keySet()
10.18.2Map子集
|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。
|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。
和Set很像。
其实大家，Set底层就是使用了Map集合。
HashTable必须实现hashCode和equals方法。
*/
import java.util.*;
class MapDemo
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
//添加元素,添加元素，如果出现添加时，相同的键。那么后添加的值会覆盖原有键对应值。并put方法会返回被覆盖的值。put方法有返回值。
System.out.println("put:"+map.put("01","zhangsan1"));
System.out.println("put:"+map.put("01","wnagwu"));
map.put("02","zhangsan2");
map.put("03","zhangsan3");
System.out.println("containsKey:"+map.containsKey("022"));
//System.out.println("remove:"+map.remove("02"));
System.out.println("get:"+map.get("023"));//可以判断是否存在
map.put("04",null);
System.out.println("get:"+map.get("04"));
//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。
//获取map集合中所有的值。
Collection<String> coll = map.values();
System.out.println(coll);
System.out.println(map);//01=zhangsan1
}
}
10.18.3Map集合中从所有元素取出
map集合的两种取出方式：
10.18.3.1 map集合的两种取出方式一：Set<k> keySet
将map中所有的键存入到Set集合。因为set具备迭代器。
所以可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。
Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。
10.18.3.2 map集合的两种取出方式一：Set<Map.Entry<k,v>> entrySet
将map集合中的映射关系存入到了set集合中，
而这个关系的数据类型就是：Map.Entry
Entry其实就是Map中的一个static内部接口。
为什么要定义在内部呢？
因为只有有了Map集合，有了键值对，才会有键值的映射关系。
关系属于Map集合中的一个内部事物。
而且该事物在直接访问Map集合中的元素。
键是不可以重复的，值是可以重复的。
*/
import java.util.*;
class MapDemo2
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
map.put("02","zhangsan2");
map.put("03","zhangsan3");
map.put("01","zhangsan1");
map.put("04","zhangsan4");
//第二种方式：将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);
}//
10.18.3.3entry方法图例
/*
//先获取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+",value:"+value);
}
*/
10.18.3.4keySet方法的图例如下
/*
Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。
interface Map
{
public static interface Entry//内部接口
{
public abstract Object getKey();
public abstract Object getValue();
}
}
class HashMap implements Map
{
class Hahs implements Map.Entry
{
public Object getKey(){}
public Object getValue(){}
}
}
*/
10.18.4Map练习：保证学生的唯一性（重要）
/*
每一个学生都有对应的归属地。
学生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 int compareTo(Student s)//比较存入是否相同
{
int num = new Integer(this.age).compareTo(new Integer(s.age));
if(num==0)
return this.name.compareTo(s.name);
return num;
}
public int hashCode()//确保唯一性，默认按地址值排序
{
return name.hashCode()+age*34;
}
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;
}
public String getName()//设置名字和获取名字
{
return name;
}
public int getAge()//设置年龄和设置年龄
{
return age;
}
public String toString()//转换成字符串
{
return name+":"+age;
}
}
class MapTest
{
public static void main(String[] args)
{
//创建HashMap集合：
HashMap<Student,String> hm = new HashMap<Student,String>();
//存入元素
hm.put(new Student("lisi1",21),"beijing");
hm.put(new Student("lisi1",21),"tianjin");
hm.put(new Student("lisi2",22),"shanghai");
hm.put(new Student("lisi3",23),"nanjing");
hm.put(new Student("lisi4",24),"wuhan");
//取出元素
//第一种取出方式 keySet
Set<Student> keySet = hm.keySet();
Iterator<Student> it = keySet.iterator();
while(it.hasNext())
{
Student stu = it.next();
String addr = hm.get(stu);
System.out.println(stu+".."+addr);
}
//第二种取出方式 entrySet
Set<Map.Entry<Student,String>> entrySet = hm.entrySet();
Iterator<Map.Entry<Student,String>> iter = entrySet.iterator();
while(iter.hasNext())
{
Map.Entry<Student,String> me = iter.next();
Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu+"........."+addr);
}
}
}
10.18.5Map练习：对学生对象的年龄进行升序排序
/*
需求：对学生对象的年龄进行升序排序。
因为数据是以键值对形式存在的。
所以要使用可以排序的Map集合。TreeMap。
*/
import java.util.*;
class StuNameComparator implements Comparator<Student>
{
public int compare(Student s1,Student s2)//存入的元素进行排序
{
int num = s1.getName().compareTo(s2.getName());
if(num==0)
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
return num;
}
}
class MapTest2
{
public static void main(String[] args)
{
TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator());
tm.put(new Student("blisi3",23),"nanjing");
tm.put(new Student("lisi1",21),"beijing");
tm.put(new Student("alisi4",24),"wuhan");
tm.put(new Student("lisi1",21),"tianjin");
tm.put(new Student("lisi2",22),"shanghai");
Set<Map.Entry<Student,String>> entrySet = tm.entrySet();
Iterator<Map.Entry<Student,String>> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<Student,String> me = it.next();
Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu+":::"+addr);
}
}
}
10.18.6Map练习：获取该字符串中的字母出现的次数
"sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。
希望打印结果：a(1)c(2).....
通过结果发现，每一个字母都有对应的次数。
说明字母和次数之间都有映射关系。
注意了，当发现有映射关系时，可以选择map集合。
因为map集合中存放就是映射关系。
10.18.7什么时候使用map集合呢
当数据之间存在这映射关系时，就要先想map集合。
思路：
1，将字符串转换成字符数组。因为要对每一个字母进行操作。
2，定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合。
3，遍历字符数组。
将每一个字母作为键去查map集合。
如果返回null，将该字母和1存入到map集合中。
如果返回不是null，说明该字母在map集合已经存在并有对应次数。
那么就获取该次数并进行自增。，然后将该字母和自增后的次数存入到map集合中。覆盖调用原理键所对应的值。
4，将map集合中的数据变成指定的字符串形式返回。
import java.util.*;
class MapTest3
{
public static void main(String[] args)
{
String s= charCount("ak+abAf1c,dCkaAbc-defa");
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++;//若有值，则计数器加1
tm.put(chs[x],count);//直接往集合中存储字符和数字，为什么可以，因为自动装箱。
count = 0;//将计数器清零，进行下一个对象的索取
/*
if(value==null)
{
tm.put(chs[x],1);
}
else
{
value = value + 1;
tm.put(chs[x],value);
}
*/
}
//System.out.println(tm);
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();//返回缓冲区以字符串形式，表示
}
}
10.18.8map扩展知识
map集合被使用是因为具备映射关系。
"yureban" Student("01" "zhangsan");
"yureban" Student("02" "lisi");
"jiuyeban" "01" "wangwu";
"jiuyeban" "02" "zhaoliu";
一个学校有多个教室。每一个教室都有名称。
import java.util.*;
class Student
{
private String id;
private String name;
Student(String id,String name)
{
this.id = id;
this.name = name;
}
public String toString()
{
return id+":::"+name;
}
}
class MapDemo3
{
public static void demo()
{
HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();
List<Student> reyu = new ArrayList<Student>();
List<Student> jiuye = new ArrayList<Student>();
czbk.put("yureban",reyu);
czbk.put("jiuyeban",jiuye);
reyu.add(new Student("01","zhagnsa"));
reyu.add(new Student("04","wangwu"));
jiuye.add(new Student("01","zhouqi"));
jiuye.add(new Student("02","zhaoli"));
Iterator<String> it = czbk.keySet().iterator();
while(it.hasNext())
{
String roomName = it.next();
List<Student> room = czbk.get(roomName);
System.out.println(roomName);
getInfos(room);
}
}
public static void getInfos(List<Student> list)
{
Iterator<Student> it = list.iterator();
while(it.hasNext())
{
Student s = it.next();
System.out.println(s);
}
}
public static void main(String[] args)
{
demo();
}
10.19集合框架的工具类
Collections:集合框架的工具类。里面定义的都是静态方法。
10.19.1Collections和Collection有什么区别
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
它有两个常用的子接口，
List：对元素都有定义索引。有序的。可以重复元素。
Set：不可以重复元素。无序。
Collections是集合框架中的一个工具类。该类中的方法都是静态的
提供的方法中有可以对list集合进行排序，二分查找等方法。
通常常用的集合都是线程不安全的。因为要提高效率。
如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。
*/
10.19.2集合框架的工具类：演示常用方法一
import java.util.*;
class CollectionsDemo
{
public static void main(String[] args)
{
sortDemo();
}
public static void binarySearchDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
Collections.sort(list,new StrLenComparator());//排序之中含有比较器
sop(list);
//int index = Collections.binarySearch(list,"aaaa");//二分搜索法
//int index = halfSearch(list,"cc");
int index = halfSearch2(list,"aaaa",new StrLenComparator());二分搜索法，带比较器
sop("index="+index);
}
//二分搜索法的原理
public static int halfSearch(List<String> list,String key)
{
int max,min,mid;
max = list.size()-1;
min = 0;
while(min<=max)
{
mid = (max+min)>>1;// /2;
String str = list.get(mid);
int num = str.compareTo(key);
if(num>0)
max = mid -1;
else if(num<0)
min = mid + 1;
else
return mid;
}
return -min-1;
}
public static int halfSearch2(List<String> list,String key,Comparator<String> cmp)//二分搜索法的原理，添加比较器
{
int max,min,mid;
max = list.size()-1;
min = 0;
while(min<=max)
{
mid = (max+min)>>1;// /2;
String str = list.get(mid);
int num = cmp.compare(str,key);
if(num>0)
max = mid -1;
else if(num<0)
min = mid + 1;
else
return mid;
}
return -min-1;
}
public static void maxDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
Collections.sort(list);
sop(list);
String max = Collections.max(list);//集合中的元素最大值
String max = Collections.max(list,new StrLenComparator());//集合中的最大长度
sop("max="+max);
}
public static void sortDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
sop(list);//输出形式为数组，可以存在重复元素
//Collections.sort(list);//框架工具类的排序方法，默认排序
//参数为List集合，比较器
Collections.sort(list,new StrLenComparator());
//Collections.swap(list,1,2);
sop(list);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
class StrLenComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
return s1.compareTo(s2);
}
}
/*
public static <T extends Comparable<? super T>> void sort(List<T> list)
{
//排序方法的声明，compareable的子类进行默认排序排序
}
*/
总结：
Compareable的默认排序方法compareTo
Compartor比较器的compare方法
对象比较时：
public int compare(String s1,String s2)
{
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
return s1.compareTo(s2);
}
10.19.3集合框架的工具类：演示常用方法二
import java.util.*;
class StrComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
/*
int num = s1.compareTo(s2);
if(num>0)
return -1;
if( num<0)
return 1;
return num;
*/
return s2.compareTo(s1);
}
}
class StrLenComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
return s1.compareTo(s2);
}
}
class CollectionsDemo2
{
public static void main(String[] args)
{
shuffleDemo();
}
public static void shuffleDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
list.add("z");
sop(list);
Collections.shuffle(list);//随机调换位置，扑克牌，骰子
sop(list);
}
public static void orderDemo()
{
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
ts.add("abcde");
ts.add("aaa");
ts.add("k");
ts.add("cc");
Iterator it = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
public static void replaceAllDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
sop(list);
Collections.replaceAll(list,"aaa","pp");//将aaa替换为pp
sop(list);
Collections.reverse(list);//集合的反转
sop(list);
}
/*
练习。fill方法可以将list集合中所有元素替换成指定元素。将list集合中部分元素替换成指定元素。
*/
public static void fillDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
sop(list);
Collections.fill(list,"pp");//将集合中的元素全部替换为pp，应用于替换某一段元素。
sop(list);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
10.20Arrays:用于操作数组的工具类
里面都是静态方法。
10.20.1asList:将数组变成list集合
*/
import java.util.*;
class ArraysDemo
{
public static void main(String[] args)
{
// int[] arr = {2,4,5};
// System.out.println(Arrays.toString(arr));//转成字符串
String[] arr = {"abc","cc","kkkk"};
把数组变成list集合有什么好处？
可以使用集合的思想和方法来操作数组中的元素。
UnsupportedOperationException：不支持的操作异常
注意：将数组变成集合，不可以使用集合的增删方法。
因为数组的长度是固定。
contains。可以
get可以
indexOf()可以
subList();可以
如果你增删。那么会反生UnsupportedOperationException,
*/
List<String> list = Arrays.asList(arr);
//sop("contains:"+list.contains("cc"));
//list.add("qq");//UnsupportedOperationException,不支持的操作异常
//sop(list);
//int[] nums = {2,4,5};
Integer[] nums = {2,4,5};
List<Integer> li = Arrays.asList(nums);
List li = Arrays.asList(nums);
/*
如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
*/
sop(li);//打印的结果是哈希值
}//判断是否包含元素Contains方法的原理
public static boolean myContains(String[] arr,String key)
{
for(int x=0;x<arr.length; x++)
{
if(arr[x].equals(key))
return true;
}
return false;
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
10.21集合变数组
/*
集合变数组。
Collection接口中的toArray方法。
*/
import java.util.*;
class CollectionToArray
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
/*
1,指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。
所以创建一个刚刚好的数组最优。
2,为什么要将集合变数组？
为了限定对元素的操作。不需要进行增删了。
*/
String[] arr = al.toArray(new String[al.size()]);
System.out.println(Arrays.toString(arr));
}
}
10.22高级for循环(简化书写)
10.22.1格式
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{
}
对集合进行遍历。
只能获取集合元素。但是不能对集合进行操作。
迭代器除了遍历，还可以进行remove集合中元素的动作。
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。
10.22.2传统for和高级for有什么区别呢？
高级for有一个局限性。必须有被遍历的目标。
建议在遍历数组的时候，还是希望是用传统for。因为传统for可以定义脚标。
import java.util.*;
class ForEachDemo
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
for(String s : al)//s指向的对象在变化
{
//s = "kk";//只可对集合中的元素进行取出，不可修改
System.out.println(s);
}
System.out.println(al);
/*
Iterator<String> it = al.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
*/
int[] arr = {3,5,1};
for(int x=0; x<arr.length; x++)
{
System.out.println(arr[x]);
}
for(int i : arr)
{
System.out.println("i:"+i);
}
HashMap<Integer,String> hm = new HashMap<Integer,String>();
hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c");
Set<Integer> keySet = hm.keySet();
for(Integer i : keySet)
{
System.out.println(i+"::"+hm.get(i));
}
// Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
// for(Map.Entry<Integer,String> me : entrySet)
for(Map.Entry<Integer,String> me : hm.entrySet())
{
System.out.println(me.getKey()+"------"+me.getValue());
}
}
}
10.23JDK1.5版本出现的新特性：方法的可变参数
方法的可变参数
在使用时注意：可变参数一定要定义在参数列表最后面。前面匹配完
class ParamMethodDemo
{
public static void main(String[] args)
{
//show(3,4);
/*
//虽然少定义了多个方法。
但是每次都要定义一个数组。作为实际参数。
int[] arr = {3,4};
show(arr);
int[] arr1 = {2,3,4,5};
show(arr1);
*/
/*
可变参数。
其实就是上一种数组参数的简写形式。
不用每一次都手动的建立数组对象。
只要将要操作的元素作为参数传递即可。
隐式将这些参数封装成了数组。
*/
show("haha",2,3,4,5,6);
//show(2,3,4,5,6,4,2,35,9,"heh");
//show();
}
public static void show(String str,int... arr)
{
System.out.println(arr.length);
}
/*
public static void show(int[] arr)
{
}
*/
/*
public static void show(int a,int b)
{
System.out.println(a+","+b);
}
public static void show(int a,int b,int c)
{}
*/
}
10.24JDK1.5版本出现的新特性：静态导入
StaticImport 静态导入。
当类名重名时，需要指定具体的包名。
当方法重名是，指定具备所属的对象或者类。
*/
import java.util.*;
import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
import static java.util.Collections.*;
/*
packa/Demo.class
packb/Demo.class
import packa.*;
import packb.*;
*/
import static java.lang.System.*;//导入了System类中所有静态成员。
class StaticImport //extends Object
{
public static void main(String[] args)
{
out.println("haha");
int[] arr = {3,1,5};
sort(arr);
int index = binarySearch(arr,1);
out.println(Arrays.toString(arr));
System.out.println("Index="+index);
ArrayList al = new ArrayList();
al.add(1);
al.add(3);
al.add(2);
out.println(al);
sort(al);
out.println(al);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
