黑马程序员-_笔记十五_集合框架

----------android培训、java培训期待与您交流！----------

集合

在面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

所谓的类集就是一个动态的对象数组，是对一些实现好的数据结构进行了包装，这样在使用时就非常方便，而且最重要的是类集框架本身不受对象数组长度的限制·

在整个Java类集中最常使用的类集接口是:Collection，List,Set,Map,Iterator,ListIterator,Enumeration,SortedSet,SortedMap,Queue,Map.Entry

 

Collection:是存放一组单值得最大接口，所谓单值是指集合中的每个元素都是一个对象（很少直接用此接口进行操作）

List：是Collection接口的子接口，对Collection进行了大量的扩充，也是最常用的接口。里面的内容是允许重复的，因为该集合体系有索引

Set：是Collection接口的子类，没有对Collection接口进行扩充，不允许存放重复内容

Map:是存放一对值的最大接口，即接口中的每一个元素都是一对，以Key-Value的形式保存

Iterator：集合的输出接口，用于输出集合中的内容，只能进行从前到后的单向输出

ListIterator：是Iterator的子接口，可以进行双向输出

Enumeration：是最早的输出接口，用于输出指定集合中的内容

SortedSet：单值得排序接口，实现此接口的集合类，里面的内容可以使用比较器排序

SortedMap：存放一对值的排序接口，实现此接口的集合类，里面的内容按照key排序，使用比较器排序

Queue：队列接口，此接口的子类可以实现队列操作

Map.Entry:Map.Entry的内部接口，每个Map.Entry对象都保存着一对KEY-VALUE的内容，每个接口中都保存有多个Map.Entry接口实例

 

继承关系

Collection---List

                |---Set

                |---Queue

                |---SortedSet

 

Map------SortedMap

 

Collection接口

Collection接口是单值存放的最大父接口。实际开发中，很少直接使用，一般都是使用其子类接口。

子类接口主要有List，Set，Queue，SortedSet

 

 List接口

List接口比Collection接口扩充了更多方法，而且操作起来很方便，使用此接口，可以通过其子类进行实例化

 

List接口的常用子接口和方法

 add(index,element);//增加元素

 addAll(index,Collection);//增加元素

 remove(index);//删除元素

 set(index,element);//修改指定位置元素

 get(index);;//得到指定位置元素

 subList(from,to);//返回列表中指定的 fromIndex（包括）和 toIndex（不包括）之间的部分视图

 listIterator();//返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始

 

子类ArrayList（底层使用数组结构，查询快，但是增删慢。线程不同步）

常用操作

增加元素：

public class Demo{
     public static void main(String args[]){
          List<String>allList = null ;
          Collection<String>allCollection = null ;
          allList = newArrayList<String>() ;     // 指定操作的泛型为String
          allCollection = newArrayList<String>() ;     // 指定一个集合
         allList.add("Hello") ;     // 此方法由Collection接口而来
         allList.add(0,"World") ;     // 在第一个位置上添加新的内容
         System.out.println(allList) ;
     
     }
};

 

删除元素：

public class Demo{
     public static void main(String args[]){
          List<String>allList = null ;
          allList = newArrayList<String>() ;     // 指定操作的泛型为String
         allList.add("Hello") ;     // 此方法由Collection接口而来
         allList.add(0,"World") ;     // 在第一个位置上添加新的内容
          allList.remove(0) ; // 删除第一个元素，指定删除的位置
          System.out.println(allList) ;
     }
};

 

输出集合中的元素

public class Demo{
     public static void main(String args[]){
          List<String>allList = null ;
          allList = newArrayList<String>() ;     // 指定操作的泛型为String
         allList.add("Hello") ;     // 此方法由Collection接口而来
         allList.add("Hello") ;    
          System.out.print("由前向后输出：") ;
          for(inti=0;i<allList.size();i++){
              System.out.print(allList.get(i) + "、") ;//通过下标得到每一个元素并打印
          }
       
     }
};

 

集合的相关其他操作

包括截取集合，查找元素位置，判断元素是否存在，集合是否为空等操作

 

