java---集合


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

指定者:

接口 List<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);
        }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值