java.util包和集合框架【学习笔记】(上)

先来学几个英语单词看看

 

calender  日历        collection  集合

date  日期        dictionary 字典

element  元素        hash  哈希

list  列表        map  映射

parse  解析、分列        random  随机

remove  移除        stack  堆栈

vector  矢量

---------------------------------------------------------------------------------------------------------------------------------

【回顾】

1、在java中装箱和拆箱都是自动进行的

2、Math类是final类，里面的方法都是static final方法

3、String类代表的字符串是不可变的

4、也就是说字符串是常量并且不能改变他们

---------------------------------------------------------------------------------------------------------------------------------

java.util包和集合框架

一、其他知识内容

Calendar类

根据给定的Date对象，Calendar类可以以YEAR和MONTH类等整型的形式检索信息

它是抽象的，因此不能实例化

GregorianCalendar：是Calendar的子类，实现Gregorian形式的日历

import java.util.*;

public class CCalendar {
    public static void main(String[] args) {
        Calendar today = Calendar.getInstance();//获取Calendar对象，该对象存储当前系统时间
        System.out.print("今天是：" + today.get(Calendar.YEAR) + "年");
        System.out.print(today.get(Calendar.MONTH) + 1 + "月");
        //注意月的值从0开始，即如果取出的月份为0，则为1月
        System.out.print(today.get(Calendar.DATE) + "日");
        System.out.print(today.get(Calendar.HOUR) + "点");
        System.out.println(today.get(Calendar.MINUTE) + "分");
        int i=7;
        today.add(Calendar.DATE, i);
        //add根据日历规则，将指定的（有符号的）时间量添加到给定的日历字段中
        System.out.print("再过"+ i +"天是" + today.get(Calendar.YEAR) + "年");
        System.out.print(today.get(Calendar.MONTH) + 1 +"月");
        System.out.println(today.get(Calendar.DATE) + "日");
        today.set(2015,1,19);
        //设置年月日
        // today.clear(Calendar.HOUR);
        // today.clear(Calendar.MINUTE);
        // today.clear(Calendar.SECOND);
        System.out.print("羊年的春节是:" + today.get(Calendar.YEAR) + "年");
        System.out.print(today.get(Calendar.MONTH) + 1 + "月");
        System.out.println(today.get(Calendar.DATE)+"日");
    }
}

Random类

 该类可以产生随机整数、随机浮点数

构造方法	说明
Random()	创建一个新的随机数生成器
Random(long seed)	使用单个long种子创建一个新的随机数生成器

public int nextInt()方法：

返回下一个随机整数，它是此随机生成器的序列中均匀分布的int值，所有2^32个可能int值的生成概率大致相同

public int nextInt(int n)

返回一个随机整数，它是取自此随机数生成器序列的在0（包括）和指定值（不包括）之间均匀分布的int值，所有可能的n个int值的生成概率大致相同

import java.util.*;

public class RandomTest {
    public static void main(String[] args) {
        Random ran1 =new Random();
        Random ran2 =new Random(1000);//创建了两个类Random 的对象
        System.out.println("The 1st set of random numbers:");
        System.out.println("Integer:" + ran1.nextInt());
        System.out.println("Long:" + ran1.nextLong());
        System.out.println("Float:" + ran1.nextFloat());
        System.out.println("Double:" +ran1.nextDouble());
        System.out.println("Gaussian:" + ran1.nextGaussian());
        //产生各种类型的随机数
        System.out.println("The 2nd set of random numbers: ");
        for(int i=0; i<5; i++){
            System.out.println(ran2.nextDouble());
            //产生同种类型的不同的随机数
        }
    }
}

---------------------------------------------------------------------------------------------------------------------------------

 二、集合框架内容

1.Collection 接口

2.Interator 接口

3.List接口：ArrayList类、LinkedList类、Voctor类

4.Set接口：HashSet类、TreeSet类

5.Map接口：HashMap类、TreeMap类

6.Collections 父类

7.Comparable和Comparator比较接口

为什么需要集合框架？

集合是用于储存、检索和操纵数据

集合框架是用于表示和操纵集合的统一体系结构

集合框架包含三个组件：

接口：是表示集合的抽象数据类型

