6.JAVA常用类库工具

Java常用类库

java中已经预编写好的，供程序员使用的功能类

一、Object常用基础类

Java中所有数据都称为对象，Object类是所有数据类型的超级父类

Object对象的创建

Object中只提供唯一一种创建对象的构造器

public Object(){
    
}

Java中所有的引用类型对象都可以赋值给Object类型的变量

//创建User的引用类型并赋值给Object类型变量
Object user = new User();

由于对象类型的变量和引用类型不同，此对象属于上转型对象

Object类的常用方法

toString()对象转换字串符类型方法

toString方法返回一个对象的字串符形式

格式为：该对象所在包路径@该对象哈希码值转换成十六进制的整型数据

例：com.JavaSE.ClassLibrary.ObjectClass.User@1b6d3586

此方法可以被任何子类重写

toClass()对象返回包路径方法

返回此Object的运行时类。

格式：返回该对象的所在包路径

此方法不能被子类重写

equals()对象比较方法

比较当前对象是否与给定的对象等一，返回值为boolean类型数据

此方法可以被任何子类重写

例：

/*equals 方法*/
        boolean result = user.equals(user1);//比较当前对象与给定的对象是否相同
        System.out.println("user和user1对象比较结果："+result);

hashCode()返回对象哈希码值方法

返回对象的哈希码值，返回值为int类型数据

二、Integer包装类

java中定义了值类型的包装类，为了弥补基本数据类型可以使用相关属性或者方法值类型实例化操作

Integer包装类的创建

Integer属于int类型的包装类，每种基本数据类型都有一个互相兼容的包装类

数据类型包装类

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

Integer类的常用方法

常量字段

与Byte，Short，Long，Float，Double同样拥有

        /*Integer包装类提供的常量字段*/
        System.out.println("表示int类型占用多少字节："+Integer.BYTES);
        System.out.println("表示int类型占用多少位："+Integer.SIZE);
        System.out.println("表示int类型的最大值："+Integer.MAX_VALUE);
        System.out.println("表示int类型的最小值："+Integer.MIN_VALUE);

compareTo()比较方法

比较Integer对象中int值与给定的Integer对象或常量的大小比Integer对象大返回-1 比Integer对象小返回1 与Integer对象相等返回0

/*compareTo方法*/
Integer num = new Integer(100);
        Integer num2 = num;
        System.out.println("num对象与常量150比较结果："+num.compareTo(150));
        System.out.println("num对象与常量200比较结果："+num.compareTo(50));
        System.out.println("num对象与num2对象比较结果："+num.compareTo(num2));

intValue()字串符转换int方法

Integer对象包含的数值转换成int类型并返回值

/*intValue方法*/
int num3 = num.intValue();
System.out.println("Integer对象转换成int类型值返回："+num3);

parseInt()字串符转换进制方法

parseInt()中提供两种参数列表

parseInt(String s)将字符串参数解析为带符号的十进制整数
parseInt(String s,int radix)将字符串参数解析为第二个参数指定的基数中的有符号整数

parseInt()属于静态方法

/*parseInt方法*/
System.out.println("通过字串符形式转换十进制结果："+Integer.parseInt("173"));
System.out.println("通过字串符形式转换八进制结果："+Integer.parseInt("75",8));

valueOf()Integer对象返回int的实例

valueOf()与parseInt()的不同之处，自动创建Integer的实例并返回int值

valueOf()提供三种参数列表

valueOf(int a)返回Integer指定的int值的Integer实例，不需要创建新的Integer实例
valueOf(String a)返回Integer实例的字串符形式转换为int值
valueOf(String a,int radix)将字串符返回int值，根据radix提供的基数进行解析

/*valueOf方法*/
        System.out.println(Integer.valueOf(15));//构造方法1返回对象的int类型
        System.out.println(Integer.valueOf("200"));//构造方法1返回对象的字符串类型的数值
        System.out.println(Integer.valueOf("350",8));//构造方法1返回对象的字符串类型转换基数的形式

toBinaryString()int值解析为二进制字串符形式

在基数2中返回整数参数的字符串表示形式为无符号整数

类似的方法还有

toOctalString()int值解析为八进制字串符形式

toHexString()int值解析为十六进制字串符形式

此方法为静态方法