public class Demo{
     public static void main(String args[]){
          List<String>allList = null ;
          allList = newArrayList<String>() ;     // 指定操作的泛型为String
         System.out.println("集合操作前是否为空？" + allList.isEmpty()) ;
         allList.add("Hello") ;     // 此方法由Collection接口而来
         allList.add(0,"World") ;     // 在第一个位置上添加新的内容
         allList.add("Hello1") ;     // 向Collection中加入内容

         allList.add("World1") ;

         System.out.println(allList.contains("Hello")?"\"Hello\"字符串存在！" : "\"Hello\"字符串不存在！") ;
          List<String>allSub = allList.subList(2,3) ;     // 字符串截取
         System.out.println("集合截取：") ;
          for(inti=0;i<allSub.size();i++){
              System.out.print(allSub.get(i) + "、") ;//通过下标得到每一个元素并打印
          }
         System.out.println("Hello1字符串的位置：" +allList.indexOf("Hello1")) ;//判断字符串Hello1的位置

         System.out.println("集合操作后是否为空？" + allList.isEmpty()) ;//判断结合是否为空
     }
};

 

去除相同元素

public class IODemo {

 

     public staticvoid main(String[] args) {

          List allOld = new ArrayList();

          List allNew = new ArrayList();

          allOld.add( "hello1");

          allOld.add( "hello1");

          allOld.add( "hello2");

          allOld.add( "hello2");

          allOld.add( "hello3");

          allOld.add( "hello3");

          Iterator ite = allOld.iterator();

          while (ite.hasNext()){

              Object obj = ite.next();

              if (!allNew.contains(obj)){//List集合判断元素是否相同，依据是元素的equals方法

                  allNew.add(obj);

              }

          }

           System. out .println(allNew);

    }

 

}

结果：[hello1, hello2, hello3]

 

 Vector（底层是数组数据结构，线程同步）子类，很早就存在的类，在JDK1.0时代就已经存在。考虑到大部分人已经习惯使用了Vector类，所以java设计者就让Vector多实现了List接口，这才保留下来。不过现在一般都使用ArrayList类。

常见实例

public class Demo{
     public static void main(String args[]){
          List<String>allList = null ;
          allList = newVector<String>() ;     // 指定操作的泛型为String
         allList.add("Hello") ;     // 此方法由Collection接口而来
         allList.add("Hello") ;     // 此方法由Collection接口而来
         allList.add(0,"World") ;     // 在第一个位置上添加新的内容
          for(int i=0;i<allList.size();i++){//循环输出，打印出集合中的每一个值
              System.out.print(allList.get(i) + "、") ;
          }
     }
};

 

 

LinkedList子类与Queue接口

ListkedList表示的是一个链表的操作类（底层属于链表结构）

Queue表示的是队列的操作接口，采用FIFO（先进先出）的操作方式

LinkedList（底层使用链表结构，增删快，查询慢）

LinkedList特有方法

addFirst（）；将指定元素插入此列表的开头。

addLast（）；将指定元素插入此列表的结尾。

getFirst（）；返回此列表的第一个元素

getLast（）；返回此列表的最后一个元素

removeFirst（）；移除并返回此列表的第一个元素。

removeLast（）；移除并返回此列表的最后一个元素。

LinkedList实例操作

1 为链表增加数据

public class Demo{ 
     public static void main(String args[]){
          LinkedList<String>link = new LinkedList<String>() ;
          link.add("1");     // 增加元素
          link.add("2");     // 增加元素
          link.add("3");     // 增加元素
         System.out.println("初始化链表：" + link) ;
         link.addFirst("X") ;     // 在开头增加数据
         link.addLast("Y");          // 在结尾增加数据
         System.out.println("增加头和尾之后的链表：" + link) ;
     }
};

 

2 找到链表头

在LinkedList中存在很多找到链表头的操作，常用如下

--->找到表头 public E element()

--->找到不删除表头 public E peek()

--->找到并删除表头 public E poll()

范例：找到表头

public class Demo{
     public static void main(String args[]){
          LinkedList<String>link = new LinkedList<String>() ;
          link.add("1");     // 增加元素
          link.add("2");     // 增加元素
          link.add("3");     // 增加元素
         System.out.println("1-1、element()方法找到表头：" + link.element()) ;
         System.out.println("1-2、找完之后的链表的内容：" + link) ;
         System.out.println("2-1、peek()方法找到表头：" + link.peek()) ;
         System.out.println("2-2、找完之后的链表的内容：" + link) ;
         System.out.println("3-1、poll()方法找到表头：" + link.poll()) ;
         System.out.println("3-2、找完之后的链表的内容：" + link) ;
         
     }
};

 

