JAVA基础-集合框架

JAVA学习笔记 专栏收录该内容
11 篇文章 0 订阅


1、概述

(1)集合类是对对象进行存储的最常用的一种方式。

(2)集合类与数组的区别:

-数组也可以存储对象,但长度是固定的,集合长度是可变的

-数组中可以存储基本数据类型,集合只能存储对象。

(3)集合类的特点:

-集合只用于存储对象。

-集合长度是可变。

-集合可以存储不同类型的对象。

-集合中存储的都是对象的引用(地址)。

2、Collection

(1)Collection是集合框架中的根接口,该接口不提供任何直接实现,它提供更具体的子接口(如List和Set)实现。

(2)Collection接口提供的主要共性方法:

-boolean add(E e):添加元素。

-boolean addAll(Collection<? extends E>c): 将指定 collection 中的所有元素都添加到此 collection 中。

-void clear():移除此 collection 中的所有元素。

-boolean contains(Object o):如果此 collection 包含指定的元素,则返回 true

-boolean containsAll(Collect<?> c):如果此 collection 包含指定 collection 中的所有元素,则返回 true

-boolean equals(Object o):比较此 collection 与指定对象是否相等。

-boolean isEmpty():如果此 collection 不包含元素,则返回 true

-Iterator<E> iterator():返回在此 collection 的元素上进行迭代的迭代器。

-boolean remove(Object o):从此 collection 中移除指定元素的单个实例,如果存在的话。

-boolean removeAll(Collection<? > c): 移除此 collection 中那些也包含在指定 collection 中的所有元素。

-boolean retainAll(Collection<? > c): 仅保留此 collection 中那些也包含在指定 collection 的元素。

-int size():返回此 collection 中的元素数。

-Object[] toArray():返回包含此 collection 中所有元素的数组。

3、迭代器

(1)迭代器(Iterator)是一个接口,可以对集合进行迭代,用于取出集合中的元素。

(2)Iterator 中的方法:

-boolean hasNext():如果仍有元素可以迭代,则返回 true

-E next():返回迭代的下一个元素。

-void remove():从迭代器指向的 collection 中移除迭代器返回的最后一个元素。

(3)迭代器为每一个集合提供了元素的取出方式,因为集合中把取出方式定义为对象定义在集合内部,这样取出方式就可以直接访问集合的元素,那么取出方式就被定义成了内部类,而每一个容器的数据结构不同,所以取出的动作细节也不一样,但是都有共性内容(判断和取出),那么就将这些共性抽取。通过一个对外提供的方法获取集合的取出对象即iterator()。

4、List

(1)List是Collection的一个子接口,此接口的元素是有序的,元素可以重复,因为该集合体系有索引。

(2)List中的特有方法:

-void add(int index,E element):在列表的指定位置插入指定元素。

-boolean addAll(int index,Collection<?extend E> c):添加指定 collection 中的所有元素到此列表的结尾。

-E get(int index):返回列表中指定位置的元素。

-int indexOf(Object o):返回此列表中第一次出现的指定元素的索引;如果此列表不包含该元素,则返回 -1。

-int lastIndexOf(Object o):返回此列表中最后出现的指定元素的索引;如果列表不包含此元素,则返回 -1。

-ListIterator listIterator():返回此列表元素的列表迭代器。

-E set(int index,E element):用指定元素替换列表中指定位置的元素,返回以前在指定位置的元素。

-List<E> subList(int fromIndex,inttoIndex):返回列表中指定的 fromIndex(包括 )和 toIndex(不包括)之间的部分视图。

(3)List集合的迭代器:List集合特有的迭代器ListIterator是Iterator的子接口,在迭代时,不可以通过集合对象的方法操作集合中的元素,因为会发生异常,所以在迭代器时,只能用迭代器的方法操作元素,可是Iterator方法是有限的,只能对元素进行判断、取出和删除操作,如果想要其他的操作如添加、修改等就需要使用其子接口ListIterator中的方法,该接口只能通过List集合的ListIterator方法获取。

(4)ListIterator中定义的特有方法:

-void add(E e):将指定的元素插入列表。该元素直接插入到 next 返回的下一个元素的前面(如果有),或者 previous 返回的下一个元素之后(如果有);如果列表没有元素,那么新元素就成为列表中的唯一元素。

-boolean hasPrevious():如果以逆向遍历列表,列表迭代器有多个元素,则返回 true

-E previous():返回列表中的前一个元素。