/*toBinaryString方法*/
        System.out.println("int类型解析为二进制字串符："+Integer.toBinaryString(+25));
        System.out.println("int类型解析为八进制字串符："+Integer.toOctalString(25));
        System.out.println("int类型解析为十六进制字串符："+Integer.toHexString(25));

三、Character包装类

Character构造方法

通过对象的形式调用构造器

/*character构造方法*/
        char objc = new Character('A');//通过Character实例返回char值
        System.out.println(objc);

通过类的静态方式调用构造器

/*character构造方法*/
		char objc2 = Character.valueOf('B');//通过静态方法返回char值
        System.out.println(objc2);

Character类常用实例方法

和其他包装类类似拥有的方法，只能通过对象调用

/*character的实例方法*/
        /*
        比较两个char值的大小，
        第一个参数比第二个参数大，返回1
        第一个参数比第二个参数小，返回-1
        第一个参数和第二个参数相同，返回0
         */
        System.out.println(Character.compare('a','b'));//char比较方法

        System.out.println(Character.toString('人'));//char类型返回String类型

Character类常用静态方法

返回boolean类型

isDefined() 判断字符是否为unicode字符范围：0~65533
isDigit() 判断字符是否为数字
isLetter() 判断字符是否为字母
isLowerCase() 判断字符是否为小写字母
isUpperCase() 判断字符是否为大写字母
isWhiteSpace() 判断字符是否为空格
isLetterOrDigit() 判断字符是否为数字或字母

返回char类型

toUpperCase() 将字符转换为大写字母
toLowerCase() 将字符转换为小写字母

四、System类

System一般指的是JavaJVM虚拟机，关于Java控制台的类。此类的一些方法只能被调用，不能被重写

System常用方法

System.in标准输入流，一般用在Scanner构造方法中接收控制台键盘输入
System.out标准输出流，通常使用println()方法，调用控制台打印
System.err错误输出流，一般用于输出错误信息，输出文本为红色
System.gc()启用垃圾回收器，Java尽力去回收未被使用的对象
System.exit()终止当前运行的java虚拟机操作，之后的代码不会被执行
System.getProperties()显示当前系统属性信息的集合，通过Properties类型对象接收
System.getProperty()通过给定的字串符形式的系统属性进行显示

五、String类

String类表示字串符，字串符在JVM中以常量方法储存，当String类的实例被创建后不能被更改，只能被覆盖

String类是Java中常用的引用类型，几乎所有的数据都可以用字串符来表示

String类的对象创建

构造器

public String()

String str = new String();//使用构造器创建一个空字符实例

public String(byte[] byte)

public String(char[] ch)

byte[] bytes = {1,3,4,5};
String bytearr = new String(bytes);//通过String构造方法创建含有byte数组的实例或者char数组

public String(String str)

String string = new String("我是中国人");
System.out.println(string);//创建含有字串符的实例

public String(char[] chs,int offset,int count)

char[] chars = {'w','o','r','k','e','r'};
/*从char型数组中查找并返回某一段字符，
offset是从哪开始查找的索引值
count是从offset开始查找几个字符*/
String word = new String(chars,0,4);
System.out.println(word);

String类的常用方法

charAt()方法

/**
 * charAt()方法
 * 在一段字串符中通过索引位置来这个字符用char值返回
 * @param resource 字串符变量名
 * @param index 字串符索引 从0开始
 * @return 返回索引表达的字符
 */
public static char findCharByIndex(String resource,int index){

    return resource.charAt(index);
}

compareTo()方法

/**
 * String.compareTo()方法
 * 比较两个字串符数据类型字符长度
 * @param str 第一个字串符
 * @param str2 第二个字串符
 * @return 若相同返回0 若不同返回字串符1的长度减去字串符2的长度
 */
public static int stringCompareTo(String str,String str2){
    return str.compareTo(str2);
}

equals()方法

/**
 * String.equals()方法
 * 此方法为Object类中equals方法的重写
 * 比较两个字串符中字符序列是否一致
 * @param str 第一个字串符
 * @param str2 第二个字串符
 * @return 结果为真返回true 结果为假返回false
 */
public static boolean stringEquals(String str,String str2){
    return str.equals(str2);
}

equalsIgnoreCase()方法