算法：是对实现接口的对象执行计算的方法

实现：是接口的实际表现

集合框架的优点：

        提供有用的数据接口和算法，从而减少编程工作

        提高了程序速度和质量，因为它提供了高性能的数据结构和算法

        允许不同API之间的互操作，API之间可以来回传递集合

        可以方便地拓展或改写集合

java的集合（Collection）框架：

Java的集合框架支持三种类型的集合：线性表List、规则集Set和映射Map

List的实例存储一组顺序排列的元素

Set的实例存储一组互不相同的元素

Map的实例存储一组对象，改实例中的每个元素都有一个关联的关键字

Collection接口是构造集合框架的基础，它是处理对象集合的根接口，声明了所有Collection类都将拥有所有的核心方法。

 

Collection接口声明的方法

方法	功能描述
bollean add(Object obj)	为当前调用的集合添加元素obj
boolean addAll(Collection c)	将c中的所有元素加入调用的集合中
void clear()	删除当前集合的所有元素
boolean contains(Object o)	若当前集合包含元素o则返回true，否则返回false返回当前集合的散列码
boolean containsAll(Collection c)	若当前集合包含集合c的所有元素则返回true
boolean equals(Object o)	若当前集合与o相等则返回true，否则返回false
int hashCode()	返回当前集合的散列码
boolean isEmpty()	若当前集合不包含任何元素则返回true
Iterator iterator( )	返回当前集合元素的迭代探子
boolean remove(Object o)	删除当前集合中的元素o
boolean removeAll(Collection c)	删除集合c中的所有元素
boolean retainAll(Collection c)	删除当前集合中与集合c共有的元素，若当前集合发生变化则返回true，否则返回false
int size()	返回当前集合元素的个数
Object[] toArray()	返回当前集合所有元素构成的数组

集合接口：

List接口	元素以线性方式存储 存储的顺序与添加顺序相同
Map接口	以键-值的映射来存储元素 键值不允许重复
Set接口	不保证元素的存储 不允许重复元素

List接口：

        允许重复的元素

        允许null值

        保证元素的顺序

        常用的实现该接口的类：

        1.ArrayList-类似数组

        2.Vector-矢量

        3.LinkedList-链表

        4.Stack-堆栈（LIFO）

ArrayList：

        ArrayList对象是长度可变的对象引用数组，类似于动态数组（见ArrayListExample）

        继承AbstractList并实现List接口

        随着元素的添加，元素的数目会增加，列表也会随着扩展

        访问和便利对象时，它提供更好的性能

ArrayList类的构造方法包括：

构造方法	说明
ArrayList	创建一个空ArrayList
ArrayList(Collection c)	根据给定集合的元素创建数组列表
ArrayList(int size)	使用给定大小创建一个数组列表， 向数组列表添加元素时，此大小 自动增加

Vector类-向量类：

import java.util.Vector; 
import java.lang.*; 
import java.util.Enumeration; 


public class VectorTest {
    public static void main(String[] args) {
        Vector v1 = new Vector();
        Integer integer1 = new Integer(1);
        v1.addElement("one");//加入的为字符串对象
        v1.addElement(integer1);
        v1.addElement(integer1);//加入的为Integer的对象
        v1.addElement("two");
        v1.addElement(new Integer(2));
        v1.addElement(integer1);
        v1.addElement(integer1);
        System.out.println("The vector v1 is: \t" + v1);
        //往指定位置插入新的对象，指定位置后的对象依次往后顺延
        v1.insertElementAt("three",2);
        v1.insertElementAt(new Float(3.9),3);
        System.out.println("The vector v1(used method insertElementAt()) is: \t " + v1);
        //将指定位置的对象设置为新的对象
        v1.setElementAt("four",2);
        System.out.println("The vector v1(used method setElementAt()) is: lt " + v1);
        //从向量对象v1中删除对象integer1由于存在多个integer1 所以从头开始找，
        //删除找到的第一个integer1
        v1.removeElement(integer1);
        //使用枚举类(Enumeration)的方法来获取向量对象的每个元素
        Enumeration enum1=v1.elements();
        System.out.print("The vector v1(used method removeElement()is:");
        while(enum1.hasMoreElements())
        System.out.print(enum1.nextElement() + " ");
        System.out.println();
        //按不同的方向查找对象integer1所处的位置
        System.out.println("The position of object 1(top-to-bottom):" + v1.indexOf(integer1));
        System.out.println("The position of object 1(tottom-to-top):" +v1.lastIndexOf(integer1));
        //重新设置√1的大小，多余的元素被行弃
        v1.setSize(4);
        System.out.println("The new vector(resized the vector)is:" +v1);
    }
}

