Java高级部分--集合（2）

一.集合类

Java中数组与集合的比较
1.数组也是容器，它是定长的，访问较快，但是数组不会自动扩充
2.数组可以包含基本数据类型或引用类型的对象，而集合中只能包含引用类型的对象

Java中集合框架层次结构

Collection接口

1.一组称为元素的对象

2.一个Collection中可以放不同
类型的数据
1.是Set接口和List接口的父类
2.是否有特定的顺序以及是否允许重复，取决于它的实现

3.Set － 无序的集合；不允许重复  如：HashSet
4.List － 有序的集合；允许重复  如：ArrayList,LinkedList

Set接口
1.Collection的子接口
2.用来包含一组 无序无重复 的对象
3.无序-----是指元素存入顺序和集合内存储的顺序不同
4.无重复------两个对象e1和e2，如果e1.equals(e2)返回true，则认为e1和e2重复

Set接口的实现类 
1.HashSet-----HashSet的特性在于其内部对象的散列存取，即采用哈希技术
2.TreeSet-----TreeSet存入的顺序跟存储的顺序不同，但是存储是按照排序存储的

List接口

1.Collection的子接口
2.用来包含一组 有序有重复 的对象
3.List中的元素都对应一个整数型的序号，记载其在容器中的位置，可以根据序号存取容器中的元素
4.List有两种主要的集合实现类：ArrayList,LinkedList

List接口的实现类
1.ArrayList是线性顺序存储的，是一种线性表
2.它的特性和数组很接近，数组大小是不变的，而ArrayList的大小是可以动态改变的

3.LinkedList最主要的功能方面的增强是可以在List的头部和尾部添加、删除、取得元素，直接提供了这些方法的实现

ArrayList与LinkedList的比较
　　存储结构
1.ArrayList是线性顺序存储
2.LinkedList对象间彼此串连起来的一个链表
　　操作性能
1.ArrayList适合随机查询的场合
2.LinkedList元素的插入和删除操作性高

Map接口
1.Map内存储的是键/值对这样以成对的对象组(可以把一组对象当成一个元素)，通过“键”对象来查询“值”对象
2.Map是不同于Collection的另外一种集合接口
3.Map中，key值是唯一的(不能重复)，而key对象是与value对象关联在一起的
　　Map接口有两个实现：
1.HashMap — key/value对是按照Hash算法存储的
2.TreeMap — key/value对是排序(按key排序)存储的

HashMap与TreeMap的比较
1.HashMap基于哈希表实现
2.TreeMap基于树实现
3.HashMap可以通过调优初始容量和负载因子，优化HashMap空间的使用
4.TreeMap没有调优选项，因为该树总处于平衡状态
5.HashMap性能优于TreeMap

Iterator接口
1.Iterator对象称作迭代器，用来方便的实现对容器内的元素进行遍历操作
2.所有实现了Collection接口的集合类都有一个iterator( )方法，返回一个实现了Iterator接口的对象
3.Iterator对象实现了统一的一个用来遍历Collection中对象的方法
4.Iterator是为遍历而设计，能够从集合中取出元素和删除元素，但是没有添加元素的功能
5.Iterator的功能上比较简单，使用中，只能单向移动

hasNext方法

用来判断指针右边是否还有数据

Next方法

将指针向右移动一次，将划过的数据取出来

Iterator<String>    iter=hs1.iterator();
           while(iter.hasNext()){
       System.out.println( iter.next());
　　}

如何选择集合类
1.Set内存放的元素不允许重复，List存放的元素有一定的顺序
2.Map的应用主要在利用键/值对进行快速查询
3.ArrayList和LinkedList的区别在于随机查询性能上ArrayList要好，但LinkedList的中间元素的插入与删除性能好 
4.HashSet和TreeSet的区别在于集合内元素是否排序 

collection接口

package util1;

import java.util.Collection;
import java.util.HashSet;

public class Collection1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        //实例化对象
        Collection   c1=new HashSet();   //向上转型---  声明成接口类型，调用实现类的构造方法
        Collection   c2=new HashSet(); 
         //添加数据
        c1.add(1);
        c1.add("你");
        c1.add(new  A());  
        
        System.out.println(c1);    //整体取出数据：直接输出集合名称  
        
        c2.addAll(c1);   //添加其他集合
        System.out.println(c2.size());    //取集合长度
        System.out.println(c2.contains("sgtht"));   //判断是否包含某些数据
        
        System.out.println("///////////////");   
       Object  o[]    =c2.toArray();    //将集合转换成数组
       /*for(int i=0;i<o.length;i++){
           System.out.println(o[i]);
       }*/
       
         System.out.println(o[0]);
         System.out.println(o[1]);
         System.out.println(o[2]);
       
        
    }

}

set集合

hashSet,treeSet

package util1;

import java.util.HashSet;
import java.util.Iterator;
import java.util.TreeSet;

public class HashSet1 {