/**
 * equalsIgnoreCase()方法
 * 比较两个字符串中包含字符是否一致，忽略大小写的区分
 * @param str 第一个参数
 * @param str2 第二个参数
 * @return 返回true or false
 */
public static boolean stringEqualsIgnoreUpperOrLower(String str,String str2){
    return str.equalsIgnoreCase(str2);
}

startsWith()方法

/**
 * startsWith()方法
 * 判断字串符前缀是否为给定的
 * @param name 给定的字串符
 * @param prefix 判断的前缀字符
 * @return 返回true or false
 */
public static boolean validatePrefix(String name,String prefix){
    return name.startsWith(prefix);
}

endsWith()方法

/**
 * endsWith()方法
 * 判断字串符后缀是否为给定的
 * @param name 给定的字串符
 * @param suffix 判断的后缀字符
 * @return 返回true or false
 */
public static boolean validateSuffix(String name,String suffix){
    return name.endsWith(suffix);
}

trim()方法

/**
 * trim()方法
 * 去除字符串首尾的空字符
 * @param source 给定的字串符
 */
public static void stringRemoveSpace(String source){
    String result = source.trim();
    System.out.println(result);
}

split()方法

/**
 * split()方法
 * 通过输入的String类型字符作为分割符，对一组字符串进行拆分
 * regex 给定的分割符
 */
String oldStr = "猫,狗,兔子,猪,鸡";
String []newStr = oldStr.split(",");
for (String s:newStr){
    System.out.print(s +" ");	
}
System.out.println();

indexOf()方法

/**
 * indexOf()方法
 *字符串中通过输入字符查询给定字符的索引
 * @param str 给定的字串符
 * @param ch 查询索引的字符
 * @return 返回索引，若找不到返回-1
 */
public static int searchStringIndex(String str,char ch){
    return str.indexOf(ch);
}

/**
 * indexOf()方法重载
 * 字符串中通过输入字符查询给定字符的索引
 * @param str 给定的字串符
 * @param ch 查询索引的字符
 * @param fromIndex 从哪个下标开始查询
 * @return 返回索引，若找不到返回-1
 */
public static int searchStringFromIndex(String str,char ch,int fromIndex){
    return str.indexOf(ch,fromIndex);
}

subString()方法

/**
 * subString()方法
 * 返回一个字符串，该字符串是此字符串的子字符串
 * @param str 给定的字串符
 * @param beginIndex 从指定字符开始
 * param endIndex 从指定字符作为结尾，扩展中不包括结尾部分
 * @return 子字符串以指定索引处的字符开头，并扩展到该字符串的末尾
 */
public static String subString(String str,int beginIndex){
    return str.substring(beginIndex);
}

toUpperCase(),toLowerCase()方法

/**
 * 将字串符中所有的字符转换为大写或小写
 * @param str 给定的字符串
 * @param choice 输入1转换成大写否则转换为小写
 * @return 返回转换后的数组，原数组不变
 */
public static String StringToUpperOrLower(String str,int choice){
    if (choice == 1)
        return str.toUpperCase();
    return str.toLowerCase();
}

toCharArray()方法

/**
 * toCharArray()方法
 * 将字串符转换成char数组类型
 */
String str4 = "happy";
for (char arr:str4.toCharArray()){
    System.out.print(arr+" ");
}
System.out.println();

replace()方法

替换字串符中的子字符

replace(char oldChar,char newChar)

oldChar 指定一个被替换的char类型
newChar 给定替换的char

replace(String oldString,String newString)

oldString 被替换的字符串
newString 给定替换的字符串

六、StringBuilder类

相对于String类，StringBuilder类中的字串符序列是可变的，String类中的字符串是通过创建新的String变量进行更改，原字符串内的字符是不变的。StringBuilder是一个非线程安全的字符序列，与其类似的还有StringBuffer，但StringBuffer是线程同步的。在不涉及多线程应用中应使用StringBuilder，它的执行效率比StringBuffer要高，允许对某个字符串的源序列进行更改。StringBuilder的一些方法与String类通用。

StringBuilder的对象创建

StringBuilder的构造器

public StringBuilder()

构造一个没有字符的字符串构建器，初始容量为16个字符。

public StringBuilder(int capacity)

构造一个没有字符的字符串构建器，由 capacity参数指定的初始容量

public Stringbuilder(String str)