-int nextIndex():返回对 next 的后续调用所返回元素的索引。

-int previousIntdex():返回对 previous 的后续调用所返回元素的索引。

-void set(E e):用指定元素替换 nextprevious 返回的最后一个元素。

(5)List集合有3个主要子类:

-ArrayList:底层的数据结构使用的是数组结构,特点:查询速度很快,但增删稍慢,线程不同步。

-LinkedList:底层使用的是链表数据结构,特点:增删速度很快,查询稍慢。

-Vector:底层是数组数据结构,线程同步,但查询增删很慢,被ArrayList替代了。

5、Vector

(1)Vector中特有方法:

-Enumeration elements():返回此向量的组件的枚举。

(2)Enumeration是一个接口,它生成一系列元素,一次生成一个。连续调用 nextElement 方法将返回一系列的连续元素。枚举是Vector特有的取出方式,其实枚举和迭代是一样的,因为枚举的名称以及方法的名称都过长,所以被迭代器取代了。

(3)Enumeration中的方法:

-boolean hasMoreElements():测试此枚举是否包含更多的元素。

-E nextElement():如果此枚举对象至少还有一个可提供的元素,则返回此枚举的下一个元素。

6、LinkedList

(1)LinkedList特有方法:

-void addFirst(E e):将指定元素插入此列表的开头。

-void addLast(E e):将指定元素添加到此列表的结尾。

-boolean offerFirst(E e):在此列表的开头插入指定的元素。

-boolean offerLast(E e):在此列表末尾插入指定的元素。

-E getFirst():返回此列表的第一个元素。但不会删除该元素。

-E getLast():返回此列表的最后一个元素。但不会删除该元素。

-E removeFirst():移除并返回此列表的第一个元素。如果此列表为空抛出NoSuchElementException

-E removeLast():移除并返回此列表的最后一个元素。如果此列表为空抛出NoSuchElementException

-E pollFirst():获取并移除此列表的第一个元素;如果此列表为空,则返回 null

-E pollLast():获取并移除此列表的最后一个元素;如果此列表为空,则返回 null

-E peekFirst():获取但不移除此列表的第一个元素;如果此列表为空,则返回 null

-E peekLast():获取但不移除此列表的最后一个元素;如果此列表为空,则返回 null

(2)LinkedList练习:使用LinkedList模拟一个队列数据结构:

import java.util.*;

class DuiLie//定义DuiLie类

{

     private LinkedList list;

     public DuiLie()

     {

              list=new LinkedList();

     }

     public void myAdd(Object obj)//定义向队列添加元素的方法

     {

              list.addLast(obj);

     }

     public Object myGet()//定义获取队列元素的方法

     {

              return list.removeFirst();

     }

     public boolean isNull()//判断队列是否为空

     {

              return list.isEmpty();

     }

     public String toString()//复写toString方法

     {

              return list.toString();

     }

}

public class LinkedListTest

{

     public static void main(String[] args)

     {

              DuiLie dl=new DuiLie();//创建一个队列

      //向队列添加元素

              dl.myAdd("java01");

              dl.myAdd("java02");

              dl.myAdd("java03");

              while(!dl.isNull())

              {

                        System.out.println(dl.myGet());

              }

     }

}

7、ArrayList练习

(1)去除ArrayList集合中重复的元素

import java.util.*;

public class ArrayListTest

{

     public static void main(String[] args)

     {

              ArrayList al=new ArrayList(); //创建一个ArrayList对象

//向ArrayList添加元素

              al.add("java01");

              al.add("java02");

              al.add("java03");

              al.add("java01");

              al.add("java01");

              al.add("java02");

              System.out.println(al); //打印原ArrayList

              al=singleElement(al);//调用方法去除重复元素

              System.out.println(al);//打印新ArrayList

     }

     public static ArrayListsingleElement(ArrayList al)//定义去除ArrayList 中重复元素的方法 

     {

              ArrayList newAl=new ArrayList();//创建一个新ArrayList用于存放非重复的元素

              Iterator it=al.iterator();//获取迭代器

//遍历ArrayList中元素并去除重复元素

              while(it.hasNext())

              {

                        Object obj=it.next();

                        if(!newAl.contains(obj))

                                 newAl.add(obj);

              }

              return newAl; //返回没有重复元素的ArrayList

     }

}

(2)将自定义对象作为元素存到ArrayList集合中,并去除重复元素。

import java.util.*;

class Person

{

         privateString name;

