常用API,基本类型包装类,日期类,异常,集合进阶,IO流,多线程

​

十九.常用API

19.1Math

Math包含执行基本数字运算的方法

没有构造方法，如何使用类中的成员呢?

看类的成员是否都是静态的，如果是，通过类名就可以直接调用公

19.1.1 Math的常用方法

绝对值

public class MathDemo {
    public static void main(String[] args) {
        //public static int abs(int a) :返回参数的绝对值
        System.out.println(Math.abs(88));
        System.out.println(Math.abs(-88));
    }
}
//88
//88

返回大于或等于参数的最小double值，等于一个整数

public class MathDemo {
    public static void main(String[] args) {
        ///public static double ceil(double a):返回大于或等于参数的最小double值，等于一个整数
        System.out.println(Math.ceil(12.34));
        System.out.println(Math.ceil(12.56));
    }
}
//13.0
//13.0

返回小于或等于参数的最大douple值，等于一个整数

public class MathDemo {
    public static void main(String[] args) {
        //public static double floor(double a):返回小于或等于参数的最大douple值，等于一个整数
        System.out.println(Math.floor(12.34));
        System.out.println(Math.floor(12.56));
    }
}
//12.0
//12.0

按照四舍五入返回最接近参数的int

public class MathDemo {
    public static void main(String[] args) {
        //public static int round(float a):按照四舍五入返回最接近参数的int
        System.out.println(Math.round(12.34f));
        System.out.println(Math.round(12.56f));
    }
}
//12
//13

返回两个int值中的较大值

public class MathDemo {
    public static void main(String[] args) {
        //public static int max(int a,int b):返回两个int值中的较大值
        System.out.println(Math.max(9,12));
    }
}
//12

返回两个int值中的较小值

public class MathDemo {
    public static void main(String[] args) {
        //public static int min(int a,int b):返回两个int值中的较大值
        System.out.println(Math.min(9,12));
    }
}
//9

返回a的b次幂的值

public class MathDemo {
    public static void main(String[] args) {
       //public static double pow (double a , double b):返回a的b次幂的值
        System.out.println(Math.pow(2.0,3.0));//2^3

    }
}
//8.0

返回值为double的正值，在[0.0,1.0)之间

public class MathDemo {
    public static void main(String[] args) {
        // public static double random ():返回值为double的正值，[0.0,1.0)
        System.out.println(Math.random());
    }
}
//0.7355578370042718
//随机数[0.0,1.0)

//强转[0,100]
System.out.println((int)(Math.random()*100)+1);

19.2 System

概述:System包含几个有用的类字段和方法，它不能被实例化(他的成员都被静态修饰的)

方法名	说明
public static void exit (int status)	终止当前运行的java虚拟机,非零表示异常终止
public static long currentTimeMillis()	返回当前时间(以毫秒为单位)

public static void exit (int status) 终止当前运行的java虚拟机,非零表示异常终止

public class SystemDemo {
    public static void main(String[] args) {
//public static void exit (int status) 终止当前运行的java虚拟机,非零表示异常终止
        System.out.println("开始");
        System.exit(0);
        System.out.println("结束");
     }
}
//开始

public static long currentTimeMillis()返回当前时间(以毫秒为单位)

public class SystemDemo {
    public static void main(String[] args) {
    //public static long currentTimeMillis()返回当前时间(以毫秒为单位)
        System.out.println(System.currentTimeMillis() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");
    }
}
//50.909943042776504年

循环结束的时间

public class SystemDemo {
    public static void main(String[] args) {

        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("共耗时:" + (end - start) + "毫秒");
    }
}
//共耗时:86毫秒

19.3 Object

Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类

构造方法: public Object( )

回想面向对象中，为什么说子类的构造方法默认访问的是父类的无参构造方法?

因为它们的顶级父类只有无参构造方法

public String toString()返回对象的字符串表示形式.建议所有子类重写该方法,自动生成

//Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或者间接的继承自该类
public class ObjectDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("张三");
        s.setAge(23);
        System.out.println(s);//com.java2.API.Student@14ae5a5
        System.out.println(s.toString());

    }
}
/*
Student{name='张三', age=23}
Student{name='张三', age=23}
*/

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
//建议所有子类重写此方法
 //自动生成alt+ins tostring
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

19.3.1 Object 类常用的方法

方法名	说明
public String toString()	返回对象的字符串表示形式.建议所有子类重写该方法,自动生成
public boolean equals(Object obj)	比较对象是否相等。默认比较地址，重写可以比较内容，自动生成

public boolean equals(Object obj) 比较对象是否相等。默认比较地址，重写可以比较内容，自动生成

public class ObjectDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("张三");
        s1.setAge(23);

        Student s2 = new Student();
        s2.setName("张三");
        s2.setAge(23);

/*        //需求;比较两个对象的内容是否相同
        System.out.println(s1 == s2);//false
        */
        System.out.println(s1.equals(s2));
/*        public boolean equals(Object obj) {
                //this ----s1
                //obj -----s2
            return (this == obj);
        }*/
    }
}

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public boolean equals(Object o) {
/*      this ----s1
        o -----s2*/
        //比较地址是否相同,如果相同,直接返回true
        if (this == o) return true;
        //参数是否为null
        //判断俩个对象是否来自同一个类
        if (o == null || getClass() != o.getClass()) return false;
        //向下转型
        Student student = (Student) o;//student = s2
        //比较年龄是否相同
        if (age != student.age) return false;
        //比较姓名内容是否相同
        return name != null ? name.equals(student.name) : student.name == null;
    }
}

19.4 Arrays

19.4.1 冒泡排序

排序: 将一组数据按照固定的规则进行排列

冒泡排序:一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序

• 如果有n个数据进行排序，总共需要比较n-1次
• 每一次比较完毕，下一次的比较就会少一个数据参与

冒泡排序优化前

