##正则表达式常见类的使用

最新推荐文章于 2023-05-24 10:07:00 发布

大官人的西门庆

最新推荐文章于 2023-05-24 10:07:00 发布

阅读量243

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_56612475/article/details/117093597

版权

##正则表达式//常见类的使用//集合

###正则表达式

A：正则表达式:正确规则的表达式规则java给我们定的
是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。

B：

案例演示
	需求：校验qq号码.
		1:要求必须是5-15位数字
		2:0不能开头
		
	a:非正则表达式实现

	b:正则表达式实现
public class MyTest {
    public static void main(String[] args) {
        //我们定义了数据，这个数据有格式的，所以我们要求这些数据，符合我们的格式要求，所以我们需要对数据格式进行校验
        //身份证号 ，车牌号，手机号 邮箱  网址
        //正则表达式：正确规则的表达式，是一种独立的语法，很多语言都支持。他的作用，就是用来校验数据符不符合我定义的规则。
        //正则表达式：定义规则的一种语法
      /*  需求：校验qq号码.

        1:要求必须是5 - 15 位数字
        2:0 不能开头 */
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的秋秋号，5 - 15 位数字 0 不能开头");
        String qqNumber = sc.nextLine();
        //定义校验的方法
        // boolean b = checkQQNumber(qqNumber);
        boolean b = checkQQNumber2(qqNumber);
        if (b) {
            System.out.println("QQ号规则正确");
        } else {
            System.out.println("QQ号规则错误");
        }

        //

    }

    private static boolean checkQQNumber2(String qqNumber) {
        // 1:要求必须是5 - 15 位数字
        // 2:0 不能开头
        //定义正则表达达式
        String regx = "[1-9][0-9]{4,14}";
        boolean b = qqNumber.matches(regx);
        return b;

    }


    private static boolean checkQQNumber(String qqNumber) {		//传统的方法
        // 1:要求必须是5 - 15 位数字
        // 2:0 不能开头
        boolean flag = false;
        if (qqNumber.length() >= 5 && qqNumber.length() <= 15 && !qqNumber.startsWith("0")) {
            for (int i = 0; i < qqNumber.length(); i++) {
                char ch = qqNumber.charAt(i);
                if (ch >= '0' && ch <= '9') {
                    flag = true;
                } else {
                    flag = false;
                    break;
                }
            }
        }

        return flag;
    }
}

###正则表达式组成规则

规则字符在java.util.regex Pattern类中

A：字符 x 字符。'a’表示字符。

\\ 反斜杠线字符；

\n 换行

\r 回车符

B:字符类
[abc] a、b 或 c（简单类）

[^ab从] 任何字符，除了 a、b 或 c（否定）

