Java API 之集合

1. 包装类

（基本类型中没有多少我们能够使用的方法和属性，为了便捷我们需要自己去写）

针对每一种基本类型提供了对应的类的形式 --- 包装类

 

byte	short	int	long	float	double	char	boolean	void
Byte	Short	Integer	Long	Float	Double	Character	Boolean	Void

void 是一个最终类，不能被实例化。

 

 

 

package cn.tedu.baozhuang;

public class IntegerDemo1 {

    public static void main(String[] args) {

        int i = 7;
        //封箱
        Integer in = new Integer(i);

        //自动封箱,都是 JDK1.5 的特性
        //其实就是在底层默认调用 Interger 类身上的静态方法 valueOf，Double Boolean 这些也是这样的！！
        //Integer in2 = Integer.valueOf(i);
        Integer in2 = i;

        Integer in3 = new Integer(5);
        //自动拆箱，在底层调用对象身上的 IntegerValue()
        //in3.IntegerValue();
        int i3 = in3;

    }
}

 

当把基本类型的变量直接赋值给对应的引用类型的对象，--- 自动封箱，底层是调用了对应类身上的 valueOf() 方法

当把引用类型的对象直接赋值给对应的基本类型的变量，---自动拆箱，底层是调用了对应类身上的***Value() 方法，

 

package cn.tedu.baozhuang;

public class IntegerDemo2 {

    public static void main(String[] args) {

        //Integer i1 = Integer.valueOf();
        //如果这个值不在 -128~127 底层的 valueOf() 调用构造方法 new 一把，返回一个新对象！！！
        //如果在 -128~127,从 cache 数组中对应下标位置上取值。
        Integer i1 = 50;
        Integer i2 = 50;

        System.out.println(i1 == i2);

        Integer in = 400;
        int i = 400;
        //包装类和基本类型比较时，会进行自动拆箱成基本类型
        System.out.println(in == i);

    }

}

四种整数型都有范围判断（-128~127），float 就没有，直接 new 了！

 

 

注意：凡是 Number 的子类都会提供将字符串转化为对应类型的构造方法

 

 

 

包装类产生的对象的哈希码是固定的，不随环境改变。

 

注意：字面量的哈希码不随环境不随系统而改变

 

 

 

2. 数学类

（是在代码中调用 Java 中写好的数学类）

 

Math --- 最终类，针对基本类型提供了基本的数学运算

BigDecimal --- 能够精确运算，要求参数以字符串形式传递

 

几个比较重要的方法对应如下代码：

package cn.tedu.math;

import java.util.Random;

public class MathDemo1 {

    public static void main(String[] args) {

        System.out.println(Math.abs(-5.86));
        //求立方根
        System.out.println(Math.cbrt(8));

        //向上取整，返回一个double 类型的数据
        System.out.println(Math.ceil(4.06));

        //向下取整，都是返回double 类型的
        System.out.println(Math.floor(4.06));

        //四舍五入,返回一个 long 类型的
        System.out.println(Math.round(3.68));

        //返回一个[0,1)的一个随机小数
        System.out.println(Math.random());

        //获取 30-90 一个随机整数
        System.out.println((int)(Math.random()*61+30));

        //获取 0-30的数，只能是整数
        Random r = new Random();
        System.out.println(r.nextInt(30));

        //抽奖系统,实际上要考虑权重问题（就是让那种经常到这里消费的人的概率高一些）
        if(Math.random() * Math.random() > 0.95){
            System.out.println("亲，恭喜你中奖啦！");
        }
    }

}

两个很大的数相乘，用一个数组存放。

int[ ] arr1 = new int[ n ];

int[ ] arr2 = new int[ n ];

int[ ] result = new int[ 2*n ];

 

for(int i = 0; i < n; i++){

    for(int j = 0;  j < n; j++){

        int r = arr1[i] * arr2[j] + result[ i+j ];//是一个暂时的数，用于后面分别存放，是i+j位的数（其实就是上一位的 i + j +1 位）

        result[ i+j ] = r % 10;  //表示第 i + j 位的结果

        result[ i+j+1 ] = r / 10; //表示第 i + j + 1 位结果，用于表示进位

    }

}

 

3. Calender --- 抽象类

 

JDK1.8的特性：简书，51CTO，是以讹传讹，自己试试是不是正确。最准确的是别人的官网！！

Map<String, Integer> map = {"a":1, "b":2};   //别人说都没有说