public class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {24, 69, 80, 57, 13};
        System.out.println("排序前: " + arrayToString(arr));

        //第一次比较
        for (int i = 0; i < arr.length-1; i++) {
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        System.out.println("第一次比较后: " + arrayToString(arr));
        //第二次比较
        for (int i = 0; i < arr.length-1-1; i++) {
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        System.out.println("第二次比较后: " + arrayToString(arr));
        //第三次比较
        for (int i = 0; i < arr.length-1-2; i++) {
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        System.out.println("第三次比较后: " + arrayToString(arr));
        //第四次比较
        for (int i = 0; i < arr.length-1-3; i++) {
            if (arr[i] > arr[i + 1]) {
                int temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        System.out.println("第四次比较后: " + arrayToString(arr));

    }

    //把数组中的元素按照指定的规则组成一个字符串;[元素1,元素2,..]
    public static String arrayToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]);

            } else {
                sb.append(arr[i]).append(",");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }
}
/*
排序前: [24,69,80,57,13]
第一次比较后: [24,69,57,13,80]
第二次比较后: [24,57,13,69,80]
第三次比较后: [24,13,57,69,80]
第四次比较后: [13,24,57,69,80]
*/

优化后的冒泡排序

//优化后
public class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {24, 69, 80, 57, 13};
        System.out.println("排序前: " + arrayToString(arr));
        
        for (int x=0;x<arr.length-1;x++){
            for (int i=0;i<arr.length-1-x;i++){
                if (arr[i]>arr[i+1]){
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
        System.out.println("排序比较后: " + arrayToString(arr));

    }

    //把数组中的元素按照指定的规则组成一个字符串;[元素1,元素2,..]
    public static String arrayToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]);

            } else {
                sb.append(arr[i]).append(",");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }
}

19.4.2 Arrays类的概述和常用方法

方法名	说明
public static String toString(int[] a)	返回指定数组的内容的字符串表示形式
public static void sort(int[] a)	按照数字顺序排列指定的数组

工具类的设计思想:·

• 构造方法用private修饰
• 成员用public static修饰

排序 public static void sort(int[] a)

import java.util.Arrays;

public class ArrayDemo02 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {24,69,80,57,13};

        System.out.println("排序前: "+ Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("排序后: "+ Arrays.toString(arr));
    }
}
/*
排序前: [24, 69, 80, 57, 13]
排序后: [13, 24, 57, 69, 80]
*/

二十.基本类型包装类

20.1 基本数据类型和其包装类

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

常用的操作之一:用于基本数据类型与字符串之间的转换

public class IntegerDemo {
    public static void main(String[] args) {
        //需求:我要判断一个数据是否在int范围内
        //public static final int MIN_VALUE
        //public static final int MAX_VALUE
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);

    }
}
/* 
int范围
-2147483648
2147483647
*/

20.2 Integer类的概述和使用

lnteger:包装一个对象中的原始类型int的值

public class IntegerDemo02 {
    public static void main(String[] args) {
        
        //过时方法
/*        Integer i1 = 100; //new Integer(100);
        System.out.println(i1);
//        Integer i2 = new Integer("abc");//NumberFormatException
        Integer i2 = new Integer("100");
        System.out.println(i2);*/

        
        Integer i1=Integer.valueOf(100);
        System.out.println(i1);

        Integer i2=Integer.valueOf("100");
        System.out.println(i2);

    }
}
/*
100
100
*/

20.3 int和String的相互转换

基本类型包装类的最常见操作就是:用于基本类型和字符串之间的相互转换

1. int转换为String

   public static String ==valueOf(inti):==返回int 参数的字符串表示形式。该方法是String类中的方法

2. String 转换为int
   public static int parselnt(String s):将字符串解析为int类型。该方法是Integer类中的方法

/*
    int和String的相互转换
 */
public class IntegerDemo03 {
    public static void main(String[] args) {
        //int---String的转换
        int number = 100;
        //方式一
        String s1 = "" + number;
        System.out.println(s1);

        //方式二
        // public static String vaLueOf (int i)
        String s2 = String.valueOf(number);
        System.out.println(s2);
        System.out.println("--------");

        //String---int的转换
        String s = "100";
        //方式1
        //String --- Integer ---int
        Integer i = Integer.valueOf(s);
        //public int intValue
        int x = i.intValue();
        System.out.println(x);
        
        //方式2
        // public static int parseInt (String s)
        int y = Integer.parseInt(s);
        System.out.println(y);

    }
}
/*
100
100
--------
100
*/

20.4 案例:字符串中的数据排序

需求:有一个字符串:“91 27 46 38 50”，请写程序实现最终输出结果是: “27 38 46 50 91"

思路:

①定义一个字符串

②把字符串中的数字数据存储到一个int类型的数组中

• 得到字符串中每一个数字数据

  • public String[] split(String regex)

• 定义一个int数组，把String数组中的每一个元素存储到int数组中

  • public static int parselnt(String s)

③对int数组进行排序

④把排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现

⑤输出结果

import java.util.Arrays;

public class IntegerText {
    public static void main(String[] args) {
        //定义一个字符串
        String s = "91 27 46 38 50";

        //把字符串中的数字数据储存到一个int类型的数组中
        String[] strArray = s.split(" ");//以空格为界拆分字符串

        //定义一个int数组,把String[]数组中的每一个元素储存到int数组中
        int[] arr = new int[strArray.length];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = Integer.parseInt(strArray[i]);
        }
        //对int数组进行排序
        Arrays.sort(arr);
        //把排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1){
                sb.append(arr[i]);

            }else {
                sb.append(arr[i]).append(" ");
            }
        }
        String result = sb.toString();
        System.out.println("结果: "+result);
    }
}

20.5 自动装箱和拆箱

• 装箱:把基本数据类型转换为对应的包装类类型
• 拆箱:把包装类类型 转换为对应的基本数据类型

public class IntegerDemo04 {
    public static void main(String[] args) {
        //装箱:把基本数据类型转换为包装类类型
        Integer i = Integer.valueOf(100);//装箱
        Integer ii = 100;//自动装箱

        //拆箱:把包装类类型转换为对应的基本数据类型
       //ii = ii.intValue()+200;
        ii += 200;//i+200自动拆箱;i=i+200;自动装箱
        System.out.println(ii);

        Integer iii = null;
        if (iii!=null){
            iii +=300;
        }
    }
}
//300

==注意:==在使用包装类类型的时候，如果做操作，最好先判断是否为null

我们推荐的是，只要是对象，在使用前就必须进行不为null的判断

二十一.日期类

6.1 Date类概述和构造方法

Date代表了一个特定的时间，精确到毫秒

import java.util.Date;

/*
     public Date():分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
     public Date(Long date):分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

 */