[a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）

[0-9] 0到9的字符都包括

C:预定义字符类

. （点）。任何字符

\s 空格

	\\w 单词字符：[a-zA-Z_0-9]
	在正则表达式里面组成单词的东西必须有这些东西组成

^ 行的开头

$ 行的结尾

\b 单词的边界就是不是单词字符的地方

	举例：hello world?haha;xixi

E:Greedy 数量词
X? X，一次或一次也没有比如""空串就是没有

X* X，零次或多次大于等于1次都算多次

X+ X，一次或多次

X{n} X，恰好 n 次

X{n,} X，至少 n 次

//X{n,m} X，至少 n 次，但是不超过 m 次

	举例：hello world?haha;xixi

1正则表达式的判断功能

A:正则表达式的判断功能
	String类的功能：public boolean matches(String regex)
B:案例演示:	判断手机号码是否满足规则
public class MyTest2 {
    public static void main(String[] args) {
        //校验手机号的规则：
        // 11位   1 开头  第二位 3 5 6 7 8 9   后面9位任意数字
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的手机号");
        String phoneNumber = sc.nextLine();
        boolean b = checkNumber(phoneNumber);

        if (b) {
            System.out.println("规则正确");
        } else {
            System.out.println("规则错误");
        }

        
        //6～18个字符，可使用字母、数字、下划线，需要以字母开头


    }


    private static boolean checkNumber(String phoneNumber) {
        //校验手机号的规则：
        // 11位   1 开头  第二位 3 5 6 7 8 9   后面9位任意数字
        boolean flag = false;
        if (phoneNumber.length() == 11 && phoneNumber.startsWith("13") || phoneNumber.startsWith("15") || phoneNumber.startsWith("16") || phoneNumber.startsWith("17") || phoneNumber.startsWith("18") || phoneNumber.startsWith("19")) {
            for (int i = 2; i < phoneNumber.length(); i++) {
                char ch = phoneNumber.charAt(i);
                if (Character.isDigit(ch)) {
                    flag = true;
                } else {
                    return false;
                }
            }
        }

        return flag;

    }


}

校验用户邮箱是否满足要求

public class MyTest3 {
    public static void main(String[] args) {
        //校验网易邮箱 xxx@x@163.com
        //6～18个字符，可使用字母、数字、下划线，需要以字母开头
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的网易邮箱");
        String eMail = sc.nextLine();
        boolean b = checkMail(eMail);

        if (b) {
            System.out.println("规则正确");
        } else {
            System.out.println("规则错误");
        }
    }

    private static boolean checkMail(String eMail) {
        if (!eMail.endsWith("@163.com")) {
            return false;
        }
        boolean flag = false;
        String mail = eMail.substring(0, eMail.lastIndexOf("@"));
        System.out.println(mail);
        if (mail.length() >= 6 && mail.length() <= 18 && Character.isLetter(mail.charAt(0))) {
        //判断受字符是否是字母
            for (int i = 1; i < mail.length(); i++) {
                char ch = mail.charAt(i);
                if (Character.isDigit(ch) || 
                //可以是数字
                Character.isLetter(ch) || ch == '_') {
                    flag = true;
                } else {
                    return false;
                }
            }
        }
        return flag;
    }
}






正则的方法public class MyTest2 {
    public static void main(String[] args) {
        //手机号的正则
        String phoneRegx = "[1][3,5,6,8,9][0-9]{9}";

        //网易邮箱的正则
        //校验网易邮箱 xxx@x@163.com
        //6～18个字符，可使用字母、数字、下划线，需要以字母开头
        String mail = "[a-zA-Z]\\w{5,17}@163\\.com";

        boolean b = "xxxaaaaax@163.com".matches(mail);
        System.out.println(b);

        String mail2 = "[a-zA-Z]\\w{5,17}@[1-9a-z]{3,18}\\.(com|net|org|cn)";

        boolean b2 = "xxxaaaaax@sina.org".matches(mail2);
        System.out.println(b2);

        String qqmail = "[1-9][0-9]{5,10}@qq\\.com";

        String mm = "([a-zA-Z]\\w{5,17}@[1-9a-z]{3,18}\\.(com|net|org|cn))|([1-9][0-9]{5,10}@qq\\.com)";


        boolean b3 = "252896387@qq.com".matches(mm);

        System.out.println(b3);


        /*
         *  /^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$|^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}([0-9]|X)$/
         *
         * */
        // 中文 匹配中文字符的正则表达式： [\u4e00-\u9fa5]

        String name = "[\\u4e00-\\u9fa5]{2,10}";
        System.out.println("王者荣耀".matches(name));

        String car = "[京津晋冀蒙辽吉黑沪苏浙皖闽赣鲁豫鄂湘粤桂琼渝川贵云藏陕甘青宁新][ABCDEFGHJKLMNPQRSTUVWXY][\\dABCDEFGHJKLNMxPQRSTUVWXYZ]{5}$";


    }
}

14.05_常见对象(正则表达式的分割功能)(掌握)

A:正则表达式的分割功能  split()方法
	String类的功能：public String[] split(String regex)
B:案例演示
	年龄范围"18-24"
	
	
public class MyTest {
    public static void main(String[] args) {
        String str = "aaa=12225544442bbb=85855555558585ccc";
        String s = str.substring(0, str.indexOf("="));
        System.out.println(s);
        String s1 = str.substring(str.indexOf("=") + 1, str.lastIndexOf("="));
        System.out.println(s1);

        String s2 = str.substring(str.lastIndexOf("=") + 1);
        System.out.println(s2);

        System.out.println("===================================");
        //split("="); 根据正则切割字符串，返回的是字符串数组
        String[] strings = str.split("[=0-9]+");
        System.out.println(strings[0]);
        System.out.println(strings[1]);
        System.out.println(strings[2]);


    }
}

把给定字符串中的数字排序

A:案例演示:	需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”

public class MyTest2 {
    public static void main(String[] args) {
       /* A:
        案例演示:
        需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”*/

        String str = "91        27     46   38   50   101  20   222 11";

        //最终要的结果是  "11 20 27 38 46 50 91 101 222"

        /*
         *
         *   * 分析:
         * a: 定义目标字符串"91 27 46 38 50"
         * b: 对这个字符串进行切割,得到的就是一个字符串数组
         * c: 把b中的字符串数组转换成int类型的数组
         * (1): 定义一个int类型的数组,数组的长度就是字符串数组长度
         * (2): 遍历字符串数组,获取每一个元素.将其转换成int类型的数据
         * (3): 把int类型的数据添加到int类型的数组的指定位置
         * d: 排序
         * e: 创建一个StringBuilder对象,用来记录拼接的结果
         * f: 遍历int类型的数组, 将其每一个元素添加到StringBuilder对象中
         * g: 就是把StringBuilder转换成String
         * h: 输出
         *
         * */
        String[] strings = str.split("\\s+");
        //Arrays.sort(strings); 按照字典顺序排列的
        //System.out.println(Arrays.toString(strings));
        int[] arr = new int[strings.length];
        for (int i = 0; i < strings.length; i++) {
            arr[i] = Integer.parseInt(strings[i]);
        }
        //排序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        //StringBuilder stringBuilder = new StringBuilder();
        StringJoiner stringJoiner = new StringJoiner(" ");
        for (int i = 0; i < arr.length; i++) {
            stringJoiner.add(String.valueOf(arr[i]));
        }

        String s = stringJoiner.toString();
        System.out.println(s);
    }
}

分析:
a: 定义目标字符串"91 27 46 38 50"
b: 对这个字符串进行切割,得到的就是一个字符串数组
c: 把b中的字符串数组转换成int类型的数组
(1): 定义一个int类型的数组,数组的长度就是字符串数组长度
(2): 遍历字符串数组,获取每一个元素.将其转换成int类型的数据
(3): 把int类型的数据添加到int类型的数组的指定位置
d: 排序
e: 创建一个StringBuilder对象,用来记录拼接的结果
f: 遍历int类型的数组, 将其每一个元素添加到StringBuilder对象中
g: 就是把StringBuilder转换成String
h: 输出

正则表达式的替换功能

A:正则表达式的替换功能
	String类的功能：public String replaceAll(String regex,String replacement)
B:案例演示
	论坛发表帖子,帖子中需要将数字替换为"*"
public class MyTest3 {
    public static void main(String[] args) {
    /*
    *
    *  A:正则表达式的替换功能
	String类的功能：public String replaceAll(String regex,String replacement)
    *
    * */

        String str = "aaa=bbb=ccc"; //aaabbbccc
        System.out.println(str.replace("=", ""));
       /* String[] strings = str.split("=");
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < strings.length; i++) {
            sb.append(strings[i]);
        }
        System.out.println(sb.toString());*/


        String str2 = "aaa=&&%%122211bbb==&&%%1222114444ccc"; //aaabbbccc
        //根据正则表达式来替换
        String s = str2.replaceAll("[^a-z]+", "");
        System.out.println(s);


    }
}

Pattern和Matcher的概述

正则的获取功能需要使用的类

A:Pattern和Matcher的概述
B:模式和匹配器的典型调用顺序
通过JDK提供的API，查看Pattern类的说明

典型的调用顺序是 
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();
public class MyTest2 {
    public static void main(String[] args) {
        //把字符串中是 三个字母组成的单词获取出来
        String str = "da jia ting wo shuo,jin tian yao xia yun,bu shang wan zi xi,gao xing bu?";
        //demo1(str);

        //Pattern 模式器 封装一个正则表达式
        String regex = "\\b[ba-zA-Z]{3}\\b";
        Pattern p = Pattern.compile(regex);
        //通过模式器调用 matcher("aaaaab"); 传入待匹配的字符串，返回一个Matcher 这个匹配器
        Matcher m = p.matcher(str);
        //提取符合正则的字符串
       /* boolean find ()
        尝试查找与该模式匹配的输入序列的下一个子序列。
        String group ()
        返回由以前匹配操作所匹配的输入子序列。*/

      /*  //先find 后  group ()
        boolean b = m.find();
        if (b) {
            String group = m.group();
            System.out.println(group);
        }
        b = m.find();
        if (b) {
            String group = m.group();
            System.out.println(group);
        }*/
        while (m.find()) {
            String group = m.group();
            System.out.println(group);
        }
    }

    private static void demo1(String str) {
        String s = str.replaceAll("[^a-z]", " ").trim();
        System.out.println(s);
        String[] strings = s.split("\\s+");

        StringJoiner stringJoiner = new StringJoiner("=");

        for (int i = 0; i < strings.length; i++) {
            if (strings[i].length() == 3) {
                stringJoiner.add(strings[i]);
            }
        }
        String x = stringJoiner.toString();
        System.out.println(x);
        String[] split = x.split("=");
    }
}

正则表达式的获取功能

A:正则表达式的获取功能
	Pattern和Matcher的结合使用
B:案例演示  使用的是 find()方法  和 group()方法  注意一定要先使用find()方法先找到 才能用group()方法获取出来
	需求：获取下面这个字符串中由三个字符组成的单词 正则表达式 \\b[a-z]{3}\\b
	da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?

Math类概述和方法使用

A:Math类概述
	Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。 
B: 成员变量
	public static final double E : 		自然底数
	public static final double PI:		圆周率
C:成员方法
	public static int abs(int a)		取绝对值
	public static double ceil(double a)	向上取整
	public static double floor(double a)	向下取整
	public static int max(int a,int b)      获取最大值
	public static int min(int a, int b)	获取最小值
	public static double pow(double a,double b) 获取a的b次幂
	public static double random()	获取随机数 返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
	public static int round(float a) 四舍五入
	public static double sqrt(double a)获取正平方根
C:案例演示:	Math类的成员方法使用
public class MyTest {
    public static void main(String[] args) {
        // Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
        System.out.println(Math.abs(-1));
        System.out.println(Math.min(50, 20));
        System.out.println(Math.max(6.3, 6.8));
        //求三个数的最大值
        Math.max(Math.max(6.3, 6.8), 2.6);
        // 向上取整
        System.out.println(Math.ceil(3.14));
        System.out.println(Math.floor(3.14));
        System.out.println(Math.pow(2, 3));

        System.out.println(Math.sqrt(4));
        //求立方根
        System.out.println(Math.pow(8, 1 / 3.0));
        //随机小数
        System.out.println(Math.random());
        //四舍五入
        System.out.println(Math.round(3.463636));
        // static double cos ( double a)
        // 返回角的三角余弦。
        //System.out.println(Math.cos(3));

        System.out.println(Math.PI);

    }
}

Random类的概述和方法使用)