构造一个初始化为指定字符串内容的字符串构建器。

public StringBuilder(CharSequence seq)

构造一个包含与指定的相同字符的字符串构建器 CharSequence

StringBuilder的常用方法

public StringBuilder append(Object obj)

追加Object参数给字符串，附加在对象字符串的后面

参数：任意一种数据类型

结果：对这个对象的引用

方法案例

/**
 * append()方法
 * 将指定的字符串附加到此字符序列的后面
 * @param strings 需要附加的字符串数组
 * @param str 给定被覆盖的字串符
 * @return 返回一个字符串
 */
public static String appendString(String str,String []strings){
    StringBuilder builder = new StringBuilder(str);//创建可变的字符串存储对象

    for (String s:strings){
        builder.append(s);//每遍历一个元素就附加在字符串后面
    }
    return builder.toString();
}

public StringBuilder deleteCharAt(int index)

通过给定的char的索引位置，删除该char值

参数：要删除的char索引

结果：返回这个对象

方法案例

/**
 * deleteCharAt()方法
 * 删除在字符串序列中的所有的空格，并返回String类型
 * @param target 给定的字符串
 * @return 返回string类型
 */
public static String deleteSpeace(String target){
    while(target.contains(" ")){//判断target中是否有空格
        StringBuilder builder = new StringBuilder(target);
        int index = builder.indexOf(" ");//查找字符串中空格的索引
        builder.deleteCharAt(index);//删除builder中的空格
        target = builder.toString();//重新赋值给目标字符串
    }

    return target;
}

public StringBuilder delete(int start,int end)

删除该字符串中一段字符，给定开始删除和结束-1索引位置的字符，若start等于end，则不做处理

参数：start 最开始删除的字符位置 end 删除结束的字符位置，此位置保留

public StringBuilder insert(int offset,Object obj)

将Object参数的字符串表示插入到此字符序列中。

参数：offset 表示第几个字符后面的位置，offset为0表示第一个字符的前面插入

public StringBuilder replace(int start,int end,String str)

用指定的String中的字符替换此序列的子字符串中的String 。子串开始于指定start并延伸到字符索引end - 1 ，或如果没有这样的字符存在的序列的结束。第一子串中的字符被去除，然后指定String被插入在start 位置之后

public StringBuilder reverse()

反转字符串中的字符序列

public void setLength(int newLength)

设置字符序列的长度，长度以外的字符全部舍弃。该序列被更改为一个新的字符序列，其长度由参数指定。

参数：

如果newLength参数大于或等于当前长度，则会附加足够的空字符（ '\u0000' ），以使长度成为newLength参数。

newLength参数必须大于或等于0 。

public void setCharAt(int index,char ch)

通过索引位置修改字符，从而改变一个字符序列。

参数：index 要修改的字符索引 ch 一个新的字符

索引参数必须大于或等于0 ，并且小于此序列的长度。

七、Date类

java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象

Java的JVM系统中的时间系统，用毫秒进行计时

Date对象的创建

Date构造器

public Date()

第一个构造函数使用当前日期和时间来初始化对象

public Date(long date)

第二个构造函数接收一个参数，该参数是从 1970 年 1 月 1 日起的毫秒数。

Date类常用方法

after()和before()

/**
 * after()方法，判断调用此方法的Date对象是否比给定的Date对象中的时间转为毫秒要大
 * before()方法，判断调用此方法的Date对象是否比给定的Date对象日期要小
 * @param date1 调用此方法的对象
 * @param date2 要判断的目标对象
 * @return 返回boolean
 */
public boolean dateAfterAntherDate(Date date1,Date date2){
    return date1.after(date2);
}
public boolean dateBeforeAntherDate(Date date1,Date date2){
    return date1.before(date2);
}

compareTo()

/**
 * 使用该方法的对象与给定的对象进行比较
 * @param date 调用此方法的对象
 * @param date2 要判断的目标对象
 * @return 返回int值 若大返回1，相同返回0，若小返回-1
 */
public int DatecompareTo(Date date,Date date2){
    return date.compareTo(date2);
}

getTime()和setTime()

/**
 * getTime()方法，将Date对象的日期换算成从1970年1月1日到现在的毫秒
 * @param date 给定的Date对象
 * @return 返回long
 */