package cn.tedu.time;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class DateDemo {

    public static void main(String[] args) throws Exception {

        //获取当前时间
        System.out.println(new Date().toString());

        //获取指定时间
        //这个方法在 1990-01的基础上进行累加
        @SuppressWarnings("deprecation")
        //压制警告
        //这个方法已过时
        Date date = new Date(2000,2,9);
        System.out.println(date);

        //将字符串转化为日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date1 = sdf.parse("2000-12-15 18:58:45");
        System.out.println(date1);

        //将日期转化为字符串
        //XX年XX月XX日
        SimpleDateFormat sdf2 = new SimpleDateFormat("yy年MM月dd日 HH时mm分ss秒");
        String str = sdf2.format(date1);

        //格里高利历（GregorianCalendar），毫秒值（time=1534494939307），偏移量---表示当前时期到零时区的毫秒值（offset=28800000）
        //WEEK_OF_MONTH=3(不完全周) DAY_OF_WEEK_IN_MONTH=3
//        Calendar 

    }

}

 

1. 时间包

在 JDK 1.8 中对时间体系进行了全新的详细的划分，LocalDate，LocalTime

 

 

 

 

 

package cn.tedu.time;

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class LocalDateDemo {

    public static void main(String[] args) {

        //LocalDate 是一个只包含日期，不包含时间
        LocalDate date = LocalDate.now();
        System.out.println(date);

        //
        LocalDate date1 = LocalDate.of(2014, 7, 8);

        //向后加几个
        System.out.println(date.plus(7,ChronoUnit.WEEKS));//表示周
        System.out.println(date.minus(8,ChronoUnit.MONTHS));

        System.out.println(date1.getDayOfMonth());

        //在某一个日期的后面吗
        System.out.println(date1.isAfter(LocalDate.now()));

        //判断闰年
        System.out.println(date1.isLeapYear());

    }

}

2. 异常

ArithmeticException    --- 运行时异常（比如 1/0）

ArrayIndexOutOfBoundsException  ---（数组下标越界），运行时异常（a[10]）

NullPointerException ---- 运行时异常（str=null ,str.length()）

ClassCastException  --- 运行时异常（String str = (str)o;）

StringIndexOutOfBoundsException  ---运行时异常

NumberFormatException   ---运行时异常(new Integer("abc"))

CloneNotSupportedException --- 编译时异常（new ExceptionDemo().clone()）

UnSupportedEncodingException --- 不支持编码异常（在getBytes() 中就是这样，要抛异常）--- 编译时异常（"abc".getBytes("abc");）

ParseException(在simpledateFormat() 参数没有指定时间格式) --- 编译时异常(new simpleDateFormate("yyyy").parse("2012");)

       

　　---异常是 Java 中用于问题处理的一套逻辑

 

运行时异常非得来处理一下，就使用try-catch(){} 捕获一把！！

 

throws PathNotExistException  //告诉调用方法的对象，

 

2.1 Throwalbe --- 异常的顶级父类

        Error --- 错误表示合理（无论在语法上还是在逻辑上都是正确的）的应用程序中出现了严重的问题，而且这个问题不应该试图捕获。 --- 意味着错误一旦出现不能处理。 --- StackOverflowError(递归层次太深，超过了范围)，OutOfMemory(堆内存的分配上) 是在虚拟机错误的子类！！

        Exception --- 表示合理的应用程序想要捕获的问题，也因此可以处理。

            编译时异常：在编译时期就已经出现要求处理。必须处理。

            运行时异常：在运行时期出现要求处理。可以处理可以不处理  --- RuntimeException （运行时异常的小父类）

2.2 异常捕获方式

A. 如果多个异常的处理方式各不一样，可以使用多个catch分别捕获分别处理

B. 如果多个异常的处理方式是一样的，可以捕获它们的父类来进行处理

C. 如果多个异常进行了分组，那么同一组的异常之间用 | 隔开进行分组处理 --- 从 JDK1.7 开始（一个分组处理的过程，一个 catch 中写两个异常，中间用 | 分开就行）

（注意：如果先捕获了父类，那么它的子类不能捕获，所以要先子后父）

 

总结：方法的重载和方法的重写

重载：方法名相同，参数列表不同，可以有抛出所有的异常

重写：方法名，参数列表相同，方法体不同，只能抛出比父类范围更小的异常。

方法的重载和重写都是行为多态。

方法重载是指在同一个类中，方法名一致而参数列表不同的方法，和修饰符、返回值类型以及异常没有关系。重载本身是一种编译时多态。

方法的重写指在父子类中存在方法签名一致的非静态方法。子类在重写父类方法的时候，子类权限修饰符的范围要大于等于父类的权限修饰符的范围。如果父类中的方法的返回值类型的基本类型

 

注意：异常一旦抛出，后面的代码就不再运行。主方法中处理了就接着执行下面的代码（主函数是 jvm 调用，相当于把异常抛给了 jvm，会打印栈轨迹）。

（看栈轨迹：先看异常的名字（Number），再看冒号后面的那个异常信息（告诉你什么出错了），接着看一个异常的栈轨迹（你写的一个代码，调用别人的，别人再调用别人的，最后在java最底层，你是最后一个拿到的，所以栈轨迹首先出现的是在 Java 底层。你能够改的是你自己的，所以要栈轨迹要倒着看））e.printStatckTrace() //打印栈轨迹

 