public class DateDemo01 {
    public static void main(String[] args) {
        //     public Date():分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
        Date d1 = new Date();
        System.out.println(d1);

        //public Date(Long date):分配一个Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数
        long date = 1000*60*60;
        Date d2 = new Date(date);
        System.out.println(d2);


    }
}
/*
Wed Nov 18 09:39:12 CST 2020
Thu Jan 01 09:00:00 CST 1970
*/

6.2 Date类的常用方法

6.3.SimpleDateFormat 类概述

SimpleDateFomat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。重点学习日期格式化和解析

日期和时间格式由日期和时间模式字符串指定，在日期和时间模式字符串中，从 ‘A’ 到 ‘Z’ 以及从 ‘a’ 到 ‘z’ 引号的字母被解释为表示日期或时间字符串的组件的模式字母

常用的模式字幕及对应关系如下:

• y 年
• M 月
• d 日
• H 时
• m 分
• s 秒

构造方法:

方法名	说明
public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat使用给定的模式和默认的日期格式

/*
		无参方法
*/
import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatDemo {
    public static void main(String[] args) {
        //.格式化(从Date到 String )
        Date d = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat();
        String s = sdf.format(d);
        System.out.println(s);
    }
}
/*
20-11-18 上午10:31
*/

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

public class SimpleDateFormatDemo {
    public static void main(String[] args) {
        //.格式化(从Date到 String )
        Date d = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s = sdf.format(d);
        System.out.println(s);
    }
}
/* 
2020年11月18日 10:29:39
*/

6.4.SimpleDateFormat 格式化和解析日期

1.格式化(从Date到 String )

public final String format(Date date):将日期格式化成日期/时间字符串

2.解析(从String到Date )

public Date parse(String source):从给定字符串的开始解析文本以生成日期

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

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        //.格式化(从Date到 String )
        Date d = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s = sdf.format(d);
        System.out.println(s);
        System.out.println("----------------------");

        //从String 到 Date
        String ss ="2020-11-18 11:11:11";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf2.parse(ss);
        System.out.println(dd);
    }
}

6.5 案例:日期工具类

需求:定义一个日期工具类(DateUtils)，包含两个方法: 把日期转换为指定格式的字符串; 把字符串解析为指定格式的日期，然后定义一个测试类(DateDemo)，测试日期工具类的方法.

思路:

①定义日期工具类(DateUtils)

②定义一个方法dateToString，用于把日期转换为指定格式的字符串

• 返回值类型: String

• 参数: Date date, String format

③定义一个方法stringToDate，用于字符串解析为指定格式的日期

• 返回值类型:Date

• 参数: String s, String format

④定义测试类DateDemo，调用日期工具类中的方法

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

public class DateUtilsDemo {
    public static void main(String[] args) throws ParseException {
        //创建日期对象
        Date d = new Date();
        String s1 = DateUtils.dateToString(d, "yyyy年MM月dd日 HH:mm:ss ");
        System.out.println(s1);
        String s2 = DateUtils.dateToString(d, "yyyy年MM月dd日");
        System.out.println(s2);

        String s3 = DateUtils.dateToString(d, "HH:mm:ss");
        System.out.println(s3);
        System.out.println("-----------");

        String s ="2020-11-18 11:20:12";
        Date dd = DateUtils.stringToDate(s,"yyyy-MM-dd HH:mm:ss");
        System.out.println(dd);
    }
}

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

public class DateUtils {
    private DateUtils(){}
    public static String dateToString(Date date,String format){
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String s = sdf.format(date);
        return s;
    }
    public static Date stringToDate(String s,String format) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date d = sdf.parse(s);
        return  d;
    }
}

6.5 Calendar 类概述

Calendar为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法

Calendar提供了一个类方法getInstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化: Calendar rightNow = Calendar.getInstance();

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //获取对象
        Calendar c = Calendar.getInstance();//多态的形式
//        public int get(int field)
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");
    }
}
//2020年11月18日

6.6 Calendar 的常用方法

//get  add  set  方法

import java.util.Calendar;

public class CalendarDemo {
    public static void main(String[] args) {
        //获取日历类对象
        Calendar c = Calendar.getInstance();//多态的形式
//     public int get(int field)
//     public abstract void add (int field,int amount):根据日历的规则，将指定的时间量添加或减去给定的日历字段
        c.add(Calendar.YEAR,-3);
        c.add(Calendar.DATE,-5);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");

        c.set(1876,11,23);
        int year2 = c.get(Calendar.YEAR);
        int month2 = c.get(Calendar.MONTH)+1;
        int date2 = c.get(Calendar.DATE);
        System.out.println(year2 + "年" + month2 + "月" + date2 + "日");

    }
}
/*
2017年11月13日
1876年12月23日
*/

6.7 案例:二月天

需求:获取任意一年的二月有多少天

思路:
①键盘录入任意的年份
②设置日历对象的年、月、日

• 年:来自于键盘录入
• 月:设置为3月，月份是从0开始的，所以设置的值是2
• 日:设置为1日

③3月1日往前推一天,就是2月的最后一天

④获取这一天输出即可

import java.util.Calendar;
import java.util.Scanner;

public class CalendarTest {
    public static void main(String[] args) {
        //键盘录入任意年份
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年份");
        int year = sc.nextInt();

        //设置日历对象的年/月/日
        Calendar c = Calendar.getInstance();
        c.set(year, 2, 1);

//        ③3月1日往前推一天,就是2月的最后一天
        c.add(Calendar.DATE, -1);
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年的二月份有" + date + "天");


    }
}

/*请输入年份
2020
2020年的二月份有29天
*/

二十二.异常

22.1异常概述

异常:就是程序出现了不正常的情况

Error:严重问题，不需要处理

Exception:称为异常类，它表示程序本身可以处理的问题

• RuntimeException:在编译期是不检查的，出现问题后，需要我们回来修改代码

• 非RuntimeException:编译期就必须处理的，否则程序不能通过编译，就更不能正常运行了

22.1 JVM的默认处理方案

如果程序出现了问题，我们没有做任何处理，最终JVM会做默认的处理

• 把异常的名称，异常原因及异常出现的位置等信息输出在了控制台
• 程序停止执行

22.3 异常处理

如果程序出现了问题，我们需要自己来处理，有两种方案:

• try … catch …

• throws

public class exceptionDemo01 {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
    }
    public static void method() {
        try {


            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);//new ArrayIndexOutOfBoundsException();
        }catch (ArrayIndexOutOfBoundsException e){
//  System.out.println("你访问的数组索引不存在");
            e.printStackTrace();
        }
    }
}
/* 
开始
你访问的数组索引不存在
结束
*/

