java学习笔记5

作者: 海洋_5ad4 | 来源:发表于2018-11-02 13:58 被阅读0次

正则表达式的概述和简单使用

A:正则表达式
- 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
- 作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的
B:案例演示
- 需求：校验qq号码.
  - 1:要求必须是5-15位数字
  - 2:0不能开头
  - 3:必须都是数字
- a:非正则表达式实现
- b:正则表达式实现

package com.heima.regex;

public class Demo1_regex {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String regex = "[1-9]\\d{4,14}";
        System.out.println("23456".matches(regex));
        System.out.println("023456".matches(regex));
    }

}

字符类演示

A:字符类
[abc] a、b 或 c（简单类）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或 f（交集）
[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）

package com.heima.regex;

public class Demo2_regex {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String regex1 = "[a-d[m-p]]";  //a到d或m到p
        String regex2 = "[a-z&&[def]]";  //d或e或f
        String regex3 = "[a-z&&[^bc]]";  //a到z除了b和c
        String regex4 = "[a-z&&[^m-p]]";//a到z，除了m到p
    }

    private static void demo3() {
        String regex = "[a-zA-Z]";
        System.out.println("a".matches(regex));
        System.out.println("A".matches(regex));
        System.out.println("z".matches(regex));
        System.out.println("Z".matches(regex));
        System.out.println("1".matches(regex));
        System.out.println("%".matches(regex));
    }

    private static void demo2() {
        String regex = "[^abc]";
        System.out.println("a".matches(regex));
        System.out.println("b".matches(regex));
        System.out.println("c".matches(regex));
        System.out.println("d".matches(regex));
        System.out.println("1".matches(regex));
        System.out.println("%".matches(regex));
        System.out.println("10".matches(regex)); //"10"代表两个字符，返回false   
    }

    private static void demo1() {
        String regex = "[abc]";
        System.out.println("a".matches(regex));  
        System.out.println("b".matches(regex));
        System.out.println("c".matches(regex));
        System.out.println("d".matches(regex));
        System.out.println("1".matches(regex));
        System.out.println("%".matches(regex)); 
    }

}

预定义字符类演示

package com.heima.regex;

public class Demo3_Regex {

    /**
     * 预定义字符类 
    . 任何字符（与行结束符可能匹配也可能不匹配） 
    \d 数字：[0-9] 
    \D 非数字： [^0-9] 
    \s 空白字符：[ \t\n\x0B\f\r] 
    \S 非空白字符：[^\s] 
    \w 单词字符：[a-zA-Z_0-9] 
    \W 非单词字符：[^\w] 

     */
    public static void main(String[] args) {
        String regex1 =".";    //任意字符，单个字符
        String regex2 ="\\d";  //\代表转义字符，如果向表示\d的话，需要\\d
        String regex3 ="\\s";
        System.out.println(" ".matches(regex3)); //一个空格，true
        System.out.println("    ".matches(regex3)); //一个tab键，true
        System.out.println("    ".matches(regex3)); //四个空格，四个字符，false
    }

}

数量词

A:Greedy 数量词
- X? X，一次或一次也没有
- X* X，零次或多次
- X+ X，一次或多次
- X{n} X，恰好 n 次
- X{n,} X，至少 n 次
- X{n,m} X，至少 n 次，但是不超过 m 次

package com.heima.regex;

public class Demo4_Regex {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String regx = "[abc]{5,15}";    //5-15次
    }

    private static void demo2() {
        String regex = "[abc]*";
        System.out.println("".matches(regex));
        System.out.println("abc".matches(regex));
        System.out.println("a".matches(regex));  //大于等于0次就可以了
    }

    private static void demo1() {
        String regex = "[abc]?";
        System.out.println("a".matches(regex));     //true
        System.out.println("b".matches(regex));     //true
        System.out.println("c".matches(regex));     //true
        System.out.println("d".matches(regex));     //不能是其他字符，false
        System.out.println("".matches(regex));      //一次也没有,true
    }

}

正则表达式的分割功能)

A:正则表达式的分割功能
- String类的功能：public String[] split(String regex)
B:案例演示
- 正则表达式的分割功能

package com.heima.regex;

public class Demo5_Split {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String s = "123.456.789";
        String[] arr = s.split("\\.");  //通过正则表达式切割字符串，这里匹配.字符需要\\.
        
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        
    }

}

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