    /**
     * set接口的特点(集合)
     *     hashset:   无顺序,数据不能重复,长度可扩展
     *     treeset:  按照自然顺序排列数据，数据不能重复,能够比较大小
     * 
     */
    public static void main(String[] args) {
        
          HashSet<String>   hs1=new HashSet<String>();
          hs1.add("a");
          hs1.add("b");
          hs1.add("b");
          hs1.add("c");
/*          System.out.println(hs1);  
          
          //挨个取出集合中的数据
         Iterator<String>    iter=hs1.iterator();
          while(iter.hasNext()){
             System.out.println( iter.next());
          }
          */
          
          
            TreeSet<Integer>   ts1=new TreeSet<Integer>();
            ts1.add(1);
            ts1.add(768);
            ts1.add(43);
            ts1.add(43);
            ts1.add(87);
            System.out.println(ts1); 
            
            
          //类型转换异常
            
            TreeSet  ts2=new TreeSet();
            ts2.add("adsf");
            ts2.add("u11");    
            ts2.add("caa");
            System.out.println(ts2);  
    }

}

list集合

linkedList

package util1;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;

public class List1 {

    /**
     *    list（列表）:   下标从0开始
     *        
     *          linkedList:  方便首尾操作 ，    数据可重复,有顺序,长度可扩展
     *          ArrayList:(数组列表)  :   数据可重复,有顺序,长度可扩展
     * 
     */
    public static void main(String[] args) {
       
        LinkedList<Integer>   ll=new LinkedList<Integer>();
        ll.add(1);
        ll.add(454);
        ll.add(454);
        ll.add(454);
        ll.add(454);
        ll.add(242);
        ll.add(0, 88);
        //ll.add(10, 77);
        System.out.println(ll);  
        ll.addFirst(66);
        System.out.println(ll);
        System.out.println(ll.get(4));    //按照下标取数据
        
        System.out.println("///////////////////");  
    
        for(int i=0;i<ll.size();i++){
            System.out.println(ll.get(i));             
        }
        
        System.out.println("///////////////////");  
        
        Iterator<Integer>  it=ll.iterator();
        while(it.hasNext()){
            System.out.println(it.next());          
        }
        
        System.out.println("///////////////////");  
        //foreach循环,增强的for循环------提高效率(封装了迭代器)
          for(Integer   in:ll){
              System.out.println(in);
          }
  
    }

}

map接口

hashmap集合

package util1;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

public class Map1 {

    /**
     * map:数据成对存放
     *     HashMap:  无序存放     key值不能重复，如果key值重复，会替换掉原来的键值对
     * 
     * 
     */
    public static void main(String[] args) {
        //声明键值对容器
        HashMap  hm1=new HashMap<String, String>();
       
        hm1.put("1", "a");  
        hm1.put("2", "b");
        hm1.put("2", null);  
        hm1.put("3", "c");
      System.out.println(hm1); 
        
        Set  keys=hm1.keySet();   //将所有key值取出组合成一个set集合
      /*   Iterator<String>   it=keys.iterator();
          while(it.hasNext()){                  //循环所有key值
        //    System.out.println(hm1.get(it.next()));      //根据key值获取value值              
          }*/
        
        
        Map<String, String>  m1=new HashMap<String, String>();   
        //向上转型:  节省内存   ,可用接口中的方法，实现类重写的方法,不能用实现类独有的方法
          m1.put("1", "a");  
          m1.put("2", "b");
          m1.put("2", "c");  
          m1.put("3", "c");
          System.out.println(m1);
          
          Set<Map.Entry<String, String>>  ens=m1.entrySet();   
          for(Entry<String, String>  e:ens){
               System.out.println(e.getKey());  
               System.out.println(e.getValue());  
          }
          
    }

}

treemap集合

package util1;

import java.util.TreeMap;

public class TreeMap1 {

    /**
     *   treemap:   按照key值的自然顺序排列数据,要求key值可以比较大小
     */
    public static void main(String[] args) {
        
           TreeMap   tm1=new TreeMap<Integer, String>();
           tm1.put(44, "gf");
           tm1.put(4654, "gf");
           tm1.put(42, "gf");
           tm1.put(4, "gf");
           System.out.println(tm1);  
          System.out.println(tm1.floorKey(5));   //得到小于参数的一个key值
          System.out.println(tm1.floorEntry(5));  //得到小于参数的一个键值对

    }

}

日期

package util1;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;   //引包

public class Date1 {

    
    public static void main(String[] args) {
        
            //当前时间
            Date   d1=new Date();    //当时的时间
            System.out.println(d1);  
            
            SimpleDateFormat   sdf=new SimpleDateFormat("yyyy年MM月dd日   a hh:mm:ss");
            String  time1=sdf.format(d1);
            System.out.println(time1); 
            
            
            //日历类
           Calendar   c= Calendar.getInstance();  //反转获得时间
           c.set(2011,11,29);  //自定义的时间
          System.out.println(c.get(Calendar.YEAR)); 

    }

}