22.4 Throwable 的成员方法

public class exceptionDemo01 {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
    }
    public static void method() {
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);
        }catch (ArrayIndexOutOfBoundsException e){
//            System.out.println(e.getMessage());
//            System.out.println(e.toString());
            e.printStackTrace();
        }
    }
}

22.5 编译时异常和运行时异常的区别

Java中的异常被分为两大类:编译时异常和运行时异常，也被称为受检异常和非受检异常所有的RuntimeException类及其子类被称为运行时异常，其他的异常都是编译时异常

• 编译时异常:必须显示处理，否则程序就会发生错误，无法通过编译

• ,运行时异常:无需显示处理，也可以和编译时异常一样处理

22.6 异常处理之throws

虽然我们通过try …catch…可以对异常进行处理，但是并不是所有的情况我们都有权限进行异常的处理也就是说，有些时候可能出现的异常是处理不了的

针对这种情况，Java提供了throws的处理方案

格式:

throw 异常类名

注意:这个格式是跟在方法的括号后面的

22.7 自定义异常

格式:

public class 异常类名 extends Exception{
	无参构造
	带参构造
}

范例:

public class scoreException extends Exception {
	public scoreException () {}
	public scoreException (string message) {
		super (message);
	}
}

public class ScoreException extends Exception {
    public ScoreException () {}
    public ScoreException (String message) {
        super (message);
    }
}

public class Teacher {
    public void checkScore(int score) throws ScoreException{
        if (score < 0 || score > 100) {
            throw new ScoreException("你给的分数有误,应该在0-100之间");
        }else {
            System.out.println("分数正常");
        }
    }
}

import java.util.Scanner;

public class Teachertest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入分数: ");
        int score = sc.nextInt();

        Teacher t = new Teacher();
        try {
            t.checkScore(score);
        } catch (ScoreException e) {
            e.printStackTrace();
        }
    }

}
/*
请输入分数: 
98
分数正常
-------------------------------------
请输入分数: 
455
com.java2.ArrayText.ScoreException: 你给的分数有误,应该在0-100之间
	at com.java2.ArrayText.Teacher.checkScore(Teacher.java:6)
	at com.java2.ArrayText.Teachertest.main(Teachertest.java:13)
*/

22.8 throws 和 throw的区别

throws

• 用在方法声明后面，跟的是异常类名

• 表示抛出异常，由该方法的调用者来处理

• 表示出现异常的一种可能性，并不一定会发生这些异常

throw

• 用在方法体内，跟的是异常对象名

• 表示抛出异常，由方法体内的语句处理

• 执行throw一定抛出了某种异常

二十三.集合进阶

23.1.Collection

1.1 集合知识回顾

集合类的特点:提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变

1.2 集合类体系结构

​ 单列集合

张三
李四
王五

​ 双列集合

name1	张三
name2	李四
name3	王五

1.3.Collection集合概述和使用

Collection集合概述

• 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素

• JDK不提供此接口的任何直接实现，它提供更具体的子接口(如Set和List)实现

创建Collection集合的对象

• 多态的方式
• 具体的实现类ArrayList

collection的基本使用add

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo01 {
    public static void main(String[] args) {
        //创建Collection集合的对象
        Collection<String> c = new ArrayList<String>();

        //添加元素 boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("java");

        //输出集合对象
        System.out.println(c);
    }
}

1.4.collection集合常用方法

• ALT+7 打开一个窗口,能够看到类的所有信息

方法名	说明
boolean add(E e)	添加元素(可添加重复元素)永远返回的是true
boolean remove(Object o)	从集合中移除指定的元素
void clear	清空集合中所有的元素
boolean contains (Object o)	判断集合中是否存在指定的元素
boolean isEmpty	判断集合是否为空
int size()	集合的长度, 也就是集合中元素的个数

boolean add(E e) 添加元素(可添加重复元素)永远返回的是true

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<String>();
        //boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("world");

        //输出集合对象
        System.out.println(c);
    }
}
/*
[hello, world, world]
*/

boolean remove(Object o) 从集合中移除指定的元素

public class CollectionDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<String>();
        //boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("world");
        //boolean  remove(Object  o) 从集合中移除指定的元素
        System.out.println(c.remove("world"));

  
        //输出集合对象
        System.out.println(c);
    }
}
/*
true
[hello, world]
*/

void clear 清空集合中所有的元素

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<String>();
        //boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("world");
        //boolean  remove(Object  o) 从集合中移除指定的元素
        System.out.println(c.remove("world"));

        //void clear 清空集合中所有的元素
        c.clear();

        //输出集合对象
        System.out.println(c);
    }
}
/*
true
[]
*/

boolean contains (Object o) 判断集合中是否存在指定的元素

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<String>();
        //boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("world");

        System.out.println(c.contains("world"));

        //输出集合对象
        System.out.println(c);
    }
}
/*
true
[hello, world, world]
*/

boolean isEmpty 判断集合是否为空

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<String>();
        //boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("world");
	
        System.out.println(c.isEmpty());

        //输出集合对象
        System.out.println(c);
    }
}
/*
false
[hello, world, world]
*/

int size() 集合的长度, 也就是集合中元素的个数

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<String>();
        //boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("world");

        System.out.println(c.size());

        //输出集合对象
        System.out.println(c);
    }
}
/* 
3
[hello, world, world]
*/

1.5.Collection 集合的遍历

lterator: 迭代器，集合的专用遍历方式

• lterator iterator():返回此集合中元素的迭代器，通过集合的iterator()方法得到
• 迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的

lterator中的常用方法

• E next():返回迭代中的下一个元素

• boolean hasNext(): 如果迭代具有更多元素，则返回true

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<String>();
        //boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("java");
//lterator iterator():返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();

 /*       System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());*///NoSuchELementException :表示被请求的元素不存在

        while (it.hasNext()){
//            System.out.println(it.next());
            String s = it.next();
            System.out.println(s);
        }
    }
}

清晰版

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<String>();
        //boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("java");
//lterator iterator():返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

1.6.集合的使用步骤

1.7.案例: Collection集合储存学生对象并遍历

需求:创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路:

①定义学生类

②创建Collection集合对象

③创建学生对象

④把学生添加到集合