package com.heima.test;

import java.util.Arrays;

public class Test1 {

    /**
     * * A:案例演示
     * 需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”
     * 分析：
     * 1，将字符串切割成字符串数组
     * 2，将字符串转换成数字并将其储存在一个等长度的int数组中
     * 3，排序
     * 4，将排序后的结果遍历并拼接成一个字符串
     */
    public static void main(String[] args) {
        String s = "91 27 46 38 50";
        //1，将字符串切割成字符串数组
        String[] sArr = s.split(" ");
        //2，将字符串转换成数字并将其储存在一个等长度的int数组中
        int[] arr = new int[sArr.length];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = Integer.parseInt(sArr[i]);     //将数组字符串转换成数字
        }
        //3，排序
        Arrays.sort(arr);
        //4，将排序后的结果遍历并拼接成一个字符串27 38 46 50 91
        /*这种方式会产生很多字符串对象，同时会把很多字符串对象当作垃圾回收
        String str = "";
        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length - 1) {
                str = str + arr[i];
            }else {
                str = str + arr[i] + " ";
            }
        }   
        System.out.println(str);
        */
        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] + " ");
            }
        }
        System.out.println(sb);
    }
}

正则表达式的替换功能

package com.heima.regex;

public class Demo6_ReplaceAll {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String s = "wo123ai245667heima";
        String regex = "\\d";       //\\d代表的是数字
        String s2 = s.replaceAll(regex, "");
        System.out.println(s2);
    }

}

正则表达式的分组功能

A:正则表达式的分组功能
- 捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组：

        1     ((A)(B(C))) 
        2     (A 
        3     (B(C)) 
        4     (C) 
    
        组零始终代表整个表达式。

B:案例演示
a:切割
需求：请按照叠词切割： "sdqqfgkkkhjppppkl";
b:替换
需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
将字符串还原成:“我要学编程”。

package com.heima.regex;

public class Demo7_Regex {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
        //将字符串还原成:“我要学编程”。
        String s = "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..";
        String s2 = s.replaceAll("\\.+", "");
        System.out.println(s2);
        String s3 = s2.replaceAll("(.)\\1+", "$1");     //$1代表第一组中的内容
        System.out.println(s3);
    }

    private static void demo2() {
        //需求：请按照叠词切割： "sdqqfgkkkhjppppkl"
        String s = "sdqqfgkkkhjppppkl";
        String regex = "(.)\\1+";       //+代表第一组出现一次到多次
        String[] arr = s.split(regex);
        
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    private static void demo1() {
        //叠词 快快乐乐，高高兴兴
        /*String regex = "(.)\\1(.)\\2";
        System.out.println("快快乐乐".matches(regex));//\\1代表第一组又出现一次
        System.out.println("快乐快乐".matches(regex));//\\2代表第二组又出现一次
        System.out.println("高高兴兴".matches(regex));
        System.out.println("快快快快".matches(regex));*/
        
        //叠词 高兴高兴，快乐快乐
        String regex2 = "(..)\\1";
        System.out.println("高兴高兴".matches(regex2));
        System.out.println("快乐快乐".matches(regex2));
        System.out.println("快快乐乐".matches(regex2));
    }

}

Pattern和Matcher的概述

A:Pattern和Matcher的概述
B:模式和匹配器的典型调用顺序
- 通过JDK提供的API，查看Pattern类的说明
- 典型的调用顺序是
- Pattern p = Pattern.compile("a*b");
- Matcher m = p.matcher("aaaaab");
- boolean b = m.matches();

package com.heima.regex;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Demo8_Pattrn {

    /**
     *  需求：把一个字符串中的手机号码获取出来
     */
    public static void main(String[] args) {
         String s = "我的手机号码是18988888888，曾经用过18987654321，还用过18812345678";
         String regex = "1[3578]\\d{9}";
         /*Pattern p = Pattern.compile(regex);
         Matcher m = p.matcher(s);
         boolean b = m.matches();
         System.out.println(b); //返回false*/
         Pattern p = Pattern.compile(regex);
         Matcher m = p.matcher(s);
         /*boolean b1 = m.find();
         System.out.println(b1);    //true
         String s1 = m.group();
         System.out.println(s1);    //先先find找到才有结果，否则会报错No match found
*/       
         while(m.find())    
             System.out.println(m.group()); 
         //18988888888
         //18987654321
         //18812345678
    }

    private static void demo1() {
        Pattern p = Pattern.compile("a*b"); //获取到正则表达式
         Matcher m = p.matcher("aaaaab");       //获取匹配器
         boolean b = m.matches();               //看是否能匹配，匹配就返回true
         System.out.println(b);
         
         System.out.println("aaaaab".matches("a*b")); //与上面的结果一致
    }

}

Math类概述和方法使用

A:Math类概述
- Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
B:成员方法
- 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) min自学
- public static double pow(double a,double b)
- public static double random()
- public static int round(float a) 参数为double的自学
- public static double sqrt(double a)

