Java 常用类与集合框架 泛型

一、常用类

常用类中将主要学习：

　　java.lang包中的类：

　　　　Object类

　　　　Math类

　　　　String类 和 StringBuffer类 （字符串）

　　　　8种基本数据类型所对应的包装类

　　java.util包中的类

　　　　Date类

1、Object 类

　　Object 类时java语言程序中所有类的父类，即java程序中其他所有类都是继承自Object类

　　Object类中包含了Java语言类中的所有公共属性。

　　　　toString( )方法

　　　　equals( )方法

　　　　getClass( )方法

　　　　clone( )方法

　　　　finalize( )方法

 2、Math

　　java.lang.Math类提供了常用的数字运算方法和两个静态常量E（自然对数的底数）和PI（圆周率）

 　（1）、Math.abs　　求绝对值　　Math.abs(-3.5);　　//返回3.5

　 （2）、Math.max　　求最大值　　Math.max(2.5,90.5);　　//返回90.5

　 （3）、第一种方法：int random = ( int )( Math.random()*10);　　//生成一个0-9之间的随机数

　　　　　第二种方法：Random rand = new Random();  int num = rand.nextint(10);　　//生成一个0-9之间的随机数

3、String 类

使用String 对象存储字符串

　　String str = " JAVA";　　

　　String str = new String();

　　String str = new String("Java");

String类常用操作：

　　计算字符串的长度 ：str.length

　　比较字符串 ： str.equals( " **")   或   “ == ”

　　　　　　　　equals() ： 检查组成字符串内容的字符是否完全一致

　　　　　　　　“ == ” ： 判断两符串在内存中的首地址，即判断是否是用一个字符串对象

　　字符串连接：方法1：使用 “ + ”  

   　　 String str1 = "Java";
       String str2 = "Hello";
       String str3 = str1+str2;

　　　　　　　方法2：使用String类中的concat()方法

        String str1 = new String("欢迎学习");
        String str2 = new String("JAVA");
        String result = str1.concat(str2);

　　字符串常用提取：

　　　　indexOf()　　//搜索第一个出现的元素的下标

　　　　lastindexOf()　　//搜索最后一个出现的元素的下标

　　　　substring(int index)　　//提取从位置索引开始的字符串的部分

　　　　sunstring(int beginindex,int enindex)　　//提取beginindex 和 endindex 之间的字符串部分

　　　　trim()　　//返回一个前后不含任何空格的调用字符串的副本

　　字符串拆分：

　　　　String类提供了split（）方法，将一个字符串分割为子字符串，结果作为字符串数组返回

        String str = "a,b,c,d,e,g";
        String[] split = str.split(",");    //将字符串str通过，拆分

4、StringBuffer类

　　StringBuffer:String增强版

　　StringBuffer声明

　　　　　　StringBuffer sb1 = new StringBuffer();

　　StringBuffer的使用

　　　　　　sb1.toString();　　//转化为String类型

　　　　　　sb1.append(" *** ")；　　//追加字符串

　　StringBuffer可以将任何类型的值追加到字符串之后

 

 5、操作日期时间

　　Date类：表示日期和时间

　　　　提供操作日期和室间各组成部分的方法

　　SimpleDateFormat类

　　　　用于定制日期时间的格式

    public static void main(String[] args) {
        
        Date date = new Date();        //获取当前时间
        System.out.println(date);
            
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");        //定义一个时间格式
        
        String date1 = format.format(date);        // 把获取的Date时间 转化成  对应格式的 String类型
        
        System.out.println(date1);
                
    }

 

 输出的结果为：

　　　　　　　　Tue Apr 02 19:53:25 CST 2019
　　　　　　　　2019-04-02 19:53:25

 6、Calendar类：

　　抽象类

　　用于设置和获取日期/时间数据的特定部分

　　Calendar类提供一些方法和静态字段来操作日历

Calendar calendar = Calendar.getInstance();        //    日历方法
        
        //获取  年分
        System.out.println(calendar.get(calendar.YEAR));
        
        //获取  月份  因为获取的是 0 -11的，所以获取当前月时要+1
        System.out.println(calendar.get(calendar.MONTH)+1);
        
        //获取 天数
        System.out.println(calendar.get(calendar.DAY_OF_MONTH));
        
        //获取  星期    因为星期是从周日开始的，所以获取当期星期要-1
        System.out.println(calendar.get(calendar.DAY_OF_WEEK)-1);
        
        //获取  小时
        System.out.println(calendar.get(calendar.HOUR));
        
        //获取  分钟
        System.out.println(calendar.get(calendar.MINUTE));
        
        //获取  秒
        System.out.println(calendar.get(calendar.SECOND));