         privateint age;

         publicPerson(String name,int age)

         {

                   this.name=name;

                   this.age=age;

         }

         publicboolean equals(Object obj)//复写equals方法以判断两个对象是否相同

         {

                   if(!(objinstanceof Person))

                            thrownew RuntimeException("wrong");

                   Personp=(Person)obj;

                   returnthis.name.equals(p.name)&&this.age==p.age;

         }

         publicString toString()

         {

                   returnname+"::"+age;

         }

         publicString getName()

         {

                   returnname;

         }

         publicint getAge()

         {

                   returnage;

         }

}

public class ArrayListTest2

{

         publicstatic void main(String[] args)

         {

                   ArrayListal=new ArrayList();//创建一个ArrayList

//向ArrayList中添加Person对象

                   al.add(newPerson("zhangsan",22));

                   al.add(newPerson("lisi",25));

                   al.add(newPerson("zhangsan",22));

                   al.add(newPerson("wangwu",23));

                   al.add(newPerson("zhangsan",22));

                   al=singleElement(al);

                   Iteratorit=al.iterator();//获取迭代器

//遍历ArrayList元素

                   while(it.hasNext())

                   {

                            Objectobj=it.next();

                            Personp=(Person)obj;

                            System.out.println(p);

                   }

                  

                  

         }

         publicstatic ArrayList singleElement(ArrayList al)//定义去除重复元素的方法

         {

                   ArrayListnewAl=new ArrayList();

                   Iteratorit=al.iterator();

                   while(it.hasNext())

                   {

                            Objectobj=it.next();

                            if(!newAl.contains(obj))

                                     newAl.add(obj);

                   }

                   returnnewAl;

         }

}

结论:List集合判断元素是否相同,依据的是元素的equals方法。

8、Set集合

(1)Set集合是Collection集合的一个子接口,其元素是无序(存入和取出的顺序不一定一致)的且元素不可以重复。

(2)Set集合的常见子类:

-HashSet:底层数据结构是哈希表,线程是非同步的。HashSet通过元素的两个方法,即hashCode和equals来保证元素唯一性,如果元素的HashCode值相同,才会判断equals是否为true。如果元素的hashCode值不同,不会调用equals判断。同样,对于判断元素是否存在及删除等操作,依赖的方法也是HashCode和equals。先比较HashCode再比较equals。

-TreeSet:底层数据结构是二叉树,可以对set集合中的元素进行排序。排序时,当主要条件相同时,一定要判断一下次要条件。保证集合中元素唯一性的依据是compareTo方法的返回值,若返回值为0则表示两元素相同。

(3)HashSet练习

importjava.util.*;

publicclass HashSetTest

{

         public static void main(String[] args)

         {

                   HashSet hs=new HashSet();//创建一个HashSet

//向集合中添加元素

                   hs.add(newPerson("a1",11));

                   hs.add(newPerson("a2",12));

                   hs.add(newPerson("a3",13));

                   hs.add(newPerson("a2",12));

                   Iterator it=hs.iterator();//获取迭代器

//遍历集合元素

                   while(it.hasNext())

                   {

                            Personp=(Person)(it.next());

                            System.out.println(p);

                   }

         }

}

classPerson

{

         private String name;

         private int age;

         public Person(String name,int age)

         {

                   this.name=name;

                   this.age=age;

         }

         public int hashCode()

         {

                   returnthis.name.hashCode()+age;

         }

         public boolean equals(Object obj)

         {

                   if(!(obj instanceof Person))

                            throw newRuntimeException("wrong");

                   Person p=(Person)obj;

                   returnthis.name.equals(p.name)&&this.age==p.age;

         }

         public String toString()

         {

                   returnname+"::"+age;

         }

         public String getName()

         {

                   return name;

         }

         public int getAge()

         {

                   return age;

         }

}

结论:当用HashSet存储自定义对象时,要复写hashCode和equals方法。

(4)TreeSet集合特有方法:

-E ceiling(E e):返回此 set 中大于等于给定元素的最小元素;如果不存在这样的元素,则返回 null

-E higher(E e):返回此 set 中严格大于给定元素的最小元素;如果不存在这样的元素,则返回 null

-E first():返回此 set 中当前第一个(最低)元素。

-E floor(E e):返回此 set 中小于等于给定元素的最大元素;如果不存在这样的元素,则返回 null

-Comparator<? supre E> comparator():返回对此 set 中的元素进行排序的比较器;如果此 set 使用其元素的自然顺序,则返回null