package com.heima.otherclass;

public class Demo1_Math {

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(Math.PI);
        System.out.println(Math.abs(-10));  //取绝对值
        //ceil天花板   //floor地板
        System.out.println(Math.ceil(-2.5));    //向上取值，结果是一个double
        System.out.println(Math.floor(-2.5));   //向下取值，结果是一个double
        //获取两个值中的最大值
        System.out.println(Math.max(20, 30));
        //前面的数是底数，后面的数是指数
        System.out.println(Math.pow(2, 3)); //2.0^3.0
        //生成0.0到1.0之间的所有小数，包括0.0，不包括1.0
        System.out.println(Math.random());
        //四舍五入
        System.out.println(Math.round(12.3f));
        System.out.println(Math.round(12.9f));
        //开平方
        System.out.println(Math.sqrt(4));
    }

}

Random类的概述和方法使用

A:Random类的概述
- 此类用于产生随机数如果用相同的种子创建两个 Random 实例，
- 则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
B:构造方法
- public Random()
- public Random(long seed)
C:成员方法
- public int nextInt()
- public int nextInt(int n)(重点掌握)

package com.heima.otherclass;

import java.util.Random;

public class Demo2_Random {

    public static void main(String[] args) {
        Random r = new Random();
        
        for (int i = 0; i < 10; i++) {
            System.out.println(r.nextInt());
        }
        System.out.println("--------->");
        Random r2 = new Random(1000);
        
        int a = r2.nextInt();
        int b = r2.nextInt();
        
        System.out.println(a);
        System.out.println(b);
        System.out.println(r.nextInt(2));   //在0（包括）和指定值（不包括）之间均匀分布的int值
    }

}

System类的概述和方法使用

A:System类的概述
- System 类包含一些有用的类字段和方法。它不能被实例化。
B:成员方法
- public static void gc()
- public static void exit(int status)
- public static long currentTimeMillis()
- pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
C:案例演示
- System类的成员方法使用

package com.heima.otherclass;

public class Demo3_System {

    
    public static void main(String[] args) {
        int[] src = {11,22,33,44,55};
        int[] dest = new int[8];
        System.arraycopy(src, 0, dest, 0, src.length);
        //System.arraycopy(src, srcPos, dest, destPos, length)
        /*
         * src源数组，srcPos源数组中的起始位置，dest目标数组, destPos目标数组中的起始位置, 
         * length要复制的数组元素的数量
         */
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }
    }

    public static void demo3() {
        long start = System.currentTimeMillis();    //获取当前时间的毫秒值
        for (int i = 0; i < 1000; i++) {
            System.out.println("*");
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);    //程序运行时间，单位毫秒，1秒=1000毫秒
    }

    public static void demo2() {
        System.out.println(2222);
        System.exit(0);     //推出jvm（java虚拟机），非0状态是异常终止
        System.out.println(1111);
    }

    public static void demo1() {
        for (int i = 0; i < 100; i++) {
            new Demo();
            System.gc();    //运行垃圾回收器，相当于呼喊保洁阿姨
        }
    }

}

class Demo {    //在一个源文件中不允许定义两个用public修饰的类

    @Override
    public void finalize()  {
        System.out.println("垃圾被清扫了");
    }
    
}

BigInteger类的概述和方法使用

A:BigInteger的概述
- 可以让超过Integer范围内的数据进行运算
B:构造方法
- public BigInteger(String val)
C:成员方法
- 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)

package com.heima.otherclass;

import java.math.BigInteger;

public class Demo4_BigInteger {