⑤遍历集合(迭代器方式)

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionlistTest {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<Student> c = new ArrayList<Student>();
        //创建学生对象
        Student s1 = new Student("张三", 30);
        Student s2 = new Student("李四", 26);
        Student s3 = new Student("王五", 33);

        //把学生添加到集合
        c.add(s1);
        c.add(s2);
        c.add(s3);
        Iterator<Student> it = c.iterator();
        while (it.hasNext()) {
            Student st = it.next();
            System.out.println(st.getName() + ", " + st.getAge());
        }
    }
}
/*
张三, 30
李四, 26
王五, 33
*/

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

23.2 List

2.1 List集合的概述和特点

List集合概述

• 有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
• 与Set集合不同，列表通常允许重复的元素

List集合特点

• 有序:存储和取出的元素顺序一致
• 可重复:存储的元素可以重复

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

public class ListDemo01 {
    public static void main(String[] args) {
        //穿件集合对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("你");
        list.add("吃了");
        list.add("几个");
        list.add("菜啊?");

        //迭代器的方法遍历
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.print(s);
        }
    }
}
/*
你吃了几个菜啊?
*/

2.2 List集合特有的方法

add

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

public class ListDemo01 {
    public static void main(String[] args) {
        //穿件集合对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("hello");
        list.add("java");
        list.add("world");

        list.add(1,"text");
        System.out.println(list);
    
    }
}
/*
[hello, text, java, world]
*/

remove

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

public class ListDemo01 {
    public static void main(String[] args) {
        //穿件集合对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("hello");
        list.add("java");
        list.add("world");

        System.out.println(list.remove(1));
        System.out.println(list);
    }
}
/*
java
[hello, world]
*/

set

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

public class ListDemo01 {
    public static void main(String[] args) {
        //穿件集合对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("hello");
        list.add("java");
        list.add("world");

        System.out.println(list.set(1,"c++"));
        System.out.println(list);
    }
}
/*
java
[hello, c++, world]
*/

get

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

public class ListDemo01 {
    public static void main(String[] args) {
        //穿件集合对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("hello");
        list.add("java");
        list.add("world");

        System.out.println(list.get(2));
        System.out.println(list);
    }
}
/*
world
[hello, java, world]
*/

遍历集合

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

public class ListDemo01 {
    public static void main(String[] args) {
        //穿件集合对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("hello");
        list.add("java");
        list.add("world");

        for (int i=0; i<list.size();i++){
            String s = list.get(i);
            System.out.println(s);

        }
    }
}

2.3 案例:List集合储存学生对象并遍历

需求:创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路:

①定义学生类

②创建List

③集合对象创建学生对象

④把学生添加到集合

⑤遍历集合(迭代器方式，for循环方式)

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

public class ListDemo01 {
    public static void main(String[] args) {
        //创建list集合对象
        List<Student> list = new ArrayList<Student>();
        //创建学生对象
        Student s1 = new Student("张三",30);
        Student s2 = new Student("李四",35);
        Student s3 = new Student("王五",25);

        //把学生添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);
        System.out.println("----迭代器方式遍历----");
 //-----------------------迭代器方式----------------
        Iterator<Student> it = list.listIterator();
        while (it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName()+", "+s.getAge());
        }
 //----------------for循环方式遍历-------------------
        System.out.println("----for循环方式遍历----");
        for (int i=0; i<list.size();i++){
            Student s = list.get(i);
            System.out.println(s.getName()+", "+s.getAge());
        }
    }
}
/*
----迭代器方式遍历----
张三, 30
李四, 35
王五, 25
----for循环方式遍历----
张三, 30
李四, 35
王五, 25
*/

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

2.4并发修改异常

ConcurrentModificationException

• 当不允许这样的修改时，可以通过检测到对象的并发修改的方法来抛出此异常。

产生原因

• 迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致。

解决方案

• 用for循环遍历，然后用集合对象做对应的操作即可。

public class ListDemo02 {
    public static void main(String[] args) {
        //穿件集合对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("hello");
        list.add("java");
        list.add("world");
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            if (s.equals("world")){
                list.add("javaee");
            }
        }
        //输出集合对象
        System.out.println(list);
    }
}
/*
Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)
	at java.util.ArrayList$Itr.next(ArrayList.java:861)
	at com.java2.listText.ListDemo02.main(ListDemo02.java:20)
*/

修改异常后

import java.util.ArrayList;
import java.util.List;
/*
  ConcurrentModificationException当不允许这样的修改时，可以通过检测到对象的并发修改的方法来抛出此异常。
 */
public class ListDemo02 {
    public static void main(String[] args) {
        //穿件集合对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("hello");
        list.add("java");
        list.add("world");

        for (int i=0; i<list.size();i++){
            String s =list.get(i);
            if (s.equals("world")){
                list.add("javaee");
            }
        }
        System.out.println(list);
    }
}
//[hello, java, world, javaee]

2.5.Listlterator

Listlterator:列表迭代器

• 通过List集合的listlterator())方法得到，所以说它是List集合特有的迭代器

• 用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

Listlterator中的常用方法:

方法	说明
E next():	返回迭代中的下一个元素
boolean hasNext():	如果迭代具有更多元素，则返回true
E previous():	返回列表中的上一个元素
boolean hasPrevious():	如果此列表迭代器在相反方向遍历列表时具有更多元
void add(E e):	将指定的元素插入列表

不常用了解即可

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

public class ListIteratorDemo03 {
    public static void main(String[] args) {
        //穿件集合对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("hello");
        list.add("java");
        list.add("world");
        //通过list集合的listIterator()方法得到
        ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()){
            String s = lit.next();
            System.out.println(s);
        }
        System.out.println("-----------");
        //逆向遍历
        while (lit.hasPrevious()){
            String s = lit.previous();
            System.out.println(s);
        }
    }
}

列表迭代器

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

public class ListIteratorDemo03 {
    public static void main(String[] args) {
        //穿件集合对象
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("hello");
        list.add("java");
        list.add("world");
		//列表迭代器
        ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()){
            String s = lit.next();
            if (s.equals("world")){
                lit.add("javase");
            }
        }
        System.out.println(list);
    }
}
/*
[hello, java, world, javase]
*/

2.6.增强for循环

增强for:简化数组和Collection集合的遍历

• 实现lterable接口的类允许其对象成为增强型for语句的目标
• 它是JDK5之后出现的，其内部原理是一个lterator迭代器

