[2017.11.05]正则表达式&集合&list

正则表达式

1.演示:

import java.util.Scanner;/** * 需求:校验一个QQ号码 *      定义一个规则:1)由5到10为组成的数字 *                2)不能以0开头   *  分析: *      1)键盘录入一个QQ号码,使用字符串接收 *      2)定义一个校验QQ的功能 *      3)在main()中调用返回boolean类型 * @author Apple */public class RegexDemo {    public static void main(String[] args) {        //创建键盘录入对象        Scanner sc = new Scanner(System.in) ;        //录入并接收数据        System.out.println("请您输入一个QQ号码:");        String QQ = sc.nextLine() ;        //写一个校验QQ的功能        boolean flag = checkQQ(QQ) ;        System.out.println("flag:"+flag);    }    /**     * 两个明确:     *  明确返回值类型:boolean类型     * 参数类型:String 输入的qq号码     */    public static boolean checkQQ(String qq){        //假设定义个标记        boolean flag = true ;        //需要判断:qq:长度5-10        if(qq.length()>=5 && qq.length()<=10){            //符合这个规则            //符合第一个规则还要符合不能以0开头            if(!qq.startsWith("0")){                //符合这个规则                //这些QQ号码必须还数字的                //可以先将qq,转换成字符数字                char[] chs = qq.toCharArray() ;                //遍历字符数组,获取每一个字符                for(int x = 0 ; x < chs.length ; x ++){                    char ch = chs[x] ;                    //获取到每一个字符,判断该字符是否是数字                    if(!Character.isDigit(ch)){                        flag = false ;                        break ;                    }                }            }else{                flag = false ;            }        }else{            flag = false ;        }        return flag ;    }}

改进:

import java.util.Scanner;/** * 需求:校验一个QQ号码 *      定义一个规则:1)由5到10为组成的数字 *                2)不能以0开头   *  分析: *      1)键盘录入一个QQ号码,使用字符串接收 *      2)定义一个校验QQ的功能 *      3)在main()中调用返回boolean类型 * @author Apple */public class RegexDemo2 {    public static void main(String[] args) {        //创建键盘了录入对象        Scanner sc = new Scanner(System.in) ;        //录入并接收数据        System.out.println("请您输入QQ号码: ");        String QQ = sc.nextLine() ;        boolean flag = checkQQ(QQ) ;        System.out.println("flag: "+flag);    }    public static boolean checkQQ(String qq){        /*//定义正则规则        String regex = "[1-9][0-9]{4,9}" ;        //public boolean matches(String regex)告知此字符串是否匹配给定的正则表达式。         boolean flag = qq.matches(regex) ;        return flag ;*/        //直接返回        return qq.matches("[1-9]\\d{4,9}");    }}

2.演示:

import java.util.Scanner;/** * 使用正则表达式校验手机号码: *      规则: *          手机号码: *              13689257284 *              13688886666 *              13892866555 *              18992844422 *              13257222222 *              ... *  *1)创建键盘录入对象,录入手机号码 *2)定义正则规则: *3)String类的特有功能 *          public boolean matches(String regex)告知此字符串是否匹配给定的正则表达式。  *4)输出 * * @author Apple */public class RegexDemo {    public static void main(String[] args) {        //创建键盘录入对象        Scanner sc = new Scanner(System.in) ;        //录入并接收        System.out.println("请您输入一个手机号码:");        String phone = sc.nextLine() ;        //定义正则规则        String regex = "1[38][0-9]{9}" ;        //匹配当前正则表达式是否和录入的手机号符合        boolean flag = phone.matches(regex) ;        System.out.println("flag:"+flag);    }}

import java.util.Scanner;/** * 需求:校验邮箱: *      QQ邮箱: *          [e-mail] *          [e-mail] *          [e-mail] *          [e-mail] *          [e-mail] *          [e-mail].... * 分析:1)键盘录入邮箱 *      2)定义正则规则 *      3)使用String中的特有功能校验 *      4)输出即可 * @author Apple */public class RegexTest {    public static void main(String[] args) {        //创建键盘录入对象        Scanner sc = new Scanner(System.in) ;        //录入并接收        System.out.println("请您输入一个邮箱:");        String email = sc.nextLine() ;        //定义正则规则:本身就是.-->\.--->\\.//      String regex = "[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,6}(\\.[a-zA-Z]{2,3})+" ;        String regex = "\\w+@\\w{2,6}(\\.[a-zA-Z]{2,3})+" ;        //校验        boolean flag = email.matches(regex) ;        System.out.println("flag:"+flag);    }}

3.String的分割功能:
public String[] split(String regex)根据给定正则表达式的匹配拆分此字符串
返回值类型是一个字符串数组类型

4.演示:

/*应用场景: *        QQ,搜索好友,相亲网:世纪佳缘... *          女  "18-24" *      String ages = "18-24" ; * */import java.util.Scanner;public class RegexDemo {    public static void main(String[] args) {        //定义一个字符串        String ages = "18-24" ;        //定义正则规则        String regex = "-" ;        //public String[] split(String regex)        String[] strArray = ages.split(regex) ;        //如何得到当前字符数组中的元素(转换int类型的数据)        int startAge = Integer.parseInt(strArray[0]) ;        int endAge = Integer.parseInt(strArray[1]) ;        //键盘录入一个年龄,属于int类型的数据        //创建键盘录入对象        Scanner sc = new Scanner(System.in) ;        //录入并接收数据        System.out.println("请您输入一个年龄:");        int age = sc.nextInt() ;        //判断是否符我们要找的一类人        if(age>=startAge && age<=endAge){            System.out.println("这就是我想要的...");        }else{            System.out.println("不是我们要找的...");        }    }}

5.演示:
分割功能的应用:

public class RegexDemo2 {    public static void main(String[] args) {        //定义个字符串        String str1 = "aa,bb,cc" ;        //使用分割功能        String[] strArray1 = str1.split(",") ;        //遍历字符串数组        for(int x = 0 ; x < strArray1.length; x ++){            System.out.println(strArray1[x]);        }        System.out.println("------------------");        //字符串:        String str2 = "aa       bb                    cc" ;        //使用切割功能:        String[] strArray2 = str2.split(" +") ;        for(int x = 0 ; x <strArray2.length ; x++){            System.out.println(strArray2[x]);        }        System.out.println("--------------------");        String str3 = "aa.bb.cc" ;        //分割功能        String[] strArray3 = str3.split("\\.") ;        for(int x =0 ; x<strArray3.length ; x ++){            System.out.println(strArray3[x]);        }        //硬盘上的路径表现形式:用两个反斜线代表一个反斜线        //E:\\JavaSE\\JavaCode\\day13        String str4 = "E:\\JavaSE\\JavaCode\\day13" ;        //使用分割功能        String[] strArray4 = str4.split("\\\\") ;        for(int x = 0 ; x <strArray4.length ; x ++){            System.out.println(strArray4[x]);        }    }}

6.String类中的替换功能:和正则表达式有关系
public String replaceAll(String regex,String replacement)
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

7.演示:

public class RegexDemo3 {    public static void main(String[] args) {        //定义一个字符串:        String str = "helloword123JavaSE45678Javaweb" ;        //需求:让当前这个字符串中的数字不显示出来        //定义当前大串中数字定义正则规则 //      String regex = "[0-9]+" ;        String regex = "\\d+" ;        String s = "*" ;        //public String replaceAll(String regex,String replacement)        String result = str.replaceAll(regex, s) ;        System.out.println("result:"+result);    }}

8.关于模式和匹配器的使用:获取功能
模式和匹配器基本使用顺序

9.演示:

import java.util.regex.Matcher;import java.util.regex.Pattern;public class RegexDemo4 {    public static void main(String[] args) {        //public static Pattern compile(String regex)将给定的正则表达式编译成一个模式对象        //1)获取模式对象(通过正则规则)        Pattern p = Pattern.compile("a*b") ;        //2)通过模式获取匹配器对象,(将一个字符串类型的数据)        Matcher m = p.matcher("aaaaaab") ;        //3)调用Match(匹配器类)中的:public boolean matches():判断当前用户录入的字符串是否和当前的正则规则匹配        boolean flag = m.matches() ;        System.out.println("flag:"+flag);        System.out.println("----------------------------");        //上述写法非常麻烦,要获取模式对象Pattern还要获取匹配器对象:Matcher,然后通过matches()方法返回一个结果        //以后可以使用下面这种格式        //定义一个正则规则        String regex = "a*b" ;        //指定某一个字符串        String str = "aaaaaaab" ;        //使用String类的功能        //使用当前给定的字符串调用public boolean matchers(String regex)        boolean flag2 = str.matches(regex) ;        System.out.println("flag2: "+flag2);    }}

10.演示:

import java.util.Arrays;/** * 我有如下一个字符串:"91 27 46 38 50"    请写代码实现最终输出结果是："27 38 46 50 91"    分析:            1)定义这个字符串            2)使用分割功能分割成一个字符串数组            3)如何得到一个int类型数组:动态初始化定义int数组 int[] arr = new int[字符串数数组.length] ;            4)遍历int数组                    获取每一个元素:arr[x] = Integer.parseInt(字符串数组对象[x])            5)排序:Arrays数组工具类型快速排序:sort(arr)            6)再去遍历int类型数组获取每一个元素,用字符串缓冲区来进行拼接            7)输出字符串 * @author Apple */public class RegexTest {    public static void main(String[] args) {        //定义一个字符串        String str = "91 27 46 38 50" ;        //使用分割功能        String[] strArray = str.split(" ") ;        //定义一个int类型的数组,动态初始化        int[] arr = new int[strArray.length] ;        //遍历int类型的数组        for(int x = 0 ; x < arr.length ; x ++){            arr[x] = Integer.parseInt(strArray[x]) ;        }        //使用Arrays数组工具类型进行操作        Arrays.sort(arr) ;        //创建StringBuilder缓冲区对象        StringBuilder sb = new StringBuilder() ;        //再去遍历int类型的数组,目的使用为了拼接        for(int x = 0 ; x < arr.length ; x ++){            //使用追加功能            sb.append(arr[x]).append(" ") ;        }        //要将字符串缓冲转换成String类型,并且去除两端空格        String result = sb.toString().trim() ;        System.out.println("result:"+result);    }}

11.正则表达式常用的语法:

A:字符    x           字符 x :任意的字符    \\          反斜线字符               在代码中书写正则表达式:\------>用两个\\代表一个反斜线    \t          制表符 ('\u0009')    \n          新行（换行）符 ('\u000A')          IO流中要写入换行符号:windows "\r\n"    \r          回车符 ('\u000D') B:字符类    [abc]       a、b 或 c（简单类）     [^abc]      任何字符，除了 a、b 或 c（否定）     [a-zA-Z]    a 到 z 或 A 到 Z，两头的字母包括在内（范围） :当前字母大小均可C:预定义字符类    .           任何字符        邮箱里面:如果本身就是.,那么在写正在表达式的时候,\.将当前.转义    \d          数字：[0-9]    \d在正则表达式应用的时候:[0-9]--->\\d    \w          单词字符：[a-zA-Z_0-9]:简单一些字符串,单词字符(规则:数字或者字母)                    javascript:[a-zA-Z0-9]D:边界匹配器    ^           行的开头     $          行的结尾    \b          单词边界 :                hello;world:haha:xixiE:Greedy 数量词    X?          X，一次或一次也没有     X*          X，零次或多次    X+          X，一次或多次     X{n}        X，恰好 n 次     X{n,}       X，至少 n 次    X{n,m}      X，至少 n 次，但是不超过 m 次 

集合

1.集合的由来:
我们学习java的语言,是一种面向对象语言,面向对象语言对事物的描述是通过对象体现出来的,那么存储很多个学生,就需要使用容器变量进行存储

2.目前:学习过哪些容器变量呢?
数组,StringBuffer/StringBuilder,对于数组来说,数组的长度是固定的,不符合实际需求(长度不可变);对于StringBuffer来说始终在内存中返回的是字符串类型,也不满足元素类型变化的要求;所以,Java就提供了一个技术:集合!

3.面试题:
集合和数组的区别?
1)长度的区别:
数组:长度是固定的;
集合:长度是可变的
2)存储数据类型的区别:
数组:可以存储引用类型,可以存储基本数据类型
集合:只能存储引用类型
3)存储元素的区别
数组:在同一个数组中,只能存储同一种数据类型的元素;举例 数组:杯子:只能装水
集合:可以 存储多种数据类型的元素; 举例:集合:杯子:装水,其他饮料…

4.集合是可以存储多种类型的元素,但是,需求如果变化,针对集合来说,Java提供了很多集合类,每一种集合类的数据结构不一样,所以,将他们之间的共性内容抽取出来,就行了

5.数据结构:存储数据的方式
Collection: 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。
一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现

6.Collection的一些功能
添加功能:
boolean add(Object e):给集合中添加指定的元素
boolean addAll(Collection c):添加一个集合中的所有元素
删除功能:
void clear():删除一个集合中的所有元素,暴力删除,(不建议使用)
boolean remove(Object o):删除一个集合中的指定元素
boolean removeAll(Collection c):删除一个集合中的所有元素?思考:删除所有算是删除还是删除一个算是删除?
判断功能:
boolean contains(Object o):判断一个集合中是否包含指定的单个元素
boolean containsAll(Collection c):判断一个集合中是否另一个集合;思考:是包含一个元素算是包含还是包含所有.
boolean isEmpty():判断集合是否为空,如果为空,则返回true
交集功能:
boolean retainAll(Collection c):思考:A集合给B集合做交集,交集的元素去哪里?返回值boolean表达什么意思?
获取功能:
int size():获取集合中的元素数
Iterator iterator():迭代器
转换功能:
Object[] toArray():将集合转换成数组

7.面试题:
数组中有没有length(),String类中有没有length(),集合中有没有length()?
数组:length属性
String:length()
集合中:size()

8.演示:

import java.util.ArrayList;import java.util.Collection;public class CollectionDemo {    public static void main(String[] args) {        //创建一个Collection集合对象//      Collection c = new Collection() ;//JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现        Collection c = new ArrayList() ;//      System.out.println(c);//[]   底层重写了toString()        //添加功能:        //boolean add(Object e):给集合中添加指定的元素//      boolean flag = c.add("hello") ;        /**         * 通过查看集合的add()方法,只要给集合中添加元素,永远返回true         *  public boolean add(E e) {         *  //省略代码            return true;            }         */        c.add("hello") ;        c.add("world") ;        c.add("Java") ;        //void clear():删除一个集合中的所有元素,暴力删除,(不建议使用)//      c.clear() ;        //boolean remove(Object o):删除一个集合中的指定元素//      System.out.println("remove:"+c.remove("hello")) ;//      System.out.println("remove:"+c.remove("javaweb")) ;        //boolean contains(Object o):判断一个集合中是否包含指定的单个元素        System.out.println("contains:"+c.contains("world"));//      System.out.println("contains:"+c.contains("android"));//      boolean isEmpty():判断集合是否为空,如果为空,则返回true//      System.out.println("isEmpty:"+c.isEmpty());        //int size():获取集合中的元素数        System.out.println("size:"+c.size());        System.out.println("c:"+c);    }}

9.集合的高级功能:
boolean addAll(Collection c):添加一个集合中的所有元素
boolean removeAll(Collection c):删除一个集合中的所有元素?思考:删除所有算是删除还是删除一个算是删除?
boolean containsAll(Collection c):判断一个集合中是否另一个集合;思考:是包含一个元素算是包含还是包含所有
boolean retainAll(Collection c):思考:A集合给B集合做交集,交集的元素去哪里?返回值boolean表达什么意思?

10.演示:

import java.util.ArrayList;import java.util.Collection;public class CollectionDemo2 {    public static void main(String[] args) {        //创建两个Collection集合对象        Collection c1 = new ArrayList() ;        Collection c2 = new ArrayList() ;        //分别给c1,c2集合添加元素        c1.add("abc1") ;        c1.add("abc2") ;        c1.add("abc3") ;        c1.add("abc4") ;        /*c2.add("abc1") ;        c2.add("abc2") ;        c2.add("abc3") ;*/        c2.add("abc4") ;//      c2.add("abc5") ;//      c2.add("abc6") ;//      c2.add("abc7") ;        //boolean addAll(Collection c):添加一个集合中的所有元素//      System.out.println("addAll:"+c1.addAll(c2));        //boolean removeAll(Collection c):删除一个集合中的所有元素?思考:删除所有算是删除还是删除一个算是删除?        //删除一个算是删除//      System.out.println("removeAll:"+c1.removeAll(c2));//      boolean containsAll(Collection c):判断一个集合中是否另一个集合;思考:是包含一个元素算是包含还是包含所有//      System.out.println("containsAll:"+c1.containsAll(c2));//包含所有算是包含        //boolean retainAll(Collection c):思考:A集合给B集合做交集,交集的元素去哪里?返回值boolean表达什么意思?        /**         * 面试题:         * A集合对B集合取交集,那么交集的元素去A集合里面了,并且返回值boolean表达的意识是A集合中的元素是否发生变化,如果发生变化,就返回true;否则,false         */        System.out.println("retianAll:"+c1.retainAll(c2));        //输出每个集合中的元素        System.out.println("c1:"+c1);        System.out.println("c2:"+c2);    }}

11.Object[] toArray():将集合转换成数组
需求:给集合中添加String类型的元素,遍历集合

12.演示:

import java.util.ArrayList;import java.util.Collection;public class CollectionDemo3 {    public static void main(String[] args) {        //创建Collection集合对象        Collection c = new ArrayList() ;        //给集合中添加元素        c.add("高圆圆") ;//c.add(Object obj)=====>Object obj = new String("高圆圆") ;//向上转型了        c.add("邓超") ;        c.add("WE") ;        c.add("RNG") ;        //集合中有元素了,将集合转换数组        Object[] objs = c.toArray() ;        //遍历对象数组        for(int x = 0 ; x < objs.length ; x ++){//          System.out.println(objs[x]);            //需求:获取集合中元素的同时,获取集合中每一个元素的字符串长度//          System.out.println(objs[x]+"---"+objs[x].length());            //要获取字符串长度:需要使用length(),该方法属于String类的特有功能            String s = (String) objs[x] ;//向下转型            System.out.println(s+"----"+s.length());        }    }}

13.演示:

import java.util.ArrayList;import java.util.Collection;/** *  需求:有5个学生,每一个学生有自己的信息(姓名,年龄等等),将5个学生的信息遍历出来! *  使用集合的转换功能去遍历学生信息 *   *  1)创建集合对象 *  2)创建5个学生对象 *  3)使用集合添加5个学生对象 *  4)将集合转换成数组:Object[] toArray() ; *  5)遍历数组 * @author Apple */public class CollectionTest {    public static void main(String[] args) {        //创建集合对象        Collection c = new ArrayList() ;        //创建5个学生对象        Student s1 = new Student("貂蝉", 25) ;        Student s2 = new Student("王昭君", 22) ;        Student s3 = new Student("西施", 28) ;        Student s4 = new Student("杨贵妃", 29) ;        Student s5 = new Student("高圆圆", 38) ;        //给集合中添加元素        c.add(s1) ;//Object obj = new Student("..") ;        c.add(s2) ;        c.add(s3) ;        c.add(s4) ;        c.add(s5) ;        //将集合转换成数组        Object[] objs = c.toArray() ;        for(int x = 0 ; x < objs.length ; x ++){//          System.out.println(objs[x]);            //使用get()获取学生姓名和年龄            //Student类型接收            Student s = (Student) objs[x] ;            System.out.println(s.getName()+"---"+s.getAge());        }    }}

public class Student {    private String name ;    private int age ;    public Student() {        super();    }    public Student(String name, int age) {        super();        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 + "]";    }}

14.集合的专有遍历方式:使用集合自己本身迭代功能遍历集合中的元素
Iterator iterator():迭代器
Iterator:迭代器:接口

15.成员方法:
Object next()返回迭代的下一个元素:获取功能
boolean hasNext():判断一个集合中是否有下一个可以迭代的元素:判断功能

16.需求:使用集合存储字符串类型的元素并遍历

17.演示:

import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;public class CollectionDemo {    public static void main(String[] args) {        //创建集合对象        Collection c = new ArrayList() ;//ArrayList是List集合的子实现类(存储和取出一致的)        //给集合中添加元素        c.add("hello") ;        c.add("world") ;        c.add("java") ;        c.add("java") ;        c.add("java") ;        c.add("java") ;        //获取迭代器对象        //Iterator iterator():迭代器        Iterator it = c.iterator() ;//底层使用ArrayList中的匿名内部类的形式:接口多态的形式        //获取元素:Object next() ;        /*Object obj = it.next() ;        System.out.println(obj);*///      System.out.println(it.next());//      System.out.println(it.next());//      System.out.println(it.next());//      //java.util.NoSuchElementException:没有这样的元素异常!//      System.out.println(it.next());        //由于当前集合中的元素获取完了,没有元素,而还要去调用next()方法,那么就出现问题,        //假设,给当前加上一个判断就可以防止出现异常!        //判断    /*  if(it.hasNext()){            //有,就获取需要被遍历的元素            System.out.println(it.next());        }        if(it.hasNext()){            //有,获取            System.out.println(it.next());        }        if(it.hasNext()){            System.out.println(it.next());        }        if(it.hasNext()){            System.out.println(it.next());        }*/        //上述代码重复度高,由于集合中的元素不固定的,所有使用while循环去改进        while(it.hasNext()){//          System.out.println(it.next());//获取字符串的内容            //获取字符串的同时,还要获取字符串长度            //Object obj = it.next() ;            //向下转型            String s = (String)it.next() ;            System.out.println(s+"----"+s.length());        }    }}

18.使用存储自定义对象并遍历
1)toArray():将集合转换成数组
2)集合专有遍历方式:迭代器遍历
注意:存储自定义对象使用迭代器遍历,it.next()不要使用多次,否则会出现异常!

19.使用迭代器遍历,使用的是while循环,可以是for循环吗?可以,但是还是while循环

20.演示:

import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;public class CollectionTest {    public static void main(String[] args) {        //创建一个学生类        //创建集合对象        Collection c = new ArrayList() ;        //创建3个学生对象        Student s1 = new Student("张三", 26) ;        Student s2 = new Student("李四", 22) ;        Student s3 = new Student("往往与", 28) ;        //给集合中添加元素        c.add(s1) ;        c.add(s2) ;        c.add(s3) ;        //获取迭代器对象        Iterator it = c.iterator() ;        //遍历        while(it.hasNext()){            Student s = (Student)it.next() ;            System.out.println(s.getName()+"---"+s.getAge());            //java.util.NoSuchElementException//          System.out.println(((Student)it.next()).getName()+"----"+((Student)it.next()).getAge());        }        System.out.println("----------------------------");        for(Iterator it2 = c.iterator();it2.hasNext();){            Student s = (Student) it2.next() ;            System.out.println(s.getName()+"---"+s.getAge());        }    }}

public class Student {    private String name ;    private int age ;    public Student() {        super();    }    public Student(String name, int age) {        super();        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 + "]";    }}

21.Iterator的源码

interace Iterator{    public abstract boolean hasNext();    public abstract Object next() ;}interface Iterable{         Iterator iterator();}interface Collection extends Iterable{        Iterator iterator() ;}inteface List extends Collection{        Iterator<E> iterator();}class ArrayList implements List{     public Iterator<E> iterator() {            return new Itr();    }    //内部类的形式    private class Itr implements Iterator {        //Itr类:内部类        public boolean hasNext() {            ....        }             public Object next() {          }    }   }

22.对象数组:可以存储对象的数组

23.演示:

/** *  * 需求:有5个学生,每一个学生有自己的信息(姓名,年龄等等),将5个学生的信息遍历出来! *  *      分析:A:定义一个学生类:     *          提供两个成员 变量     *          String name,int age     *          提供无参/有参的构造方法     *          提供set/get()方法 *          B:定义一个学生数组(对象数组) *          C:创建5个学生对象 *          D:赋值,将5个学生对象放到学生数组中 *          E:遍历数组 *          F:输出 *  * @author Apple */public class ObjectArrayDemo {    public static void main(String[] args) {        //学生类创建完毕        //定义一个学生数组:定义数组的格式:数据类型[] 数组名称 = new 数据类型[数组长度] ;        //定义一个学生数组        Student[] students = new Student[5] ;        //创建5个学生对象        Student s1 = new Student("高圆圆", 27) ;        Student s2 = new Student("黄晓明", 28) ;        Student s3 = new Student("邓超" ,30) ;        Student s4 = new Student("孙俪" ,28) ;        Student s5 = new Student("王昭君" ,25) ;        //赋值        students[0] = s1 ;        students[1] = s2 ;        students[2] = s3 ;        students[3] = s4 ;        students[4] = s5 ;        //遍历学生数组        for(int x = 0 ; x <students.length ; x ++){//          System.out.println(students[x]);            //通过底层原码重写toString()得到的每个对象的成员变量的信息            Student s = students[x] ;            System.out.println(s.getName()+"----"+s.getAge());        }    }}

public class Student {    //两个成员变量    private String name ;    private int age ;    public Student() {        super();    }    public Student(String name, int age) {        super();        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 + "]";    }}

list

1.用List集合存储字符串类型的元素,并遍历:迭代器遍历

2.演示:

public class ListDemo {    public static void main(String[] args) {        //创建集合对象        List list = new ArrayList() ;        //添加元素        list.add("hello") ;        list.add("world") ;        list.add("java") ;        //获取迭代器        Iterator it = list.iterator() ;        while(it.hasNext()){            String s = (String)it.next() ;            System.out.println(s);        }    }}

3.List集合是一个有序的集合(存储元素和取出元素是一致的!)
该集合中的元素是可以重复的

4.演示:

import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class ListDemo2 {    public static void main(String[] args) {        //创建List集合对象        List list = new ArrayList() ;        //给集合中添加元素        list.add("hello") ;        list.add("world") ;        list.add("java") ;        list.add("java") ;        list.add("javaweb") ;        list.add("world") ;        //获取迭代器        Iterator it = list.iterator() ;        while(it.hasNext()){            String s = (String)it.next() ;            System.out.println(s);        }    }}

5.List集合的特有功能:
添加功能:
void add(int index, Object element)在列表的指定位置插入指定元素
删除功能:
Object remove(int index)移除列表中指定位置的元素,返回被删除的元素
获取功能:
ListIterator listIterator():列表迭代器:List集合的专有遍历方式
Object get(int index)返回列表中指定位置的元素。
替换功能:
set(int index,Object element)用指定元素替换列表中指定位置的元素

6.演示:

import java.util.ArrayList;import java.util.List;public class ListDemo {    public static void main(String[] args) {        //创建List集合对象        List list = new ArrayList() ;        //添加一些元素        list.add("hello") ;        list.add("world") ;        list.add("java") ;        //void add(int index, Object element)在列表的指定位置插入指定元素,在指定位置前面插入一个新的元素//      list.add(1, "javaweb") ;        //Object remove(int index)移除列表中指定位置的元素,返回被删除的元素        //IndexOutOfBoundsException:角标越界了//      System.out.println("remove:"+list.remove(3));//      System.out.println("remove:"+list.remove(2));        // set(int index,Object element)用指定元素替换列表中指定位置的元素//      System.out.println("set:"+list.set(1, "JavaEE")) ;        System.out.println("get:"+list.get(1)) ;//      System.out.println("get:"+list.get(11)) ;        System.out.println("list"+list);    }}

7.List集合的遍历方式
1)toArray()
2)Collection集合中的Iterator iterator();

8.演示:

import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class ListDemo2 {    public static void main(String[] args) {        //创建集合对象        List list = new ArrayList() ;        //添加元素        list.add("hello") ;        list.add("java") ;        list.add("hello") ;        list.add("javaweb") ;        list.add("hello") ;        list.add("python") ;        //获取集合中的元素    /*  System.out.println(list.get(0));        System.out.println(list.get(1));        System.out.println(list.get(2));        System.out.println(list.get(3));        System.out.println(list.get(4));        System.out.println(list.get(5));*/        //使用普通for的方法去遍历list集合,使用size()和get()相结合        for(int  x = 0 ; x < list.size(); x ++){//          Object object = list.get(x) ;            //需求:获取字符串内容同时,获取字符串长度            String s = (String)list.get(x) ;            System.out.println(s+"----"+s.length());        }        System.out.println("-------------------------");        //获取迭代器对象        Iterator it = list.iterator() ;        while(it.hasNext()){            String s = (String) it.next() ;            System.out.println(s+"----"+s.length());        }    }}

9.List集合的列表迭代器
ListIterator listIterator()
列表迭代器接口中有以下几个方法:
boolean hasNext():判断是否有下一个可以迭代的元素(正向遍历)
Object next():如果有可以遍历的元素,就获取这个元素
boolean hasPrevious():判断是否有上一个可以迭代的元素(逆向遍历)
Object previous():如果有上一个可以迭代的元素,就获取上一个元素
注意:
要使用逆向遍历,前提必须有正向遍历存在,直接使用逆向遍历,没有意义!

10.演示:

import java.util.ArrayList;import java.util.List;import java.util.ListIterator;public class ListDemo3 {    public static void main(String[] args) {        //创建集合对象        List list = new ArrayList() ;        //给集合中添加元素        list.add("hello") ;        list.add("world") ;        list.add("java") ;        //获取列表迭代器        ListIterator it = list.listIterator() ;        while(it.hasNext()){            String s = (String)it.next();            System.out.println(s);        }        System.out.println("-----------------------");        //boolean hasPrevious():判断是否有上一个可以迭代的元素(逆向遍历)         //Object  previous():如果有上一个可以迭代的元素,就获取上一个元素        while(it.hasPrevious()){            String s = (String)it.previous() ;            System.out.println(s);        }    }}

11.演示:

import java.util.ArrayList;import java.util.Iterator;import java.util.List;import java.util.ListIterator;/** * 问题? *      我有一个集合，如下，请问，我想判断里面有没有"world"这个元素， *          如果有，我就添加一个"javaee"元素，请写代码实现 *  并发(同一个时间点),并行(同一个时间段) *java.util.ConcurrentModificationException:并发修改异常:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。 *  原因:当前我们用迭代器去遍历元素,使用集合添加的元素,对于迭代器不知道集合添加了这个元素,所以会发生这个异常 *  描述:使用迭代器去遍历集合,是不能直接集合添加元素! *  解决方案: *          1)使用迭代器遍历集合,使用迭代器添加元素 *          2)使用集合遍历,使用集合添加元素 * @author Apple */public class ListTest {    public static void main(String[] args) {        //创建List集合对象        List list = new ArrayList() ;        //给集合中添加元素        list.add("hello") ;        list.add("world") ;        list.add("java") ;//      //获取迭代器//      Iterator it = list.iterator() ;//      //遍历//      while(it.hasNext()){//          String s = (String)it.next() ;//          //判断//          if("world".equals(s)){//              //添加一个元素//              list.add("javaee") ;//          }//      }        //方案1:1)使用迭代器遍历集合,使用迭代器添加元素//      Iterator it = list.iterator() ; 该迭代器中没有添加功能,List集合中的专有遍历方式:列表迭代器有添加功能:add(Object obj)        //将指定的元素插入到列表中(指定元素后面插入)        //ListIterator it = list.listIterator() ;//      while(it.hasNext()){//          String s = (String) it.next() ;//          //          //判断//          if("world".equals(s)){//              //使用迭代器添加//              it.add("javaee") ;//          }//      }        //方案2:2)使用集合遍历(普通for循环size()和get()相结合),使用集合添加元素        for(int x = 0 ; x <list.size() ; x ++){            String s = (String) list.get(x) ;            //判断            if("world".equals(s)){                //集合添加                list.add("javaee") ;//在末尾添加元素            }        }        //输出集合        System.out.println("list:"+list);    }}