A:Random类的概述
此类用于产生随机数如果用相同的种子创建两个 Random 实例，
则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
B:构造方法
public Random() 没有给定种子,使用的是默认的(当前系统的毫秒值)
public Random(long seed) 给定一个long类型的种子,给定以后每一次生成的随机数是相同的
C:成员方法
public int nextInt()//没有参数表示的随机数范围是int类型的范围
public int nextInt(int n)//可以指定一个随机数范围
void nextBytes(byte[] bytes) 生成随机字节并将其置于用户提供的空的 byte 数组中。
D:案例演示
Random类的构造方法和成员方法使用

public class MyTest2 {
    public static void main(String[] args) {
        //Random 用来生成随机数据
        Random random = new Random();
        for (int i = 0; i < 500; i++) {
            //没有给参数生成的随机数范围是int范围
            // int num = random.nextInt();
            int num = random.nextInt(100); //范围 0---99
            System.out.println(num);
            //double num = random.nextDouble();
            //System.out.println(num);
            // boolean b = random.nextBoolean();
            // System.out.println(b);

```
    }
    byte[] bytes = new byte[20];
    random.nextBytes(bytes);

    System.out.println(Arrays.toString(bytes));
```

```
}
```

}

System类的概述和方法使用

A:System类的概述
	System 类包含一些有用的类字段和方法。它不能被实例化。 
B:成员方法
	public static void gc()//调用垃圾回收器
	public static void exit(int status)//退出java虚拟机 0 为正常退出 非0为 异常退出
	public static long currentTimeMillis()//获取当前时间的毫秒值
C:案例演示:	System类的成员方法使用
public class MyTest4 {
    public static void main(String[] args) {
        //System
        Scanner scanner = new Scanner(System.in);
        //
      /*  static InputStream in
          “标准”输入流。
        static PrintStream out
          “标准”输出流。*/
        //标准”输入流。此流已打开并准备提供输入数据。通常，此流对应于键盘输入
        InputStream in = System.in;

        //PrintStream
        //“标准”输出流。此流已打开并准备接受输出数据。通常，此流对应于显示器
        /*
        *  对于简单独立的 Java 应用程序，编写一行输出数据的典型方式是：

         System.out.println(data)

        *
        * */
        PrintStream out = System.out;

        out.print("abc");
        out.println(2000);

        System.err.println(200);


    }
}


public class MyTest5 {
    public static void main(String[] args) {
        // static void gc ()
        // 运行垃圾回收器。
        Scanner scanner = new Scanner(System.in);


        scanner = null;
        // scanner.close();
        //public static void exit ( int status)//退出java虚拟机 0 为正常退出 非0为 异常退出

        System.gc();

        // static String getProperty (String key)
        // 获取指定键指示的系统属性。
        Properties properties = System.getProperties();
        //System.out.println(properties.keySet());
        String path = System.getProperty("user.home");
        System.out.println(path);

    }
}



//
public class MyTest7 {
    public static void main(String[] args) {
        //public static long currentTimeMillis ()//获取当前时间的毫秒值
        //1s=1000ms
        //计算机历元年 1970 01-01 00：00：00------到现在的这个时间所间隔的毫秒值
        long timeMillis = System.currentTimeMillis();
        //System.out.println(timeMillis);

        for (int i = 0; i < 50000; i++) {
            System.out.println(i);
        }

        long end = System.currentTimeMillis();
        System.out.println("耗时" + (end - timeMillis) + "毫秒");

        System.out.println("====================================");


    }
}

BigDecimal类的概述和方法使用

A:BigDecimal的概述
由于在运算的时候，float类型和double很容易丢失精度，演示案例。
所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal

不可变的、任意精度的有符号十进制数。

B:构造方法
public BigDecimal(String val)
C:成员方法
public BigDecimal add(BigDecimal augend)//加
public BigDecimal subtract(BigDecimal subtrahend)//减
public BigDecimal multiply(BigDecimal multiplicand)//乘
public BigDecimal divide(BigDecimal divisor)//除法
public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)//scale 小数点后面保留几位
// roundingMode 取舍模式比如四舍五入
D:案例演示
BigDecimal类的构造方法和成员方法使用

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