增强for的格式

• 格式:

for(元素数据类型变量名:数组或者Collection集合){

//在此处使用变量即可，该变量就是元素

}

• 范例:

int[] arr = {1,2,3,4,5};

for(int i:arr){
	System.out.println(i);
}

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

public class ForDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        for (int i : arr) {
            System.out.println(i);
        }
        System.out.println("----");

        String[] strArray = {"hello", "world", "java"};
        for (String s : strArray) {
            System.out.println(s);
        }
        System.out.println("----");

        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        for (String s : list) {
            System.out.println(s);
        }
        //内部原理是一个Iterator迭代器 抛出异常
        for (String s :list){
            if (s.equals("world")){
                list.add("javase");//ConcurrentModificationException
            }
        }
    }
/*
1
2
3
4
5
----
hello
world
java
----
hello
world
java
Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)
	at java.util.ArrayList$Itr.next(ArrayList.java:861)
	at com.java2.listText.ForDemo.main(ForDemo.java:28)

Process finished with exit code 1

*/

2.7.案例:List集合储存学生对象用三种方式遍历

需求:创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路:

①定义学生类

②创建List集合对象

③创建学生对象

④把学生添加到集合

⑤遍历集合

​ 迭代器:集合特有的遍历方式

​ 普通for:带有索引的遍历方式

​ 增强for:最方便的遍历方式

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

public class ListDemo05 {
    public static void main(String[] args) {
        //创建list集合对象
        List<Student> list = new ArrayList<Student>();
        //创建学生对象
        Student s1 = new Student("张三", 30);
        Student s2 = new Student("李四", 35);
        Student s3 = new Student("王五", 25);

        //把学生添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);
//            迭代器:集合特有的遍历方式
        Iterator<Student> it = list.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + ", " + s.getAge());
        }
        System.out.println("---------");
//         普通for:带有索引的遍历方式
        for (int i = 0;i<list.size();i++){
            Student s = list.get(i);
            System.out.println(s.getName() + ", " + s.getAge());

        }
        System.out.println("-------");
//            增强for:最方便的遍历方式
        for (Student s:list){
            System.out.println(s.getName() + ", " + s.getAge());
        }
    }
}
/*
张三, 30
李四, 35
王五, 25
---------
张三, 30
李四, 35
王五, 25
-------
张三, 30
李四, 35
王五, 25
*/

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

2.8.数据结构

数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率

2.8.1 常见数据结构之栈

2.8.2 常见数据结构之队列

2.8.3 常见数据结构之数组

查询快,增删慢,添加效率低

2.8.4常见数据值链表

格式特点

描述

储存

添加b插入ac之间

删除数据BD之间的数据c

增删快 ,查询慢(对比数组)

2.9.List集合子类特点

List集合常用子类:ArrayList，LinkedList

• ArrayList:底层数据结构是数组，查询快，增删慢

• LinkedList:底层数据结构是链表，查询慢，增删快

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;

public class ListDemo06 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> array = new ArrayList<String>();

        array.add("hello");
        array.add("world");
        array.add("java");
        //遍历
        for (String s :array){
            System.out.println(s);
        }
        System.out.println("-----迭代器-----");
        Iterator<String> it = array.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("----for循环索引-----");
        for(int i = 0; i<array.size(); i++){
            String s = array.get(i);
            System.out.println(s);
        }
        
        System.out.println("--------");
        LinkedList<String> linkedList = new LinkedList<String>();

        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");
        for (String s : linkedList){
            System.out.println(s);
        }
    }
}

2.10.案例:ArrayList集合储存学生对象用三种方式遍历

需求:创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路:

①定义学生类

②创建ArrayList集合对象

③创建学生对象

④把学生添加到集合

⑤遍历集合

​ 迭代器:集合特有的遍历方式

​ 普通for:带有索引的遍历方式

​ 增强for:最方便的遍历方式

mport java.util.ArrayList;
import java.util.Iterator;

public class ArrayListDemo01 {
    public static void main(String[] args) {
        //创建arraylist集合对象
        ArrayList<Student> array = new ArrayList<Student>();

        //创建学生对象
        Student s1 = new Student("张三", 30);
        Student s2 = new Student("李四", 35);
        Student s3 = new Student("王五", 25);
        //把学生添加到集合
        array.add(s1);
        array.add(s2);
        array.add(s2);
        System.out.println("---迭代器----");
        Iterator<Student> it = array.iterator();
            while (it.hasNext()){
                Student s = it.next();
                System.out.println(s.getName()+", "+s.getAge());
            }
        System.out.println("---普通for---");
            for (int i = 0;i<array.size();i++){
                Student s = array.get(i);
                System.out.println(s.getName()+", "+s.getAge());
            }
        System.out.println("---增强for--");
        for (Student s : array){
            System.out.println(s.getName()+", "+s.getAge());

        }
    }
}

2.11.LinkedList集合的特有功能

public void addFirst(E e):在该列表开头插入指定的元素
public void addLast(E e):将指定的元素追加到此列表的末尾

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> lk = new LinkedList<String>();

         lk.add("hello");
         lk.add("world");
         lk.add("java");
//public void addFirst(E e):在该列表开头插入指定的元素
//public void addLast(E e):将指定的元素追加到此列表的末尾
        lk.addFirst("javase");
        lk.addLast("javaee");
        System.out.println(lk);

    }
}
/*
[javase, hello, world, java, javaee]
*/

public E getFirst():返回此列表中的第一个元素
public E getLast():返回此列表中的最后—个元素

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> lk = new LinkedList<String>();

         lk.add("hello");
         lk.add("world");
         lk.add("java");

//public E getFirst():返回此列表中的第一个元素
//public E getLast():返回此列表中的最后—个元素
        System.out.println(lk.getFirst());
        System.out.println(lk.getLast());

    }
}
/*
hello
java
*/

public E removeFirst():从此列表中册除并返回第一个元素
public E removeLast():从此列表中删除并返回最后一个元素

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> lk = new LinkedList<String>();

         lk.add("hello");
         lk.add("world");
         lk.add("java");
//public E removeFirst():从此列表中册除并返回第一个元素
//public E removeLast():从此列表中删除并返回最后一个元素
        System.out.println(lk.removeFirst());
        System.out.println(lk.removeLast());
        System.out.println(lk);
    }
}
/*
hello
java
[world]
*/

