java集合
Day14
01-集合框架(体系概述) java.util包Collection接口
1 为什么出现集合类?
因为面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储。集合就是存储对象最常用的一种方式
2 数组和集合类同是容器，有何不同？
数组虽然也可以存储对象，但是长度是固定的，集合长度可变
数组中可以存储基本数据类型，就和只能存储对象
3 集合类的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象
4 为什么会出现这么多的容器？
因为每一个容器对数据的存储方式都有不同。这个存储方式称为：数据结构
02-集合框架(共性方法)
1 add()方法的参数类型是Object，以便于接受任意类型的对象
2 集合中存储的都是对象的引用（地址）
ArrayLista1 = newArrayList();//创建一个集合容器。使用Collection接口的子类ArrayList
// 1 添加元素
a1.add("java01");
// 1 打印集合a1，结果为[java01, java02, java03, java04]
sop(a1);
//3 删除元素
a1.remove("java02");
a1.clear(); //清空元素
//4 判断元素
sop("java03是否存在："+a1.contains("java03"));
sop("集合是否为空："+a1.isEmpty());
//取交集，a1只会保留和a2中相同的元素
a1.retainAll(a2);
//移除a1中与a2相同的元素
a1.removeAll(a2);
}
03-集合框架(迭代器)
什么是迭代器？其实就是集合取出元素的方式
Iterator it =a1.iterator(); //获取集合的迭代器，用于取出集合中的元素
while(it.hasNext()) //如果仍有元素可以迭代，则返回 true。
{
sop(it.next()); //返回迭代的下一个元素。
}
还可写成：
for(Iteratoritr = a1.iterator(); it.hasNext(); )
{
sop(itr.next());
}
理解：每一个容器的数据结构不同，取出元素的动作不同，但是都有共性内容（取出和判断），那么可以将共性抽取，定义在集合内部（内部类）；这样他就可以直接访问集合内容的元素。这些内部类都符合一个规则Iterator 接口。通过调用对外的方法iterator()方法就可获得其子类对象
----------------------------------------------------List集合---------------------------------------
04-集合框架(List集合共性方法)
Collection
|—List 元素是有序的，元素可重复。因为该集合体系中有索引
|—Set 元素是无序的，元素不可重复
增：add(index, element)； addAll(index,Collection)
删：remove(index)
改：set(index, element)\
查：get(index) indexOf(element) subList(from, to) listIterator();
int index =a1.indexOf("java02");//获取对象的位置
Listsub = a1.subList(1, 3); //返回列表中 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
a1.add(1,"java06"); //在1角标处插入元素
a1.remove(2); //删除指定位置元素的引用
a1.set(2,"java004"); //修改指定位置元素为java004
a1.get(1); //通过角标获取元素
List还可以通过角标遍历取元素，也可以用迭代器
05-集合框架(ListIterator)列表迭代器
List集合特有的迭代器，ListIterator是Iterator的子接口，继承了Iterator添加自己的方法。Iterator接口中只有hasNext() next() remove()三个方法
在迭代时，不可以通过集合对象的方法（add）操作集合中元素，因为会发生ConcurrenModificationException（并发修改）异常，所以在迭代是，只能通过迭代器操作元素。可是Iterator的方法是有限的，只能对元素进行判断，取出，删除的操作；如果想要其他操作如添加，修改等，就需要使用其子接口ListIterator。该接口只能通过List集合的listIterator方法获取
boolean hasNext() 正向迭代，如果有下一个元素返回true
boolean HasPrevious();逆向迭代列表，列表迭代器前面有元素返回true
ListIterator li =arr.listIterator();
sop(li.hasPrevious()); //返回false，因为li现在指向第一个元素，他前面没元素
while(li.hasNext())
{
Objectobj = li.next();
if(obj.equals("java02"))
//li.add("java009"); 在迭代过程中添加元素
li.set("java06"); //修改元素
}
while(li.hasNext())
{
sop(li.hasPrevious()); //返回true，因为li现在指向最后一个元素
}
sop(arr);
06-集合框架(List集合具体对象的特点)
Collection
|---List:元素是有序的，可重复，因为该集合体系有索引
|—ArrayList:底层的数据结构使用的是数组数据结构。
特点：查询速度快，增删稍慢，线程不同步
|—LinkedList:底层使用的链表数据结构。特点：增删速度快，查询慢
|—Vector:底层是数组数据结构。线程同步，被ArrayList代替了
07-集合框架(Vector中的枚举)
枚举就是Vector特有的取出方式。其实和迭代器是一样的。
因为枚举的名称以及方法名称都过长，所以被迭代器取代了
Vector v = newVector();
v.add("java01");
v.add("java02");
v.add("java03");
Enumerationen = v.elements(); //返回此向量数组的枚举
while(en.hasMoreElements()) //测试此枚举是否包含更多的元素
{
System.out.println(en.nextElement());//如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素
}
08-集合框架(LinkedList)
LinkedList：特有方法：
addFirst(); addLast();
getFirst() getLast()
获取元素，但不删除元素，如果集合中没有元素，会出现NoSuchElementException
removeFirst() removeLast()
获取元素，但是会被删除，如果集合中没有元素，会出现NoSuchElementException
在JDK1.6出现了代替方法：
offerFirst() offerLast() 在列表开头/ 结尾插入指定元素
peekFirst() peekLast()
获取但不移除才列表第一个或最后一个元素，如果列表为空，返回null
pollFirst() pollLast()
获取并移除列表第一个或最后一个元素，列表为空时返回null
09-集合框架(LinkedList练习)
/*
* 使用LinkedList模拟一个堆栈和队列数据结构
* 堆栈：先进后出 如同一个杯子
* 队列：先进先出 First in First out FIFO如同一个水管
*/
// 堆栈：加入第一个，取出第一个，先加入后被取走
class DuiZhan
{
privateLinkedListlink;
DuiZhan()
{
link = newLinkedList();
}
public void myAdd(Object obj)
{
link.addFirst(obj); //将元素添加到第一个
}
public Object myGet()
{
returnlink.removeFirst(); //取出第一个元素
}
public boolean isNull()
{
returnlink.isEmpty();
}
}
//队列：加入第一个，取最后一个，先加入先被取走
class DuiLie
{
privateLinkedListlink;
DuiLie()
{
link = newLinkedList();
}
public void myAdd(Object obj)
{
link.addFirst(obj); //将元素添加到第一个
}
public Object myGet()
{
returnlink.removeLast(); //取出最后一个元素
}
public boolean isNull()
{
returnlink.isEmpty();
}
}
堆栈：把removelast（）改为removeFirst()
10-集合框架(ArrayList练习)
在迭代中循环调用next一次，就要hasNext判断一次，否则会出异常
//去除ArrayList集合中的重复元素
public static ArrayListsingleElement(ArrayList a1)
{
ArrayListnewAL = newArrayList();
Iterator it = a1.iterator(); //获取a1的迭代器
while(it.hasNext())
{
Objectobj = it.next(); //接受a1中的元素
if(!newAL.contains(obj)) //当newAL中不存在obj时才加进去
newAL.add(obj);
}
return newAL;
}
11-集合框架(ArrayList练习2)
List集合判断元素是否相同，依据的是元素的equals方法。比如contains和remove
public static ArrayListsingleElement(ArrayLista1)
{
ArrayList newAL =newArrayList();
Iterator it = a1.iterator(); //获取a1的迭代器
while(it.hasNext())
{
Objectobj = it.next(); //接受a1中的元素
if(!newAL.contains(obj)) //contain方法在底层是调用equals方法，所以重写equals
newAL.add(obj);
}
return newAL;
}
重写equals();
public boolean equals(Objectobj) //重写，让它比较的是内容而不是地址
{
if(!(objinstanceof Person))
returnfalse;
Personp = (Person)obj;
System.out.println(this.name +"^^^^^^"+p.name);
return this.name.equals(p.name) &&this.age ==p.age; //此处equals是String中的，比较内容
}
----------------------------------Set集合----------------------------------------------------
12-集合框架(HashSet)
\list有角标，set无角标，无序不重复。Set集合的功能和Collection是一致的
|—Set：元素无序（存入和取出的顺序不一定一致），元素不可重复
|—HashSet：底层数据结构是哈希表，按哈希表排序。线程不同步。
保证元素唯一性原理：判断元素hashCode值（找到其存储区域），如果不存在存储区域说明不存在。当找到存储区域时，判断equals方法，是否为true；如果false就存。所以一般复写这两个方法
注意：对于判断元素是否存在，删除等操作，依赖的方法是元素的hashCode和equals方法
|—TreeSet：可以对Set集合中的元素进行排序。底层数据结构是二叉树
保证元素唯一性依据：compareTo方法return0
排序方式两种（让元素自身具有可比性；让集合自身具备比较性）
HashSeths = newHashSet();
System.out.println(hs.add("java01")); //true
System.out.println(hs.add("java01")); //false 因为已存在，元素不重复
hs.add("java02");
hs.add("java03");
Iteratorit = hs.iterator(); //获取集合迭代器
while(it.hasNext())
{
System.out.println(it.next()); //打印结果无序
}
13-集合框架(HashSet存储自定义对象)
public static void main(String[]args)
{
HashSet hs =newHashSet();
hs.add(new Person("a1",11));
hs.add(new Person("a2",12));
hs.add(new Person("a3",13));
hs.add(new Person("a1",11)); //先判断hashCode值，相同时再用equals比较，这两个方法在ArrayListTest2中重写了
//hs.contains(newPerson("a2",12));
//hs.remove(newPerson("a4",14)); //判断元素是否存在和删除操作都会先调用hashCode方法，相同时在调用equals
Iteratorit = hs.iterator();
while(it.hasNext())
{
Personp = (Person)it.next();
System.out.println(p.getName()+"::::"+p.getAge());
}
}
14-集合框架(HashSet判断和删除的依据)
判断元素是否存在和删除操作都会先调用hashCode方法，相同时在调用equals。依赖于hashCode和equals方法
Day15
01- 集合框架(TreeSet)按字母顺序排序，大写排前面
|—TreeSet：可以对Set集合中的元素进行排序。底层数据结构是二叉树
保证元素唯一性依据：compareTo方法return0
排序方式两种（让元素自身具有可比性；让集合自身具备比较性）
TreeSet第一种排序方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo()；这种方式称为元素的自然排序，或者默认排序
第二种方式：当元素自身不具备比较性时，或者比较性不是所需要的。这时就需要让集合自身具备比较性。
定义比较器，并将比较器对象作为参数传给TreeSet构造函数，在集合一初始化时就具有比较性
定义一个类，实现Comparator接口，覆盖compare()方法
当两种排序都存在时，以比较器为主
02-集合框架(TreeSet存储自定义对象)
第一种排序方式
往TreeSet里面存对象要有可比性。排序，这时这个自定义类要实现Comparable接口
此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法
int compareTo(T o)
比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
importjava.util.Iterator;
import java.util.TreeSet;
/*
* 需求：往TreeSet集合中存储自定义学生对象，想按照学生年龄进行排序
* 当年龄相同时,将姓名按字典顺序排序
*/
class StudentimplementsComparable //改接口强制让学生具备比较性
{
private Stringname;
private int age;
Student(Stringname,int age)
{
this.name = name ;
this.age = age;
}
public int compareTo(Objectobj)
{
if(!(objinstanceof Student))
thrownew RuntimeException("不是学生对象");
Students = (Student)obj;
System.out.println(this.name+"……compareto……"+s.name);
if(this.age>s.age)
return 1;
if(this.age==s.age) //当主要条件相同，判断次要条件
{
returnthis.name.compareTo(s.name); //String类实现了Comparabe接口，重写compareTo按字典顺序排序
}
return -1;
}
public String getName()
{
returnname;
}
public int getAge()
{
returnage;
}
}
public class TreeSetDemo
{
public static void main(String[]args)
{
TreeSetts = newTreeSet();
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi06",19));
ts.add(new Student("lisi06",19)); //重复元素进不来
Iteratorit = ts.iterator();
while(it.hasNext())
{
Studentstu = (Student)it.next();
System.out.println(stu.getName()+"……"+stu.getAge());
}
}
}
03-集合框架(二叉树)
04-集合框架(实现Comparator方式排序)
TreeSet第二种排序方式：让集合自身具比较性
* 定义一个类，实现Comparator接口，覆盖compare()方法
* 当两种排序都存在时，以比较器为主
class MyCompareimplementsComparator //定义比较器类
{
public int compare(Objecto1,Object o2)
{
Students1 = (Student)o1;
Students2 = (Student)o2;
int num =s1.getName().compareTo(s2.getName()); //按姓名排序
if(num == 0) //姓名相同时，按年龄排
{
returnnewInteger(s1.getAge()).compareTo(newInteger(s2.getAge())); //Integer类实现了Comparable重写了compareTo()
/*
* if(s1.getAge()>s2.getAge())也可这样写
* return1;
* if(s1.getAge()==s2.getAge())
* return0;
* return -1;
*/
}
return num; //按姓名排，当姓名不同时。
}
}
public class TreeSetDemo2
{
public static void main(String[]args)
{
TreeSetts = new TreeSet(new MyCompare()); //让集合对象自身具比较性，传入参数为比较器
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi06",19));
ts.add(new Student("lisi06",19)); //重复元素进不来
Iteratorit = ts.iterator();
while(it.hasNext())
{
Studentstu = (Student)it.next();
System.out.println(stu.getName()+"……"+stu.getAge());
}
}
}
05-集合框架(TreeSet练习) (1)
/*
* 练习：按字符串长度排序
* 字符串本身具备比较性。但是它的比较方式不是所需要的，这时就只能使用比较器
*/
public class TreeSetTest
{
public static void main(String[]args)
{
TreeSetts = new TreeSet(newStrLenComparator());
ts.add("abds");
ts.add("aaa");
ts.add("csd");
ts.add("a");
ts.add("ef");
Iteratorit = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
class StrLenComparatorimplementsComparator
{
public int compare(Objecto1,Object o2)
{
Strings1 = (String)o1;
Strings2 = (String)o2;
int num =newInteger(s1.length()).compareTo(s2.length());
if(num==0) //当主要因素相同时，还要考虑次要因素排序
return s1.compareTo(s2);
return num;
}
}
05-集合框架(TreeSet练习) (2)
/*
* 集合框架中的泛型
*/
public class GenericDemo
{
public static void main(String[]args)
{
TreeSet<String>ts = new TreeSet<String>(newLenComparator());
ts.add("abds");
ts.add("aaa");
ts.add("csd");
ts.add("a");
ts.add("ef");
Iteratorit = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
//比较器，让字符串倒序
class LenComparator implements Comparator<String>
{
public int compare(Stringo1,String o2)
{
int num =newInteger(o2.length()).compareTo(o1.length());
if(num==0) //当主要因素相同时，还要考虑次要因素排序
return o2.compareTo(o1);
return num;
}
}
06-集合框架(泛型概述)、
泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制
好处：1 将运行时期出现问题ClassCastException（聚合存放对象肯定是要操作对象的，将对象取出操作要用到对象所特有方法，这时就要转型）,转移到了编译时期，方便于程序员解决问题，让运行时问题减少。
2 避免了强制转换麻烦
泛型格式：通过<>来定义要操作的引用数据类型；；；通常在集合框架中很常见
08-集合框架(泛型类)
泛型类：当类中要操作的引用数据类型不确定时，早起定义Object来完成扩展；现在定义泛型来完成扩展。。泛型类一确定（创建对象），要操作的类型就确定了
class Student{}
class Worker{}
//泛型前做法
class Tool
{
private Objectobj;
public void setObject(Objectobj)
{
this.obj = obj;
}
public Object getObject()
{
returnobj;
}
}
//泛型：将运行时的异常转换到编译时期
class Utils<QQ>
{
private QQq;
public void setObject(QQ q)
{
this.q = q;
}
public QQ getObject()
{
returnq;
}
}
public class GenericDemo3
{
public static void main(String[]args)
{
Toolt = new Tool();
t.setObject(new Student()); //传入一个Student对象
Workerw = (Worker)t.getObject(); //将Student对象转换为Workwe对象出错
}
}
09-集合框架(泛型方法)（静态泛型方法）
/*
* 泛型类定义的泛型，在整个类中有效。如果被方法使用，
* 那么泛型类对象明确要操作的具体类型后，所有要操作的类型就已经固定了
* 为了让不同方法可以操作不同类型，而且类型还不确定，就可以将泛型定义在方法上
*
* 特殊之处：静态方法不可以访问类上定义的泛型。静态先加载，那时候还没有泛型类的对象，所以不能访问T
* 如果静态方法操作的引用数据类型不确定，可将泛型定义在方法上
*/
class Demo<T>//泛型类
{
public <T>void show(T t)
{
System.out.println("show "+t);
}
public <Q>void print(Q q) //泛型方法
{
System.out.println("show "+q);
}
public static <W> void method(W w) //静态泛型方法
{
System.out.println("method "+w);
}
}
public class GenericDemo4
{
public static void main(String[]args)
{
Demod = newDemo();
d.show("haha");
d.show(new Integer(4));
d.print("heihie");
}
}
11-集合框架(泛型接口)
//泛型定义在接口上 注意：用到泛型的时候必须传参数
interface Inter<T>
{
void show(T t);
}
class InterImplimplementsInter<String> //子类实现的时候指定了类型，只能操作String
{
public void show(String t)
{
System.out.println("show::"+t);
}
}
classInterImpl2<T>implements Inter<T>//实现时不指定，但是要传参数<T>,又用户自己指定
{
public void show(T t)
{
System.out.println("show::"+t);
}
}
12-集合框架(泛型限定)
<?> 通配符，也可以理解为占位符，告诉别人这里有泛型
？ extends E:可以接受E类型或者E类型的子类型。 上限
？ super E : 可以接受E类型或者E的父类型。 下限
泛型限定是用来对泛型的扩展
class Comp implements Comparator<Persons> //定义比较器时传入Person作为反泛型参数
{
public int compare(Persons p1,Persons p2)
{
returnp2.getName().compareTo(p1.getName());
}
}
TreeSet<Workers> ts1 = newTreeSet<Workers>(new Comp()); //传入的比较器可以比较所有Persons的子类
ts1.add(new Workers("sadq02"));
ts1.add(new Workers("sadq03"));
Day16
01-集合(Map概述)
Map集合：该集合存储键值对，一对一对往里存。而且要保证键的唯一性
1、添加
put(K key, V value) 返回的是对应键的值，如果没有，返回空
putAll(Map<?extends K,?extends V> m)
2、删除
clear()
remove(Objectkey)
3、判断
containsKey(Objectkey)
containsValue(Objectvalue)
isEmpty()
4、获取
get(Objectkey) 返回指定键所映射的值；若映射不包含该键的映射关系，则返回 null。
size() 返回此映射中的键-值映射关系数。
values() 返回此映射中包含的值的 Collection 视图
entrySet() 返回此映射中包含的映射关系的 Set 视图。
keySet() 返回此映射中包含的键的 Set 视图。
02-集合(Map子类对象特点)
Map
|—Hashtable 底层是哈希表数据结构，不可存入null键null值。该集合是线程同步的。Jdk1.0 效率低
|—HashMap 底层是哈希表数据结构，允许使用null键null值。该集合是不同步的。Jdk1.2 效率高
|—treeMap 底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序
和Set很像，其实Set底层就是使用了Map集合
03-集合(Map共性方法)MapDemo
Map<String,String> map = newHashMap<String,String>();
//添加元素，如果出现添加时相同的键，后添加的值会覆盖原有的键对应的值，并put方法会返回被覆盖的值
System.out.println("put："+map.put("01","zhangsan1")); //put：null
System.out.println("put："+map.put("01","wangwu")); //put：zhangsan1 返回01对应的值，并替换掉
map.put("02","zhangsan2");
map.put("03","zhangsan3");
System.out.println("containsKey："+map.containsKey("022")); //containsKey：false
System.out.println("remove："+map.remove("02")); //remove：zhangsan2
System.out.println("get："+map.get("023")); //get：null
map.put("04",null);
//可以通过get方法返回值来判断一个键是否存在。通过返回nill来判断
System.out.println("get："+map.get("04")); //get：null
Collection<String>coll = map.values(); //获取集合中所有的值，因为Map构造时V=String
System.out.println(coll); //[null,wangwu,zhangsan3]
System.out.println(map); //{04=null, 01=wangwu,03=zhangsan3}
04-集合(Map-keySet)KeySetDemo
Set<K> keySet() 返回此映射中包含的键的 Set 视图。
将map中所有的键存入Set集合。因为Set具备迭代器。所以可以迭代方式取出所有的键，再根据get方法，获取每个键对应的值
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");
Set<String>keySet = map.keySet(); //先获取,map集合的所有键的Set集合，keySet()
Iterator<String>it = keySet.iterator(); //有了Set集合，就可以获取其迭代器
while(it.hasNext())
{
Stringkey = it.next(); //迭代器取出所有键
Stringvalue = map.get(key); //get()方法取出键对应的值
System.out.println("key："+key+",value："+value);
}
}
05-集合(Map-entrySet) EntrySetDemo
Set<Map.Entry<K,V>>entrySet() 返回此映射中包含的映射关系的 Set 视图
将map集合中的映射关系存入到Set集合中，这个关系的数据类型是Map.Entry
Map<String,String> map = newHashMap<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();//这个映射关系的数据类型是Map.Entry
Stringkey = me.getKey(); //通过Map.Entry中的getKey()和getValue()获取键和值
Stringvalue = me.getValue();
System.out.println("key："+key+" ,value："+value);
}
其实Map.Entry是Map接口的类部接口。（如下）
interface Map
{
public static interface Entry
{
public abstract Object getKey();
public abstract Object getValue();
}
}
06-集合(Map练习) java文件MapTest
import java.util.*;
/*
* 每一个学生都有对应归属地。学生属性：姓名，年龄
* 注意：姓名和年龄相同的视为同一个学生，保证学生唯一性
*/
//描述学生
class StudentimplementsComparable<Student>
{
private Stringname;
private int age;
Student(Stringname,int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
returnname;
}
public int getAge()
{
returnage;
}
public int compareTo(Students) //重写Comparable接口的方法，让学生具备比较性
{
int num =new Integer(this.age).compareTo(new Integer(s.age));
if(num == 0)
returnthis.name.compareTo(s.name);
return num;
}
public int hashCode() //重写hashCode方法
{
returnname.hashCode()+age*34;
}
public boolean equals(Object obj)//重写equals方法
{
if(!(objinstanceof Student))
thrownewClassCastException("类型不匹配");
Students = (Student)obj;
return this.name.equals(s.name) &&this.age == s.age;
}
public String toString()
{
returnname+"："+age;
}
}
public class MapTest
{
public static void main(String[]args)
{
//定义map容器，将学生作为键，地址为值，存入
HashMap<Student,String>hm = new HashMap<Student,String>();
hm.put(new Student("lisi1",21),"beijing");
hm.put(new Student("lisi1",21),"shanghai");
hm.put(new Student("lisi3",23),"nanjing");
hm.put(new Student("lisi4",24),"hunan");
//第一种取出方式keySet
Set<Student>keySet = hm.keySet(); //获取所有键值，也就是学生
Iterator<Student>it = keySet.iterator();
while(it.hasNext())
{
Studentstu = it.next();
Stringaddr = hm.get(stu);
System.out.println(stu+"："+addr);
}
//第二种取出方式
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();
Studentst = me.getKey();
Stringaddr = me.getValue();
System.out.println(st+"…………"+addr);
}
}
}
07-集合(TreeMap练习) java文件TreeMapDemo
定义的比较器类用来让TreeMap具比较性，唯一性
import java.util.*;
/*
* 因为数据是以键值对形式存在的，所以要使用可以排序的Map集合。TreeMap
*/
class StuNameComparatorimplementsComparator<Student> //比较器类
{
public int compare(Students1,Student s2)
{
int num =s1.getName().compareTo(s2.getName());
if(num == 0)
returnnewInteger(s1.getAge()).compareTo(newInteger(s2.getAge()));
return num;
}
}
public class TreeMapDemo
{
public static void main(String[]args)
{
//定义Treemap容器，将学生作为键，地址为值，存入.此容器在保证元素唯一性和排序时只调用compareTo
TreeMap<Student,String>tm = new TreeMap<Student,String>(newStuNameComparator());
tm.put(new Student("lisi1",23),"beijing");
tm.put(new Student("lisi2",25),"shanghai");
tm.put(new Student("lisi3",21),"nanjing");
tm.put(new Student("lisi4",28),"hunan");
//第一种取出方式keySet
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();
Studentstu = me.getKey();
Stringaddr = me.getValue();
System.out.println(stu+"："+addr);
}
}
}
08-集合(TreeMap练习-字母出现的次数) TreeMapDemo2
“sadwerfecdsaasadf”获取该字符串中的个字母出现的次数。打印结果：a(4)c(1)…… 因为Character实现了Comparable接口，具比较性（排序）
通过结果发现，每个字母都有对应的次数，说明字母和次数之间有映射关系。当发生有映射关系是，可以选择map集合，因为map集合中存放的就是映射关系
public static StringcharCount(String str)
{
int count = 0;
char[] chs =str.toCharArray();
TreeMap<Character,Integer>tm = new TreeMap<Character,Integer>();//创建TreeMap对象
for(int x = 0;x<chs.length;x++)
{
if(!(chs[x]>='a' &&chs[x]<='z' || chs[x]>='A' && chs[x]<='Z'))
continue; //当不是字母时，结束本次循环，继续下次循环
Integervalue = tm.get(chs[x]);
if(value !=null)
count= value;
count++;
tm.put(chs[x],count);
count= 0; //每次循环后归0
}
StringBuildersb = new StringBuilder();//定义字符串缓冲区，存放字母和数字
Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet(); //获取Map集合中所有映射关系
Iterator<Map.Entry<Character,Integer>> it =entrySet.iterator(); //获取set集合迭代器
while(it.hasNext())
{
Map.Entry<Character,Integer> me = it.next();
Characterch = me.getKey();
Integervalue = me.getValue();
sb.append(ch+"("+value+")");
}
return sb.toString();
}
09-集合(Map扩展) MapDemo1
Map集合被使用是因为具备映射关系
* 1 Map集合中嵌套Map集合 map学校（班级，map学生（学号，姓名））
* 2 通常将学生封装为对象
day17（集合框架的工具类） java.util包
10-集合(Collections-sort) CollectionsDemo
List集合本来不可以排序，怎样村就怎样出。但是用集合工具类可以给List集合排序
1 static <T extends Comparable<? super T>>void sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序。这适合元素T自身具备比较性，比如String
//sort()方法中的参数集合T必须要有比较性，不然运行时挂了，因为将T转换为comparable时异常，
//所以继承Comparable，Comparable使用泛型，T的父类即可
Collections.sort(lt); // String类本身复写了compareTo();
System.out.println(lt); //[abcd, few,ghjmk, z,z]
2 static <T>void sort(List<T> list, Comparator<?super T> c) 根据指定比较器产生的顺序对指定列表进行排序。当元素自身不具备比较性或者不是想要的，可以传递一个比较器对List集合元素排序
//定以比较器，首先根据字符串长度排序，长度相同时自然排序
class StrLenComparatorimplementsComparator<String>
{
public int compare(String s1,String s2) {
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
returns1.compareTo(s2); //长度相同时自然排序
}
}
Collections.sort(lt ,newStrLenComparator()); //传入比较器
System.out.println(lt); //[z, z, few, abcd, ghjmk]
day17-11-集合(Collections-max) CollectionsDemo
static <T> T max(Collection<?extends T> coll,Comparator<?super T>comp)
根据指定比较器产生的顺序，返回给定 collection 的最大元素。
day17-12-集合(Collections-binarySearch) CollectionsDemo
static<T>int binarySearch(List<? extends Comparable<?super T>> list,Tkey)
使用二分搜索法搜索指定列表，以获得指定对象。
如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点被定义为将键插入列表的那一点：即第一个大于此键的元素索引；如果列表中的所有元素都小于指定的键，则为list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
day17-13-集合(Collections-替换反转) CollectionsDemo1
static <T> void fill(List<?super T> list, T obj) 使用指定元素替换指定列表中的所有元素
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
使用另一个值替换列表中出现的所有某一指定值。
static void reverse(List<?> list) 反转指定列表中元素的顺序。
static void swap(List<?>list, int i,int j) 在指定列表的指定位置处交换元素。
其实reverse底层就是调用了swap方法
static voidshuffle(List<?> list, Random rnd) 使用指定的随机源对指定列表进行置换。（洗牌）
day17-14-集合(Collections-reverseOrder) 逆转排序
static <T>Comparator<T> reverseOrder()
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
static <T>Comparator<T> reverseOrder(Comparator<T>cmp)
返回一个比较器，它强行逆转指定比较器的顺序。
例子：TreeSet<String> ts=
new TreeSet<String>(Collections.reverseOrder(newStrLenComparator()));
将一个比较器逆转
day17-15-集合(Collections-SynList)返回同步集合
原理：其实在底层，这些方法内部是通过 new synchronizedList（List）对象。将需要同步的集合传入。通过synchronizedList类的构造方法返回一个同步的集合。这个类中重写了集合的所有方法，都加了同步并使用同一个锁。
static <T>List<T> synchronizedList(List<T>list) 返回指定列表支持的同步（线程安全的）列表。
static <K,V>Map<K,V> synchronizedMap(Map<K,V>m) 返回由指定映射支持的同步（线程安全的）映射。
static <T>Set<T> synchronizedSet(Set<T>s) 返回指定 set 支持的同步（线程安全的）set。
day17-16-集合(Arrays)ArraysDemo java,util包
Arrays：用于操作数组的工具类，里面都是静态方法。而且都是重载
static <T> List<T> asList(T... a) 返回一个受指定数组支持的固定大小的列表。（数组转换为集合）
binarySearch() 使用二分搜索法来搜索指定数组
copyOf() 复制指定的数组
copyOfRange() 将指定数组的指定范围复制到一个新数组。
deepEquals() 如果两个指定数组彼此是深层相等 的，则返回true。
equals() 如果两个指定的 boolean 型数组彼此相等，则返回true。
fill() 将指定的值分配给指定类型数组的每个元素。
hashCode（) 基于指定数组的内容返回哈希码。
sort(char[] a) 对指定的char 型数组按数字升序进行排序。
toString(int[] a) 返回指定数组内容的字符串表示形式。
1 把数组变成list集合有什么好处？
可以使用集合的思想和方法操作数组中的元素
2 注意：将数组变成集合，不可以使用集合的增删方法。因为数组长度是固定的、
可用 contains get indexOf subList
如果增删，会发生UnsupportedOperationException异常
String[] arr1= {"abc","dsa","ewtk"};
List<String>list = Arrays.asList(arr1);
System.out.println(list); //[abc,dsa,ewtk] 集合可以直接打印
// 可用list集合的方法判断数组中是否存在某元素。如果用数组，要遍历比较
System.out.println("contains："+list.contains("cc"));
list.add("qq"); //UnsupportedOperationException
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转换成集合中的元素
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在
int[] arr3 = {2,4,7};
Listlist1 = Arrays.asList(arr3); // List<int[]> list1 =Arrays.asList(arr3);
System.out.println(list1); //[[I@1c0ec97]
Integer[]arr4 = {2,4,7};
List<Integer> list2 = Arrays.asList(arr4);
System.out.println(list2); //[2, 4, 7]
day17-17-集合(集合转成数组) CollectionToArray
ArrayList<String> a1 = newArrayList<String>();
a1.add("abc1");
a1.add("abc2");
a1.add("abc3");
/*
*1 指定类型的数组到底要定义多长呢？
* 当指定的数组长度小于了集合的size，那么toArray内部会创建一个新数组，长度为集合的size
* 当指定类型的数组长度大于集合的size，就不会创建新数组，空位用null
* 所以创建一个刚刚好的数组最优 【a1.size()】
*
* 2 为什么要将集合变数组？
* 为了限定对元素的操作（增删） 数组再转化为集合时，就不可以使用集合增删方法
*/
String[] arr = a1.toArray(new String[0]);//将集合变数组
System.out.println(Arrays.toString(arr));
day17-18-集合(增强for循环) ForEachDemo
1 支持Iterator迭代的都支持高级for，迭代是Collection特性。Map不支持迭代
2 格式：for（数据类型 变量名 ： 被遍历的集合（Collection）或者数组）{}
3 对集合进行遍历：只能获取集合元素，但是不能得意集合进行任何操作
迭代器除了遍历：还可以进行remove集合中元素的动作；如果是ListIterator，还可以在遍历的过程中对集合元素进行增删改查的动作
4 传统的for和高级for有什么区别？
高级for有一个局限性，必须要有被遍历的目标
建议在遍历数组的时候，还是用传统for，因为传统for可以定义脚标
ArrayList<String> al = newArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
//加强for循环遍历集合
for(String s :al) //注意：如果集合没加泛型，就不能写String，只能写Obiect
{
//s="kk"; //不能对集合元素操作，但是迭代可以对元素操作，List的迭代器还能增删改
System.out.println(s);
}
//遍历Map集合
HashMap<Integer,String> hm = newHashMap<Integer,String>();
hm.put(1, "a");
hm.put(2, "b");
hm.put(3, "c");
Set<Integer> keySet = hm.keySet(); //获取集合中所有的键的集合
//高级for遍历集合
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());
}
day17-19-集合(可变参数)
1 JDK1.5版本出现的新特性：方法的可变参数
2 在使用是注意：可变参数一定要定义在参数列表最后面
3 用数组作为参数时虽然少定义（重载）了多个方法，但是每次都要定义一个数组作为实际参数
4 可变参数：其实就是一种数组参数的简写形式。不用每次都手动建立数组对象，只要将操作的元素作为参数传递即可；隐式将这些参数封装成了数组。
5 可变参数一定要定义在参数列表的最后面
public static void show(int ... arr){}
public static void show(String str,int ... arr){}
day17-20-集合(静态导入)
importjava.util.Arrays; //导入Arrays这个类
/*
* 当类名重名时，需要指定具体的包名；
* 当方法重名时，指定具备所属的对象或者类
*/
import staticjava.util.Arrays.*; //导入Arrays这个类中的所有静态成员
import staticjava.lang.System.*; //导入System类中所有静态成员
public class StaticImport
{
public static void main(String[]args)
{
int[] arr = {3,4,1};
sort(arr);
int index =binarySearch(arr,1);
out.println(Arrays.toString(arr));//Object中的和Arrays中的同名方法，所以指定类名
System.out.println("index="+index);
}
}