-SortedSet<E> subset(E fromElement,E toElement):返回此 set 的部分视图,其元素从 fromElement(包括)到toElement(不包括)。

-SortedSet<E> tailSet(E fromElement):返回此 set 的部分视图,其元素大于等于 fromElement

-SortedSet headset(E toElement):返回此 set 的部分视图,其元素严格小于 toElement

(5)Comparable接口

此接口强行对实现它的每个类的对象进行整体排序,这种排序被称为类的自然排序。接口的Int compareTo(T o)方法可以比较对象与指定对象的顺序,根据对象小于、等于或大于指定对象而返回负数、零或正数。若定义一个类时希望该具有比较性,则可以让该类实现Comparabler接口并重写该接口的compareTo方法。

(6)TreeSet集合存储自定义对象时,则自定义对象定义时需实现Comparable接口并重写其compareTo方法以实现比较性。下面例中,在TreeSet集合中存储Student对象,根据Student对象的年龄进行排序,若年龄相同则根据姓名排序。

import java.util.*;

public class TreeSetDemo

{

         publicstatic void main(String[] args)

         {

                   TreeSetts=new TreeSet();//创建一个TreeSet

//向集合添加元素

                   ts.add(newStudent("s1",15));

                   ts.add(newStudent("s2",12));

                   ts.add(newStudent("s3",16));

                   ts.add(newStudent("s4",15));

                   Iteratorit=ts.iterator();//获取迭代器

//遍历集合元素

                   while(it.hasNext())

                   {

                            Students=(Student)(it.next());

                            System.out.println(s);

                   }

         }

}

class Student implements Comparable//实现Comarable接口使Student类具有比较性

{

         privateString name;

         privateint age;

         publicStudent(String name,int age)

         {

                   this.name=name;

                   this.age=age;

         }

//复写compareTo方法

         public int compareTo(Object obj)

         {

                   if(!(objinstanceof Student))

                            thrownew RuntimeException("not Student");

                   Students=(Student)obj;

                   if(this.age>s.age)

                            return1;

                   elseif(this.age==s.age)

                            returnthis.name.compareTo(s.name);

                   else

                            return-1;

         }       

         publicString toString()

         {

                   returnthis.name+"..."+this.age;

         }

}

结论:TreeSet排序的第一种方式:让元素自身具备比较性,元素需要实现Compparable接口,覆盖compareTo方法,这种方式也成为元素的自然顺序,或者叫做默认顺序。

(7)Comparator接口

该接口的子类对象可以作为TreeSet 集合的构造函数的参数去初始化TreeSet集合,从而使TreeSet集合具备比较性,实现对TreeSet集合中元素进行排序。该接口的方法:

-int compare(T o1,To2):根据第一个参数小于、等于或大于第二个参数分别返回负数、零或正数。

(8)在TreeSet集合中存储Student对象,根据Student的姓名进行排序,若姓名相同则根据年龄排序。

import java.util.*;

public class TreeSetDemo2

{

         publicstatic void main(String[] args)

         {

                   TreeSet ts=new TreeSet(new MyComparator()); //创建TreeSet时传入比较器对象使集合具有比较性

                   ts.add(newStudent("s1",15));

                   ts.add(newStudent("s3",12));

                   ts.add(newStudent("s3",16));

                   ts.add(newStudent("s4",15));

                   System.out.println(ts);

                   Iteratorit=ts.iterator();

                   while(it.hasNext())

                   {

                            Students=(Student)(it.next());

                            System.out.println(s);

                   }

         }

}

class Student implements Comparable

{

         privateString name;

         privateint age;

         publicStudent(String name,int age)

         {

                   this.name=name;

                   this.age=age;

         }

         publicint compareTo(Object obj)

         {

                   if(!(objinstanceof Student))

                            thrownew RuntimeException("not Student");

                   Students=(Student)obj;

                   if(this.age>s.age)

                            return1;

                   elseif(this.age==s.age)

                            returnthis.name.compareTo(s.name);

                   else

                            return-1;

         }       

         publicString toString()

         {

                   returnthis.name+"..."+this.age;

         }

         publicString getName()

         {

                   returnthis.name;

         }

         publicint getAge()

         {

                   returnthis.age;

         }

}

class MyComparator implementsComparator// 定义一个比较器

{

         publicint compare(Object o1,Object o2)//复写compare方法