    /**
     * @param args
     */
    public static void main(String[] args) {
        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]);
        }
    }

}

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)
D:案例演示
- BigDecimal类的构造方法和成员方法使用

package com.heima.otherclass;

import java.math.BigDecimal;

public class Demo5_BigDecimal {

    public static void main(String[] args) {
        //System.out.println(2.0 - 1.1);        //0.8999999999999999
        /*BigDecimal bd1 = new BigDecimal(2.0);
        BigDecimal bd2 = new BigDecimal(1.1);
        
        System.out.println(bd1.subtract(bd2));  //结果也不精确，所以在开发中不推荐
*/  
        /*BigDecimal bd1 = new BigDecimal("2.0");   //通过构造中传入字符串的方法
        BigDecimal bd2 = new BigDecimal("1.1"); //开发推荐
        
        System.out.println(bd1.subtract(bd2));*/
        BigDecimal bd1 = BigDecimal.valueOf(2.0);   //这种方式也推荐
        BigDecimal bd2 = BigDecimal.valueOf(1.1);
        System.out.println(bd1.subtract(bd2));

    }

}

Date类的概述和方法使用

A:Date类的概述(是util包下的，不能导入sql包的）
* 类 Date 表示特定的瞬间，精确到毫秒。

B:构造方法
- public Date()
- public Date(long date)
C:成员方法
- public long getTime()
- public void setTime(long time)

package com.heima.otherclass;

import java.util.Date;

public class Demo6_Date {

    public static void main(String[] args) {
        Date d1 = new Date();
        d1.setTime(1000);               //设置毫秒值，改变时间对象
        System.out.println(d1);
    }

    public static void demo2() {
        Date d1 = new Date();
        System.out.println(d1.getTime());               //通过时间对象获取当前时间毫秒值
        System.out.println(System.currentTimeMillis()); //通过系统类的方法获取当前时间毫秒值
    }

    public static void demo1() {
        Date d1 = new Date();       //如果没有传参数代表的是当前时间
        System.out.println(d1);
        
        Date d2 = new Date(0);      //如果构造方法中参数传为0代表的是1970年1月1日
        System.out.println(d2);     //通过毫秒值创建时间对象
    }

}

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

A:DateFormat类的概述
- DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类，所以使用其子类SimpleDateFormat
B:SimpleDateFormat构造方法
- public SimpleDateFormat()
- public SimpleDateFormat(String pattern)
C:成员方法
- public final String format(Date date)
- public Date parse(String source

package com.heima.otherclass;

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

public class Demo7_SimpleDateFromat {

    /**
     * @param args
     * @throws ParseException 
     */
    public static void main(String[] args) throws ParseException {
        //将时间字符串转换成日期对象
        String str = "2000年08月08日 08:08:08";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date d = sdf.parse(str);
        System.out.println(d);
    }

    public static void demo3() {
        Date d = new Date();                                
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");    //指定格式输出
        System.out.println(sdf.format(d));          //将日期对象转换成字符串
    }

    public static void demo2() {
        Date d = new Date();                                //获取当前时间对象
        SimpleDateFormat sdf = new SimpleDateFormat();      //创建日期格式化对象
        System.out.println(sdf.format(d));                  //结果18-11-5 下午9:00
    }

    public static void demo1() {
        //DateFormat df = new DateFormat();     //DateFormat是抽象类，不允许实例化
        DateFormat df1 = DateFormat.getDateInstance();//相当于父类引用指向子类对象，右边的方法返回一个子类对象
        //底层类似于DateFormat df1 = new SimpleDateFormat();
    }

}

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

package com.heima.test;

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

public class Test2 {

  /**
   * @param args
   * @throws ParseException 
   */
  public static void main(String[] args) throws ParseException {
      //1,将生日字符串和今天字符串存在String类型的变量中
      String birthday = "1993年08月17日";
      String today = "2088年11月5日";
      //2,定义日期格式化对象
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
      //3,将日期字符串转换成日期对象
      Date d1 = sdf.parse(birthday);
      Date d2 = sdf.parse(today);
      //4,通过日期对象获取时间毫秒值
      long time = d2.getTime() - d1.getTime();
      //5,将两个时间毫秒值相减处以1000，再除以3600，再除以24
      System.out.println(time /1000 /3600 /24 /365);
  }

}

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

A:Calendar类的概述
* Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

B:成员方法
- public static Calendar getInstance()
- public int get(int field)
C:成员方法
- public void add(int field,int amount)
- public final void set(int year,int month,int date)
D:案例演示
- Calendar类的成员方法使用

package com.heima.test;

import java.util.Calendar;

public class Demo9_Calender {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();        //父类引用指向子类对象
        c.add(Calendar.DAY_OF_WEEK, 1);             //对指定的字段进行加或者减
        c.set(Calendar.YEAR, 2000);                 //修改指定字段为后面的传入值
        c.set(2000, 8, 8);                          //修改指定字段依次为年月日，按下面的格式输出为2000年09月08日星期五，说明这里的月份会加一
        System.out.println(c.get(Calendar.YEAR) + "年" 
        + getNum((c.get(Calendar.MONTH)+1))
                + "月" + getNum(c.get(Calendar.DAY_OF_MONTH)) 
                + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
    }
    public static void demo1() {
        Calendar c = Calendar.getInstance();        //父类引用指向子类对象
        System.out.println(c.get(Calendar.YEAR));   //通过字段获取年
        System.out.println(c.get(Calendar.MONTH));  //通过字段获取月，但是月是从0开始编号的
        System.out.println(c.get(Calendar.DAY_OF_MONTH));   //月中的第几天
        System.out.println(c.get(Calendar.DAY_OF_WEEK));    //周日是第一天 
        
        System.out.println(c.get(Calendar.YEAR) + "年" + getNum((c.get(Calendar.MONTH)+1))
                + "月" + getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
    }
    //将星期储存在表中查询
    public static String getWeek(int week) {
        String[] arr = {"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
        return arr[week-1];
    }
    //如果是个位数前面补零。输入为int，返回一个字符串
    public static String getNum(int num) {
        /*if(num > 9) {
            return "" + num;
        } else {
            return "0" + num;
        }*/
        return num > 9 ? "" + num : "0" + num;
    }
}

如何获取任意年份是平年还是闰年

package com.heima.test;

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

public class Test3 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年份，判断该年份是闰年还是平年");
        String line = sc.nextLine();            //录入数字字符串
        int year = Integer.parseInt(line);      //将数字字符串转换成数字
        boolean b = getYear(year);
        System.out.println(b);
    }

    private static boolean getYear(int year) {
        //2,创建Calendar c = Calendar.getInstance();
        Calendar c = Calendar.getInstance();
        //3.设置为那一年的3月1日
        c.set(year,2,1);
        //将日减去1
        c.add(Calendar.DAY_OF_MONTH,-1);
        //判断是否为29
        return c.get(Calendar.DAY_OF_MONTH) == 29;
    }

}

对象数组的概述和使用

package com.heima.collection;

import com.heima.bean.Student;

public class Demo1_Array {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //int[] arr = new int[5];                   //创建基本数据类型数组
        Student[] arr = new Student[5];             //创建引用数据类型数组
        arr[0] = new Student("张三", 23);             //创建一个学生对象，存储在数组的第一个位置
        arr[1] = new Student("李四", 24);             //创建一个学生对象，存储在数组的第二个位置
        arr[2] = new Student("王五", 25);             //创建一个学生对象，存储在数组的第三个位置
        
        for(int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

}

数组存储引用数据类型.png

集合的由来及集合继承体系图

A:集合的由来
- 数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少
B:数组和集合的区别
- 区别1 :
  - 数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
  - 集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
- 区别2:
  - 数组长度是固定的,不能自动增长
  - 集合的长度的是可变的,可以根据元素的增加而增长
C:数组和集合什么时候用
* 1,如果元素个数是固定的推荐用数组
* 2,如果元素个数不是固定的推荐用集合
D:集合继承体系图

集合体系图.png

Collection集合的基本功能测试

A:案例演示
基本功能演示

        boolean add(E e)
        boolean remove(Object o)
        void clear()
        boolean contains(Object o)
        boolean isEmpty()
        int size()

B:注意:
collectionXxx.java使用了未经检查或不安全的操作.
注意:要了解详细信息,请使用 -Xlint:unchecked重新编译.
java编译器认为该程序存在安全隐患
温馨提示:这不是编译失败,所以先不用理会,等学了泛型你就知道了

package com.heima.collection;

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

import com.heima.bean.Student;

@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo2_Collection {

    /*
     * add方法如果是List集合一直都返回true，因为List集合中是可以存储重复元素的
     * 如果是Set集合当存储重复元素的时候，就会返回false
     */
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");
        //c.remove("b");                //删除指定元素
        //c.clear();                        //清空集合
        //System.out.println(c.contains("b"));  //判断是否包含
        //System.out.println(c.isEmpty());      //判断是否为空
        System.out.println(c.size());           //获取集合元素个数  
        System.out.println(c);
    }

    public static void demo1() {
        Collection c = new ArrayList();             //父类引用指向子类对象
        boolean b1 = c.add("abc");
        boolean b2 = c.add(true);                   //自动装箱new Boolean(true);
        boolean b3 = c.add(100);
        boolean b4 = c.add(new Student("张三",23));
        boolean b5 = c.add("abc");
        
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(b4);
        System.out.println(b5);
        
        System.out.println(c);  //ArrayList的父类的父类重写了toString方法，
        //所以在打印对象的引用的时候，输出的结果不是Object类中toString的结果
    }

}

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

package com.heima.collection;

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

import com.heima.bean.Student;

@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo3_Collection {
    public static void main(String[] args) {
        Collection c = new ArrayList();     
        c.add("a");                     //父类引用指向子类对象，编译看左边，运行看右边
        c.add(true);                    //多态
        c.add(1);                       //多态不能使用子特有的行为，向下转型就可以使用了。注意这个特有
        c.add(new Student("张三",23));    //Object obj = new Student("张三",23);        
        //Student [name=张三, age=23]，重写了toString方法，编译看左边，运行看右边
        Object[] arr = c.toArray();                 //将集合转换成数组
        for(int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

}

Collection集合的带All功能测试

/*
boolean addAll(Collection c)
boolean removeAll(Collection c)
boolean containsAll(Collection c)
boolean retainAll(Collection c)
*/
package com.heima.collection;

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

public class Demo4_CollectionAll {

    public static void main(String[] args) {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        
        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("z");
                
        boolean b = c1.retainAll(c2);   //取交集
        System.out.println(b);          //取交集，如果调用的集合改变就返回true，如果不变则返回false
        System.out.println(c1);         //[a, b]
    }

    public static void demo3() {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        
        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        //c2.add("b");      //有重复的会返回true，
        c2.add("z");        //不同会返回false
        
        Boolean b = c1.containsAll(c2);         //判断调用的集合是否包含传入的集合
        System.out.println(b);
    }

    public static void demo2() {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        
        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("z");
        
        boolean b = c1.removeAll(c2);//删除成功返回true，且删除的是交集，即只删除两个集合相同的部分
        System.out.println(b);
        System.out.println(c1);
    }

    public static void demo1() {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        
        Collection c2 = new ArrayList();        //alt+shift+r一起改名字
        c2.add("e");
        c2.add("f");
        c2.add("g");
        c2.add("h");
        
        c1.addAll(c2);      //将c2中的每一个元素添加到c1中
        c1.add(c2);         //将c2看成一个对象添加到c1中
        System.out.println(c1);//[a, b, c, d, e, f, g, h, [e, f, g, h]]
    }

}

集合的遍历之迭代器遍历

A:迭代器概述
- 集合是用来存储元素,存储的元素需要查看,那么就需要迭代(遍历)
B:案例演示
- 迭代器的使用

package com.heima.collection;

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

import com.heima.bean.Student;

public class Demo5_Iterator {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(new Student("张三",23));        //Object obj = new Student("张三",23);
        c.add(new Student("李四",24));
        c.add(new Student("王五",25));
        c.add(new Student("赵六",26));
        
        //获取迭代器
        Iterator it = c.iterator();
        while(it.hasNext()) {
            //System.out.println(it.next());
            Student s = (Student)it.next();     //向下转型
            System.out.println(s.getName());
        }
    }

    public static void demo1() {
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");
        
        //对集合中的元素迭代（遍历）
        Iterator it = c.iterator();             //获取迭代器
        /*boolean b1 = it.hasNext();            //判断集合中是否有元素，有就返回true
        Object obj1 = it.next();            
        System.out.println(b1);
        System.out.println(obj1);*/
        
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }

}