public long dateTomillisecond(Date date){
    return date.getTime();
}

/**
 * setTime()方法，给Date对象设置一个毫秒数换算成Date日期格式的时间
 * @param date 给定的Date对象
 * @param millisecond 需要设置的毫秒数
 */
public void dateSetMillisecond(Date date,long millisecond){
   date.setTime(millisecond);
   String strDate = new SimpleDateFormat("yyyy/MM/dd").format(date);
    System.out.println("毫秒换算成Date对象的日期格式："+strDate);
}

DateFormat类

也称日期格式化类

Date类中大部分方法由DateFormat类中的方法所替代。Datemat是Date的一个子类，而且是一个抽象类。

DateFormat构造方法

public DateFormat()

创建一个日期格式

SimpleDateFormat类

是一个以语言环境敏感的方式来格式化和分析日期的类，DateFormat类的子类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行。

SimpleDateFormat对象的创建

使用日期格式化类将Date对象以字符串的形式获取系统时间

        Date date = new Date();//创建Date类的对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");//自定义格式
        System.out.println(sdf.format(date));//将Date对象按照自定义日期格式

format()方法

Date对象类型转换成字符串类型

通过用户输入获取日期到Date对象

		System.out.println("请输入员工生日");
        System.out.println("请输入生日年份");
        int year = input.nextInt();
        System.out.println("请输入生日月份");
        int month = input.nextInt();
        System.out.println("请输入生日天数");
        int day = input.nextInt();

        String birStr = year+"-"+month+"-"+day;//String类型的日期格式与simpleDate自定义格式要相同

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //DateFormat df = DateFormat.getDateInstance();不同计算机的日期格式不同，所以调用simple的子类格式化类
        TestSimple ts = new TestSimple();

        Date birth = null;
        try {//使用try catch进行异常捕获
            birth = sdf.parse(birStr);//使用parse方法字符串类型转换成Date类型，这个日期格式是Date默认的日期格式

        } catch (ParseException e) {
            e.printStackTrace();
        }

parse()方法

字符串类型的日期格式转换为Date对象类型的日期格式，日期使用的格式要一致。

八、Calendar类

是一个抽象类，不能通过实例进行访问

Calendar类对象的创建

		/*使用日历类的静态方式调用默认时区当前系统的时间*/
        Calendar cal = Calendar.getInstance();//Calendar是一个抽象类

        int year = cal.get(Calendar.YEAR);//使用get方法调用日历的日期常量
        int month = cal.get(Calendar.MONTH+1);//北京时区的月份需要+1
        int day = cal.get(Calendar.DATE);
        System.out.println(year+"/"+month+"/"+day);

        /*获取当前日历所对于的Date对象*/
        Date date = cal.getTime();//getTime方法将Calendar对象的当前时间换算为Date对象的当前时间
        String beijingTime = new SimpleDateFormat("yyyy/mm/dd HH:mm:ss").format(date);
        System.out.println("当前北京时间："+beijingTime);

使用Calendar的实例方法get

可以获取当前系统时间表示年，月，日的常量字段

Calendar类主要的常量字段

public static final int AM

AM的值表示从午夜到中午之前的一天中的一段时间。

public static final int PM

pm表示从中午到午夜之前的一天中的一段时间。

public static final int YEAR

表示日历中的年

public static final int MONTH

日历中当年的月份，从0开始

public static final int DATE

日历中当月的一天，从1开始

public static final int HOUR

日历12小时制从0到11

public static final int HOUR_OF_DAY

日历24小时制

public static final int MINUTE

表示一小时中的一分钟

public static final int SECOND

表示一分钟的一秒

public static final int MILLSECOND

表示一秒中的一微秒

Calendar类常用方法

add()方法

/**
 * add()方法
 * 改变Calendar变量中DATE字段的时间
 * @param cal 给定的对象
 * @param value 增加的值
 * @return 返回Date类型
 */
public Date addCalendar(Calendar cal, int value){
    cal.add(Calendar.DATE,value);
    return cal.getTime();//Calendar类型转换为Date对象
}

after()和before()方法

/**
 * after()方法和before()方法
 * 日期相关属性进行比较
 * @param cal 调用该方法的对象
 * @param cal2 给定比较的对象
 * @return 返回boolean
 */