        // System.out.println(1.2 * 3); //
        // System.out.println(0.1 + 0.2); //
        //double d = 10.0 / 3;
        //System.out.println(d);
        //对精度要求高
        //会有对应的类
        double a = 3.3333333333333335;
        double b = 3.3333333333333335;
        System.out.println(a * b);

        BigDecimal aa = new BigDecimal("3.3333333333333335");

        BigDecimal bb = new BigDecimal("3.3333333333333335");


        BigDecimal multiply = aa.multiply(bb);
        System.out.println(multiply.toString());


    }
}

Date类的概述和方法使用

A:Date类的概述
	类 Date 表示特定的瞬间，精确到毫秒。 
B:构造方法
	public Date()
	public Date(long date)  //把一个long类型的毫秒值转换成一个日期对象
C:成员方法

public long getTime(): 获取一个日期对象对象毫秒值
public void setTime(long time): 给一个日期对象设置上指定的毫秒值例：date.setTime(1000 * 60 * 60) ;
D:案例演示
Date类的构造方法和成员方法使用

public class MyTest {
    public static void main(String[] args) {
        Date date = new Date();
        //Sat May 15 16:24:13 CST 2021
        System.out.println(date);
        //月份由从 0 至 11 的整数表示；0 是一月、1 是二月等等；因此 11 是十二月
        int month = date.getMonth();
        System.out.println(month);
        //返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
        long time = date.getTime();  //跟 System.currentTimeMillis();


    }
}



public class MyTest2 {
    public static void main(String[] args) {
        //Fri Jan 02 08:00:00 CST 1970
        //给历元年加上相应的时间量 单位是毫秒
        // Date date = new Date(1000 * 60 * 60 * 24);
        //  System.out.println(date);

        Date date = new Date();
        //给历元年加上相应的时间量 单位是毫秒
        date.setTime(1000 * 60 * 60 * 24);
        System.out.println(date);

        /*
        *  Date ---- long 的转换
                调用getTime方法

            long --- Date 的转换
            可以使用构造方法
                setTime(long time)
        *
        * */
        Date date1 = new Date();
        long time = date1.getTime();

        Date date2 = new Date(time);


    }
}

Date ---- long 的转换
调用getTime方法

long — Date 的转换
可以使用构造方法
setTime(long time)

SimpleDateFormat类实现日期和字符串的相互转换

SimpleDateFormat: 可以把一个日期对象格式化成一个文本(字符串) , 也可以把一个日期字符串解析成一个日期对象
public class MyTest2 {
    public static void main(String[] args) throws ParseException {
        String str = "2021-05-05 16:40:30"; //Date
        //ParseException 你的日期字符串和日期格式要一一对应。
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = dateFormat.parse(str);
        System.out.println(date);
        //Date----String
        // simpleDateFormat.format(date);

        //String----Date
        // dateFormat.parse(str)
    }
}

构造方法:
public SimpleDateFormat():使用默认的模式来创建一个SimpleDateFormat对象
public SimpleDateFormat(String pattern):使用指定的模式（规则比如yyyy:MM:dd HH:mm:ss）来创建一个SimpleDateFormat对象
规则的定义
y 年
M 月
d 天
H 时
m 分
s 秒
成员方法:
public String format(Date date): 把一个日期对象格式化成一个字符串
public Date parse(String dateStr): 把一个日期字符串解析成一个日期对象注意要以指定格式解析