finally  (读文件无论成功与否，都要将文件关闭) --- 无论出现异常与否都要执行一次

 

如果在项目开发期间遇到异常，记录栈轨迹，找异常来源进行改正；如果项目已经上线，记录错误日志（是记录项目运行信息的，在某个链接上卡死，为后续统一工作提供参考），往往跳转错误页面（点进去就网页丢失了，）

 

3. 集合  ---  Collection

（购物车，把东西加到购物车中，每个人买的东西不一样，容器也不一样）

存储多个统一类型的数据的容器 --- 大小不固定

 

3.1 <E> - 泛型 - 在集合中的作用是用于表示元素类型。- 由于泛型的限制，集合中只能存储对象。

String[] arr; arr 的数据类型是数组，元素类型是String

Collection<String> c; c 的数据类型是集合，元素类型是 String。

 

Collection<int[]> c; --- 表示集合中存储的是数组。int[] 是一个引用类型，也是对象。

 

3.2  List - 列表

有序（保证元素的存入顺序）的集合。怎么放就怎么拿出来。 --- 存在了下标，因此能够通过下标来操作这个列表。

package cn.tedu.collection;

import java.util.ArrayList;
import java.util.List;

public class ListDemo {

    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();

        //保证元素的存入顺序
        list.add("xiaofang");
        list.add("daqiang");
        list.add("weichang");
        list.add("dadaxu");

        //截取子列表

        //获取指定元素在列表中第一次出现的位置

        //遍历这个列表，是size
        for(int i = 0; i < list.size(); i++)
            System.out.println(list.get(i));

        //向列表的指定的下标插入指定的元素，原位置就移到下一个位置上了，
        //放在元素末尾，就是追加了，可以的，但是不能向末尾后面增加，不然就数组下标越界异常！！（移除超过了也会报这个异常）
        list.add(2,"插入了");
        System.out.println(list);

        //替换指定位置上的元素，移除这个再插入一位，也有自己的set
        list.set(2,"替换了");
        System.out.println(list);

        //比较两个列表的时候是逐位比较是否一致，元素中是new String("xiaoqiang")也是正确的！！

    }

}

 

3.2.1 ArrayList - 顺序表

 

异常的顶级父类是 Throwable。

异常的捕获方式：多个catch；捕获父类，统一处理；将同一组异常之间用 | 隔开，分组处理 --- JDK1.7

 

1. List<E>中的元素是可以重复的。

1.1 ArrayList 扩容是增加一半，是通过右移实现的。增删操作相对复杂，查询操作相对简单。内存空间是连续的。是一个线程不安全的列表！！

 

1.2 LinkedList - 链表

基于节点（Node）来实现的。利用节点来存储数据以及维系链表之间每一个节点的关系。增删操作相对简单，查询操作相对复杂。内存空间不连续。随用随开辟，不需要初始容量。是一个线程不安全的。

 

 

2. Vector - 向量

最早的列表，依靠数组存储数据，初始容量默认是10。每次扩容默认增加两倍（也可以默认初始和增量）。是一个线程安全的列表。

elements() 返回迭代器（一个集合中有很多的元素，通过下标遍历是间接的过程，Java中提供了直接获取的方法，就是这个迭代器）

迭代器：创建指针，通过指针的移动就获取那个元素，指定谁谁就上。每挪动一次，都要判断 hasMoreElements()，找下一个是 nextElement()（候诊室叫号，有人的话就叫下一个）？？nextElement()

关于 nextElement() 查看API文档得知是返回这个元素的下一个元素，因为之前在 while 循环中判断了后面是否还有元素，所以在这一步是到不了最后那个元素的，所以不用考虑。

又去百度了一下，说的是nextElement() 如果 Enumeration 中是第一个元素，就取这个，接着联合 hasMoreElement()可以一次取下一个元素。

 

2.1 Stack - 栈

继承了Vector。遵循后进先出/先进后出的原则。（比如往盒子里放东西，从上往下挪，最后诺进去的东西就先拿出来）。最先放入栈中的元素 ---栈底元素，最后放入栈中的元素 --- 栈顶元素。将元素放入栈中 --- 入栈/压栈，将元素从栈中取出 --- 出栈/弹栈。

练习：使用数组/节点完成一个Stack --- empty peek pop push search

 

3. Set - 散列集合

包含的元素不重复。

 

3.1 HashSet

不包含重复的元素，不保证元素的存储顺序。底层基于HashMap来进行数据的存储。默认初始容量是16，默认加载因子是 0.75f。

HashMap 底层是基于数组 + 链表结构

 

 

3.2 TreeSet - 对元素进行整体的自然排序（升序），需要这个元素对应的类实现 comparable 接口

 

Comparator --- 用于给某个对象单独指定规则。