3 以先进先出的方式取出全部数据

public class Demo{
     public static void main(String args[]){
          LinkedList<String>link = new LinkedList<String>() ;
          link.add("1");     // 增加元素
          link.add("2");     // 增加元素
          link.add("3");     // 增加元素
          System.out.print("以FIFO的方式输出：") ;
          for(inti=0;i<=link.size()+1;i++){
              System.out.print(link.poll() + "、") ;
          }
     }
};

 

 Set接口

Set接口也是Collection接口的子接口，与List接口不同的是，Set接口中是不能加入重复元素的（通过Object类中的hashCode和equals方法来完成元素是否重复的判断）)

 

Set接口的常用子类

HathSet类

HathSet类（底层数据结构是哈希表）：里面不能存放重复元素，而且采用散列的存储方式，所以没有顺序

 

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

 

HashSet为了保证唯一性，是通过元素的2个方法，，hasCode（）和equals方法来完成的。如果元素的hashCode码相同，才会判断equals（）是否为true。如果元素的hashCode不同，不会调用equals

 

实例代码

 

public class Demo{
     public static void main(String args[]){
          Set<String> allSet= new HashSet<String>() ;
          allSet.add("A");     // 增加内容
         allSet.add("B") ;     // 增加内容
         allSet.add("C") ;     // 增加内容
         allSet.add("C") ;     // 重复内容
         allSet.add("C") ;     // 重复内容
         allSet.add("D") ;     // 增加内容
         allSet.add("E") ;     // 增加内容
         System.out.println(allSet) ;
     }
};

PS：输出时，对于重复元素只会增加一次，而且程序运行时向集合中加入元素的顺序并不是集合中的保存顺序

 

2有序的存放：TreeSet

使用TreeSet可以对输入的数据进行有序的排列

public class Demo{
     public static void main(String args[]){
          Set<String> allSet= new TreeSet<String>() ;
         allSet.add("C") ;     // 增加内容
         allSet.add("C") ;     // 重复内容
         allSet.add("C") ;     // 重复内容
         allSet.add("D") ;     // 增加内容
         allSet.add("B") ;     // 增加内容
         allSet.add("A") ;     // 增加内容
          allSet.add("E");     // 增加内容
         System.out.println(allSet) ;
     }
};

最后输出结果为  [A, B, C, D, E]，结果进行了排序

 

 关于Set的排序扩展说明

1 如果我们自定义一个类进行排序，那么必须对对象制定好排序规则，并且，每个对象所在的类都必须实现Comparable接口（这种方式也称为元素的自然顺序，或者叫做默认顺序）才可以使用

2 Set接口中规定是不能有重复元素的，因此要想去掉重复元素，首先要进行对象是否重复的判断，这样一个类中就必须覆写Object类中的equals()方法，同时还是覆写hashCode()方法，才能完成对象是否相等的判断

ps:hashCode()方法，表示一个哈希编码，可以简单的理解为是对一个对象的编码。一般哈希码是通过公式进行计算的，可以将类中的全部属性进行适当的计算，求出一个不会重复的哈希码

 

示例代码

class Person implementsCompareable<Person>{
     private String name ;
     private int age ;
     public Person(String name,int age){
          this.name = name ;
          this.age = age ;
     }
     public boolean equals(Objectobj){     // 覆写equals，完成对象比较
          if(this==obj){
              return true ;
          }
          if(!(obj instanceofPerson)){
              return false ;
          }
          Person p = (Person)obj;     // 向下转型
         if(this.name.equals(p.name)&&this.age==p.age){
              return true ;
          }else{
              return false ;
          }
     }
     public int hashCode(){//覆写Object类的hashCode方法
          returnthis.name.hashCode() * this.age     ; // 定义一个公式，返回一个hashCode值*年龄的数据
     }
     public String toString(){//覆写Object类的toString方法，返回我们能理解的对象信息

         return "姓名：" + this.name + "；年龄：" + this.age ;
     }
};
public class RepeatDemo02{
     public static void main(String args[]){
          Set<Person> allSet= new HashSet<Person>() ;
          allSet.add(newPerson("张三",30)) ;
          allSet.add(newPerson("张三",30)) ;

         allSet.add(new Person("李四",32)) ;
          allSet.add(newPerson("李四",32)) ;
         System.out.println(allSet) ;
     }
};

 