public boolean calAfter(Calendar cal,Calendar cal2){

    return cal.after(cal2);
}

public boolean calBefore(Calendar cal,Calendar cal2){
    return cal.before(cal2);
}

public final Date getTime()

获取日历中时间返回Date对象

public void set(int field,int value)

设置日历中某个常量字段为给定的时间

九、Math类

Math类包含执行基本数字运算的方法，如基本指数，对数，平方根和三角函数。

Math类常用字段

public static final double E

double值比其他任何一个更接近 e ，自然对数的基数。

public static final double PI

double值比任何其他的更接近 pi ，圆周长与其直径的比率。

Math类常用方法

abs() 求某个值的绝对值

cbrt() 求某个值的立方根

ceil() 返回大于或等于某个值的最小整数

floor() 返回小于或等于某个值的最大整数

max() 比较两个值并返回最大的那一个

min() 比较两个值并返回最大的那一个

pow() 计算某个值的幂运算

random() 返回一个随机的带正号的值，范围在0.0~0.9之间

十、List接口

其父接口是Collection，List接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。

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

List作为集合接口，提供动态储存多个元素的功能，通过集合子接口或实现类进行操作。

接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象
实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

List接口提供的常用方法

public abstract int size()

返回集合的大小，返回一个int值

public abstract Object get(int index)

返回此集合中指定位置的元素，返回Object对象

void add(Object obj)

给调用此方法的集合追加一个obj

void add(int index,Object obj)

将指定的项目添加到指定的索引位置

void clear()

清除当前集合中的所有元素

boolean contains(Object obj)

如果此列表包含指定的元素，则返回真

Object get(int index)

返回指定位置的项目

boolean isEmpity()

判断当前元素是否为空

Iterator<E> iterator()

使用List集合中的Iterator迭代器

boolean remove(Object obj)

从集合中删除指定元素

Object remove(int index)

删除该集合中指定位置的元素

Object set(int index,Object obj)

替换当前集合中指定位置的元素

Object [] toArray()

将集合转换为Object类型数组并返回

ArrayList集合实现类

是List集合接口中大小可变数组的功能实现类

此实现类是用于非线程安全的，在不进行多线程的操作时效率较快

ArrayList类对象的创建

通过ArrayList实现类创建List类型的集合,创建集合父类类型的对象便于获取更多功能

List list = new ArrayList();

Iterator迭代器

Iterator迭代器的创建

Iterator iterrator = arrList.iterator();//通过创建一个List集合实例来构建迭代器

Iterator迭代器的常用方法

boolean hasNext()

判断一个集合中是否有下一个元素，若有返回true

next()

返回集合中的下一个元素

Vector集合实现类

称为向量集合。与ArrayList很相似，处理数据的效率较低，常用于多线程安全的使用

Vector集合具备ArrayList集合中的所有方法

Vector对象的创建

Vector vector = new Vector();

Enumeration元素枚举迭代器

只能使用Vector的实例进行创建，是Vector的独有方法

Enumeration enu = vector.element();

使用枚举迭代器遍历某个集合的元素

	/*使用枚举迭代器遍历输出元素*/
        while(enu.hasMoreElements()){//类似于hasNext()是否有下一个元素返回true
            Object obj = enu.nextElement();//类似next() 返回下一个元素
            Student temp = (Student) obj;
            System.out.println(temp.getName()+temp.getSex()+temp.getAge());
        }

十一、Set接口

Set 具有与 Collection 完全一样的接口，跟List接口类似，都是Collection的子接口。

Set 中储存的元素都是无序的，唯一的。

若传入的对象引用地址一致时，将原来的对象进行替换，保持集合的长度不变

HashSet 是无序的，即不会记录插入的顺序。

HashSet 不是线程安全的，如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。

HashSet集合实现类

HashSet对象的创建

Set hashset = new HashSet();//通过Set的实现类创建一个无序的集合

HashSet由于是无序的集合，所以只能使用Iterator迭代器进行元素遍历

TreeSet集合实现类

该类实现Set接口，可以为对象实现排序功能

创建TreeSet的对象

TreeSet集合对象的创建（默认排序方式）

TreeSet objectSort = new TreeSet();

默认构造器，为添加的对象从小达到进行排序

TreeSet集合对象的创建（自定排序方式）