日期工具类的编写和测试案例

A:案例演示
	日期工具类的编写
	日期工具类的测试
	
public class MyTest2 {
    public static void main(String[] args) {
        Calendar instance = Calendar.getInstance();
        int year = instance.get(Calendar.YEAR);
        System.out.println(year);
        int month = instance.get(Calendar.MONTH);
        System.out.println(month);
        int day = instance.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
        int i = instance.get(Calendar.HOUR_OF_DAY);
        System.out.println(i);
        int h = instance.get(Calendar.HOUR);
        System.out.println(h);


    }
}

你来到这个世界多少天案例

A:案例演示:	需求：算一下你来到这个世界多少天?
分析:

public class MyTest {
    public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的生日 1990-01-01");
        String birthday = sc.nextLine();
        //把你出生的这天毫秒值算算出来
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date = dateFormat.parse(birthday);
        long time = date.getTime();


        long now = System.currentTimeMillis();

        int day = (int) ((now - time) / 1000 / 60 / 60 / 24);
        System.out.println("来到这个世界" + day + "天");

    }
}

a: 键盘录入一个生日(日期字符串)
b: 把这个日期字符串对象解析成一个日期对象
c: 获取b中的日期对象对应的毫秒值
d: 获取当前系统时间对应的毫秒值
e: 使用d中的毫秒值 - c中的毫秒值
f: 把e中的差值换算成对应的天差值/1000/60/60/24
g: 输出

Calendar类的概述和获取日期的方法

A:Calendar类的概述
Calendar 类是一个抽象类，不能直接new对象，可以通过他的一个静态成员方法getInstance()来获取他的对象
它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR
等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
B:成员方法
public static Calendar getInstance() 使用默认时区和语言环境获得一个日历对象
public int get(int field) 获得给定日历字段对应的值 field通过Calendar提供的字段来拿
C:案例演示
Calendar类的成员方法使用

Calendar类的add()和set()方法)

A:成员方法
	public void add(int field,int amount)		根据日历的规则，为给定的日历字段添加或减去指定的时间量
	public final void set(int year,int month,int date)	设置日历时间 年月日
B:案例演示
	Calendar类的成员方法使用

如何获取任意年份的2月份有多少天

A:案例演示
	需求：键盘录入任意一个年份，获取任意一年的二月有多少天
	分析:
public class MyTest2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个年份");
        int year = sc.nextInt();
        //把日期设置到 3月 1号
        Calendar cal = Calendar.getInstance();
        //0---1
        cal.set(year, 2, 1);
        //我再把日期减去1天 就到了二月最后一天，我拿到这一天
        cal.add(Calendar.DAY_OF_MONTH, -1);
        int i = cal.get(Calendar.DAY_OF_MONTH);
        System.out.println(i);
    }
}

a: 键盘录入一个年份
b: 创建一个Calendar对象
c: 把这个Calendar的时间设置为a中录入的年的3月1号注意2表示3月
d: 向前推算一天
e: 获取月中的天
f: 输出

// 创建一个Scanner对象
Scanner sc = new Scanner(System.in) ;

	// 友情提示
	System.out.println("请您输入一个年: ");
	
	// 获取键盘录入数据
	int year = sc.nextInt() ;

补充:判断是不是一个闰年
if(year%40&&year%100!=0||year%4000){
System.out.println(“是闰年”);
}

BigInteger概述可以让超过long范围内的数据进行运算

构造方法
public BigInteger(String val)
成员方法
public BigInteger add(BigInteger val)
public BigInteger subtract(BigInteger val)
public BigInteger multiply(BigInteger val)
public BigInteger divide(BigInteger val)
public BigInteger[] divideAndRemainder(BigInteger val)

示例
 BigInteger bi1=new BigInteger("100");
 BigInteger bi2=new BigInteger("2");
        
System.out.println(bi1.add(bi2));   //+
System.out.println(bi1.subtract(bi2));   //-
System.out.println(bi1.multiply(bi2));   //*
System.out.println(bi1.divide(bi2));    //(除)
        
 BigInteger[] arr=bi1.divideAndRemainder(bi2);    //取除数和余数
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

##集合

对象数组的概述和使用

A:案例演示
	需求：我有3个学生，请把这个3个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。
		  学生：Student
			成员变量：name,age
			构造方法：无参,带参
			成员方法：getXxx()/setXxx()
			存储学生的数组?自己想想应该是什么样子的?
public class MyTest {
    public static void main(String[] args) {
        /*A:
        案例演示
        需求：我有3个学生，请把这个3个学生的信息存储到数组中，并遍历数组，获取得到每一个学生信息。*/

        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王五", 25);
        Student s4 = new Student("赵六", 26);

        //定义数组 对象数组
        Student[] arr = {s1, s2, s3};

        for (int i = 0; i < arr.length; i++) {

            Student student = arr[i];
            System.out.println(student.getName() + "====" + student.getAge());
        }
        /*
         * 数组作为容器，可以存储基本数据类型也可以存储引用数据类型，
         * 但是数组作为容器，一旦定义，长度就不能改变了，所以我们在操作数组中的元素时，就不是很方便，
         * 所以Java为了我们更加方便的去操作容器中的元素，给我们提供了一种新的容器，叫做集合。
         * 因为集合的长度是可变的。
         * */


        //数组和集合的区别？
        //数组的长度是固定的，一旦定义长度就不能改变了，集合的长度是可变的。
        //数组即可以存储基本数据类型，也可以存储引用数据类型，集合只能存储引用数据类型。
        //数组只能存储同一种数据类型，集合可以存储多种数据类型。

    }
}


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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

集合的由来以及集合继承

