-------android培训、java培训、期待与您交流！ ----------
一：集合类的概述：
（一） 为什么出现集合框架及特点！
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行了存储，集合就是存储对象最常用的一种方式；
集合只用于存储对象，集合长度是可变的集合可以存储不同的类型对象；
集合框架共包含三大类接口：List Set 和Map 区别如下：
1： Collection 接口存储的是一组不唯一，无序的对象；
2：Set 接口继承Collection 接口，存储一组唯一，无序的对象；
3：List 接口继承Collection 接口 存储一组不唯一，有序的对象；
4：接口存储一组成对的（键--值）对象，并提供key到value的映射，key不要求有序，不允许重复，value同样不要求有序但允许重复；
（二）数组和集合类同时容器，有什么不同呢！
1：数组虽然也可以存储对象，但长度是固定的，集合的长度是可变的，数组中可以存储基本数据类型，集合只能存储对象。
2：定义数组时必须指定数组元素类型，集合默认其中所有元素都是Object；
3：无法直接回去数组实际存储的元素个数，length用来获取数组的长度，但可以通过size()直接获取集合实际存储的元素个数；
4：集合有多种实现方式和不同的适用场合，而不像数组仅采用分配连续空间方式。
5：集合以接口和类的形式存在，具有封装、继承和多态等类的特性，通过简单的方法和属性调用即可实现各种复杂操作，大大的提高了软件的开发效率；
JDK中有一个Arrays类，专门用来操作数组它提供了一系列静态方法实现对数组搜索，排序，比较和填充等操作，JDK中有一个Collectios类，专门用来操
他提供了一系列静态方法实现对各种集合的搜索，复制，排序和线程安全化等操作；
二 集合框架的使用：
List 集合 的常用方法：
1：add(E e) :将指定的元素添加到此列表的尾部。 add(int index,E element): 将指定的元素插入此列表中的指定位置。
2：size(); 返回此列表中的元素数。
3:remove(int index) ： 移除此列表中指定位置上的元素。
4: clear() : 移除此列表中的所有元素。
5:lastIndexOf(Object o) : 返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
6: isEmpty() : 如果此列表中没有元素，则返回true
7: get(int index) 返回此列表中指定位置上的元素
8：set(index i,E element) 用指定的元素替换指定位置的元素；
9：sublist(int formIndex, int toIndex)；//获取指定列表中的元素包括formIndex不包括toIndex；
10: 获取元素的迭代器：public interface Iterator<E>
hasNext() 如果仍有元素可以迭代，则返回true。
next() 返回迭代的下一个元素。
remove() 从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。
其实迭代器就是取出方式定义在集合的内部这样取出方式就可以直接访问集合内容的元素，这时就把这种取出方式定义成了内部类；
而每一个容器的数据结构不同所以取出的方式也不一样，但是都有共性的内容就是要（判断和取出）这时就可以将共性抽取；此时这些
内部类都符合一个规则就是Iterator。那么如何获取集合的取出对象呢？就是通过一个对外提供的方法iterator()；
具体使用如下示例：
（一）：ArrayList底层使用的是数组结构；特点是查询的速度快，增删稍慢；线程不同步；
public static void show(){
ArrayList list=new ArrayList();
list.add("张三");//添加元素
list.add("李四");
list.add("王五");
list.add("赵六");
//使用Iterator迭代器遍历集合中的元素
Iterator it=list.iterator();
while(it.hasNext()){
System.out.print(it.next()+"\t");
}
System.out.println("\n"+list.size());//获取元素的个数
System.out.println(list.subList(0, 2));//获取指定位置的元素
list.set(2, "赵敏");//使用set方法修改指定的位置的元素
System.out.println(list.get(2));//获取下标为2的元素
System.out.println(list.remove(0));//删除第0个元素
System.out.println(list.remove("李四"));//删除指定的元素
System.out.println(list.isEmpty());//判断集合中是否为空
list.clear();//情况所有元素
System.out.println(list.isEmpty());//判断集合中是否为空
}
11： List集合特有的迭代器：ListIterator是Iterator的子接口： 该接口在迭代式不可以通过集合对象的方法操作集合中的元素，因为会
发生ConcurrentModificationException异常；所以在迭代时只能用迭代器的迭代过的操作元素，可是Iterator方法是有限的，如果想
要其他的操作如添加，修改，取出，删除操作就需要使用其子接口，ListIterator；
该接口只能通过List集合中的子接口ListIterator接口完成；
如示例：
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList list=new ArrayList();
list.add("张三");//添加元素
list.add("李四");
list.add("王五");
list.add("赵六");
//使用Iterator迭代器的子接口操作集合中的元素
ListIterator it=list.listIterator();
while(it.hasNext()){
Object obj=it.next();
if(obj.equals("王五")){
//在这里就可以进行 增删改查 了;但是只能操作一种不能有添加又修改；
it.add("youyou");
//it.set("wangwu");
//it.remove();
}
}
//修改后的集合
ListIterator ait=list.listIterator();
while(ait.hasNext()){
System.out.println(ait.next());
}
}
（二）LinkedList：底层使用的是链表数据结构：增删速度很快，但查询稍慢；
LinkedList集合的特有方法：获取元素
: addFirst();将指定元素插入此列表的开头。
addLast();将指定元素添加到此列表的结尾。
getFirst(); 返回此列表的第一个元素。
getLast();返回此列表的最后一个元素。
特点是：获取元素不删除元素；如果集合中没有元素会报出异常：NOSuchElementException；
removerFirst():移除并返回此列表的第一个元素。
removerLast();移除并返回此列表的最后一个元素。
特点是：获取元素且删除元素；如果集合中没有元素会报出异常：NOSuchElementException；
但在JDK1.6版本后出现了以下方法替代了以上方法：
offerFirst(E e) 在不违反容量限制的情况下，将指定的元素插入此双端队列的开头。
offerLast(E e) 在不违反容量限制的情况下，将指定的元素插入此双端队列的末尾。
peekFirst() 获取，但不移除此双端队列的第一个元素；如果此双端队列为空，则返回null。
peekLast() 获取，但不移除此双端队列的最后一个元素；如果此双端队列为空，则返回null。
pollFirst() ： 获取并移除此双端队列的第一个元素；如果此双端队列为空，则返回null。
pollLast() 获取并移除此双端队列的最后一个元素；如果此双端队列为空，则返回null。
poll() 获取并移除此双端队列所表示的队列的头部（换句话说，此双端队列的第一个元素）；如果此双端队列为空，则返回null。
如示例：
public static void main(String[] args) {
// TODO Auto-generated method stub
LinkedList link=new LinkedList();
link.offerLast("张三3");//使用offerFirst添加将元素添加到最后一个
link.offerLast("张三4");
link.offerFirst("张三1");//使用offerFirst添加将元素添加到第一个
link.offerFirst("张三2");
Iterator it=link.iterator();
while(it.hasNext()){
System.out.print(it.next());
}
System.out.println("\n"+link.peekFirst());//获取第一个元素但不删除
System.out.println(link.pollLast());//获取第一个元素但删除
Iterator its=link.iterator();//被删除后的元素
while(its.hasNext()){
System.out.print(its.next());
}
练习：模仿堆栈 或队列 先进先出或先进后出的练习
public static void main(String[] args) {
// TODO Auto-generated method stub
Queue q=new Queue();
q.setLink("JAVA1");
q.setLink("C#2");
q.setLink("JAVA3");
q.setLink("JSP4");
while(!q.isNull()){
System.out.println(q.getLink());
}
}
}
class Queue{
private LinkedList link;
//在创建对象时就创建一个LinkedList集合
public Queue(){
link=new LinkedList();
}
//添加的方法
public void setLink(Object obj){
link.add(obj);
}
//去元素的方法
public Object getLink(){
//return link.pollFirst();//先进先出的输出方法
return link.pollLast(); //先进后出的输出方法
}
//调用isEmpty的方法
public boolean isNull(){
return link.isEmpty();
}
}
（三） List集合判断元素是否相同，依据是元素的equals方法；
如示例：
public static void main(String[] args) {
// TODO Auto-generated method stub
//定义集合并传入Student对象的构造函数传入值
ArrayList list=new ArrayList();
list.add(new Student("张三1",25));
list.add(new Student("张三2",25));
list.add(new Student("张三3",25));
list.add(new Student("张三1",25));
list.add(new Student("张三2",28));
list.add(new Student("张三4",25));
list=new Student().isd(list);//调用判断是否是同一个值
Iterator it=list.iterator();
while(it.hasNext()){
Object obj=it.next();
Student stu=(Student)obj;
System.out.println(stu.getName()+"...."+stu.getAge());
}
}
}
class Student{
private String name;//定义变量name并给出get 和set方法
private int age;//定义变量age并给出get 和set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student(String name,int age){
this.name=name;
this.age=age;
}
public Student() {
// TODO Auto-generated constructor stub
}
//重写Object的equals方法
public boolean equals(Object obj){
//判断传入的对象是否是Student对象
if(!(obj instanceof Student)){
return false;
}
Student s=(Student)obj;//类型转换
//判断如果姓名和年龄一样就是为同一个人不存入集合中
return this.name.equals(s.name) && this.age==s.age;
}
@SuppressWarnings("unchecked")
public static ArrayList isd(ArrayList li){
//定义临时集合存储数据
ArrayList al=new ArrayList();
for(Iterator it=li.iterator();it.hasNext();){
//类型转换
Object obj=it.next();
//这里使用了contains方法判断元素是否相同时先会调用equals方法做判断
if(!al.contains(obj)){
al.add(obj);//如果不同就将值存入al临时集合中
}
}
return al;
}
}
Set集合的使用：Set集合的功能和Collection的功能是一致的。
（一）Set集合概述：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。
（1）HashSet：底层数据结构式哈希表；线程是非同步的；
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法：hashCode和equals来完成的；如果元素的HashCode值相同才会判断equals是否为true；
如果hashCode值不同就不会调用equals方法。所以在使用HashSet集合时一般都会复写hashCode和equals方法；
如示例：
public static void main(String[] args) {
// TODO Auto-generated method stub
//hashCode和equals方法都是自动调用的
HashSet hs=new HashSet();
hs.add(new Student("张三",25));
hs.add(new Student("李四",22));
hs.add(new Student("王五",23));
hs.add(new Student("赵六",21));
hs.add(new Student("王五",23));
hs.add(new Student("李四",22));
Iterator it=hs.iterator();
while(it.hasNext()){
Student stu=(Student)it.next();
System.out.println(stu.getName()+"...."+stu.getAge());
}
}
}
class Student{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student(String name,int age){
this.name=name;
this.age=age;
}
//复写hashCode方法自定生成哈希值判断对象的哈希值地址是否相同如果相同在调用equals方法判断
public int hashCode(){
return name.hashCode()+age*25;
}
//复写Object的equals方法来判断值是否相同如果相同就存入集合中
public boolean equals(Object obj){
if(!(obj instanceof Student)){//判断对象是否是Student
return false;
}
Student stu=(Student)obj;//类型转换
return this.name.equals(stu.name)&& this.age==stu.age;
}
}
（2）TreeSet：可以对Set集合中的元素进行排序，底层数据结构是二叉树；在保证元素唯一性的依据是compareTo方法返回的0；因为
compareTo方法返回值是整数就是大的值，负数是小的值，0是相同的值。
TreeSet排序的第一种方式：让元素自身具有比较性，元素需要实现Comparable接口，覆盖compareTo方法，这种方式也称为元素的自然顺序
或叫做默认顺序；
如示例：
public static void main(String[] args) {
// TODO Auto-generated method stub
TreeSet hs=new TreeSet();
hs.add(new Studen("张三",25));
hs.add(new Studen("李四",22));
hs.add(new Studen("王五",23));
hs.add(new Studen("赵六",21));
hs.add(new Studen("王五",23));
hs.add(new Studen("李四1",22));
Iterator it=hs.iterator();
while(it.hasNext()){
Studen stu=(Studen)it.next();
System.out.println(stu.getName()+"...."+stu.getAge());
}
}
}
class Studen implements Comparable{//实现该Comparable接口将强制进行排序
private String name;
private int age;
public String getName() {
return name;
}
public int getAge() {
return age;
}
public Studen(String name,int age){
this.name=name;
this.age=age;
}
public int compareTo(Object obj) {
if(!(obj instanceof Studen)){
throw new RuntimeException("不是同一对象");
}
Studen stu=(Studen)obj;
if(this.age>stu.age){//此对象大于指定对象就返回整数
return 1;
}
if(this.age==stu.age){//此对象等于指定对象就返回0；
//如果年龄相同在使用姓名判断是否是同一个如果是就不存进集合否则就存
return this.name.compareTo(stu.name);
}
return-1;//此对象小于指定对象就返回负数
}
}
泛型集合：
一 泛型概述：JDK 1.5版本后出现的新特性，用于解决安全问题，是一个类型安全机制；
（一）特点：
（1）：将运行出现的问题ClassCastException转移到了编译时期的问题，方便与程序员解决问题，让运行事情的问题减少从而提高安全性；
（2）避免了强制转换的麻烦；
（二）泛型的格式：通过 < 参数类型> 括号来定义要操作的引用数据类型在使用java提供的对象是；
什么时候写泛型呢？
通常在集合框架中很常见，只要是用<>定义的集合就是泛型集合；
（三） 泛型集合的使用----如示例：
public static void main(String[] args) {
// TODO Auto-generated method stub
//定义泛型集合的类型为String
TreeSet<String> tr=new TreeSet<String>(new sd());
tr.add("abc");
tr.add("hsc");
tr.add("edfe");
tr.add("sec");
tr.add("agc");
tr.add("agc");
Iterator<String> it=tr.iterator();//Iterator迭代器也要指定和集合一样的类型
while(it.hasNext()){
System.out.println(it.next());
}
}
}
//实现Comparator接口进行排序，并制定泛型集合的类型<String>
class sd implements Comparator<String>{
//实现compare的排序方法
public int compare(String s1, String s2) {
//获取正负数并返回其对象判断后排序的的值
int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num==0){
//如果返回0说明之相等就在用compareTo()方法来判断其是不是同一个值是就不存进集合中
return s1.compareTo(s2);
}
return num;
}
}
二 泛型定义在：类中或方法中的使用：
（一）泛型类定义的泛型在整个类中有效，如果被方法使用那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了；
（二）在方法中也可以定义泛型这就是泛型方法了，而且类型是不确定，因此这个类型就是随着方法传入的数据来确定的；
（三）静态泛型方法的特殊之处：
静态方法不可以访问类上定义的泛型;因为静态的数据是先存在于对象之前的；
（四）泛型还可以定义在接口上：如： interface inter<T t>{ void show(T t); } 这个类型由实现类来确定是什么类型；
泛型的使用如下示例：
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建对象后确定类型为String后此对象的类型就不可改变；
Test_2<String> t=new Test_2<String>();
t.show("String");
//t.show(50);如果传人的值为int就会报错
t.prints(50);//而这个方法的类型是由传入的值来确定的类型所以会报错
t.prints("String");
Test_2.sho("这是静态泛型类！");
}
}
class Test_2 <E>{//泛型定义在类中的格式
public void show(E e){//这个方法类型是有对象来确定的
System.out.println("是什么类型的数据由--类--来确定：："+e);
}
//泛型定义在方法中的格式
public<T> void prints(T t){
System.out.println("是什么类型的数据由--方法--来确定：："+t);
}
//泛型定义在静态方法中的格式：但不能使用类中的泛型类型
public static <S> void sho(S s){
System.out.println("是什么类型的数据由--方法--来确定：："+s);
}
}
Map集合：将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值。
一 public interface Map<K,V> 接口概述：
Map 接口提供三种collection 视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容； 映射顺序 定义为迭代器在映射的
collection 视图上返回其元素的顺序， 某些映射实现可明确保证其顺序，如 TreeMap 类；另一些映射实现则不保证顺序，如HashMap类 ；
注意： 将可变对象用作映射键时必须格外小心。当对象是映射中某个键时，如果以影响 equals 比较的方式更改了对象的值，则映射的行为将是
不确定的。此项禁止的一种特殊情况是不允许某个映射将自身作为一个键包含。虽然允许某个映射将自身作为值包含，但请格外小心：在这
样的映射上 equals 和 hashCode 方法的定义将不再是明确的。
常用的方法：
添加：
put(K key,V value) 在此映射中关联指定值与指定键。
putAll(Map<? extendsK,? extendsV> m)
将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系。
删除：
remove(Object key) 从此映射中移除指定键的映射关系（如果存在）。
clear() 从此映射中移除所有映射关系。
判断：
containsKey(Object key) 如果此映射包含对于指定键的映射关系，则返回true。
containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回true。
isEmpty() 如果此映射不包含键-值映射关系，则返回true。
获取：
get(Object key) 返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回null。
size() 返回此映射中的键-值映射关系数。
values() 返回此映射所包含的值的Collection 视图。
map集合的两种取值方法：
（1） entrySet() 返回此映射所包含的映射关系的Set 视图。
就是将map集合中的映射关系村到set集合中，而这个关系的数据类型就是map.Entry；
（2） keySet() 返回此映射中所包含的键的Set 视图。
是将map中所有的键存入到set集合中，因为set具备迭代器；所以可以以迭代方式取出所有的键，在根据get方法获取每一个键中对应的值；
map集合的取出原理： 其实就是将map集合转成set集合，在通过迭代的方式取值；
常用的子类有如下
二： public class Hashtable<K,V> 此类实现一个哈希表，该哈希表将键映射到相应的值。任何非null 对象都可以用作键或值。
注意： 为了成功地在哈希表中存储和获取对象，用作键的对象必须实现 hashCode 方法和equals 方法。此集合是线程同步的；
三 public class HashMap<K,V> 集合概述： 基于哈希表的Map 接口的实现。此实现提供所有可选的映射操作，并允许使用null 值和null 键。
（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。） 此类不保证映射的顺序，特别是它不保证该顺序恒久不变，
线程非同步的，且效率比Hashtable效率高；
使用如示例：
public static void main(String[] args) {
// TODO Auto-generated method stub
Map<String,String> map=new HashMap<String,String>();
map.put("01", "张三");
map.put("02", "李四");
map.put("03", "王五");
map.put("04", "赵六");
System.out.println(map);//获取集合中的所有值
System.out.println(map.get("03"));//通过key得到value值
map.remove("03");//通过key删除该键值对；
System.out.println(map.containsKey("02"));//判断是否存在该键值
System.out.println(map.containsValue("王五"));//盘断是否存在该value值
System.out.println(map.size());//返回此映射中的键-值映射关系数
Set<String> set=map.keySet();//通过keySet获取所有的key并存到Set集合中；
Iterator<String> it=set.iterator();//获取set集合的迭代器String为map集合的key值类型要一致
while(it.hasNext()){
String key=it.next();//获取key在同过get方法获取所有的value值
System.out.println(key+"........."+map.get(key));
}
Set<Map.Entry<String, String>> st=map.entrySet();//通过Map集合中的映射关系取出存储到set集合中；
Iterator<Map.Entry<String, String>> its=st.iterator();//获取set集合中的迭代器
while(its.hasNext()){
Map.Entry<String, String> en=its.next();//获取Map.Entry接口的对象在通过对象.方法获取其键 和值
System.out.println(en.getKey()+"..."+en.getValue());
}
四 public class TreeMap<K,V> 基于红黑树（Red-Black tree）的NavigableMap 实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时
提供的 Comparator 进行排序，具体取决于使用的构造方法。
注意： 如果要正确实现 Map 接口，则有序映射所保持的顺序（无论是否明确提供了比较器）都必须与 equals 一致。（关于与 equals 一致 的精确
定义，请参阅 Comparable 或 Comparator）。这是因为Map 接口是按照equals 操作定义的，但有序映射使用它的compareTo（或
compare）方法对所有键进行比较，因此从有序映射的观点来看，此方法认为相等的两个键就是相等的。即使排序与 equals 不一致，有序映
射的行为仍然是 定义良好的，只不过没有遵守 Map 接口的常规协定。
如示例：
public static void main(String[] args) {
// TODO Auto-generated method stub
TreeMap<Student,String> tm=new TreeMap<Student,String>(new cmp());
tm.put(new Student("张三5",22), "beijin");
tm.put(new Student("张三3",24), "beijin");
tm.put(new Student("张三2",20), "beijin");
tm.put(new Student("张三4",21), "beijin");
tm.put(new Student("张三4",21), "beijin");
//第一种取值的方法
Set<Student> st=tm.keySet();
for(Iterator<Student> it=st.iterator();it.hasNext();){
Student stu=it.next();
String value=tm.get(stu);
System.out.println(stu.getName()+"..."+stu.getAge()+"..."+value);
}
//第二种取值的方法
Set<Map.Entry<Student, String>> se=tm.entrySet();
for(Iterator<Map.Entry<Student, String>> its=se.iterator();its.hasNext();){
Map.Entry<Student, String> en=its.next();
Student sts=(Student)en.getKey();
System.out.println(sts.getName()+"..."+sts.getAge()+"..."+en.getValue());
}
}
}
//实现comparator即口的compare方法实现按照姓名排序
class cmp implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
//调用compareTo方法来获取返回值：正 负 及 0
int num=o1.getName().compareTo(o2.getName());
if(num==0){
//如果返回值为0说明姓名相同在判断其年龄是否相同如相同就是为同一个人
return new Integer(o1.getAge()).compareTo(new Integer(o2.getAge()));
}
return num;
}
}
//实现comparable接口
class Student implements Comparable<Student>{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student(String name,int age){
this.name=name;
this.age=age;
}
//实现compareTo方法实现按年龄来排序。
public int compareTo(Student o) {
if(!(o instanceof Student)){
throw new ClassCastException();
}
int num=new Integer(this.getAge()).compareTo(new Integer(o.getAge()));
if(num==0){
return this.getName().compareTo(o.getName());
}
return num;
}
//返回一个自定义的哈希值
public int hashCode(){
return this.name.hashCode()+this.age*25;
}
//实现equals方法
public boolean equals(Object obj){
if(obj instanceof Student){
throw new ClassCastException();
}
Student st=(Student)obj;
return this.name.equals(st.name)&&this.age==st.age;
}
}
五 泛型的多层嵌套：就是泛型集合中在嵌套其他的集合，这要根据需求来确定要使用什么集合来嵌套集合；如下示例是HashMap泛型嵌套HashMap泛型：
如示例：
public static void main(String[] args) {
// TODO Auto-generated method stub
//创建一个嵌套的HashMap泛型集合
HashMap<String,HashMap<Students,String>> team=new HashMap<String,HashMap<Students,String>>();
HashMap<Students,String> jiyeb=new HashMap<Students,String>();//为外出层集合创建两个内层集合
HashMap<Students,String> caiwu=new HashMap<Students,String>();
team.put("jiyeb", jiyeb);//给外出集合赋值
team.put("caiwu", caiwu);
jiyeb.put(new Students("张三1",22), "beij");//给第一个内层集合赋值
jiyeb.put(new Students("张三2",24), "shanghai");
caiwu.put(new Students("张三3",12), "nanjin");//给第二个内层集合赋值
caiwu.put(new Students("张三4",17), "tianjin");
caiwu.put(new Students("张三5",16), "tianjin");
Set<Map.Entry<String, HashMap<Students, String>>> st=team.entrySet();//获取外出集合的迭代器
//循环获取外出集合的key值
for(Iterator<Map.Entry<String, HashMap<Students, String>>> it=st.iterator();it.hasNext();){
Entry<String, HashMap<Students, String>> mp=it.next();
System.out.println(mp.getKey());//输出外出的key值
Set<Map.Entry<Students, String>> te=team.get(mp.getKey()).entrySet();//通过外出的key值获取内层集合的迭代器
for(Iterator<Map.Entry<Students, String>> ti=te.iterator();ti.hasNext();){
Entry<Students, String> en=ti.next();//输出内层的key值和value值
Students s=en.getKey();
System.out.println(s.getName()+"..."+s.getName()+"..."+en.getValue());
}
}
}
}
class Students implements Comparable<Students>{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Students(String name,int age){
this.name=name;
this.age=age;
}
public int compareTo(Students o) {
int num= this.name.compareTo(o.name);
if(num==0){
return new Integer(this.getAge()).compareTo(new Integer(o.getAge()));
}
return num;
}
public boolean equals(Object obj){
if(!(obj instanceof Student)){
throw new ClassCastException();
}
Students st=(Students)obj;
return this.name.equals(st.name) &&this.age==st.age;
}
}
六 Collections 工具类：此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。
常用方法有：
copy(List<? super T> dest,List<? extends T> src) 将所有元素从一个列表复制到另一个列表。
fill(List<? super T> list, T obj) 使用指定元素替换指定列表中的所有元素。
max(Collection<? extends T> coll) 根据元素的自然顺序，返回给定 collection 的最大元素。
sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序。
binarySearch(List<? extendsComparable<? super T>> list, T key) 使用二分搜索法搜索指定列表，以获得指定对象。
frequency(Collection<?> c,Object o) 返回指定 collection 中等于指定对象的元素数。
reverse(List<?> list) 反转指定列表中元素的顺序。
replaceAll(List<T> list, T oldVal, T newVal) 使用另一个值替换列表中出现的所有某一指定值。
shuffle(List<?> list) 使用默认随机源对指定列表进行置换。
如示例：
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<String> list=new ArrayList<String>();
list.add("sdf");
list.add("qawe");
list.add("sdfe");
list.add("aasdw");
list.add("iuygf");
System.out.println(list);
int s=Collections.binarySearch(list,"sdfe");//binarySearch返回的是该字符串中的位置；如果不存在就返回要存入的位置；
System.out.println(s);
Collections.sort(list);//集合的数据排序
System.out.println(list);
Collections.reverse(list);//集合的数据翻转
System.out.println(list);
//Collections.fill(list, "a");//将数据全部替换成a
System.out.println(list);
int ss=Collections.frequency(list, "qq");//返回集合中存指定元素的个数；没有就返回0；
System.out.println(ss);
Collections.replaceAll(list, "sdf", "sde");//指定要替换的原值和新值；
System.out.println(list);
show();
Collections.shuffle(list);//随机将集合中的数据进行从新排序；
System.out.println(list);
}
public static void show(){
//通过Collections.reversOrder(传入按长度的比较器)翻转数据
TreeSet<String> t=new TreeSet<String>(Collections.reverseOrder(new cop()));
t.add("22wewrwrw");
t.add("qw");
t.add("ew");
t.add("24wqe");
t.add("qww");
System.out.println(t);
}
}
class cop implements Comparator<String>{
@Override
public int compare(String o1, String o2) {
int num=new Integer(o1.length()).compareTo(new Integer(o2.length()));
if(num==0){
return o1.compareTo(o2);
}
return num;
}
}
七：高级for循环：
（一）格式：for（数据类型 变量名：被遍历的集合（conllection）或是数组）{ }
（二）对集合进行遍历，只能获取集合元素，但不能队集合进行操作；
（三）迭代器出来遍历还可以进行remover集合中的元素操作，如果是使用ListIterator，还可以在遍历集合的过程中进行增删改查的操作；
（四）传统for循环和高级for循环有什么区别呢？
高级for循环有一个局限性：就是要有遍历的目标；建议在遍历数组时还是使用传统的for循环因为可以设置循环的条件，还可以定义
for循环的角标；
（五）数组与集合之间的转换：
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
Collections接口中toArray方法
1：指定类型的数组到底要定义的长度是多少呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size；
当指定类型的数组长度大于了集合的size，就不会新创建数组了，而是使用传递进来的数组，所以创建一个刚刚好的数组最好
这时就可以使用集合的size()方法来指定长度了；
2：为什么要将集合变成数组呢？
是为了限定元素的操作：不需要进行增删；
*/
ArrayList<String> lists=new ArrayList<String>();
lists.add("sdfs");
lists.add("ghjt");
lists.add("qwrf");
lists.add("luf");
String[] str=lists.toArray(new String[lists.size()]);
System.out.println(Arrays.toString(str));
/*
* 不数组变成集合的好处？
* 可以使用集合中的思想和方法来操作数组中的元素；
* 注意：将数组变成集合，不可以使用集合中的增删方法，因为数组的长度是固定的；
* 如果使用这些方法的话就会报错：UnsupportedOperationException
*/
String[] name={"sad","sdfe","wetf"};//创建一个String类型的数组
System.out.println(Arrays.toString(name));
List<String> list=Arrays.asList(name);//使用Arrays的静态方法asList（传入数组）；
System.out.println(list.contains("sdf"));//使用集合的特有方法
System.out.println(list.get(02));
//list.remove(2);
/*
* 如果数组中的元素都是对象，那么变成集合石，数组中的元素就直接转成集合中的元素
* 如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在；
*/
Integer[] i={1,5,8,4};
List<Integer> lt=Arrays.asList(i);
System.out.println(lt);
}
} 八 Runtime类：每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过getRuntime 方法获取当前运行时。
该类并没有提供构造函数：说明不可以new对象，那么该类会提供了一个方法获取本类对象。而且该方法是静态的并返回值类型是本类类型
由这个特点可以看出该类使用了单例设计模式完成的：
该方法就是 static Runtime getRuntime(); Runtime r=Runtime.getRuntime();
1:exec(String command) 在单独的进程中执行指定的字符串命令。Process p=r.exec(“程序的exe文件”)：用于打开一个程序；
2：destroy() 杀掉子进程。在上面打开的程序也可以使用destroy（）方法 来关掉该进程， p.destroy();
九：Data类：一个包装了毫秒值的瘦包装器 (thin wrapper)，它允许 JDBC 将毫秒值标识为 SQLDATE 值。 毫秒值表示自 1970 年 1 月 1 日 00:00:00 GMT
以来经过的毫秒数。
常用方法：
setTime(long date) 使用给定毫秒时间值设置现有Date 对象。
toString() 格式化日期转义形式 yyyy-mm-dd 的日期。
valueOf(String s) 将 JDBC 日期转义形式的字符串转换成Date 值。
DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。以下是他的子类：SimpleDateFormat
SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。
日期和时间模式的图表：
定义了以下模式字母（所有其他字符 'A' 到 'Z' 和'a' 到 'z' 都被保留）：
字母 日期或时间元素 表示 示例 GEra 标志符 Text ADy年 Year 1996;96M年中的月份 Month July;Jul;07w年中的周数 Number 27W月份中的周数 Number 2D年中的天数 Number 189d月份中的天数 Number 10F月份中的星期 Number 2E星期中的天数 Text Tuesday;TueaAm/pm 标记 Text PMH一天中的小时数（0-23） Number 0k一天中的小时数（1-24） Number 24Kam/pm 中的小时数（0-11） Number 0ham/pm 中的小时数（1-12） Number 12m小时中的分钟数 Number 30s分钟中的秒数 Number 55S毫秒数 Number 978z时区 General time zone Pacific Standard Time;PST;GMT-08:00Z时区 RFC 822 time zone -0800
十：Calendar 类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段
（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）
的偏移量。
示例：
public static void main(String[] args) {
// TODO Auto-generated method stub
Date d=new Date(2013);
System.out.println(d);//1970-01-01
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日--E hh:mm:ss");
String time=sdf.format(d);
System.out.println(time);
Calendar cd=Calendar.getInstance();//获取Calendar的实例对象；
show(cd,2012);
}
//获取某一年的2月是有几天
public static void show(Calendar cd,int year){
cd.set(year, 2, 1); //设置要获取的年份的二月的时间
cd.add(Calendar.DAY_OF_MONTH, -1);//设置要获取的年份的三月的时间在减一天就是二月最后一天了
System.out.print(cd.get(Calendar.YEAR)+"年");//获取年 月 日
System.out.print(cd.get(Calendar.MONDAY)+1+"月");
System.out.print(cd.get(Calendar.DAY_OF_MONTH)+"日");
}
十一 ：Math类：
Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
常用方法：
ceil(double a) 返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。
floor(double a) 返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。
round(float a) 返回最接近参数的int。
random() 返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
如示例：
public static void main(String[] args) {
// TODO Auto-generated method stub
double ce=Math.ceil(12.5);//返回接近该数据的最大整数
System.out.println(ce);
double fo=Math.floor(12.5);//返回接近该数据的最小整数
System.out.println(fo);
System.out.println(Math.round(12.4));//四舍五入
for(int i=0;i<10;i++){
int t=(int)(Math.random()*10);//生成伪随机数0-9之间
System.out.println(t);
}
-------android培训、java培训、期待与您交流！ ----------
扫一扫
1148
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