输出结果：[姓名：张三；年龄：30,姓名：李四；年龄：32]

PS:如果碰到区分是否为统一对象的问题，在编写类是，最好覆写Object类中的hashCode()，equals(),和toString（）方法

 

 

 集合的输出

如果要输出Colleciton，Set集合中的内容，可以将其转换为对象数组输出，而使用List则可以直接通过get方法输出，但是这些都不是最好的输出方式。在类集中提供了以下4种常见的输出方式

--->Iterator:迭代输出，是使用最多的输出方式

--->ListIterator：是Iterator的子接口，专门用于输出List中的内容

--->Enumeration：是一个旧的接口，功能与Iterator类似

--->foreach：JDK1.5之后提供的新功能，可以输出数组或者集合

在实际开发中，使用Iterator接口进行输出，是最为标准的做法。

4.1 迭代输出:Iterator

4.1.1 Iterator接口详情

Iterator是专门的迭代I输出接口，所以的迭代输出就是将元素一个一个进行判断，判断其是否有内容，如果有内容则把内容取走

PS:在迭代时，不可以通过结合对象的方法操作集合中的元素，不然会发生异常。

 所以在迭代时，只能对元素进行判断，取出，删除的操作。如果想要其他的操作如添加，修改

就需要使用其子接口，ListIterator，该接口只能通过List集合ListIterator接口获取

=

Iterator接口中常用的方法

hasNext():判断是否有下一个元素

E next():取出当前元素

remove():移除当前元素

 

Iterator接口的操作实例

输出操作

public class Demo{
     public static void main(String args[]){
          List<String>all=  new ArrayList<String>() ;     //
          all.add("hello");//增加元素
          all.add("_");//增加元素
         all.add("world") ;//增加元素
          Iterator<String>iter = all.iterator() ;     // 为Iterator接口实例化
         while(iter.hasNext()){     // 判断是否有内容
              System.out.println(iter.next()) ;     // 输出内容
          }
     }
};

结果：hello

_

world

 

删除操作

public class Demo{
     public static void main(String args[]){
          List<String>all=  new ArrayList<String>() ;     //
         all.add("hello") ;
          all.add("_") ;
          all.add("world");
          Iterator<String>iter = all.iterator() ;     // 为Iterator接口实例化
         while(iter.hasNext()){     // 判断是否有内容
              String str = iter.next() ;
              if("_".equals(str)){ 
                   iter.remove() ;     // 删除元素         
              }else{
                   System.out.println(str) ;     // 输出内容
              }
          }
         System.out.println("删除之后的集合：" + all) ;
     }
};

 

结果：hello

world

删除之后的集合：[hello, world]

 

 ListIterator接口详情

Iterator接口的主要功能是由前向后单向输出，而此时如果向完成由后向前或者是由前向后的双向输出，则必须使用Iterator的子接口-ListIterator

此接口定义了比Iterator接口中更多的方法，典型方法如下

hasPrevious():判断是否有上一个元素

previous():取出当前元素

 

进行双向迭代输出

public class Demo{
     public static void main(String argsp[]){
          List<String> all =new ArrayList<String>() ;
         all.add("hello") ;
          all.add("_") ;
         all.add("world") ;
         ListIterator<String> iter = all.listIterator() ;// 为Iterator接口实例化
          System.out.print("由前向后输出：") ;
         while(iter.hasNext()){  // 判断是否有内容
              String str = iter.next() ;
              System.out.print(str + "、") ;
          }
         System.out.print("\n由后向前输出：") ;
         while(iter.hasPrevious()){  // 判断是否有内容
              String str = iter.previous() ;
              System.out.print(str + "、") ;
          }
     }
};

结果：由前向后输出：hello、_、world、

由后向前输出：world、_、hello、

 

Java新支持：foreach输出

使用foreach除了可以完成数组的输出，对于集合也同样支持