23.3.Set

3.1.Set集合的概述和特点

Set集合特点

• 不包含重复元素的集合

• 没有带索引的方法，所以不能使用普通for循环遍历

Set集合练习

• 存储字符串并遍历

HashSet:对集合的迭代顺序不做任何保证

import java.util.HashSet;
import java.util.Set;

public class SetDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        Set<String> set = new HashSet<String>();
        //添加元素
        set.add("hello");
        set.add("java");
        set.add("world");
        for (String s : set) {
            System.out.println(s);

        }
    }
}
/*
java
world
hello
*/

3.2.哈希值

哈希值:是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

Object类中有一个方法可以获取对象的哈希值

• public int hashCode):返回对象的哈希码值

对象的哈希值特点

• 同一个对象多次调用hashCode(方法返回的哈希值是相同的

• 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

public class HashDemo {
    public static void main(String[] args) {
        Student s1 =new Student("风清扬",65);
        //同一个对象多次调用hashCode()方法返回的哈希值是相同的
        System.out.println(s1.hashCode());
        System.out.println(s1.hashCode());
        System.out.println("----");

        //默认情况下不同对象的哈希值是不相同的
//        通过方法重写可以实现不同对象哈希值是相同的
        Student s2 =new Student("风清扬",65);
        System.out.println(s2.hashCode());
        System.out.println("------");
        System.out.println("hello".hashCode());
        System.out.println("java".hashCode());

    }
}
/*
21685669
21685669
----
2133927002
------
99162322
3254818
*/

3.3 HashSet集合概述和特点

HashSet集合特点

• 底层数据结构是哈希表

• 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致

• 没有带索引的方法，所以不能使用普通for循环遍历

• 由于是Set集合，所以是不包含重复元素的集合

HashSet集合练习

• 存储字符串并遍历

import java.util.HashSet;

public class HashSetDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> hs = new HashSet<String>();
        //添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        //遍历
        for (String s :hs){
            System.out.println(s);
        }
    }
}
/*
world
java
hello
*/

HashSet集合存储元素:

要保证元素唯一性，需要重写hashCode()和equals()

3.4 常见数据结构之哈希表

哈希表

• JDK8之前，底层采用数组+链表实现，可以说是一个元素为链表的数组
• JDK8以后，在长度比较长的时候，底层实现了优化

3.5.案例:HashSet集合储存学生对象并遍历

需求:创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合

要求:学生对象的成员变量值相同，我们就认为是同一个对象

思路:

①定义学生类

②创建HashSet集合对象

③创建学生对象

④把学生添加到集合

⑤遍历集合(增强for)

⑥在学生类中重写两个方法

​ hashCode()和equals()自动生成即可

import java.util.HashSet;

public class HashSetDemo03 {
    public static void main(String[] args) {
        //创建HashSet集合对象
        HashSet<Student> hs = new HashSet<Student>();
        //创建学生对象
        Student s1 = new Student("杨过",27);
        Student s2 = new Student("王重阳",92);
        Student s3 = new Student("郭靖",51);
        Student s4 = new Student("郭靖",51);

        //把学生添加到集合
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        hs.add(s4);
        //遍历集合(增强for)
        for (Student s : hs){
            System.out.println(s.getName()+", "+s.getAge());
        }
    }
}

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

3.6.LinkedHashSet集合概述和特点

LinkedHashSet集合特点

• 哈希表和链表实现的Set接口，具有可预测的迭代次序

• 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的

• 由哈希表保证元素唯一，也就是说没有重复的元素

LinkedHashSet集合练习·
存储字符串并遍历

import java.util.LinkedHashSet;

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<String>();
        //添加元素
        linkedHashSet.add("hello");
        linkedHashSet.add("world");
        linkedHashSet.add("java");

        linkedHashSet.add("java");
        for (String s : linkedHashSet){
            System.out.println(s);
        }
    }
}

3.7 TreeSet集合概述和特点

TreeSet集合特点

• 元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法

  • TreeSet():根据其元素的自然排序进行排序

  • TreeSet(Comparator comparator):根据指定的比较器进行排序

• 没有带索引的方法，所以不能使用普通for循环遍历

• 由于是Set集合，所以不包含重复元素的集合

TreeSet集合练习

• 存储整数并遍历心

import java.util.TreeSet;

public class TreeSetDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Integer> ts = new TreeSet<Integer>();

        //添加元素
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(50);
        ts.add(20);
        for (Integer i : ts) {
            System.out.println(i);

        }
    }
/*
10
20
30
40
50
*/

3.8.自然排序Comparable的使用

• 存储学生对象并遍历，创建TreeSet集合使用无参构造方法

• 要求:按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

结论

• 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的

• 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法

• 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

import java.util.TreeSet;

public class TreeSetDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<Student>();

        Student s1 = new Student("xishi", 29);
        Student s2 = new Student("lisi", 15);
        Student s3 = new Student("zhangsan", 30);
        Student s4 = new Student("wangwu", 33);
        Student s5 = new Student("2bbb", 33);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        //添加元素
        for (Student s : ts) {
            System.out.println(s.getName() + ", " + s.getAge());

        }
    }
}
/*
lisi, 15
xishi, 29
zhangsan, 30
2bbb, 33
wangwu, 33
*/

public class Student implements Comparable<Student> {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Student s) {
//        return -1;
//        int num =s.age - this.age;//降序!
        int num = this.age - s.age;//升序
//      年龄相同时，按照姓名的字母顺序排序
        int num2 = num == 0 ? this.name.compareTo(s.name) : num;
        return num2;
    }
}
　//理解：按照age升序排列，若age相同，则按照姓名的字母顺序排列。注意主要条件是age，次要条件是name。
　//理解：this理解为较大的元素，s理解为较小的元素；若返回this.age – s.age ，则按照升序存储，若返回 s.age – this.age ，则按照降序存储；若返回0，则不添加。 

3.9.比较器排序Comparator的使用

• 存储学生对象并遍历，创建TreeSet集合使用带参构造方法
• 要求:按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

结论

• 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的

• 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(To1,T o2)方法

• 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写、

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });
        Student s1 = new Student("xishi", 29);
        Student s2 = new Student("lisi", 15);
        Student s3 = new Student("zhangsan", 30);
        Student s4 = new Student("wangwu", 33);
        Student s5 = new Student("2bbb", 33);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        //添加元素
        for (Student s : ts) {
            System.out.println(s.getName() + ", " + s.getAge());
        }
    }
}