A:集合的由来
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。
B:数组和集合的区别
(1): 长度区别:
数组的长度是固定的而集合的长度是可变的
(2): 存储数据类型的区别:
数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型
(3): 内容区别:
数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素
C:集合继承体系图

Collection集合的功能概述

A:Collection的功能概述(通过API查看即可得到)
a:添加功能
boolean add(Object obj):添加一个元素
// boolean addAll(Collection c):添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)
b:删除功能
void clear():移除所有元素
boolean remove(Object o):移除一个元素
// boolean removeAll(Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素
如果没有交集元素则删除失败返回false
c:判断功能
boolean contains(Object o)：判断集合中是否包含指定的元素
boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(这个集合包含另一个集合中所有的元素才算包含才返回true)
比如：1，2，3 containsAll 12=true 1,2,3 containsAll 2,3,4=false
boolean isEmpty()：判断集合是否为空
d:获取功能
Iterator iterator()(重点)
e:长度功能
int size():元素的个数
面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?
f:交集功能
//例如：A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化
//A集合对B集合取交集元素，如果没有取到交集元素A集合会被清空
boolean retainAll(Collection c):获取两个集合的交集元素(交集：两个集合都有的元素)
g:把集合转换为数组
Object[] toArray()

Collection集合的基本功能测试

A:案例演示	
	boolean add(E e)
	boolean remove(Object o)
	void clear()
	boolean contains(Object o)
	boolean isEmpty()
	int size()
public class MyTest {
    public static void main(String[] args) {
        //集合一种容器，每种集合都有不同的特点，Java给我们提供了很多集合。
        //Collection 集合 他说一种单列集合
        //Collection 是一个集合体系，有父接口和实现类

        //顶层接口定义的方法， 下面的两个子接口中，子接口中也会定义自己特有的功能 实现类 得实现他两个父接口的功能
        //多态的方式
        //创建了集合
        Collection list = new ArrayList();
        //往容器中添加内容 add()
        boolean b = list.add("张三");
        list.add("李四");
        list.add("王五");
        System.out.println(list);


    }
}

public class MyTest4 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add(200);
        list.add(200);
        list.add(300);

        //清空集合中的元素
        //list.clear();
        //删除单个元素
        list.remove(200);
        System.out.println(list);
    }
}

public class MyTest {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add(200);
        list.add(400);
        list.add(300);
        list.add(1);
        //判断集合中是否包含该元素
        boolean b = list.contains(4000);
        System.out.println(b);
    }
}

Collection集合的高级功能

A:案例演示
	boolean addAll(Collection c)
	boolean removeAll(Collection c)
	boolean containsAll(Collection c)
	boolean retainAll(Collection c)
public class MyTest2 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add(200);
        list.add(400);
        list.add(300);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(10);
        list.add(5555);

        Collection list2 = new ArrayList();
        list2.add(2);
        list2.add(3);
        list2.add(4);
        list2.add(400);
        list2.add(10);
        list2.add(200);
        //A集合containsAll(B集合); A集合中的元素是否包含了B集合中所有的元素，包含了就返回true,没有就返回false
        boolean b = list.containsAll(list2);
        System.out.println(b);
    }
}



public class MyTest5 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add(200);
        list.add(400);
        list.add(300);
        list.add(1);

        Collection list2 = new ArrayList();
        list2.add(2);
        list2.add(3);
        list2.add(4);
        list2.add(400);
        list2.add(200);
        //A集合removeAll(B); A集合中会删除掉两个集合中的交集元素，B集合不会发生变化。返回值的意思就是如果有交集元素被删除就返回true
        boolean b = list.removeAll(list2);
        System.out.println(b);
        System.out.println(list);
        System.out.println(list2);
    }
}

集合的遍历之集合转数组遍历

A:集合的遍历  
	toArray() 把一个集合转成数组
	
	其实就是依次获取集合中的每一个元素。
B:案例演示
	把集合转成数组toArray()，遍历这个数组 可以实现集合的遍历
	
	
	
public class MyTest4 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add(200);
        list.add(400);
        list.add(300);
        list.add(1);
        //把集合转换成数组
        int size = list.size();
        Integer[] arr = new Integer[size];

        Iterator iterator = list.iterator();
        int i = 0;
        while (iterator.hasNext()) {
            Integer next = (Integer) iterator.next();
            arr[i] = next;
            i++;
        }

        System.out.println(Arrays.toString(arr));

        System.out.println("===========================================");

        //把集合转换成数组。
        Object[] objects = list.toArray();

        /*
        *     public Object[] toArray() {
                        return Arrays.copyOf(elementData, size);
                }
        *
        * */

    }
}

Collection存储自定义对象并遍历

A:案例演示
	Collection存储自定义对象并把集合转成对象数组遍历

集合的遍历之迭代器遍历)

A:迭代器概述:	对 collection 进行迭代的迭代器
B:案例演示:		迭代器的使用
public class MyTest2 {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add(200);
        list.add(400);
        list.add(300);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(10);
        list.add(5555);

        Collection list2 = new ArrayList();
        list2.add(2);
        list2.add(3);
        list2.add(4);
        list2.add(400);
        list2.add(10);
        list2.add(200);
        //A集合containsAll(B集合); A集合中的元素是否包含了B集合中所有的元素，包含了就返回true,没有就返回false
        boolean b = list.containsAll(list2);
        System.out.println(b);
    }
}

A:案例演示:	Collection存储自定义对象并用迭代器遍历

(迭代器的原理及源码解析)

A:迭代器原理:	为什么迭代器不定义成一个类 , 而是定义成一个接口?
B:迭代器源码解析

(Collection集合存储字符串并遍历)

A:学生练习
	Collection集合存储字符串并遍历
	迭代器的方式