输出结果：　

　　　　2019
　　　　4
　　　　2
　　　　2
　　　　8
　　　　1
　　　　48

 

7、枚举类

　　　枚举指由一组固定的常量组成的类型

　　　枚举类的好处：　　类型安全，易于输入，代码清晰

/**
 * 创建一个性别的枚举类
 * @author Administrator
 *
 */
public enum Sex {
    男,女
}

 

二、Java集合框架

　　Java集合框架位于java.util包中，提供了一套性能优良、使用方便的接口和类

 1、List接口

　　　List接口存储一组不唯一，有序（插入顺序）的对象

　　　ArrayList类实现了长度可变的数组，在内存中分配连续的空间。遍历元素的随机访问元素的效率比较高

　　　LinkedList类采用链表存储方式。插入、删除元素时效率比较高

　　ArrayList常用方法

　　　　定义一个ArrayList集合：List list = new ArrayList();

        //定义一个ArrayList集合
        List list = new ArrayList();
        
        list.add(1);    //将元素添加到集合中
        
        list.add(1, 2);     //将元素 2 插入到集合的 下标为 1 的位置
        
        list.get(1);    //返回集合中索引为 1 的元素
        
        list.indexOf(2);    //返回元素 2 在集合中出现的索引
        
        list.set(1, 3);        //将下标为 1 的元素替换为 3
        
        list.remove(1);        //删除并返回 下标为 1 的元素
        
        list.isEmpty();     // 判断 list集合是否为空    返回的是boolean类型
        
        list.contains(3);    // 判断list集合中是否包含 3  返回的是boolean类型

　　LinkedList常用方法：

　　　　定义一个LinkedList : LinkedList list = new LinkedList();

//定义一个 LinkedList集合
        LinkedList list = new LinkedList();
        
        list.addFirst(1);         //将给定元素插入当前集合头部
        
        list.addLast(5);         //将给定元素插入当前集合尾部
        
        list.getFirst();        //获取当前集合的第一个元素
        
        list.getLast();            //获取当前集合的最后一个元素
        
        list.removeFirst();        //移除并返回当前集合的第一个元素
        
        list.removeLast();        //移除并返回当前集合的最后一个元素

2、Set接口

　　set接口存储一组唯一，无序的对象

　　HashSet 是Set接口常用的实现类

•  　　HashSet允许集合元素值为null
• 　　操作数据的方法与List类似，Set接口不存在get()方法

　　定义一个Set集合 ： Set set = new HashSet();

 3、HashMap

　　HashMap 是Map接口最常见的实现类

　　存储一组成对的 键 - 值对象，提供key（键）到 value（值）的映射，通过key来索引

• 　　key不允许重复
• 　　value允许重复
• 　　添加的对象将转换为Object类型

 　　定义一个HashMap 集合 ： HashMap map = new HashMap();

    
        //定义一个HashMap 集合
        Map map = new HashMap();
        
        map.put(1, "编号");        //将互相关联的一个关键字（key）与一个值（value）放入该集合
        
        map.remove(1);            //将 key值为 1的元素移除
        
        map.get(1);                //获取与关键字key相关的值。如果该键不关联任何非null值，则返回null
        
        map.containsKey(1);     //判断集合中是否存在关键字key
        
        map.containsValue("11");     //判断集合中是否存在值value
        
        map.isEmpty();        //判断集合中是否存在元素
        
        map.clear();         //清楚集合中的所有元素
        
        map.size();            //返回集合中元素的数量
        
         Set set1 =map.keySet();    //获取所有键key的集合
         
         Collection set2 =map.values();        //获取所有值value的集合

遍历HashMap：

　　keySet()方法获取键的集合

　　values()方法获取值得集合

//定义一个HashMap 集合
        Map map = new HashMap();
        
        //循环给map集合赋值
        for(int i = 0;i<=5;i++){
            map.put(i, i*5);
        }
        
        //遍历map集合
        Set sets = map.keySet();
        
        //foreach循环
        for(Object o : sets){
            System.out.println(o +"  "+ map.get(o));
        }

 打印结果为：