public class Student  {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

3.10.案例成绩排序

需求:用TreeSet集合存储多个学生信息(姓名，语文成绩，数学成绩)，并遍历该集合

要求:按照总分从高到低出现

思路:

①定义学生类

②创建TreeSet集合对象，通过比较器排序进行排序

③创建学生对象

④把学生对象添加到集合

⑤遍历集合

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetDem01 {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //主要条件
                int num = s2.getSum() - s1.getSum();
                //次要条件
                int num2 = num == 0 ? s2.getChinese() - s1.getChinese() : num;
                int num3 = num2==0?s2.getName().compareTo(s1.getName()):num2;
                return num3;
            }
        });
        //创建学生对象
        Student s1 = new Student("张三", 98, 100);
        Student s2 = new Student("李四", 95, 95);
        Student s3 = new Student("王五", 100, 93);
        Student s4 = new Student("柳树", 100, 97);
        Student s5 = new Student("黑色", 92, 98);

        Student s6 = new Student("白色", 99, 98);
        Student s7 = new Student("赵云", 99, 98);

        //把学生对象添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        ts.add(s7);
//        遍历集合
        for (Student s : ts) {
            System.out.println(s.getName() + ": " + s.getChinese() + ", " + s.getMath() + ", " + s.getSum());
        }
    }
}
/*  
张三: 98, 100, 198
柳树: 100, 97, 197
赵云: 99, 98, 197
白色: 99, 98, 197
王五: 100, 93, 193
李四: 95, 95, 190
黑色: 92, 98, 190
*/

3.11.不重复的随机数

需求:编写一个程序，获取10个1-20之间的随机数，要求随机数不能重复，并在控制台输出

思路:

①创建Set集合对象

②创建随机数对象

③判断集合的长度是不是小于10

​ 是:产生一个随机数，添加到集合

​ 回到3继续

④遍历集合

hashset实现的

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

public class SetDemo01 {
    public static void main(String[] args) {
//        创建Set集合对象
        Set<Integer> set = new HashSet<Integer>();
        //创建随机数对象
        Random r = new Random();
        while (set.size()<10){
            //产生一个随机数,添加到集合
            int number = r.nextInt(20)+1;
            set.add(number);
        }
        //遍历集合
        for(Integer i :set){
            System.out.println(i);
        }
    }
}
/* 

*/

TreeSet

import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

public class SetDemo01 {
    public static void main(String[] args) {
//        创建Set集合对象
        Set<Integer> set = new TreeSet<Integer>();

        //创建随机数对象
        Random r = new Random();
        while (set.size()<10){
            //产生一个随机数,添加到集合
            int number = r.nextInt(20)+1;
            set.add(number);
        }
        //遍历集合
        for(Integer i :set){
            System.out.println(i);
        }
    }
}

23.4.泛型

4.1.泛型概述

泛型:是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型,它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数

一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢? 顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型

这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

泛型定义格式：

• <类型>：指定一种类型的格式。这里的类型可以看成是形参
• <类型1,类型2…>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
• 将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型

泛型的好处：

• 把运行时期的问题提前到了编译期间
• 避免了强制类型转换

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class GenericDemo {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<String>();
        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");

//        遍历集合
        Iterator<String>it = c.iterator();
        while (it.hasNext()){
//            Object obj = it.next();
//            System.out.println(obj);
            String s = it.next();
            System.out.println(s);
        }
    }
}
/* 
hello
world
java
*/

4.2.泛型类

泛型类的定义格式：

• 格式：修饰符 class 类名<类型> { }
• 范例：public class Generic < T > { }
  此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型

//测试类
public class GenericDEmo02 {
    public static void main(String[] args) {
        Student01 s = new Student01();
        s.setName("林青霞");
        System.out.println(s.getName());

        Teacher t =new Teacher();
        t.setAge(30);
        System.out.println(t.getAge());
        System.out.println("--------");

      Generic01<String> g1 = new Generic01<String>();
         g1.setT("林青霞");
        System.out.println(g1.getT());

        Generic01<Integer> g2 = new Generic01<Integer>();
        g2.setT(30);
        System.out.println(g2.getT());
    }
}

//泛型类
public class Generic<T> {

  private T t; 
  
  public T getT() {
  return t; 
  }
  
  public void setT(T t) {
   this.t = t; 
   } 
}

4.3.泛型方法

泛型方法的定义格式：

• 格式：修饰符 <类型> 返回值类型 方法名(类型 变量名) { }
• 范例：public < T > void show(T t) { }

带有泛型方法的类：

public class Generic {
	 public <T> void show(T t) { 
	 	System.out.println(t); 
	 } 
}

测试类

public class GenericDemo { 
	public static void main(String[] args) { 
		Generic g = new Generic(); 
		g.show("林青霞"); 
		g.show(30); 
		g.show(true); 
		g.show(12.34); 
	} 
}

4.4.泛型接口

泛型接口的定义格式：

• 格式：修饰符 interface 接口名<类型> { }
• 范例：public interface Generic { }

泛型接口：

//接口
public interface GenericDemo03<T> {
    void show (T t);

}

泛型接口实现类：

//实现类
public class Genericlmpl<T> implements GenericDemo03<T>{
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

测试类：

//            测试类
public class GenericDemo01 {
    public static void main(String[] args) {
        GenericDemo03<String> g1 = new Genericlmpl<String>();
        g1.show("林青霞");
        GenericDemo03<Integer> g2 = new Genericlmpl<Integer>();
        g2.show(50);
    }
}
/* 
林青霞
50
*/

4.5.类型通配符

为了表示各种泛型List的父类，可以使用类型通配符

• 类型通配符：
• List：表示元素类型未知的List，它的元素可以匹配任何的类型
• 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中

如果说我们不希望List是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限

• 类型通配符上限：
• List：它表示的类型是Number或者其子类型

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限

• 类型通配符下限：
• List：它表示的类型是Number或者其父类型

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

public class GenericDemo {
    public static void main(String[] args) {
        //类型通配符,
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        System.out.println("---------");
//        类型通配符上限：
//        左边是最高类型 右边是他的子类型,不可高过左边
        List<? extends Number> list4 = new ArrayList<Number>();
        List<? extends Number> list5 = new ArrayList<Integer>();
//  报错 List list6 = new ArrayList