foreach输出格式

for(类对象：集合){

//集合操作

}

public class Demo{
     public static void main(String args[]){
          List<String> all =new ArrayList<String>() ;
         all.add("hello") ;
          all.add("_") ;
         all.add("world") ;
          for(String str:all){
              System.out.print(str + "、") ;
          }
     }
};

结果：

hello、_、world、

 

 

Enumeration接口

Enumeration接口是JDK1.0时就退出的，是最早的迭代输出接口，最早使用Vector时就是使用Enumeration接口进行输出的

常用方法

hasMoreElements():判断是否有下一个值

E nextElement():取出当前元素

 

使用Enumeration进行输出

public class Demo{
     public static void main(String args[]){
          Vector<String> all= new Vector<String>() ;
         all.add("hello") ;
          all.add("_") ;
         all.add("world") ;
         Enumeration<String> enu = all.elements() ;
         while(enu.hasMoreElements()){     //判断是否有内容，hasNext()
              System.out.print(enu.nextElement() + "、") ;     //输出元素：next()
          }
     }
};

 结果：hello、_、world、

 

 

Map接口

Map每次操作的是一对对象，既二元对象，Map中的每个元素都使用key-value的形式存储在集合中。

常见方法

put(K key,V value)：向集合中加入元素

putAll(Map<? extends K,?extends V> m)将一个Map集合加入到另外一个Map集合中去

clear() 清空Map集合

remove(Object key)根据key删除value值

containKey(Object key)判断指定的key是否存在

containValue(Object value)判断指定的value是否存在

 

isEmpy()判断集合是否为空

get(Object key)根据key取得value的值9

 

Map.Entry

Map.Entry是Map内部定义的一个接口，专门用来保存key-value的内容。Map.Entry是使用static关键字声明的内部接口，此接口可以由外部通过"外部类。内部类"的形式直接调用

Map.Entry接口的常用方法

equals(Object o)对象比较

K getKey（）取得Key

V getValue（）取得value

int hashCode()返回哈希码

V setValue（V value）设置value的值

在map的操作中，所有的内容都是通过key-value的形式保存数据的，那么对于集合来讲，实际上是将key-value的数据保存在了Map.Entry的实例之后，再在Map集合中插入的是一个Map.Entry的实例化对象

Map接口的常用子类

要使用Map接口也必须依靠其他子类实例化。Map接口中常用的子类如下

HashMap:无序存放，是新的操作类，key不允许重复。底层是哈希表结构，线程不同步

Hashtable：无序存放，是旧的操作类，key不允许重复.底层是哈希表结构，线程同步

TreeMap：可以排序的Map集合，按集合中的key排序，key不允许重复。底层是二叉树数据结果，线程不同步

WeakHashMap：弱引用的Map集合，当集合中的某些内容不再使用时清除掉无用的数据，使用gc进行回收

IdentityHashMap：key可以重复的Map集合

以上所有类的操作，都是以Map接口为操作的标准，而且一般HashMap子类较为常用

 

HashMap主要操作方法

1 向集合中增加和取出内容（在Map接口中使用put（Object key，Object value）方法可以向集合中增加内容，之后可以通过get(E key)方法根据key找出其对应的value）

 

public class Demo{
     public static void main(String args[]){
          Map<String,String>map = null; // 声明Map对象，其中key和value的类型为String
          map = newHashMap<String,String>() ;
         map.put("hello","world") ;     // 增加内容
         map.put("hello1","world1");     // 增加内容
          String val =map.get("hello1") ;     // 根据key取出值

         System.out.println("取出的内容是：" + val) ;
     }
};

 

结果：取出的内容是：world1

 

 

2 判断指定的key或者value是否存在

 

如果要判断某一个指定的key或者value是否存在，可以使用Map接口中提供的containsKey（Object key）和

containsValue（Object value）2个方法，前者判断Map集合是否存在制定的key，后者是判断Map集合是否存在制定的value

 

public class Demo{
     public static void main(String args[]){
          Map<String,String>map = null; // 声明Map对象，其中key和value的类型为String
          map = newHashMap<String,String>() ;
         map.put("hello","world") ;     // 增加内容
           if(map.containsKey("hello")){    // 判断key是否存在

              System.out.println("搜索的key存在！") ;
          }else{
              System.out.println("搜索的key不存在！") ;
          }
         if(map.containsValue("world")){     // 判断value是否存在

              System.out.println("搜索的value存在！") ;
          }else{
              System.out.println("搜索的value不存在！") ;
          }
     }
};