　　　　 0 0
　　　　1 5
　　　　2 10
　　　　3 15
　　　　4 20
　　　　5 25

 4、Collections类

　　Collections和Collection不同，前者是集合的操作类，后者是集合接口
　　Collections提供的静态方法
　　　　sort():排序
　　　　binarySearch()：查找
　　　　fill()：替换

 

三、泛型

　　将对象类型作为参数，制定到其他类或者方法上，从而保证类型转换安全性和稳定性

　　　　本质是参数化类型

 泛型包括：

　　　　1、泛型集合　：限定集合中的数据类型，使得集合在取值时能被正确使用

　　　　2、泛型方法　：在方法中定义泛型，泛型作用在该方法上，出了方法谁也不认识。

　　　　　　　　　　　此处泛型是一个泛指，是根据实现使用时变化的数据类型

　　　　3、泛型类　　：在类中定义泛型，在类的方法或常量中就可以使用该泛型作为数据类型

　　　　4、泛型接口　：在接口中定义泛型，在接口的方法或常量中就可以使用该泛型作为数据类型。

　　　　　　　　　　　　此处泛型是一个泛指，是根据实现使用时变化的数据类型

　　　　5、多重泛型　：在定义泛型时，可以使用N个泛型变量

 泛型集合：

　　泛型集合可以约束集合内的元素类型

　　典型泛型集合 ArrayList<E>,HashMap<K,V>

　　

ArrayList<E>

public static void main(String[] args) {
        
        // ArrayList<E>  定义一个只能存放字符串类型的List集合
        List<String> list = new ArrayList<String>();
        list.add("123");        //只能向该集合中添加字符串类型的数据
        list.add("xxx");
        
        //ArrayList   定义一个没有声明泛型的List集合
        List list1 = new ArrayList(); 
        list1.add("123");    //可以装字符串
        list1.add(123);        // 数字
        list1.add(true);    //    boolean类型
    }

HashMap<k,V>

    // HashMap<K,V>   定义一个键只能存放 字符串类型， 值只能存放 integer类型的Map集合
        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("123", 111);    //key 只能是字符串类型，value只能是int类型
        map.put("adasd", 358);
        
        // HashMap   定义一个没有声明泛型的Map集合
        Map map1 = new HashMap();
        map1.put(123, 123);        //没有使用泛型来限制key value 的数据类型，所有key value 可以是任何Object对象
        map1.put(true, "123");

　　

泛型接口：

　　泛型接口就是一个或多个类型参数的接口

语法：

　　public interface 接口名<类型形参>{

　　　　方法名（类型形参 类型形参实例）；

　　}

示例：

/**
 * 创建一个泛型接口
 *
 *
 * @param <T>
 */
public interface interface1<T>{
    
    //定义一个方法  其中返回值是任意类型，参数类型也可以是任意类型的参数
    public T fun(T t);
}

/**
 * 
 * 创建一个类实现泛型接口
 *
 * @param <T>
 */
public class Demo2<T> implements interface1<T> {

    public static void main(String[] args) {
        
        Demo2 demo2 = new Demo2();
        String str =  (String) demo2.fun("123");
        System.out.println(str);
    
    }

    @Override
    public T fun(T t) {
        return t;
    }

}

控制台输出的结果为：123

泛型类：

　　　　泛型类就是具有一个或者多个类型参数的类

语法：

　　public class 类名<类型形参>{

　　　　方法名（类型形参 类型形参实例）{

　　　　　　方法执行体

·　　　　}

　　}

示例：

/**
 * 泛型类
 * 
 *
 * @param <T>
 */
public class Demo3<T> {
    
    /**
     *     有参有返回值的泛型方法 
     *     输入什么，返回什么
     * @param t
     * @return
     */
    public T fun(T t){
        return t;
    }
        
}

　　

泛型方法

　　　　泛型方法就是带有类型参数的方法

语法：

　　修饰符<类型形参> 返回值 方法名（任意对象的形参，参数）{

　　　　方法体

　　}

 

示例：

    /**
     *     有参有返回值的泛型方法 
     *     输入什么，返回什么
     * @param t
     * @return
     */
    public T fun(T t){
        return t;
    }

泛型继承

　　　　面向对象的特性同样适用于泛型类，所以泛型类也可以被继承

　　　　继承了泛型类的子类，必须也是泛型类

 语法：

　　clas 子类<T> extends 父类<T>{

　　}