         {

                   if(!(o1instanceof Student)||!(o2 instanceof Student))

                            thrownew RuntimeException("not Student");

                   Students1=(Student)o1;

                   Students2=(Student)o2;

                   intnum=s1.getName().compareTo(s2.getName());

                   if(num==0)

                            returnnew Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));

                   else

                            returnnum;

         }

}

结论:TreeSet排序的第二种排序方式:当元素自身不具备比较性,或具备的比较性不是所需要的,这时就需要让集合自身具备比较性。让集合一初始化时就有了比较方式,定义比较器,通过定义一个类实现 Comparator接口覆盖compare方法,将比较器对象作为参数传递给TreeSet集合的构造函数。

当两种排序都存在时以比较器为主。

(9)TreeSet练习:按照字符串的长度排序。因为字符串体具备按自然顺序排序的比较性,所以这时需要使用比较器。

import java.util.*;

public class TreeSetTest

{

         publicstatic void main(String[] args)

         {

                   TreeSetts=new TreeSet(new StrLenComparator());//创建TreeSet集合

//添加元素

                   ts.add("acn");

                   ts.add("accddw");

                   ts.add("abcd");

                   ts.add("acfg");

                   Iteratorit=ts.iterator();//获取迭代器

//遍历元素

                   while(it.hasNext())

                   {

                            Strings=(String)(it.next());

                            System.out.println(s);

                   }

         }

}

class StrLenComparator implements Comparator//定义比较器

{

         publicint compare(Object o1,Object o2)//复写compare方法

         {

                   if(!(o1instanceof String)||!(o2 instanceof String))

                            thrownew RuntimeException("not String");

                   Strings1=(String)o1;

                   Strings2=(String)o2;

                   intnum=new Integer(s1.length()).compareTo(new Integer(s2.length()));

                   if(num==0)

                            returns1.compareTo(s2);

                   else

                            returnnum;

         }

}

9、泛型

(1)泛型是JDK1.5版本以后出现的新特性,用于解决安全问题,是一个安全机制。通过<>来定义要操作的引用数据类型,其实<>就是用来接收类型的,当使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可。

(2)格式:集合类型<数据类型>  集合名=new集合类型<数据类型>();

(3)泛型好处:

-将动行时出现的问题ClassCastException,转移到了编译时期,方便于程序员解决问题,让运行时问题减少、安全。

-避免了强制转换麻烦。

示例:

classGenericDemo

{

         ArrayList<String> al=newArrayList<String>();//创建集合时指定集合存储的类型为String

         al.add(“a1”);

         al.add(“a2”);

         Iterator<String>it=al.iterator();

         while(it.hasNext())

         {

                   String s=it.next();

                   System.out.println(s);

         }

}

(4)泛型类:当类中要操作的引用数据类型不确定的时候,早期定义Object来完成扩展,现在可以定义泛型来完成扩展。

比如定义一个操作对象的泛型类:

class Utils<T>

{

         private T t;

         public void setObject(T t)

         {

                   this.t=t;

         }

         public T getObject()

         {

                   return t;

         }

}

(5)泛型方法:泛型类定义的泛型,在整个类中有效,如果被方法使用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型,而且类型还不确定,那么可以将泛型定义在方法上。

如:

classDemo

{

         pubic <T> void show(T t)

         {

                   System.out.println(t);

}

}

调用时可以show方法参数可以是不同类型,如:

newDemo().show(“abc”);

newDemo().show(new Integer(2));

(6)可以在泛型类中再定义泛型方法。如:

classDemo<T>

{

         pubic void show(T t)

         {

                   System.out.println(t);

}

pubic <Q> void print(Q q)

         {

                   System.out.println(q);

}

}

上例中,show方法只能操作Demo类对象初始化时明确的数据类型的数据,而print方法可以操作不同的数据类型。

注意:静态方法不可以访问类上定义的泛型,如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。在方法上定义泛型时,<>在放在方法的返回值类型前面。

(7)泛型接口:当一个接口为泛型接口时,其子类在实现该泛型接口时明确要操作的数据类型,也可以在实现该接口时定义为泛型类。如:

interfaceInter<T>

{

         public void show(T t);

}

classInterImp1 implements Inter<String>

{

         public void show(String t)

         {

                   System.out.println(t);

         }

}

classInterImp2<T> implements Inter<T>

{

         public void show(T t)

         {

                   System.out.println(t);

         }

}

(8)泛型限定

泛型限定的两种使用:

-?  extends E:表示可以接收E类型或者E的子类型。

-?  super E:表示可以接收E类型或者E的父类型。

注意:在泛型中,?表示通配符,也可理解为占位符。当泛型中用?时,表示可接受所有类型。

示例:

importjava.util.*;

public class GenericDemo

{

         public static void main(String[] args)

         {

//创建集合时指定集合存储的类型是Person        

                   ArrayList<Person>al1=new ArrayList<Person>();

                   ArrayList<Student>al2=new ArrayList<Student>();

//添加元素

                   al1.add(newPerson("p1"));

                   al1.add(newPerson("p1"));

                   al2.add(newStudent("s1"));

                   al2.add(newStudent("s2"));

                   printColl(al1);

                   printColl(al2);

         }

         public static void printColl(ArrayList<?extends Person> al)//定义方法用于遍历集合

         {

                   Iterator<? extendsPerson> it=al.iterator();

                   while(it.hasNext())

                   {

                            System.out.println(it.next().getName());

                   }

         }

}

classPerson

{

         private String name;

         public Person(String name)

         {

                   this.name=name;

         }

         public String getName()

         {

                   return name;

         }

}

classStudent extends Person

{

         public Student(String name)

         {

                   super(name);

         }

}

10、Map集合

(1)Map是一个接口,该集合存储键值对,一对一对往里存,而且要保证键的唯一性。当数据之间存在有映射关系时,要先想到map集合,因为map集合中存放的就是映射关系。

(2)Map集合方法

- void clear():从此映射中移除所有映射关系。

-boolean containsKey(Object key):如果此映射包含指定键的映射关系,则返回 true

-boolean containsValue(Object value):如果此映射将一个或多个键映射到指定值,则返回 true

-Set(Map.Entry<K,V>) entrySet():返回此映射中包含的映射关系的Set视图。

-boolean equals(Object o):比较指定的对象与此映射是否相等。

-V get(Object ket):返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回 null

-boolean isEmpty():如果此映射未包含键-值映射关系,则返回 true

-Set<K> ketSet():返回此映射中包含的键的Set视图。

-V put(K key,V value): 将指定的值与此映射中的指定键关联,如果此映射以前包含一个该键的映射关系,则用指定值替换旧值,返回以前与 key 关联的值,如果没有针对 key 的映射关系,则返回 null

-void putAll(Map<? extends K,?extends V> m)从指定映射中将所有映射关系复制到此映射中。

-Vremove(Object o):如果存在一个键的映射关系,则将其从此映射中移除,返回以前与 key 关联的值;如果没有 key 的映射关系,则返回 null。

-int size():返回此映射中的键-值映射关系数。

-Collection<V> values():返回此映射中包含的值的Collection视图。

(3)Map有3个常见子类:

-Hashtable:底层是哈希表数据结构的,不可以存入null键和null值,该集合是线程同步的,效率较低。

-HashMap:底层是哈希表数据结构的,允许使用null键和null值,该集合是线程同步的,效率较高。

-TreeMap:底层是二叉树数据结构的,线程不同步,可以用于给Map集合中的键进行排序。

(4)通过keySet方式取出Map集合:将map中所有的键取出存入到Set集合,因为Set具备迭代器,所以可以用迭代方式取出所有的键,再根据get方法获取每一个键对应的值。

过程:通过map集合的keySet方法获取集合的所有键的集合-->获取keySet集合的迭代器-->取出键后可以通过map集合的get方法获取其对应的值。

示例:

import java.util.*;

public class MapDemo

{

    public staticvoid main(String[] args)

    {

        Map<String,String>map=new HashMap<String,String>();//创建Map对象

//添加元素

        map.put("01","map1");

        map.put("03","map3");

        map.put("04","map4");

        map.put("02","map2");

        Set<String>keySet=map.keySet();//获致键的集合

        Iterator<String>it=keySet.iterator();//获取键集合的迭代器

//取出键值对

        while(it.hasNext())

        {

            String key=it.next();

            System.out.println(key+"="+map.get(key));

        }

    }

}

(5)通过entrySet方式取出Map集合:将map集合中的映射关系存入到Set集合中,而这个关系的数据类型是Map.Entry。

过程:通过map集合的entrySet方法将map集合中的映射关系取出放入类型为Map.Entry的Set集合中-->获取Set集合的迭代器-->通过迭代器获取Map.Entry后通过Map.Entry中的getKey和getValue方法获取映射关系中的键和值。