结果：搜索的key存在！

搜索的value存在！

 

3 输出全部的key

在Map中提供了一个叫keySet（）的方法，可以将一个Map中的全部key变为一个Set集合，一旦有了Set实例，就可以直接使用Iterator输出

public class Demo{
     public static void main(String args[]){
          Map<String,String>map = null; // 声明Map对象，其中key和value的类型为String
          map = newHashMap<String,String>() ;
         map.put("hello","world") ;     // 增加内容
         map.put("hello1","world1") ;     // 增加内容world

         Set<String> keys = map.keySet() ;     //得到全部的key
          Iterator<String>iter = keys.iterator() ;
          while(iter.hasNext()){
              String str = iter.next() ;
              System.out.print(str + "、") ;
          }
     }
};

 结果：hello、hello1、

 

 

4 输出全部的value

输出全部的value，使用values（）方法，返回类型是Colleciton

 

public class Demo{
     public static void main(String args[]){
          Map<String,String>map = null; // 声明Map对象，其中key和value的类型为String
          map = newHashMap<String,String>() ;
         map.put("hello","world") ;     //增加内容

         map.put("hello1","world1") ;     //增加内容world

         Collection<String> values = map.values() ;     //得到全部的value
          Iterator<String>iter = values.iterator() ;
          while(iter.hasNext()){
              String str = iter.next() ;
              System.out.print(str + "、") ;
          }
     }
};

结果world、world1、

 

 

旧的子类:Hashtable类

Hashtable也是Map中的一个子类，与Vector类的推出时间一样，都属于旧的操作类

Hashtable的操作实例

public class Demo{
     public static void main(String args[]){
          Map<String,String>map = null; // 声明Map对象，其中key和value的类型为String
          map = newHashMap<String,String>() ;
          map.put("hello","world") ;     // 增加内容

         map.put("hello1","world1") ;     //增加内容world

         System.out.print("全部的key：") ;
          Set<String> keys =map.keySet() ;     // 得到全部的key
          Iterator<String>iter = keys.iterator() ;
          while(iter.hasNext()){
              String str = iter.next() ;
              System.out.print(str + "、") ;
          }
         System.out.print("\n全部的value：") ;
          Collection<String>values = map.values() ;     // 得到全部的value
          Iterator<String>iter2 = values.iterator() ;
          while(iter2.hasNext()){
              String str = iter2.next() ;
              System.out.print(str + "、") ;
          }
     }
};

 

结果：全部的key：hello、hello1、

全部的value：world、world1、

 

排序的子类：TreeMap

TreeMap的主要功能是按key排序

 

public class Demo{
     public static void main(String args[]){
          Map<String,String>map = null; // 声明Map对象，其中key和value的类型为String
          map = newTreeMap<String,String>() ;
          map.put("hello1","world") ;     // 增加内容

         map.put("hello2","world1") ;     //增加内容

         Set<String> keys = map.keySet() ;     //得到全部的key
          Iterator<String>iter = keys.iterator() ;
          while(iter.hasNext()){
              String str = iter.next() ;
              System.out.println(str + " --> " + map.get(str)) ; // 取出内容
          }
     }
};

 

结果hello1 --> world

hello2 --> world1

 

弱引用类：WeakHashMap

之前所讲解的Map子类中的数据都是使用强引用保存的，及里面的内容不管是否使用都始终在集合中保留，如果希望集合自动清理暂时不用的数据，就使用WeakHashMap类；这样，当进行垃圾收集时会释放掉集合中的垃圾信息

 

观察弱引用的Map集合

public class Demo{
     public static void main(String args[]){
       Map<String,String> map = null; // 声明Map对象，其中key和value的类型为String
        map = newWeakHashMap<String,String>() ;
        map.put( newString("hello1" ), new String("hello1" )) ;
        map.put( newString("hello11" ), new String("hello11" )) ;
        map.put( newString("hello111" ), new String("hello111" )) ;
        System. gc() ;    // 强制性进行垃圾的收集操作
        map.put( newString("hello1111" ), new String("hello1111" )) ;
        System. out .println(map) ;
     }
};