Set接口：

        Set接口不保证元素的顺序，不允许出现重复的元素

        实现Set接口的类：HashSet、TreeSet

        HashSet类不允许出现重复元素，不保证集合中元素的顺序，只允许一个null元素

        TreeSet是Set的一种变体，可以实现按照自然顺序排序，在添加元素时会自动插入到已经

        有序的元素序列中（字符串按照“字典”的顺序、整数按照数字大小的顺序）

HashSet和TreeSet的区别：HashSet不保证元素的顺序，而TreeSet可以自然顺序插入添加的元素

Map接口：

        使用键-值的成对映射来存储元素

        键-值不允许重复

        常用实现Map接口的类：

类名	null	元素顺序	线程安全
HashMap	允许	不保证元素顺序	线程不安全
Hashtable	不允许	不保证	线程安全
TreeMap	不允许	可以按键值的自然顺序将值排列

 HashMap：

        实现了Map接口

        用于存储键/值映射的关系

        不能保证其元素的存储过程

        此类的构造方法包括：

构造方法	说明
HashMap()	创建一个具有默认容量和负载系数空映射
HashMap(int size)	创建一个具有指定大小的容量和默认负载系数的空映射
HashMap(int size,float load)	创建一个具有指定的容量和指定的负载系数的空映射
HashMap(Map map)	创建一个具有指定map映射的散列映射

        它在存放键值时允许为null值

        比如：HashMap map = new HashMap();  map.put("name",null);

Iterator遍历元素接口：

        Iterator接口可以以统一的方式对各种集合元素进行遍历，也成为“迭代器”，它还可以在遍历元素的同时移除元素

        hasNext()方法检测集合中是否还有下一个元素

        next()方法返回集合中的下一个元素

        Iterator遍历集合元素的语法

Iterator it = 集合对象名.iterator();
while(it.hasNext()){
    Object o = it.next();
    System.out.println(o);
}

import java.util.*;

public class IteratorTest {
    public static void main(String[] args) {
        Collection coll = new ArrayList();
        //ArrayList是实现了Collection接口的类
        coll.add("Ann");
        coll.add("Bill");
        coll.add("Smith");
        coll.add("Tom");
        System.out.print("using Iterator: ");
        Iterator it = coll.iterator();
        String name;
        while(it.hasNext()){ //hasNext()方法检测集合中是否还有下一个元素
            name= (String)it.next();  //next()方法返回集合中的下一个元素
            if(name.equals("Bill"))
            it.remove();
            else
            System.out.print(name +" ");
        }
        System.out.println();
        System.out.print("using forEach:");
        coll.forEach(e->System.out.print(e +" "));
    }
}

Comparable接口：

        Java.lang包中定义的一个比较对象的接口

        提供抽象方法compare To()，可以对对象进行整体排序

        使用方法：对要进行比较对象的类实现Comparable接口，重写compareTo()方法

        Comparable接口不仅仅用于集合框架，可用于任何需要进行对象比较的场合

        Java.util包中提供的一个对某个对象集合进行整体排序的比较接口

        提供了compare的比较方法来比较对象

        使用步骤：

                定义实现该接口的类（该类又称为比较器，并重写compare方法）

                实例化该比较器类的对象

                把该对象比作Collections.sort()方法的第二个参数

//实现Comparator接口，比较学生的姓名
class NameComp implements Comparator{
	//重写Comparator接口中的compare方法
	public int compare(Object o1,Object o2){
		Student s1=(Student)o1;
		Student s2=(Student)o2;
		return s1.name.compareTo(s2.name);
	}	
}
...
	public static void main (String[] args) {
		...
		NameComparator nc=new NameComparator();
		Collections.sort(al, nc);
	}
...