Map.Entry:Map.entrySet 方法返回映射的 collection 视图,其中的元素属于此类。

Map.Entry中的方法:

-K getKey():返回与此项对应的键。

-V getValue():返回与此项对应的值。

-V setValue(V value):用指定的值替换与此项对应的值,返回与此项对应的旧值。

-int hashCode():返回此映射项的哈希码值。

示例:

import java.util.*;

public class MapDemo2

{

    public staticvoid main(String[] args)

    {

        Map<String,String>map=new HashMap<String,String>();//创建Map对象

        map.put("01","map1");

        map.put("03","map3");

        map.put("04","map4");

        map.put("02","map2");

        Set<Map.Entry<String,String>>entrySet=map.entrySet();//获取Map.Entry集合

        Iterator<Map.Entry<String,String>>it=entrySet.iterator();//获取Map.Entry集合迭代器

//取出键值对

        while(it.hasNext())

        {

            Map.Entry<String,String>me=it.next();

            Stringkey=me.getKey();

            Stringvalue=me.getValue();

            System.out.println(key+"::"+value);

        }

    }

}

(6)Map练习:将Student对象和其对应地址存入Map集合,当Student中姓名和年龄相同时视为同一个学生。

import java.util.*;

public class MapTest

{

    public staticvoid main(String[] args)

    {

        HashMap<Student,String>hm=new HashMap<Student,String>();//创建HashMap对象

//添加元素

        hm.put(newStudent("s1",11),"bj");

        hm.put(newStudent("s2",22),"sz");

        hm.put(newStudent("s3",33),"wh");

        hm.put(newStudent("s4",44),"nc");

        Set<Student>keySet=hm.keySet();//获取键的集合

        Iterator<Student>it=keySet.iterator();//获取迭代器

//取出键值对

        while(it.hasNext())

        {

            Students=it.next();

            Stringaddr=hm.get(s);

            System.out.println(s+"..."+addr);

        }

       

        Set<Map.Entry<Student,String>>entrySet=hm.entrySet();//获取Map.Entry集合

        Iterator<Map.Entry<Student,String>>it1=entrySet.iterator();获取Map.Entry集合迭代器

//取出键值对

        while(it1.hasNext())

        {

            Map.Entry<Student,String>me=it1.next();

            Students=me.getKey();

            Stringaddr=me.getValue();

            System.out.println(s+"..."+addr);

        }

    }

}

class Student implements Comparable<Student>

{

    privateString name;

    private intage;

    publicStudent(String name,int age)

    {

        this.name=name;

        this.age=age;

    }

    public intcompareTo(Student s)//复写compareTo方法

    {

        intnum=this.name.compareTo(s.name);

        if(num==0)

        {

            returnnew Integer(this.age).compareTo(new Integer(s.age));

        }

        else

            returnnum;

    }

    publicboolean equals(Object obj)//复写equals方法

    {

        if(!(objinstanceof Student))

            thrownew RuntimeException("not Studrnt");

        Students=(Student)obj;

        returnthis.name.equals(s.name)&&this.age==s.age;

    }

    public inthashCode()//复写hashCode方法

    {

        returnname.hashCode()+age*34;

    }

    public StringtoString()

    {

        returnthis.name+"::"+this.age;

    }

}

(7)TreeMap练习:将Student对象和其对应地址存入Map集合,当Student中姓名和年龄相同时视为同一个学生。按学习年龄的升序排序。

import java.util.*;

public class TreeMapTest

{

    public staticvoid main(String[] args)

    {

        TreeMap<Student,String>tm=new TreeMap<Student,String>(new MyComparator());

        tm.put(newStudent("s2",12),"sz");

        tm.put(newStudent("s1",13),"bj");

        tm.put(newStudent("s4",22),"nc");

        tm.put(newStudent("s3",33),"wh");

       

        Set<Student>keySet=tm.keySet();

        Iterator<Student>it=keySet.iterator();

        while(it.hasNext())

        {

            Student s=it.next();

            Stringaddr=tm.get(s);

            System.out.println(s+"..."+addr);

        }

    }

}

class MyComparator implementsComparator<Student>//定义比较器

{

    public intcompare(Student s1,Student s2)

    {

        intnum=new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));

        if(num==0)

            returns1.getName().compareTo(s2.getName());

        else

            returnnum;

    }

}

class Student implements Comparable<Student>

{

    privateString name;

    private intage;

    publicStudent(String name,int age)