结果：{hello1111=hello1111}

因为使用了弱引用，所以对于Map集合中暂时不用的数据会被清除掉

 

PS:对象强度的引用说明

强引用：当内存不足时，JVM宁可出现内存溢出，也不会回收此对象

软引用：当内存不足时，会回收这些对象的内存，用来实现内存敏感的告诉缓存

弱引用：无论内存是否紧张，被垃圾回收期发现立即回收

虚引用：和没有任何引用一样

 

Map接口的注意事项：对于Map接口来说，其本身是不能直接使用迭代来进行输出的，因为Map中的每一个位置存放的是一对值，而Iterator中每次只能找到一个值。如果非要使用迭代进行输出，则必须按照下列步骤

（Map集合在开发中基本作为查询来使用，输出的操作较少，而Collection在开发中主要就是用来传递内容及输出）

1 将Map的实例通过entrySet（）方法变为Set接口对象

2 通过Set接口实例为Iterator

3 通过Iterator迭代输出，每个内容都是Map.Entry的对象

4 通过Map.Entry进行key-value的分离

public class Demo{
     public static void main(String args[]){
          Map<String,String>map = null; // 声明Map对象，其中key和value的类型为String
          map = newHashMap<String,String>() ;
         map.put("hello1","hello1") ;     // 增加内容
          map.put("hello2","hello2") ;     // 增加内容

         map.put("hell3","hello4") ;     //增加内容

         Set<Map.Entry<String,String>> allSet = null ;
          allSet = map.entrySet();
         Iterator<Map.Entry<String,String>> iter = null ;
          iter = allSet.iterator();
          while(iter.hasNext()){
              Map.Entry<String,String> me = iter.next() ;
              System.out.println(me.getKey() + " --> " + me.getValue()) ;
          }
     }
};

结果hell3 --> hello3

hello2 --> hello2

hello1 --> hello1

 

集合工具类：Collection（更加方便的操作集合）

 

为集合增加内容

public class Demo{
     public static void main(String args[]){
          List<String> all =new ArrayList<String>() ;     // 返回空的 List集合
         Collections.addAll(all,"hello","world","java") ;
          Iterator<String>iter = all.iterator() ;
          while(iter.hasNext()){
              System.out.print(iter.next() + "、") ;
          }
     }
};

结果：hello、world、java、

 

 

反转集合的内容

public class Demo{
     public static void main(String args[]){
          List<String> all =new ArrayList<String>() ;     // 返回空的 List集合
         Collections.addAll(all,"hello","world","java");
          Collections.reverse(all);     // 内容反转
          Iterator<String>iter = all.iterator() ;
          while(iter.hasNext()){
              System.out.print(iter.next() + "、") ;
          }
     }
};

 

结果：java、world、hello、

 

 

检索内容

public class Demo{
     public static void main(String args[]){
          List<String> all =new ArrayList<String>() ;     // 返回空的 List集合
          Collections.addAll(all,"hello","world","java");
          int point =Collections.binarySearch(all,"hello") ;     // 检索数据
          System.out.println("检索结果：" + point) ;
         
     }
};

结果：检索结果：0

 

小结：

1 类集的目的是用来创建动态的对象数组

2 Collection接口是类集中的最大单值操作的父接口，但是一般不会直接使用此接口，而是使用List或者Set接口

3 List接口扩展了Collection，里面的内容是允许重复的

4 List接口的常用子类是ArryList和Vector，ArrayList性能较高，属于异步处理，而Vector性能较低，属于同步处理

5 Set接口与Collection接口的定义一直，里面的内容是不允许重复的，依靠Object类中的equals（）和hashCode（）方法来区分是否是同一个对象

6 Set接口的常用子类是HashSet和TreeSet，前者是散列存放，没有顺序，后者是顺序存放，使用Comparable进行排序操作

7 集合的输出使用Iterator接口完成，Iterator属于迭代输出接口

8 Map接口可以存放一对内容，所有的内容一key-value的形式保存，每一对key-value都是一个Map.entry对象的实例

9 类集中提供了Collections工具类完成类集的相关操作