TreeSet objectSort new TreeSet(Comparator comparator);

调用Comparator接口的自定义实现类

实现类重写Comparator接口中的compare抽象方法

abstract int compare(Object o1,Object o2)

自定义的排序方法
@param o1 相邻的第一个对象
@param o2 相邻的第二个对象
@return 返回-1,1和0

TreeSet的常用方法

调用DescendingIterator降序迭代器

		Iterator descendingSort = objectSort.descendingIterator();//通过集合调用降序迭代器方法

        /*使用降序迭代器进行遍历*/
        System.out.println("DescendingIterator迭代器");
        while(descendingSort.hasNext()){
            System.out.print(descendingSort.next()+"\t");
        }

public E last()

返回集合最后一个元素

public E first()

返回集合第一个元素

LinkedHashSet集合实现类

具有可预知迭代顺序的 Set接口的哈希表和链接列表实现

集合中的元素按照对象录入顺序进行排列

根据具体的业务需求来决定使用HashSet集合还是LinkedHashSet集合

十二、Map接口

Map 接口存储一组键值对象，提供key（键）到value（值）的映射。

value需要通过key进行访问，并且Map接口是无序的。

HashMap集合实现类

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

HashMap 是无序的，即不会记录插入的顺序，不支持线程同步

HashMap常用方法

void put(Object key,Object value)

添加定义一对键值对象

Value get(Object key)

集合中通过键对象返回值对象

Set keySet()

获取当前Map集合中所有的键对象返回一个Set集合类型

Collection values()

获取当前Map集合中所有的值对象返回一个Collection接口类型

boolean containsKey()和containsValue()

判断当前集合中是否包含给定的key或value

void remove()

清空当前集合中的所有键和值对象

TreeMap集合实现类

此类是对Map接口的实现类，具有排序功能

与TreeSet集合类似，可以通过调用Comparator接口的实现类作为参数进行自定义排序

TreeMap类的常用方法与HashMap类似

TreeMap不是线程安全的，在多线程中需要手动处理同步的问题

Hashtable集合实现类

和HashMap的用法类似，最大的区别是HashTable是支持线程同步，HashMap是非线程同步的

在实际的开发当中可以使用Hashtable替代实体对象作为模板，减少类的定义

public class TestHashtable {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        /*使用Hashtable代替实体模板类定义对象*/
        List emList = new ArrayList();//用于存放对象的集合

        System.out.println("请输入员工的基本信息");

        for (int i = 1; i <= 3 ; i++) {
            Map employeeMap = new Hashtable();//定义一个Hashtable局部对象用于信息
            System.out.println("请输入第"+i+"个员工的信息");
            System.out.println("请输入员工的姓名");
            String name = input.next();
            employeeMap.put("name",name);//key代替实体类私有属性的类型，value为输入的信息
            System.out.println("请输入员工的性别");
            String sex = input.next();
            employeeMap.put("sex",sex);
            System.out.println("请输入员工的年龄");
            int age = input.nextInt();
            employeeMap.put("age",age);

            emList.add(employeeMap);//将Map集合对象添加到Set集合对象中
        }
        for (Object m:emList){
            Map temp = (Hashtable)m;//Object转换成HashMap对象
            System.out.println(temp.get("name")+"\t"+temp.get("sex")+"\t"+
                    temp.get("age")+"\n");
        }
    }
}

十三、Java泛型

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

泛型的基本语法

//对ArrayList使用泛型限制，只能添加Set的类型
List<Set> arrList = new ArrayList<>();

泛型通配符

/*泛型通配符*/
    List<Integer> arrayList = new ArrayList<>();//表示Set集合只能存储Integer类型

    List<String> arrayList2 = new ArrayList<>();//表示List集合中只能存储String类型

    List<?> list = new ArrayList<>();//此集合使用通配符泛型

    arrayList.add(new Integer(100));
    arrayList.add(new Integer(200));

    list = arrayList;//此时list中支持存放Integer类型

    for (Object i:list){//由于此时的泛型为动态，所以循环遍历只能接收Object类型
        System.out.println(i);
}

list = arrayList2;//此时list支持存放String类型

arrayList2.add("姓名");
arrayList2.add("年龄");

for (Object s: list){
    System.out.println(s);
}

集合的泛型应用