    {

        this.name=name;

        this.age=age;

    }

    public intcompareTo(Student s)

    {

        intnum=this.name.compareTo(s.name);

        if(num==0)

        {

            returnnew Integer(this.age).compareTo(new Integer(s.age));

        }

        else

            returnnum;

    }

    publicboolean equals(Object obj)

    {

        if(!(objinstanceof Student))

            thrownew RuntimeException("not Studrnt");

        Students=(Student)obj;

        returnthis.name.equals(s.name)&&this.age==s.age;

    }

    public inthashCode()

    {

        returnname.hashCode()+age*34;

    }

    public StringtoString()

    {

        returnthis.name+"::"+this.age;

    }

    public StringgetName()

    {

        returnthis.name;

    }

    public intgetAge()

    {

        returnthis.age;

    }

}

11、Collections类

(1)Collections类是对集合进行操作的工具类,该类定义了许多对集合进行操作的静态方法。

(2)Collections的常用方法:

-static<T extends Comparable<? super T>> voidsort(List<T> list):根据元素的自然顺序 对指定列表按升序进行排序。

-static <T> void sort(List<T>list,Comparator<? super T> c):根据指定比较器产生的顺序对指定列表进行排序。

-static <T extendsObject&Comparable<? super T> T max(Collection<? extends T> c):根据元素的自然顺序,返回给定 collection 的最大元素。collection 中的所有元素都必须实现Comparable 接口。

-static <T> T max(Collection<?extends T> c,Comparator<? super T> com):根据指定比较器产生的顺序,返回给定 collection 的最大元素。collection 中的所有元素都必须可通过指定比较器相互比较。

-static<T> int binarySearch(List<? extends Comparable<?super T>> list,T key):使用二分搜索法搜索指定列表,以获得指定对象。在进行此调用之前,必须根据列表元素的自然顺序对列表进行升序排序。

-static <T> int binarySearch(List<?extends T>list,T key,Comparator<? super T> c):使用二分搜索法搜索指定列表,以获得指定对象。在进行此调用之前,必须根据指定的比较器对列表进行升序排序。

-static <T> void copy(List<? superT> dest,List<? extends T> src):将所有元素从一个列表复制到另一个列表。

-static<T> void fill(List<? superT> List,T obj):使用指定元素替换指定列表中的所有元素。

-static <T> Boolean replaceAll(List<T>list,T oldVal,T newVal):使用另一个值替换列表中出现的所有某一指定值。

-static void reverse(List<?> list):反转指定列表中元素的顺序。

-static <T> Comparator<T> reverseOrder():返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

-static <T> Comparator<T>reverseOrder(Comparator<T> cmp):返回一个比较器,它强行逆转指定比较器的顺序。

-static void swap(List<?> list,int I,intj):在指定列表的指定位置处交换元素。

12、Array类

(1)Array类是用于操作数组的工具类,该类中的都是静态方法。

(2)asList(T…a):返回一个受指定数组支持的固定大小的列表。

把数组变成List集合的好处:可以用集合的思想和方法来操作数组中的元素。但是将数组变成集合,不可以使用集合的增删方法,因为数组的长度是固定的。

如果数组中的元素都是对象,那么变成集合时,数组中的元素就直接变成集合中的元素,如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在。

(3)Collection接口中的toArray方法可以将集合变成数组。当指定义类型的数组长度小于了集合的size,那么该方法内部会创建一个新的数组,长度为集合的size,当指定类型的数组长度大于集合的size,就不会创建新的数组,而是使用传递进来的数组,所以创建一个刚刚好的数组最优。

(4)为什么将集合变数组:为了限定对元素的操作。不需要进行增删。

13、高级for循环

(1)格式:for(数据类型 变量名:被遍历的集合(Collection)或者数组){}

(2)高级for循环对集合进行遍历,只能获取集合元素而不能对集合进行操作,而迭代器除了遍历,还可以进行remove集合中的元素,如果使用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。

(3)传统for和高级for的区别:高级for有一个局限性,必须要有被遍历的目标。

14、静态导入

(1)格式:import static 包名.类名.*;表示导入该类中的所有静态成员。如import static java.lang.Arrays.*;

15、其他对象

(1)System类

System 类包含一些有用的类字段和方法。它不能被实例化。

(2)Runtime

每个 Java 应用程序都有一个 Runtime 类实例,使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。应用程序不能创建自己的 Runtime 类实例。

(3)Math类Math 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。

 


  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值