public class MyTest3 {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王五", 25);
        Student s4 = new Student("赵六", 26);
        Collection list = new ArrayList();
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);

        Iterator iterator = list.iterator();
        /*
        *    public Iterator<E> iterator() {
                return new Itr();
              }
        * */
        while (iterator.hasNext()) {
            Student stu = (Student) iterator.next();
            System.out.println(stu.getName() + "===" + stu.getAge());
        }

        list.clear();
        boolean empty = list.isEmpty();
        System.out.println(empty);
        if (list.size() == 0) {

        }
    }
}

Collection集合存储自定义对象并遍历

A:学生练习
	Collection集合存储自定义对象并遍历
	迭代器的方式
public class MyTest3 {
    public static void main(String[] args) {
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王五", 25);
        Student s4 = new Student("赵六", 26);
        Collection list = new ArrayList();
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);

        Iterator iterator = list.iterator();
        /*
        *    public Iterator<E> iterator() {
                return new Itr();
              }
        * */
        while (iterator.hasNext()) {
            Student stu = (Student) iterator.next();
            System.out.println(stu.getName() + "===" + stu.getAge());
        }

        list.clear();
        boolean empty = list.isEmpty();
        System.out.println(empty);
        if (list.size() == 0) {

        }
    }
}

(List概述及特点以及存储字符串并遍历)

A:List概述及特点:	元素有序,并且每一个元素都存在一个索引.元素可以重复.
B:案例演示
	List集合存储字符串并遍历
	迭代器的方式
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(500);

        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            System.out.println(o);
        }
        System.out.println("================================");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }

        System.out.println("===================================");

        //ArrayList$ListItr
        /*

        boolean hasPrevious()
          如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
        *   E previous()
          返回列表中的前一个元素。
        *
        * */
        ListIterator listIterator = list.listIterator();
        System.out.println(listIterator);
        while (listIterator.hasNext()) {
            Object next = listIterator.next();
            System.out.println(next);
        }
    }
}




public class MyTest2 {

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");
        list.add("fff");

        ListIterator listIterator = list.listIterator();
        //System.out.println(listIterator);
        //你要反向迭代，先要正向迭代
        while (listIterator.hasNext()) {
            Object next = listIterator.next();
            System.out.println(next);
        }
        System.out.println("============================");

        while (listIterator.hasPrevious()) {
            Object previous = listIterator.previous();
            System.out.println(previous);
        }
    }
}

(List集合存储学生对象并遍历)

A:案例演示:	List集合存储学生对象并遍历
			迭代器的方式

(List集合的特有功能概述和测试)

A:List集合的特有功能概述
void add(int index,E element): 在指定索引处添加元素
E remove(int index):移除指定索引处的元素返回的是移除的元素
E get(int index):获取指定索引处的元素
E set(int index,E element):更改指定索引处的元素返回的而是被替换的元素
int indexOf(Object o)
返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
int lastIndexOf(Object o)
返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
B:案例演示: 特有功能测试

public class MyTest3 {
    public static void main(String[] args) {
        // 需求：我有一个集合，请问，我想判断里面有没有 "world" 这个元素，如果有，我就添加一个 "javaee" 元素，请写代码实现。

        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");
        list.add("world");

     /*   if (list.contains("world")) {
            list.add("javaee");
        }
        System.out.println(list);*/
        /*
         *  ConcurrentModificationException 并发修改异常。
         *
         *我们用Iterator这个迭代器遍历采用hasNext方法和next方法，集合修改集合 会出现并发修改异常
	原因是我们的迭代依赖与集合 当我们往集合中添加好了元素之后 获取迭代器  那么迭代器已经知道了集合的元素个数
	这个时候你在遍历的时候又突然想给 集合里面加一个元素（用的是集合的add方法） 那迭代器不同意 就报错了
         *
         *
         * */
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            String ele = (String) listIterator.next();
            if ("world".equals(ele)) {
                //list.add("javaee");
                //list.remove("aaa");
                listIterator.add("javaee");
                //listIterator.remove();
            }
        }
        System.out.println(list);
        //解决方案
        //采用for循环
     /*   for (int i = 0; i < list.size(); i++) {
            String ele = (String) list.get(i);
            if ("world".equals(ele)) {
                list.add("javaee");
            }
        }

        System.out.println(list);*/

        //你用迭代器遍历，中途想要往集合中添加或删除元素，你要用迭代器自带的添加删除方法，就不会抛出异常。

    }
}

(List集合的特有遍历功能)

A:案例演示: 使用for循环	通过size()和get()方法结合使用遍历。
public class MyTest3 {
    public static void main(String[] args) {
        // 需求：我有一个集合，请问，我想判断里面有没有 "world" 这个元素，如果有，我就添加一个 "javaee" 元素，请写代码实现。

        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");
        list.add("world");

     /*   if (list.contains("world")) {
            list.add("javaee");
        }
        System.out.println(list);*/
        /*
         *  ConcurrentModificationException 并发修改异常。
         *
         *我们用Iterator这个迭代器遍历采用hasNext方法和next方法，集合修改集合 会出现并发修改异常
	原因是我们的迭代依赖与集合 当我们往集合中添加好了元素之后 获取迭代器  那么迭代器已经知道了集合的元素个数
	这个时候你在遍历的时候又突然想给 集合里面加一个元素（用的是集合的add方法） 那迭代器不同意 就报错了
         *
         *
         * */
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            String ele = (String) listIterator.next();
            if ("world".equals(ele)) {
                //list.add("javaee");
                //list.remove("aaa");
                listIterator.add("javaee");
                //listIterator.remove();
            }
        }
        System.out.println(list);
        //解决方案
        //采用for循环
     /*   for (int i = 0; i < list.size(); i++) {
            String ele = (String) list.get(i);
            if ("world".equals(ele)) {
                list.add("javaee");
            }
        }

        System.out.println(list);*/