/*静态泛型*/
//对ArrayList使用泛型限制，只能添加Set的类型
List<Set> arrList = new ArrayList<>();

Set<Student> stuSet = new HashSet<>();

Student stu0 = new Student();
stu0.setName("Lucy");
stu0.setAge(21);

Student stu2 = new Student();
stu2.setName("James");
stu2.setAge(24);

//当前集合使用泛型指定数据类型，该集合的方法也只能使用这个类型进行传参
stuSet.add(stu0);
stuSet.add(stu2);

arrList.add(stuSet);

//使用泛型语法的集合不必再通过Object强转数据类型
for (Student s:stuSet){
    System.out.println(s.getName()+"\t"+s.getAge()+"\n");
}

类的泛型应用

/*静态泛型*/
//对ArrayList使用泛型限制，只能添加Set的类型
List<Set> arrList = new ArrayList<>();

Set<Student> stuSet = new HashSet<>();

Student stu0 = new Student();
stu0.setName("Lucy");
stu0.setAge(21);

Student stu2 = new Student();
stu2.setName("James");
stu2.setAge(24);

//当前集合使用泛型指定数据类型，该集合的方法也只能使用这个类型进行传参
stuSet.add(stu0);
stuSet.add(stu2);

arrList.add(stuSet);

//使用泛型语法的集合不必再通过Object强转数据类型
for (Student s:stuSet){
    System.out.println(s.getName()+"\t"+s.getAge()+"\n");
}

接口的泛型应用

public interface<T> Interfaces{
    //当具备泛型的接口指定了一个类型，则该接口的抽象方法被调用时只能限用与此类型
}

十四、Exception异常类

一、什么是异常

在实际工作中，程序的功能并不是完美的。会在运行的过程中遇到各种各样的原因导致程序的中止。

例如：

创建模块时，用户并没有按照代码的要求输入

程序打开某个文件时，找不到文件或者文件格式不符

程序运行的过程中，内存或硬盘被占满等等

到遇到以上这些不致命的问题时，我们可以选择抛出并捕获异常，写上解决异常的代码，从而保证程序能够顺利跑起来

二、异常体系结构

为了能够避免和处理在编程中所遇到的异常，Java将这些异常作为对象，按照异常种类的不同定义不同的类，并定义一个java.lang.Throwable作为所有异常的超类。

Java异常分类结构图

Throwable为异常的顶层父类，在异常超类往下细分为Error类和Exception类

Error类：此类异常是通过Java虚拟机发出的错误，不能被代码处理，不会在编译阶段被发现，运行中出现此类异常会导致JVM直接终止程序。
Exception类：此类在程序运行中发生错误，可以通过代码进行捕获并处理，异常捕获后程序会继续运行。

根据Java处理异常方式的不同，可以把异常分类

运行时异常

包括Error（错误）和RuntimeException（运行时异常）。

这些异常发生后编译还是正常通过了，可以使用（try...catch...finally）代码处理，也可以忽略。产生这些异常绝大部分为代码的原因，应当修正代码。

编译型异常

Error和RuntimeException之外的全部异常。

这些异常必须被处理，否则会导致编译不通过。

异常案例：整数除以0出现的算数异常类型

计算代码如下：

在此代码中，给a变量赋予任意一个整数，给b变量赋予0时，则会发生算数类型异常，属于检查性异常。

当检查到代码中出现了异常后，系统会首先找出异常的抛出点所在的进程并显示出受影响的进程，这种结构称为异常追踪栈。

三、异常的抛出和捕获

异常的声明和抛出

可以将方法中的运行时才能发现的异常在编译时查询到

语法格式：

/**
 * 定义一个方法并将方法中异常进行抛出
 * 在编译阶段就能发现不符合要求的异常
 * @param length 方法参数
 * @return 返回一个数组长度
 * @throws Exception 声明的异常类型
 */
public static int displayArr(int length) throws Exception{//多个异常类型需要用逗号分开

    int[] ints = new int[length];
    if (length <= 0)

        //抛出的异常实例，必须与声明的类型相同或是其子类，构造方法中可以自定义异常提示
        throw new Exception("数组的长度不能为0或负数");
    return ints.length;
}

异常处理的基本语法

为了避免代码中发生不可预见的异常时，通过try-catch-finally等操作，来处理程序出现异常的情况。