        //你用迭代器遍历，中途想要往集合中添加或删除元素，你要用迭代器自带的添加删除方法，就不会抛出异常。

    }
}


public class MyTest2 {

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");
        list.add("fff");

        ListIterator listIterator = list.listIterator();
        //System.out.println(listIterator);
        //你要反向迭代，先要正向迭代
        while (listIterator.hasNext()) {
            Object next = listIterator.next();
            System.out.println(next);
        }
        System.out.println("============================");

        while (listIterator.hasPrevious()) {
            Object previous = listIterator.previous();
            System.out.println(previous);
        }
    }
}

(List集合存储学生对象并遍历)

A:学生练习:	List集合存储学生对象并遍历。通过size()和get()方法结合使用遍历。
public class MyTest5 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(new Student("张三", 23));
        list.add(new Student("张三", 23));
        list.add(new Student("李四", 24));
        list.add(new Student("李四", 24));
        list.add(new Student("王五", 25));
        list.add(new Student("赵六", 26));

        ArrayList newList = new ArrayList();
        for (int i = 0; i < list.size(); i++) {
            Student student = (Student) list.get(i);
            if (!newList.contains(student)) {
                newList.add(student);
            }
        }
        System.out.println(newList);
    }
}

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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", 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;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

(ListIterator的特有功能)

ListIterator 继承自Iterator 可以使用Iterator中的方法
A:ListIterator的特有功能
boolean hasPrevious(): 是否存在前一个元素
E previous(): 返回列表中的前一个元素
// 以上两个方法可以实现反向遍历但是注意要完成反向遍历之前要先进行正向遍历这样指针才能移到最后
// 如果直接反向遍历是没有效果的因为指针默认位置就在最前面他前面没有元素
B:案例演示: ListIterator的特有功能

public class MyTest2 {

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");
        list.add("fff");

        ListIterator listIterator = list.listIterator();
        //System.out.println(listIterator);
        //你要反向迭代，先要正向迭代
        while (listIterator.hasNext()) {
            Object next = listIterator.next();
            System.out.println(next);
        }
        System.out.println("============================");

        while (listIterator.hasPrevious()) {
            Object previous = listIterator.previous();
            System.out.println(previous);
        }
    }
}

并发修改异常产生的原因及解决方案)(了解)

A:案例演示
	需求：我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。
B:ConcurrentModificationException出现
	我们用Iterator这个迭代器遍历采用hasNext方法和next方法，集合修改集合 会出现并发修改异常
	原因是我们的迭代依赖与集合 当我们往集合中添加好了元素之后 获取迭代器  那么迭代器已经知道了集合的元素个数
	这个时候你在遍历的时候又突然想给 集合里面加一个元素（用的是集合的add方法） 那迭代器不同意 就报错了
C:解决方案 我们用ListIterator迭代器遍历 用迭代器自带的add方法添加元素 那就不会报错了
	a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
	b:集合遍历元素，集合修改元素

	解决方案2 使用for循环遍历集合 添加元素 不会报错

1(数据结构之栈和队列)

A:数据结构概述及常见数据结构
	数据结构其实就是存储数据的格式
	分类:	栈 , 队列 , 数组 , 链表 , 树 , 哈希表 图
B:栈特点: 	先进后出 弹夹

C:队列: 	先进先出

数据结构之数组和链表

A:数组特点:	查询快 , 增删慢
B:链表特点: 	查询慢 , 增删快

List的三个子类的特点

A:List的三个子类的特点
	ArrayList:
		底层数据结构是数组，查询快，增删慢。
		线程不安全，效率高。
	Vector:
		底层数据结构是数组，查询快，增删慢。
		线程安全，效率低。
	LinkedList:
		底层数据结构是链表，查询慢，增删快。
		线程不安全，效率高。
B:List有三个儿子，我们到底使用谁呢?
得看  要安全还是要效率
  是查找多还是增删多
public class MyTest2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(100);
        list.add(20);
        list.add(3);
        list.add(0);
        list.add(2);
        //Comparator
        list.sort(new Comparator() {
            @Override
            public int compare(Object a, Object b) {
                System.out.println(a + "====" + b);
                // 大 小 等于  正 负  0
                Integer num1 = (Integer) a;
                Integer num2 = (Integer) b;
                return -(num1 - num2);
            }
        });

        System.out.println(list);

        System.out.println("==========================================");
        //Consumer
        list.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });

    }
}


public class MyTest4 {
    public static void main(String[] args) {
       /* A:
        Vector类概述:
        java.util.Vector 类可以实现可增长的对象数组, Vector 是同步的。
        B:
        Vector类特有功能
        public void addElement (E obj)
        public E elementAt ( int index)
        public Enumeration elements ()
        E firstElement () 返回此向量的第一个组件（位于索引 0)处的项）。
        E lastElement () 返回此向量的最后一个组件。
        void insertElementAt (E obj,int index)将指定对象作为此向量中的组件插入到指定的 index 处。*/

        Vector vector = new Vector();
        vector.add(0, 200);
        vector.addElement(200);
        // Object o = vector.get(0);
        // Object o1 = vector.elementAt(2);

        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()) {
            Object o = elements.nextElement();
            System.out.println(o);
        }

    }
}

大官人的西门庆

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
##正则表达式常见类的使用

##正则表达式//常见类的使用//集合###正则表达式A：正则表达式:正确规则的表达式规则java给我们定的是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。B：案例演示需求：校验qq号码. 1:要求必须是5-15位数字 2:0不能开头 a:非正则表达式实现 b:正则表达式实现public class MyTest { public static void main(String[] args) {
复制链接

扫一扫