3.1_12 JavaSE入门 P11 【集合】单例 Collection集合

已于 2022-04-29 09:15:22 修改
阅读量4k 收藏
点赞数
分类专栏： 三.Java 文章标签： java
于 2021-04-21 15:03:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43529621/article/details/115954338
版权

相关链接

目录

P11 【集合】单例 Collection集合

1 集合的概述

  • 概述
    • 集合是一个容器,是用来存储和获取数据;
  • 集合类的特点
    • 长度可变;

1.1 为什么会出现集合类

  • 我们学习的是面向对象的编程语言，面向对象的编程语言对事物的描述都是通过对象体现的，为了方便对多个对象进行操作，我们就必须把这多个对象进行存储，而要想存储多个对象，就不能是基本的变量了，应该是一个容器类型的变量。回顾我们学过的知识，有哪些是容器类型的呢?
  • 数组，StringBuilder，它的结果是一个字符串，不一定满足我们的需求，所以我们只能选择数组了，而数组的长度固定，不能适应变化的需求，在这种情况下，Java就提供了集合类供我们使用。
  • 由此可见，集合类的长度是可变的。

1.2 集合类体系结构图

在这里插入图片描述

2 Collection集合

2.1 Collection集合入门

  • Collection
    • 是单列集合的顶层接口。
  • 元素
    • Collection 表示一组对象，这些对象也称为 collection 的
  • 特点
    • 一些 collection 允许有重复的元素，而另一些则不允许。
    • 一些 collection 是有序的，而另一些则是无序的。
    • JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。
  • ArrayList()
    • 创建Collection集合的对象，我们采用的是多态的方式，使用的是具体的ArrayList类。因为这个类是最常用的集合类。
  • Collection
    • :是一种特殊的数据类型，泛型。这里我们会使用就可以了。如何使用呢?
      • 在出现E的地方用引用数据类型替换即可。
      • 举例：Collection,Collection

案例代码一  创建Collection集合对象并添加元素

package com.groupies.base.day11;

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

/**
 * @author GroupiesM
 * @date 2021/04/19
 * @introduction 创建Collection集合对象并添加元素
 *
 * Collection:是单列集合的顶层接口。
 * Collection 表示一组对象，这些对象也称为 collection 的元素。
 * 一些 collection 允许有重复的元素，而另一些则不允许。
 * 一些 collection 是有序的，而另一些则是无序的。
 * JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。
 *
 * 创建Collection集合的对象，我们采用的是多态的方式，使用的是具体的ArrayList类。
 * 因为这个类是最常用的集合类。
 * ArrayList()
 *
 * Collection<E>：
 * 		<E>:是一种特殊的数据类型，泛型。这里我们会使用就可以了。
 * 		如何使用呢?
 * 			在出现E的地方用引用数据类型替换即可。
 * 			举例：Collection<String>,Collection<Student>
 */
public class Demo1Collection {
    public static void main(String[] args) {
        //创建Collection集合对象
        //下面这种写法是JDK7的新特性，看懂就可以，但不建议这种写法，最好还是补全<>中的类型
        //Collection<String> c = new ArrayList<>(); //多态的方式
        Collection<String> c = new ArrayList<>();
        c.add("hello");
        c.add("world");
        c.add("java");

        //输出集合对象
        //输出了集合中的元素按照指定格式拼接的内容，说明ArrayList重写了toString()方法
        /* [hello, world, java] */
        System.out.println(c);
    }
}

2.2 Collection集合的成员方法

//添加元素
boolean add(E e);
//从集合中移除元素
boolean remove(Object o);
//清空集合中的元素
void clear();
//判断集合中是否存在指定的元素
boolean contains(Object o);
//判断集合是否为空
boolean isEmpty();
//集合的长度，也就是集合中元素的个数
int size();

案例代码二  Collection集合的成员方法

package com.groupies.base.day11;

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

/**
 * @author GroupiesM
 * @date 2021/04/19
 * @introduction Collection集合的成员方法
 *
 * 1. boolean add(E e):添加元素
 * 2. boolean remove(Object o):从集合中移除元素
 * 3. void clear():清空集合中的元素
 * 4. boolean contains(Object o):判断集合中是否存在指定的元素
 * 5. boolean isEmpty():判断集合是否为空
 * 6. int size():集合的长度，也就是集合中元素的个数
 */
public class Demo2CollectionMethod {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<>();

        /* 按住ctrl点击方法查看源码，但Collection接口不提供具体实现
           需要进入ArrayList实现类
        */

        /* //1. boolean add(E e):添加元素  通过查看源码，我们知道ArrayList集合的add方法的返回值永远都是true
            public boolean add(E e) {
                ensureCapacityInternal(size + 1);  // Increments modCount!!
                elementData[size++] = e;
                return true;
            }
         */
        System.out.println("add:" + c.add("hello"));//add:true
        System.out.println("add:" + c.add("world"));//add:true


        /* //2. boolean remove(Object o):从集合中移除元素
            public boolean remove(Object o) {
                if (o == null) {
                    for (int index = 0; index < size; index++)
                        if (elementData[index] == null) {
                            fastRemove(index);
                            return true;
                        }
                } else {
                    for (int index = 0; index < size; index++)
                        if (o.equals(elementData[index])) {
                            fastRemove(index);
                            return true;
                        }
                }
                return false;
            }
         */
        System.out.println("remove:" + c.remove("world"));//remove:true
        System.out.println("remove:" + c.remove("haha"));//remove:false

        /* //3. void clear():清空集合中的元素
            public void clear() {
                modCount++;

                // clear to let GC do its work
                for (int i = 0; i < size; i++)
                    elementData[i] = null;

                size = 0;
            }
         */
        c.clear();

        /* //4. boolean contains(Object o):判断集合中是否存在指定的元素
            public boolean contains(Object o) {
                return indexOf(o) >= 0;
            }
         */
        c.add("world");
        System.out.println("contains:" + c.contains("world"));//contains:true
        System.out.println("contains:" + c.contains("haha")); //contains:false


        /*  //5. boolean isEmpty():判断集合是否为空
            public boolean isEmpty() {
                return size == 0;
            }
         */
        System.out.println("isEmpty:" + c.isEmpty());//isEmpty:false


        /* //6. int size():集合的长度，也就是集合中元素的个数
            public int size() {
                return size;
            }
         */
        System.out.println("size:" + c.size());//size:1

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

2.3 Collection集合的遍历

  • Collection集合的遍历

    • Iterator iterator() : 返回在此 collection 的元素上进行迭代的迭代器;

    • 通过集合对象调用iterator()方法得到迭代器对象;

  • Iterator

    • E next():返回迭代的下一个元素;
    • boolean hasNext():如果仍有元素可以迭代，则返回 true;

案例代码三  Collection集合的遍历

package com.groupies.base.day11;

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

/**
 * @author GroupiesM
 * @date 2021/04/19
 * @introduction Collection集合的遍历
 *
 * Collection集合的遍历
 *
 * Iterator<E> iterator():返回在此 collection 的元素上进行迭代的迭代器。
 * 通过集合对象调用iterator()方法得到迭代器对象。
 *
 * Iterator:
 * 		E next():返回迭代的下一个元素。
 * 		boolean hasNext():如果仍有元素可以迭代，则返回 true。
 */
public class Demo3CollectionIterator {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c1 = new ArrayList<String>();

        //添加元素
        c1.add(new String("hello"));
        c1.add("world");
        c1.add("java");

        //Iterator<E> iterator()
        Iterator<String> it1 = c1.iterator();//返回的是跌抬起接口的实现类的对象

        try {
            System.out.println(it1.next());//hello
            System.out.println(it1.next());//world
            System.out.println(it1.next());//java
            System.out.println(it1.next());//NoSuchElementException:没有这样的元素异常
        } catch (NoSuchElementException e) {
            System.out.println("NoSuchElementException:没有这样的元素异常");
        }


        /* 遍历方式一：iterator.hasNext()
            boolean hasNext 如果还有下一个元素则返回true 否则跳出循环，避免NoSuchElementException
         */
        System.out.println("===========方式一：iterator.hasNext()===============");
        Iterator<String> it2 = c1.iterator();
        while (it2.hasNext()) {
            String s = it2.next();
            /*
                hello
                world
                java
             */
            System.out.println(s);
        }
        /* 遍历方式二： try catch 获取NoSuchElementException异常 */
        System.out.println("===========方式二：try catch===============");
        Iterator<String> it3 = c1.iterator();
        iter:
        while (true) {
            try {
                /*
                    hello
                    world
                    java
                    遍历结束
                 */
                System.out.println(it3.next());
            } catch (NoSuchElementException e) {
                System.out.println("遍历结束");
                break iter;
            }
        }
        /* 遍历方式三： 增强for循环 c1.for根据提示自动生成*/
        System.out.println("===========方式三：增强for循环===============");
        for (String s : c1) {
            /*
                hello
                world
                java
             */
            System.out.println(s);
        }
    }
}

2.4 集合使用步骤图解

在这里插入图片描述

2.5 Collection集合的练习存储自定义对象并遍历

  • 提示

    • 自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。

  • 集合的使用步骤

    • A : 创建集合对象
    • B : 创建元素对象
    • C : 把元素添加到集合
    • D : 遍历集合

案例代码四  Collection集合的练习存储自定义对象并遍历  【a.实体学生类】

package com.groupies.base.day11;

/**
 * @author GroupiesM
 * @date 2021/04/19
 * @introduction 实体学生类 Collection集合的练习存储自定义对象并遍历
 *
 * Collection集合存储自定义对象并遍历
 * 提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
 *
 * 集合的使用步骤：
 * 		A:创建集合对象
 * 		B:创建元素对象
 * 		C:把元素添加到集合
 * 		D:遍历集合
 */
public class Demo4POJOStudent {
    private String name;
    private int age;

    public Demo4POJOStudent(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;
    }
}

案例代码四  Collection集合的练习存储自定义对象并遍历  【b.测试类】

package com.groupies.base.day11;

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

/**
 * @author GroupiesM
 * @date 2021/04/19
 * @introduction 测试类 Collection集合的练习存储自定义对象并遍历
 *
 * Collection集合存储自定义对象并遍历
 * 提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
 *
 * 集合的使用步骤：
 * 		A:创建集合对象
 * 		B:创建元素对象
 * 		C:把元素添加到集合
 * 		D:遍历集合
 */
public class Demo4CollectionTest {
    public static void main(String[] args) {
        //创建集合对象
        Collection<Demo4POJOStudent> c = new ArrayList<Demo4POJOStudent>();

        //创建元素对象
        Demo4POJOStudent s1 = new Demo4POJOStudent("林青霞", 30);
        Demo4POJOStudent s2 = new Demo4POJOStudent("张曼玉", 35);
        Demo4POJOStudent s3 = new Demo4POJOStudent("王祖贤", 33);

        //把元素添加到集合
        c.add(s1);
        c.add(s2);
        c.add(s3);

        //遍历集合
        Iterator<Demo4POJOStudent> it = c.iterator();
        while (it.hasNext()) {
            Demo4POJOStudent s = it.next();
            /*
                林青霞---30
                张曼玉---35
                王祖贤---33
             */
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

3 List集合

3.1 List集合特点

  • List
    • 有序的 collection（也称为序列）;
    • 此接口的用户可以对列表中每个元素的插入位置进行精确地控制;
    • 用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素;
    • 与 set 不同，列表通常允许重复的元素;
  • List集合的特点
    • A : 有序（存储和取出元素的顺序一致）;
    • B : 存储的元素可以重复

案例代码五  List集合的特点

package com.groupies.base.day11;

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

/**
 * @author GroupiesM
 * @date 2021/04/19
 * @introduction List集合的特点
 *
 * List:有序的 collection（也称为序列）。
 * 此接口的用户可以对列表中每个元素的插入位置进行精确地控制。
 * 用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
 * 与 set 不同，列表通常允许重复的元素。
 *
 * List集合的特点：
 * 		A:有序(存储和取出元素的顺序一致)
 * 		B:存储的元素可以重复
 */
public class Demo5List {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();

        //存储元素
        list.add("hello");
        list.add("world");
        list.add("java");

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

3.2 List集合的特有成员方法

//在指定位置添加元素
void add(int index,E element);
//删除指定位置的元素
E remove(int index);
//获取指定位置的元素
E get(int index);
//修改指定位置的元素
E set(int index,E element);

案例代码六  List集合的特有成员方法

package com.groupies.base.day11;

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

/**
 * @author GroupiesM
 * @date 2021/04/19
 * @introduction List集合的特有成员方法
 *
 * 1. void add(int index,E element):在指定位置添加元素
 * 2. E remove(int index):删除指定位置的元素
 * 3. E get(int index):获取指定位置的元素
 * 4. E set(int index,E element):修改指定位置的元素
 */
public class Demo6ListMethod {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();

        //使用继承Collection的添加功能
        list.add("hello");
        list.add("world");
        list.add("java");
        System.out.println(list);//[hello, world, java]

        //1. void add(int index,E element):在指定位置添加元素
        System.out.println("==========1. void add(int index,E element):在指定位置添加元素==========");
        try {
            list.add(1, "javaee");
            list.add(11, "javase");//IndexOutOfBoundsException,索引超出边界异常，list中没有这个数据
        } catch (IndexOutOfBoundsException e) {
            System.out.println("IndexOutOfBoundsException,索引超出边界异常，list中没有这个数据");
        }
        System.out.println(list);//[hello, javaee, world, java]

        //2. E remove(int index):删除指定位置的元素,返回被删除的元素
        System.out.println("==========2. E remove(int index):删除指定位置的元素,返回被删除的元素==========");
        try {
            System.out.println("remove：" + list.remove(2));
            System.out.println("remove：" + list.remove(11));//IndexOutOfBoundsException,索引超出边界异常，list中没有这个数据
        } catch (IndexOutOfBoundsException e) {
            System.out.println("IndexOutOfBoundsException,索引超出边界异常，list中没有这个数据");
        }
        System.out.println(list);//[hello, javaee, java]

        //3.  E get(int index):获取指定位置的元素
        System.out.println("==========3.  E get(int index):获取指定位置的元素==========");
        try {
            System.out.println("get:" + list.get(1));
            System.out.println("get:" + list.get(11));//IndexOutOfBoundsException,索引超出边界异常，list中没有这个数据
        } catch (IndexOutOfBoundsException e) {
            System.out.println("IndexOutOfBoundsException,索引超出边界异常，list中没有这个数据");
        }
    }
}

3.3 List集合的普通for循环遍历

  • List集合的遍历方式
    • A : 迭代器
    • B : 普通for循环
    • C : 增强for循环

案例代码七  List集合的普通for循环遍历

package com.groupies.base.day11;

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

/**
 * @author GroupiesM
 * @date 2021/04/19
 * @introduction List集合的普通for循环遍历
 *
 * List集合的遍历：
 * 		A:迭代器
 * 		B:普通for循环
 */
public class Demo7ListFor01 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();

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

        // E get(int index):获取指定位置的元素
        try {
            System.out.println(list.get(0));//hello
            System.out.println(list.get(1));//world
            System.out.println(list.get(2));//java
            System.out.println(list.get(3));//IndexOutOfBoundsException,索引超出边界异常，list中没有这个数据
        } catch (IndexOutOfBoundsException e) {
            System.out.println("IndexOutOfBoundsException,索引超出边界异常，list中没有这个数据");
        }
    }
}

3.4 List集合练习

  • 提示
    • 自定义一个学生类，给出成员变量name和age。
    • 遍历集合的时候，在控制台输出学生对象的成员变量值。
  • 两种方式遍历
    • 迭代器
    • 普通for

案例代码八  List集合的普通for循环遍历  【a.实体学生类】

package com.groupies.base.day11;

/**
 * @author GroupiesM
 * @date 2021/04/19
 * @introduction 实体学生类 List集合的练习存储自定义对象并遍历
 *
 * List集合存储自定义对象并遍历
 * 提示：自定义一个学生类，给出成员变量name和age。
 * 遍历集合的时候，在控制台输出学生对象的成员变量值。
 * 两种方式遍历
 * 		迭代器
 * 		普通for
 */
public class Demo8POJOStudent {
    private String name;
    private int age;

    public Demo8POJOStudent(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;
    }

    /**
     * @introduction 重写Object类的toString方法
     * @return 学生类的姓名，年龄信息
     */
    @Override
    public String toString() {
        return "Demo8POJOStudent{" +
                       "name='" + name + '\'' +
                       ", age=" + age +
                       '}';
    }
}

案例代码八  List集合的普通for循环遍历  【b.测试类】

package com.groupies.base.day11;

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

/**
 * @author GroupiesM
 * @date 2021/04/19
 * @introduction 测试类 List集合的练习存储自定义对象并遍历
 *
 * List集合存储自定义对象并遍历
 * 提示：自定义一个学生类，给出成员变量name和age。
 * 遍历集合的时候，在控制台输出学生对象的成员变量值。
 * 三种方式遍历
 * 		a.迭代器
 * 		b.普通for
 * 	    c.增强for
 */
public class Demo8ListTest {
    public static void main(String[] args) {
        //创建集合对象
        List<Demo8POJOStudent> list = new ArrayList<Demo8POJOStudent>();

        //创建元素对象
        Demo8POJOStudent s1 = new Demo8POJOStudent("林青霞", 30);
        Demo8POJOStudent s2 = new Demo8POJOStudent("张曼玉", 35);
        Demo8POJOStudent s3 = new Demo8POJOStudent("王祖贤", 33);

        //把元素添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //a.迭代器
        System.out.println("==========a.迭代器==========");
        Iterator<Demo8POJOStudent> it = list.iterator();
        while (it.hasNext()) {
            Demo8POJOStudent s = it.next();
            /*
                Demo8POJOStudent{name='林青霞', age=30}
                Demo8POJOStudent{name='张曼玉', age=35}
                Demo8POJOStudent{name='王祖贤', age=33}
             */
            System.out.println(s.toString());
        }

        //b.普通for
        System.out.println("==========b.普通for==========");
        for (int i = 0; i < list.size(); i++) {
            Demo8POJOStudent s = list.get(i);
            /*
                Demo8POJOStudent{name='林青霞', age=30}
                Demo8POJOStudent{name='张曼玉', age=35}
                Demo8POJOStudent{name='王祖贤', age=33}
             */
            System.out.println(s.toString());
        }
        //c.增强for
        System.out.println("==========c.增强for==========");
        for (Demo8POJOStudent s : list) {
             /*
                Demo8POJOStudent{name='林青霞', age=30}
                Demo8POJOStudent{name='张曼玉', age=35}
                Demo8POJOStudent{name='王祖贤', age=33}
             */
            System.out.println(s.toString());
        }
    }
}

3.5 List.ListIterator();

  • ListIterator
    • ListIterator listIterator():返回此列表元素的列表迭代器
    • public interface ListIteratorextends Iterator
  • 特有功能
    • E previous():返回列表中的前一个元素。
    • boolean hasPrevious():如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
  • 注意
    • ListIterator可以实现逆向遍历，但是要求先正向遍历，才能逆向遍历。

案例代码九  列表迭代器的特有功能ListIterator

package com.groupies.base.day11;

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

/**
 * @author GroupiesM
 * @date 2021/04/19
 * @introduction 列表迭代器的特有功能ListIterator
 *
 * ListIterator:
 * 		ListIterator<E> listIterator():返回此列表元素的列表迭代器
 * 		public interface ListIterator<E>extends Iterator<E>
 *
 * 特有功能：
 * 		E previous():返回列表中的前一个元素。
 * 		boolean hasPrevious():如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。（
 *		注意：ListIterator可以实现逆向遍历，但是要求先正向遍历，才能逆向遍历。
 */
public class Demo9ListFor02 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        ListIterator<String> lit = list.listIterator();

        System.out.println("==========a.直接逆向遍历list数组==========");
        while (lit.hasPrevious()) {
            String s = lit.previous();
            System.out.println(s);
        }
        System.out.println("==========b.先正向遍历list数组再逆向遍历list数组==========");
        while (lit.hasNext()) {
            String s = lit.next();
        }
        while (lit.hasPrevious()) {
            String s = lit.previous();
            /*
                java
                world
                hello
             */
            System.out.println(s);
        }
    }
}

3.6 List并发修改异常

  • 需求
    • 有一个集合List list = new ArrayList();
    • 里面有三个元素list.add(“hello”);list.add(“world”);list.add(“java”);
    • 我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。
  • ConcurrentModificationException
    • 当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
  • 产生的原因
    • 迭代器依赖于集合而存在，在判断成功后，集合中添加了新的元素，而迭代器并不知道，所有就报错了。
    • 其实这个问题说的是：迭代器遍历集合中的元素的时候，不要使用集合对象去修改集合中的元素。
  • 如何解决?
    • A : 迭代器遍历的时候，我可以通过迭代器修改集合中的元素
      • 元素是跟在刚才迭代的元素后面的
    • B : 集合遍历的时候，我可以通过集合对象修改集合中的元素
      • 元素是在最后添加的

案例代码十  并发修改异常产生的原因及解决方案

package com.groupies.base.day11;

import java.util.*;

/**
 * @author GroupiesM
 * @date 2021/04/19
 * @introduction 并发修改异常产生的原因及解决方案
 *
 * 需求：
 *      我有一个集合：List<String> list = new ArrayList<String>();
 *      里面有三个元素list.add("hello");list.add("world");list.add("java");
 *      我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。
 *
 * ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
 *
 * 产生的原因：
 * 		迭代器依赖于集合而存在，在判断成功后，集合中添加了新的元素，而迭代器并不知道，所有就报错了。
 * 		其实这个问题说的是：迭代器遍历集合中的元素的时候，不要使用集合对象去修改集合中的元素。
 * 如何解决呢?
 * 		A:迭代器遍历的时候，我可以通过迭代器修改集合中的元素
 * 			元素是跟在刚才迭代的元素后面的
 * 		B:集合遍历的时候，我可以通过集合对象修改集合中的元素
 * 			元素是在最后添加的
 */
public class Demo10ListConcurrentModificationException {
    public static void main(String[] args) {
        // 创建集合对象
        List<String> list = new ArrayList<String>();

        // 添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        System.out.println(list);//[hello, world, java]
        //我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素
        Iterator<String> it = list.iterator();

        //ConcurrentModificationException:添加失败，当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
        /*while (it.hasNext()) {
            String s = it.next();
            if (s.equals("world")) {
                list.add("javaee");//ConcurrentModificationException:添加失败，当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
            }
            System.out.println(s);
        }*/

        //A:迭代器遍历的时候，我可以通过迭代器修改集合中的元素(元素是跟在刚才迭代的元素后面的)
        ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()) {
            String s = lit.next();
            if (s.equals("world")) {
                lit.add("javaee");
            }
        }
        System.out.println(list);//[hello, world, javaee, java]

        //B:集合遍历的时候，我可以通过集合对象修改集合中的元素(元素是在最后添加的)
        for (int x = 0; x < list.size(); x++) {
            String s = list.get(x);
            if (s.equals("world")) {
                list.add("javaee");
            }
        }
        System.out.println(list);//[hello, world, javaee, java, javaee]
    }
}

3.7 增强for循环

  • 格式

    //格式
for(元素的数据类型 变量名 : 数组名或者Collection集合对象名) {
	使用变量名即可，这个变量名代表的其实就是数组或者Collection集合中的元素
}

//实例
for (String s : list) {
	System.out.println(s);
}
    • 好处 ：简化了数组和Collection集合的遍历。
    • 弊端 ：目标不能为null。如何保证呢?在遍历前先对目标进行不为null的判断。

案例代码十一  增强for的概述和使用

package com.groupies.base.day11;

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

/**
 * @author GroupiesM
 * @date 2021/04/20
 * @introduction 增强for的概述和使用
 *
 * 增强for：是for循环的一种
 *
 * 格式：
 * 		for(元素的数据类型 变量名 : 数组名或者Collection集合对象名) {
 * 			使用变量名即可，这个变量名代表的其实就是数组或者Collection集合中的元素
 *        }
 *
 * 		好处：简化了数组和Collection集合的遍历
 * 		弊端：目标不能为null。如何保证呢?在遍历前先对目标进行不为null的判断。
 */
public class Demo11ListFor03 {
    public static void main(String[] args) {
        //a.定义一个int类型的数组
        int[] arr = {1, 2, 3, 4, 5};

        //a1.普通for : arr.fori
        System.out.println("----a1.普通for : arr.fori-----");
        for (int i = 0; i < arr.length; i++) {
            /*
                1
                2
                3
                4
                5
             */
            System.out.println(arr[i]);
        }

        //a2.增强for : arr.for
        System.out.println("----a2.增强for : arr.for-----");
        for (int i : arr) {
            /*
                1
                2
                3
                4
                5
             */
            System.out.println(i);
        }

        //b.定义一个String类型的数组
        String[] strArr = {"hello", "world", "java"};

        //b1.增强for : strArr.for
        System.out.println("----b1.增强for : strArr.for-----");
        for (String s : strArr) {
            /*
                hello
                world
                java
             */
            System.out.println(s);
        }

        //c.创建集合对象
        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");

        //c1.增强for : list.for
        System.out.println("----c1.增强for : list.for-----");
        for (String s : list) {
            /*
                hello
                world
                java
             */
            System.out.println(s);
        }

        //c2.目标不能为null。如何保证呢?在遍历前先对目标进行不为null的判断。
        System.out.println("----c2.目标不能为null。如何保证呢?在遍历前先对目标进行不为null的判断。----");
        list = null;
        try {
            for (String s : list) {
                System.out.println(s);//NullPointerException : 目标不能为null。如何保证呢?在遍历前先对目标进行不为null的判断。
            }
        } catch (NullPointerException e) {
            System.out.println("NullPointerException : 目标不能为null。如何保证呢?在遍历前先对目标进行不为null的判断。");
        }
        //c2.先对目标进行不为null的判断
        System.out.println("----c2.先对目标进行不为null的判断----");
        if (list != null) {
            for (String s : list) {
                System.out.println(s);
            }
        }

        //d.增强for其实就是用来替代迭代器的
        list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        System.out.println("----d.增强for其实就是用来替代迭代器的-----");
        try {
            for (String s : list) {
                if (s.equals("world")) {
                    list.add("javaee");//ConcurrentModificationException:添加失败，当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
                }
            }
        } catch (ConcurrentModificationException e) {
            System.out.println("ConcurrentModificationException:添加失败，当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。");
        }
    }
}

3.8 增强for练习

  • 需求
    • List集合存储自定义对象并遍历
  • 提示
    • 自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
  • 遍历方式
    • 增强for

案例代码十二  增强for的练习List集合存储自定义对象并遍历   【a.实体学生类】

package com.groupies.base.day11;

/**
 * @author GroupiesM
 * @date 2021/04/20
 * @introduction 实体学生类 增强for的练习List集合存储自定义对象并遍历
 *
 * List集合存储自定义对象并遍历
 * 提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
 * 遍历方式
 * 		增强for
 */
public class Demo12POJOStudent {
    private String name;
    private int age;

    public Demo12POJOStudent(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 "{name='" + name + '\'' + ", age=" + age + '}';
    }
}

案例代码十二  增强for的练习List集合存储自定义对象并遍历   【b.测试类】

package com.groupies.base.day11;

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

/**
 * @author GroupiesM
 * @date 2021/04/20
 * @introduction 测试类 增强for的练习List集合存储自定义对象并遍历
 *
 * List集合存储自定义对象并遍历
 * 提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
 * 遍历方式
 * 		增强for
 */
public class Demo12ListTest {
    public static void main(String[] args) {
        //创建集合对象
        List<Demo12POJOStudent> list = new ArrayList<Demo12POJOStudent>();

        //创建元素对象
        Demo12POJOStudent s1 = new Demo12POJOStudent("林青霞", 30);
        Demo12POJOStudent s2 = new Demo12POJOStudent("张曼玉", 35);
        Demo12POJOStudent s3 = new Demo12POJOStudent("王祖贤", 33);

        //把元素添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //增强for遍历集合 : list.for
        for (Demo12POJOStudent s : list) {
            /*
                {name='林青霞', age=30}
                {name='张曼玉', age=35}
                {name='王祖贤', age=33}
             */
            System.out.println(s.toString());
        }
    }
}

4 数据结构

  • 什么是数据结构?
    • 数据的组织方式;

4.1 常见数据结构【栈】【队列】

  • 栈 ：FIFO(First In First Out) 先进先出
  • 队列 ：FILO(First In Last Out) 先进后出

在这里插入图片描述

4.2 常见数据结构【数组】【链表】

  • 数组 ：存储同一种数据类型的多个元素的容器，有索引，方便我们获取元素;
    • 应用 ： ArrayList ;
  • 链表 ：由一个链子把多个节点连接起来的数据;
    • 结点 ：由 数据 和 下一个元素的地址 组成;
    • 应用 ： LinkedList ;

在这里插入图片描述

5 ArrayList案例

5.1 ArrayList集合存储字符串

  • List

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

  • ArrayList存储字符串并遍历

    • A : 迭代器
    • B : 普通for
    • C : 增强for

案例代码十三  ArrayList集合存储字符串并遍历   【a.实体学生类】

package com.groupies.base.day11;

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

/**
 * @author GroupiesM
 * @date 2021/04/20
 * @introduction ArrayList集合存储字符串
 *
 * List:
 * 		ArrayList:底层数据结构是数组，查询快，增删慢
 * 		LinkedList:底层数据结构是链表，查询慢，增删快
 *
 * ArrayList存储字符串并遍历：
 * 		A:迭代器
 * 		B:普通for
 * 		C:增强for
 */
public class Demo13ArrayListString {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> arr = new ArrayList<String>();

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

        //a.迭代器 arr.iterator
        System.out.println("a.迭代器 arr.iterator");
        Iterator<String> it = arr.iterator();
        while (it.hasNext()) {
            /*
                hello
                world
                java
             */
            System.out.println(it.next());
        }

        //b.普通for arr.fori
        System.out.println("b.普通for arr.fori ");
        for (int i = 0; i < arr.size(); i++) {
            /*
                hello
                world
                java
             */
            System.out.println(arr.get(i));
        }

        //c.增强for
        for (String s : arr) {
            /*
                hello
                world
                java
             */
            System.out.println(s);
        }
    }
}

5.2 ArrayList存储实体类

  • 提示

    • 自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。

  • 遍历方式

    • A : 迭代器
    • B : 普通for
    • C : 增强for

案例代码十四  ArrayList集合存储实体类   【a.实体学生类】

package com.groupies.base.day11;

/**
 * @author GroupiesM
 * @date 2021/04/20
 * @introduction 实体学生类 ArrayList存储实体类
 *
 * ArrayList集合存储自定义对象并遍历
 * 提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
 * 三种方式遍历
 * 		迭代器
 * 		普通for
 * 		增强for
 *
 * LinkedList的使用和ArrayList的相似，所以LinkedList的练习需要大家自己做
 */
public class Demo14POJOStudent {
    private String name;
    private int age;

    public Demo14POJOStudent(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 "{name='" + name + "'" + ", age=" + age + '}';
    }
}

案例代码十四  ArrayList集合存储实体类   【b.测试类】

package com.groupies.base.day11;

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

/**
 * @author GroupiesM
 * @date 2021/04/20
 * @introduction 测试类 ArrayList存储实体类
 *
 * ArrayList集合存储自定义对象并遍历
 * 提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
 * 三种方式遍历
 * 		迭代器
 * 		普通for
 * 		增强for
 *
 * LinkedList的使用和ArrayList的相似，所以LinkedList的练习需要大家自己做
 */
public class Demo14ArrayListTest {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<Demo14POJOStudent> list = new ArrayList<>();

        //创建元素对象
        Demo14POJOStudent s1 = new Demo14POJOStudent("林青霞", 30);
        Demo14POJOStudent s2 = new Demo14POJOStudent("张曼玉", 35);
        Demo14POJOStudent s3 = new Demo14POJOStudent("王祖贤", 33);

        //把元素添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //a.迭代器 list.iterator
        System.out.println("a.迭代器 list.iterator");
        Iterator<Demo14POJOStudent> it = list.iterator();
        while (it.hasNext()) {
            /*
                {name='林青霞', age=30}
                {name='张曼玉', age=35}
                {name='王祖贤', age=33}
             */
            System.out.println(it.next().toString());
        }

        //b.普通for
        System.out.println("b.普通for");
        for (int i = 0; i < list.size(); i++) {
            /*
                {name='林青霞', age=30}
                {name='张曼玉', age=35}
                {name='王祖贤', age=33}
             */
            System.out.println(list.get(i).toString());
        }

        //c.增强for
        System.out.println("c.增强for");
        for (Demo14POJOStudent s : list) {
            /*
                {name='林青霞', age=30}
                {name='张曼玉', age=35}
                {name='王祖贤', age=33}
             */
            System.out.println(s.toString());
        }
    }
}

6 Set集合特点和HashSet集合类

6.1 Set集合的特点

  • Set
    • 元素唯一，存储元素无序 ;
    • 一个不包含重复元素的 collection;
  • HashSet
    • 它不保证 set 的迭代顺序，特别是它不保证该顺序恒久不变;

案例代码十五  Set集合的特点

package com.groupies.base.day11;

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

/**
 * @author GroupiesM
 * @date 2021/04/21
 * @introduction Set集合的特点
 *
 * Collection接口 -- List（接口，可重复，存取顺序一致） 、 Set（接口，唯一，存取顺序不一致）
 *       List接口 -- ArrayList(实现类，数据结构为数组)、LinkedList(实现类，数据结构为链表)
 *        Set接口 -- HashSet(实现类)
 *
 * Set:
 * 		一个不包含重复元素的 collection
 *
 * HashSet:
 * 		它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变
 */
public class Demo15Set {
    public static void main(String[] args) {
        //创建集合对象
        Set<String> set = new HashSet<>();

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

        //set集合的唯一性 : 再次添加相同元素，但集合内该元素只有一个
        set.add("world");

        //遍历集合 set.for
        for (String s : set) {
            /*
                world
                java
                hello
             */
            System.out.println(s);
        }
    }
}

6.2 HashSet集合类

  • HashSet
    • 它不保证 set 的迭代顺序，特别是它不保证该顺序恒久不变;
6.2.1 HashSet元素唯一性原理
  • HashSet保证元素唯一性的原理?
    • 通过查看add方法的源码，我们知道了添加功能的执行过程中，是进行了数据的判断的。
    • 这个判断的流程是：
      • 首先比较对象的哈希值是否相同，这个哈希值是根据对象的hashCode()计算出来的。
        • 如果哈希值不同，就直接添加到集合中
        • 如果哈希值相同，继续执行equals()进行比较，
          • 返回的是true，说明元素重复，不添加。
          • 返回的是false，说明元素不重复，就添加。
    • 如果我们使用HashSet集合存储对象，你要想保证元素的唯一性，就必须重写hashCode()和equals()方法。

案例代码十六  HashSet保证元素唯一性的原理

package com.groupies.base.day11;

import java.util.HashSet;

/**
 * @author GroupiesM
 * @date 2021/04/21
 * @introduction HashSet保证元素唯一性的原理
 *
 * HashSet保证元素唯一性的原理?
 *
 * 通过查看add方法的源码，我们知道了添加功能的执行过程中，是进行了数据的判断的。
 * 这个判断的流程是：
 * 		首先比较对象的哈希值是否相同，这个哈希值是根据对象的hashCode()计算出来的。
 * 			如果哈希值不同，就直接添加到集合中
 * 			如果哈希值相同，继续执行equals()进行比较，
 * 				返回的是true，说明元素重复，不添加。
 * 				返回的是false，说明元素不重复，就添加。
 *
 * 如果我们使用HashSet集合存储对象，你要想保证元素的唯一性，就必须重写hashCode()和equals()方法。
 */
public class Demo16HashSet {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> hs = new HashSet<>();
        
        //添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");

        //set集合的唯一性 : 再次添加相同元素，但集合内该元素只有一个
        hs.add("world");
        
        //遍历集合
        for (String h : hs) {
            System.out.println(h);
        }
    }
}
6.2.2 HashSet集合存储实体类
  • 需求
    • 自定义一个学生类，给出成员变量name和age。
    • 遍历集合的时候，在控制台输出学生对象的成员变量值。
  • 遍历方式
    • a.迭代器
    • b.增强for

案例代码十七  HashSet集合存储实体类  【a.实体学生类】

package com.groupies.base.day11;

/**
 * @author GroupiesM
 * @date 2021/04/21
 * @introduction 实体学生类 HashSet集合存储实体类
 *
 * HashSet集合存储自定义对象并遍历
 * 提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
 * 两种方式遍历
 * 		迭代器
 * 		增强for
 */
public class Demo17POJOStudent {
    private String name;
    private int age;

    public Demo17POJOStudent(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 "{name='" + name + "'" + ", age=" + age + '}';
    }
}

案例代码十七  HashSet集合存储实体类  【b.测试类】

package com.groupies.base.day11;

import java.util.HashSet;
import java.util.Iterator;

/**
 * @author GroupiesM
 * @date 2021/04/21
 * @introduction 测试类 HashSet集合存储实体类
 *
 * HashSet集合存储自定义对象并遍历
 * 提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
 * 两种方式遍历
 * 		迭代器
 * 		增强for
 */
public class Demo17HashSet {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<Demo17POJOStudent> hs = new HashSet<>();

        //创建元素对象
        Demo17POJOStudent s1 = new Demo17POJOStudent("林青霞", 30);
        Demo17POJOStudent s2 = new Demo17POJOStudent("张曼玉", 35);
        Demo17POJOStudent s3 = new Demo17POJOStudent("王祖贤", 33);

        //把元素添加到集合
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);

        //a.迭代器遍历 hs.iterator()
        Iterator<Demo17POJOStudent> it = hs.iterator();
        System.out.println("a.迭代器遍历 hs.iterator()");
        while (it.hasNext()) {
            Demo17POJOStudent s = it.next();
            /*
                {name='林青霞', age=30}
                {name='王祖贤', age=33}
                {name='张曼玉', age=35}
             */
            System.out.println(s.toString());
        }

        //b.增强for遍历 it.next()
        System.out.println("b.增强for遍历 it.next()");
        for (Demo17POJOStudent s : hs) {
            /*
                {name='林青霞', age=30}
                {name='王祖贤', age=33}
                {name='张曼玉', age=35}
             */
            System.out.println(s);
        }

    }
}
6.2.3 HashSet重写hashCode();equals();
  • 要求
    • 如果对象的成员变量值相同，就认为是同一个元素。
  • 提示
    • 自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
  • 遍历方式
    • a.迭代器
    • b.增强for
  • 因为我们存储的元素所属的类没有重写hashCode()和equals()方法，所以保证不了元素的唯一性。
    • 而我想保证，怎么办呢?重写这两个方法就可以了。
    • 如何重写呢?自动生成就可以了。

案例代码十八  HashSet重写hashCode();equals();  【a.实体学生类】

package com.groupies.base.day11;

import java.util.Objects;

/**
 * @author GroupiesM
 * @date 2021/04/21
 * @introduction 实体学生类 HashSet重写hashCode();equals();
 *
 * HashSet集合存储自定义对象并遍历
 * 要求：如果对象的成员变量值相同，就认为是同一个元素。
 * 提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
 * 两种方式遍历
 * 		迭代器
 * 		增强for
 *
 * 因为我们存储的元素所属的类没有重写hashCode()和equals()方法，所以保证不了元素的唯一性。
 * 而我想保证，怎么办呢?重写这两个方法就可以了。
 * 如何重写呢?自动生成就可以了。
 */
public class Demo18POJOStudent {
    private String name;
    private int age;

    public Demo18POJOStudent(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 "{name='" + name + "'" + ", age=" + age + '}';
    }

    /**
     * @introduction 因为我们存储的元素所属的类没有重写hashCode()和equals()方法，所以保证不了元素的唯一性。
     *              而我想保证，怎么办呢?重写这两个方法就可以了。
     *              如何重写呢?自动生成就可以了。alt+insert
     * @param o
     * @return
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Demo18POJOStudent that = (Demo18POJOStudent) o;
        return age == that.age && name.equals(that.name);
    }

    /**
     * @introduction 因为我们存储的元素所属的类没有重写hashCode()和equals()方法，所以保证不了元素的唯一性。
     *              而我想保证，怎么办呢?重写这两个方法就可以了。
     *              如何重写呢?自动生成就可以了。alt+insert
     * @return
     */
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

案例代码十八  HashSet重写hashCode();equals();  【b.测试类】

package com.groupies.base.day11;

import java.util.HashSet;

/**
 * @author GroupiesM
 * @date 2021/04/21
 * @introduction 测试类 HashSet重写hashCode();equals();
 *
 * HashSet集合存储自定义对象并遍历
 * 要求：如果对象的成员变量值相同，就认为是同一个元素。
 * 提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
 * 两种方式遍历
 * 		迭代器
 * 		增强for
 *
 * 因为我们存储的元素所属的类没有重写hashCode()和equals()方法，所以保证不了元素的唯一性。
 * 而我想保证，怎么办呢?重写这两个方法就可以了。
 * 如何重写呢?自动生成就可以了。
 */
public class Demo18HashSet {
    public static void main(String[] args) {
        HashSet<Demo18POJOStudent> hs = new HashSet<>();

        Demo18POJOStudent s1 = new Demo18POJOStudent("林青霞", 30);
        Demo18POJOStudent s2 = new Demo18POJOStudent("张曼玉", 35);
        Demo18POJOStudent s3 = new Demo18POJOStudent("王祖贤", 33);
        Demo18POJOStudent s4 = new Demo18POJOStudent("林青霞", 30);

        //把元素天机到集合
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        hs.add(s4);

        //增强for遍历集合 hs.for
        for (Demo18POJOStudent h : hs) {
            /*
                {name='王祖贤', age=33}
                {name='张曼玉', age=35}
                {name='林青霞', age=30}
             */
            System.out.println(h);
        }
    }
}

7 课后练习

7.1 练习1 ArrayList

练习1  ArrayList

package com.groupies.base.day11;

import java.util.ArrayList;

/**
 * @author GroupiesM
 * @date 2021/04/20
 * @introduction 课后基础练习1 ArrayList
 *
 * 需求：
 *      一、	请按以下要求编写代码：
 *      1.	定义一个只能存储字符串的集合对象；
 *      2.	向集合内添加以下数据：
 *      		“孙悟空”
 *      		“猪八戒”
 *      		“沙和尚”
 *      		“铁扇公主”
 *      3.	不用遍历，直接打印集合；
 *      4.	获取第4个元素（注意，是--第4个元素，它的索引是？）
 *      5.	打印一下集合大小；
 *      6.	删除元素“铁扇公主”
 *      7.	删除第3个元素（注意：是--第3个元素）
 *      8.	将元素“猪八戒”改为“猪悟能”
 *      9.	再次打印集合；
 */
public class HomeWork1ArrayList {
    public static void main(String[] args) {
        //1.	定义一个只能存储字符串的集合对象；
        ArrayList<String> list = new ArrayList<>();

        //2.	向集合内添加以下数据：
        list.add("孙悟空");
        list.add("猪八戒");
        list.add("沙和尚");
        list.add("铁扇公主");

        //3.	不用遍历，直接打印集合；
        System.out.println(list);//[孙悟空, 猪八戒, 沙和尚, 铁扇公主]

        //4.	获取第4个元素（注意，是--第4个元素，它的索引是？）
        System.out.println(list.get(3));//铁扇公主

        //5.	打印一下集合大小；
        System.out.println(list.size());

        //6.	删除元素“铁扇公主”
        list.remove("铁扇公主");

        //7.	删除第3个元素（注意：是--第3个元素）
        list.remove(2);

        //8.	将元素“猪八戒”改为“猪悟能”
        for (int i = 0; i < list.size(); i++) {
            if ("猪八戒".equals(list.get(i))) {
                //“猪八戒”改为“猪悟能”
                list.set(i, "猪悟能");
            }
        }

        //9.	再次打印集合；
        System.out.println(list);//[孙悟空, 猪悟能]
    }
}

7.2 练习2 ArrayList

练习2  ArrayList   【a.实体学生类】

package com.groupies.base.day11;

/**
 * @author GroupiesM
 * @date 2021/04/20
 * @introduction 实体学生类 课后基础练习2 ArrayList
 *
 * 需求：
 *      二、	请按以下要求编写代码：
 *      1.	定义Student类，包含以下属性：
 *      	学号、姓名、身高
 *      2.	定义MainApp类，包含main()方法；
 *      3.	在main()方法中，创建一个可以存储Student对象的集合对象；
 *      4.	创建以下几个Student对象：
 *      		学号	姓名		身高
 *      		it001	黄渤		1.72
 *      		it002	孙红雷	1.78
 *      		it003	章子怡	1.64
 *      		it004	杨颖		1.68
 *      5.	将上面几个对象添加到集合中
 *      6.	遍历集合打印每个对象的属性值；
 *      7.	获取并打印集合大小；
 *      8.	获取第3个学员对象，并打印其属性值；
 *      9.	移除掉第4个学员对象；
 *      10.	再次获取并打印集合大小；
 *      11.	将第一个对象替换为以下对象：
 *      		it005	撒贝宁	1.67
 *      12.	遍历集合，打印出身高在1.70以上的学员信息；
 *      13.	遍历集合，打印出“孙”姓的学员信息；
 */
public class HomeWork2POJOStudent {
    //1.	定义Student类，包含以下属性：
    private String id;
    private String name;
    private double heigh;

    public HomeWork2POJOStudent(String id, String name, double heigh) {
        this.id = id;
        this.name = name;
        this.heigh = heigh;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public double getHeigh() {
        return heigh;
    }

    public void setHeigh(double heigh) {
        this.heigh = heigh;
    }

    @Override
    public String toString() {
        return "{id='" + id + "'" + ", name='" + name + "'" + ", heigh=" + heigh + '}';
    }
}

练习2  ArrayList   【b.测试类】

package com.groupies.base.day11;

import java.util.ArrayList;

/**
 * @author GroupiesM
 * @date 2021/04/20
 * @introduction 测试类 课后基础练习2 ArrayList
 *
 * 需求：
 *      二、	请按以下要求编写代码：
 *      1.	定义Student类，包含以下属性：
 *      	学号、姓名、身高
 *      2.	定义MainApp类，包含main()方法；
 *      3.	在main()方法中，创建一个可以存储Student对象的集合对象；
 *      4.	创建以下几个Student对象：
 *      		学号	姓名		身高
 *      		it001	黄渤		1.72
 *      		it002	孙红雷	1.78
 *      		it003	章子怡	1.64
 *      		it004	杨颖		1.68
 *      5.	将上面几个对象添加到集合中
 *      6.	遍历集合打印每个对象的属性值；
 *      7.	获取并打印集合大小；
 *      8.	获取第3个学员对象，并打印其属性值；
 *      9.	移除掉第4个学员对象；
 *      10.	再次获取并打印集合大小；
 *      11.	将第一个对象替换为以下对象：
 *      		it005	撒贝宁	1.67
 *      12.	遍历集合，打印出身高在1.70以上的学员信息；
 *      13.	遍历集合，打印出“孙”姓的学员信息；
 */
public class HomeWork2ArrayList {
    //2.	定义MainApp类，包含main()方法；
    public static void main(String[] args) {
        // 3.	在main()方法中，创建一个可以存储Student对象的集合对象；
        ArrayList<HomeWork2POJOStudent> list = new ArrayList<HomeWork2POJOStudent>();

        // 4.	创建以下几个Student对象：
        HomeWork2POJOStudent s1 = new HomeWork2POJOStudent("it001", "黄渤", 1.72);
        HomeWork2POJOStudent s2 = new HomeWork2POJOStudent("it002", "孙红雷", 1.78);
        HomeWork2POJOStudent s3 = new HomeWork2POJOStudent("it003", "章子怡", 1.64);
        HomeWork2POJOStudent s4 = new HomeWork2POJOStudent("it004", "杨颖", 1.68);

        // 5.	将上面几个对象添加到集合中
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);

        //6.	遍历集合打印每个对象的属性值；
        System.out.println("6.\t遍历集合打印每个对象的属性值；");
        for (HomeWork2POJOStudent s : list) {
            /*
                {id='it001', name='黄渤', heigh=1.72}
                {id='it002', name='孙红雷', heigh=1.78}
                {id='it003', name='章子怡', heigh=1.64}
                {id='it004', name='杨颖', heigh=1.68}
             */
            System.out.println(s);
        }

        //7.	获取并打印集合大小；
        System.out.println("7.\t获取并打印集合大小；");
        System.out.println(list.size());

        //8.	获取第3个学员对象，并打印其属性值；
        System.out.println("8.\t获取第3个学员对象，并打印其属性值；");
        System.out.println(list.get(2).toString());//{id='it003', name='章子怡', heigh=1.64}

        //9.	移除掉第4个学员对象；
        list.remove(3);

        //10.	再次获取并打印集合大小；
        System.out.println("10.\t再次获取并打印集合大小；");
        System.out.println(list.size());//3

        //11.	将第一个对象替换为以下对象：      it005	撒贝宁	1.67
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).getId().equals("it001")) {
                list.set(i, new HomeWork2POJOStudent("it005", "撒贝宁", 1.67));
            }
        }

        //12.	遍历集合，打印出身高在1.70以上的学员信息；
        System.out.println("12.\t遍历集合，打印出身高在1.70以上的学员信息；");
        for (HomeWork2POJOStudent s : list) {
            if (s.getHeigh() > 1.70) {
                System.out.println(s);//{id='it002', name='孙红雷', heigh=1.78}
            }
        }
        //13.	遍历集合，打印出“孙”姓的学员信息；
        System.out.println("13.\t遍历集合，打印出“孙”姓的学员信息；");
        for (HomeWork2POJOStudent s : list) {
            if (s.getName().startsWith("孙")) {
                System.out.println(s);//{id='it002', name='孙红雷', heigh=1.78}
            }
        }
    }
}

7.3 练习3 ArrayList

练习3  ArrayList   【a.实体学生类】

package com.groupies.base.day11;

/**
 * @author GroupiesM
 * @date 2021/04/20
 * @introduction 实体学生类 课后基础练习3 ArrayList
 *
 * 需求：
 *      三、需求说明：程序启动后可以接收三个学员信息，然后可以打印所有学员信息，
 *      	并找出身高最高的学员，并打印他们的详细信息
 *      	1.	定义MainApp类，包含main()方法；
 *      	2.	在main()方法中，创建一个可以存储Student对象的集合对象；
 *      	3.	从控制台接收以下几个Student对象：
 *      		学号	姓名	性别	年龄	身高
 *      		it001	黄渤	男		20		1.72
 *      		it002	孙红雷	男		22		1.78
 *      		it003	章子怡	女		18		1.64
 *      		将每个对象添加到集合中(集合中学员学号唯一)；
 *      	4.	在MainApp中创建方法，可以打印所有学员信息：
 *      		public static void printAll(ArrayList<Student>stuList){}
 *      	5.	在MainApp中创建方法，可以找出身高最高的学员，并打印：
 *      		public static void findMaxHeight(ArrayList<Student>stuList){}
 *      	6.	在main()方法中，分别调用三个方法：打印所有学员，找出身高最高的学员；
 */
public class HomeWork3POJOStudent {
    //定义Student类，包含以下属性：
    private String id;
    private String name;
    private String gender;
    private int age;
    private double heigh;

    public HomeWork3POJOStudent(String id, String name, String gender, int age, double heigh) {
        this.id = id;
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.heigh = heigh;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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

    public double getHeigh() {
        return heigh;
    }

    public void setHeigh(double heigh) {
        this.heigh = heigh;
    }

    @Override
    public String toString() {
        return "{id='" + id + "'" + ", name='" + name + "'" + ", gender='" + gender + "'" + ", age=" + age + ", heigh=" + heigh + '}';
    }
}

练习3  ArrayList   【b.测试类】

package com.groupies.base.day11;

import java.util.ArrayList;

/**
 * @author GroupiesM
 * @date 2021/04/20
 * @introduction 测试类 课后基础练习3 ArrayList
 *
 * 需求：
 *      三、需求说明：程序启动后可以接收三个学员信息，然后可以打印所有学员信息，
 *      	并找出身高最高的学员，并打印他们的详细信息
 *      	1.	定义MainApp类，包含main()方法；
 *      	2.	在main()方法中，创建一个可以存储Student对象的集合对象；
 *      	3.	从控制台接收以下几个Student对象：
 *      		学号	姓名	性别	年龄	身高
 *      		it001	黄渤	男		20		1.72
 *      		it002	孙红雷	男		22		1.78
 *      		it003	章子怡	女		18		1.64
 *      		将每个对象添加到集合中(集合中学员学号唯一)；
 *      	4.	在MainApp中创建方法，可以打印所有学员信息：
 *      		public static void printAll(ArrayList<Student>stuList){}
 *      	5.	在MainApp中创建方法，可以找出身高最高的学员，并打印：
 *      		public static void findMaxHeight(ArrayList<Student>stuList){}
 *      	6.	在main()方法中，分别调用三个方法：打印所有学员，找出身高最高的学员；
 */
public class HomeWork3ArrayList {
    //1.	定义MainApp类，包含main()方法；
    public static void main(String[] args) {
        //2.	在main()方法中，创建一个可以存储Student对象的集合对象；
        ArrayList<HomeWork3POJOStudent> list = new ArrayList<>();
        HomeWork3POJOStudent s1 = new HomeWork3POJOStudent("it001", "黄渤", "男", 20, 1.72);
        HomeWork3POJOStudent s2 = new HomeWork3POJOStudent("it002", "孙红雷", "男", 22, 1.78);
        HomeWork3POJOStudent s3 = new HomeWork3POJOStudent("it003", "章子怡", "女", 18, 1.64);
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //3.	从控制台接收以下几个Student对象：
        for (HomeWork3POJOStudent s : list) {
            /*
                {id='it001', name='黄渤', gender='男', age=20, heigh=1.72}
                {id='it002', name='孙红雷', gender='男', age=22, heigh=1.78}
                {id='it003', name='章子怡', gender='女', age=18, heigh=1.64}
             */
            System.out.println(s.toString());
        }

        //6.	在main()方法中，分别调用三个方法：打印所有学员，找出身高最高的学员；
        /*
            it001---黄渤---男---20---1.72
            it002---孙红雷---男---22---1.78
            it003---章子怡---女---18---1.64
         */
        printAll(list);
        findMaxHeight(list);//{id='it002', name='孙红雷', gender='男', age=22, heigh=1.78}
    }

    //4.	在MainApp中创建方法printAll，可以打印所有学员信息：
    public static void printAll(ArrayList<HomeWork3POJOStudent> list) {
        System.out.println("4.\t在MainApp中创建方法printAll，可以打印所有学员信息：");
        for (HomeWork3POJOStudent s : list) {
            System.out.println(s.getId() + "---" + s.getName() + "---" + s.getGender() + "---" + s.getAge() + "---" + s.getHeigh());
        }
    }

    //5.	在MainApp中创建方法findMaxHeight，可以找出身高最高的学员，并打印：
    public static void findMaxHeight(ArrayList<HomeWork3POJOStudent> list) {
        System.out.println("5.\t在MainApp中创建方法findMaxHeight，可以找出身高最高的学员，并打印：");
        HomeWork3POJOStudent student = list.get(1);
        double heightMax = list.get(1).getHeigh();
        double temp;
        for (int i = 0; i < list.size(); i++) {
            temp = list.get(i).getHeigh();
            //如果当前分大于最高分，则取当前学生为最高分学生
            student = (temp > heightMax) ? list.get(i) : student;//三元表达式
            //如果当前分大于最高分，则取当前分数为最高分
            heightMax = (temp > heightMax) ? temp : heightMax;//三元表达式
        }
        System.out.println(student.toString());
    }
}

7.4 练习4 ArrayList

练习4  ArrayList   【a.实体学生类】

package com.groupies.base.day11;

/**
 * @author GroupiesM
 * @date 2021/04/20
 * @introduction 实体学生类 课后基础练习4 ArrayList
 *
 * 一, 分析以下需求，并用代码实现
 * 	1.按照以下描述完成类的定义。
 * 		学生类
 * 			属性：
 * 				姓名name
 * 				年龄age
 * 				成绩score
 * 			行为：
 * 			吃饭eat()
 * 			study(String content)(content:表示学习的内容)
 * 	2.定义学生工具StudentsTool,有四个方法,描述如下
 * 		public void listStudents(Student[] arr):遍历打印学生信息
 * 		public int getMaxScore(Student[] arr):获取学生成绩的最高分
 * 		public Student getMaxStudent(Student[] arr):获取成绩最高的学员
 * 		public int getAverageScore(Student[] arr):获取学生成绩的平均值
 * 		public int getCount(Student[] arr):获取不及格的学员数量
 * 	3.定义测试类TestStudentTool，在main方法中首先创建长度为5的Student数组并初始化数据,
 * 	  再创建StudentsTool类的对象,并调用以上方法
 */
public class HomeWork4POJOStudent {
    private String name;
    private int age;
    private int score;

    public HomeWork4POJOStudent() {
    }

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

    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;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "{name='" + name + "'" + ", age=" + age + ", score=" + score + '}';
    }

    public void eat() {
        System.out.println("学生吃饭");
    }

    public void study(String content) {
        System.out.println("学生正在学习" + content);
    }
}

练习4  ArrayList   【b. 工具类】

package com.groupies.base.day11;

/**
 * @author GroupiesM
 * @date 2021/04/20
 * @introduction 工具类 课后基础练习4 ArrayList
 *
 * 一, 分析以下需求，并用代码实现
 * 	1.按照以下描述完成类的定义。
 * 		学生类
 * 			属性：
 * 				姓名name
 * 				年龄age
 * 				成绩score
 * 			行为：
 * 			吃饭eat()
 * 			study(String content)(content:表示学习的内容)
 * 	2.定义学生工具StudentsTool,有四个方法,描述如下
 * 		public void listStudents(Student[] arr):遍历打印学生信息
 * 		public int getMaxScore(Student[] arr):获取学生成绩的最高分
 * 		public Student getMaxStudent(Student[] arr):获取成绩最高的学员
 * 		public int getAverageScore(Student[] arr):获取学生成绩的平均值
 * 		public int getCount(Student[] arr):获取不及格的学员数量
 * 	3.定义测试类TestStudentTool，在main方法中首先创建长度为5的Student数组并初始化数据,
 * 	  再创建StudentsTool类的对象,并调用以上方法
 */
public class HomeWork4StudentsTool {
    /**
     * @introduction 遍历打印学生信息
     * @param arr 学生实体类数组
     */
    public void listStudents(HomeWork4POJOStudent[] arr) {
        for (HomeWork4POJOStudent s : arr) {
            s.toString();
        }
    }

    /**
     * @introduction 获取学生成绩的最高分
     * @param arr 学生实体类数组
     * @return 最高分的学生对象
     */
    public HomeWork4POJOStudent getMaxStudent(HomeWork4POJOStudent[] arr) {
        int maxScore = arr[1].getScore();
        HomeWork4POJOStudent returnStudent = arr[1];
        for (HomeWork4POJOStudent s : arr) {
            //如果当前分大于最高分，则取当前学生为最高分学生
            returnStudent = s.getScore() > maxScore ? s : returnStudent;//三元表达式
            //如果当前分大于最高分，则取当前分数为最高分
            maxScore = s.getScore() > maxScore ? s.getScore() : maxScore;//三元表达式
        }
        return returnStudent;
    }

    /**
     * @introduction 获取成绩最高的学员
     * @param arr 学生实体类数组
     * @return 最高学生分数
     */
    public int getMaxScore(HomeWork4POJOStudent[] arr) {
        HomeWork4POJOStudent s = getMaxStudent(arr);
        return s.getScore();
    }

    /**
     * @introduction 获取学生成绩的平均值
     * @param arr 学生实体类数组
     * @return 平均学生分数
     */
    public int getAverageScore(HomeWork4POJOStudent[] arr) {
        int count = 0;
        int sum = 0;
        for (HomeWork4POJOStudent s : arr) {
            count++;
            sum += s.getScore();
        }
        return sum / count;
    }

    /**
     * @introduction 获取不及格的学员数量
     * @param arr 学生实体类数组
     * @return 不及格学生数量
     */
    public int getCount(HomeWork4POJOStudent[] arr) {
        int count = 0;
        int temp;
        for (HomeWork4POJOStudent s : arr) {
            temp = s.getScore();
            count = temp < 60 ? ++count : count;
        }
        return count;
    }
}

练习4  ArrayList   【c.测试类】

package com.groupies.base.day11;

/**
 * @author GroupiesM
 * @date 2021/04/20
 * @introduction 测试类 课后基础练习4 ArrayList
 *
 * 一, 分析以下需求，并用代码实现
 * 	1.按照以下描述完成类的定义。
 * 		学生类
 * 			属性：
 * 				姓名name
 * 				年龄age
 * 				成绩score
 * 			行为：
 * 			吃饭eat()
 * 			study(String content)(content:表示学习的内容)
 * 	2.定义学生工具StudentsTool,有四个方法,描述如下
 * 		public void listStudents(Student[] arr):遍历打印学生信息
 * 		public int getMaxScore(Student[] arr):获取学生成绩的最高分
 * 		public Student getMaxStudent(Student[] arr):获取成绩最高的学员
 * 		public int getAverageScore(Student[] arr):获取学生成绩的平均值
 * 		public int getCount(Student[] arr):获取不及格的学员数量
 * 	3.定义测试类TestStudentTool，在main方法中首先创建长度为5的Student数组并初始化数据,
 * 	  再创建StudentsTool类的对象,并调用以上方法
 */
public class HomeWork4ArrayList {
    public static void main(String[] args) {
        HomeWork4POJOStudent[] arr = new HomeWork4POJOStudent[5];
        arr[0] = new HomeWork4POJOStudent("张三1", 31, 59);
        arr[1] = new HomeWork4POJOStudent("张三2", 32, 60);
        arr[2] = new HomeWork4POJOStudent("张三3", 33, 100);
        arr[3] = new HomeWork4POJOStudent("张三4", 34, 99);
        arr[4] = new HomeWork4POJOStudent("张三5", 35, 10);

        HomeWork4StudentsTool st = new HomeWork4StudentsTool();
        //遍历打印学生信息
        st.listStudents(arr);
        System.out.println("============================");
        //获取学生成绩的最高分
        int maxScore = st.getMaxScore(arr);
        System.out.println("最高分:" + maxScore);//最高分:100
        //获取成绩最高的学员
        HomeWork4POJOStudent maxStudent = st.getMaxStudent(arr);
        System.out.println("成绩最高的学生:" + maxStudent.getName());//成绩最高的学生:张三3
        //获取学生成绩的平均值
        int averageScore = st.getAverageScore(arr);
        System.out.println("平均分:" + averageScore);//平均分:65
        //获取不及格的学员数量
        int count = st.getCount(arr);
        System.out.println("不及格的数量是:" + count);//不及格的数量是:2
    }
}

7.5 练习5 ArrayList

练习5  ArrayList

package com.groupies.base.day11;

import java.util.ArrayList;

/**
 * @author GroupiesM
 * @date 2021/04/20
 * @introduction 课后基础练习5 Arraylist
 *
 * 需求：
 *   二, 分析以下需求，并用代码实现
 *   	1.定义ArrayList集合，存入多个字符串
 *   	   如:"ab1" "123ad"  "bca" "dadfadf"  "dddaaa"  "你好啊"  "我来啦"  "别跑啊"
 *   	2.遍历集合,删除长度大于5的字符串,打印删除后的集合对象
 *   	3.基于上一步,删除集合中元素包含0-9数字的字符串(只要字符串中包含0-9中的任意一个数字就需要删除此整个字符串)
 */
public class HomeWork5ArrayList {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("ab1");
        list.add("123ad");
        list.add("bca");
        list.add("dadfadf");
        list.add("dddaaa");
        list.add("你好啊");
        list.add("我来啦");
        list.add("别跑啊");
        //2.遍历集合,删除长度大于5的字符串
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).length() > 5) {
                list.remove(i);
            }
        }

        //2.打印删除后的集合对象
        System.out.println("2.打印删除后的集合对象");
        for (String s : list) {
            System.out.println(s);
        }

        //3.基于上一步,删除集合中元素包含0-9数字的字符串(只要字符串中包含0-9中的任意一个数字就需要删除此整个字符串)
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            for (int j = 0; j < s.length(); j++) {
                char c = s.charAt(j);
                if (c >= '0' && c <= '9'){
                    list.remove(i);
                    i--;
                    break;
                }
            }
        }
        
        System.out.println("3.打印删除后的集合对象");
        for (String s : list) {
            System.out.println(s);
        }
    }
}

21/04/21

M

GroupiesM
关注
专栏目录
尚硅谷_JavaSE_第12章_集合与泛型_扩展练习_附带参考答案.md
02-22
尚硅谷_JavaSE_第12章_集合与泛型_扩展练习_附带参考答案.md
02_JavaSE面试题：单例设计模式.avi
最新发布
09-09
02_JavaSE面试题：单例设计模式
JavaSE入门0基础笔记 集合（1）
JhonnyLee的博客
08-14 270
JavaSE入门0基础笔记 集合（1）1.Collection集合1.1集合体结构【记忆】1.2Collection集合概述和基本使用【应用】1.3Collection集合的常用方法【应用】1.4Collection集合的遍历【应用】1.5集合使用步骤图解【理解】1.6集合的案例-Collection集合存储对象并遍历【应用】2.List集合2.1List集合概述和特点【记忆】2.2 List集合的特有方法【应用】2.3集合的案例-List集合存储学生对象并遍历【应用】2.4并发修改异常【应用】2.5列表
JAVASE入门(day07_集合01)
JAVA小章的博客
08-24 124
1.Collection集合 1.1数组和集合的区别【理解】 相同点 都是容器,可以存储多个数据 不同点 数组的长度是不可变的,集合的长度是可变的 数组可以存基本数据类型和引用数据类型 集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类 1.2集合类体系结构【理解】 1.3Collection 集合概述和使用【应用】 Collection集合概述 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素 JDK 不提供此接口的任何直接实现.
3.1_1 =========JAVASE入门==========
GroupiesM的博客
09-23 198
JavaSE入门 P1 - P20目录
JavaSE进阶06：Collection集合、迭代器、List、ArrayList、LinkedList
XXXZhy丶Blog
04-11 1281
1.时间日期类 1.1 Date类（应用） 计算机中时间原点 1970年1月1日 00:00:00 时间换算单位 1秒 = 1000毫秒 Date类概述 Date 代表了一个特定的时间，精确到毫秒 Date类构造方法 方法名 说明 public Date() 分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒 public Date(long date) 分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数 示例代码 publ
JavaSE_集合.zip
07-21
JavaSE集合的全部内容，大大小小重点，全部包含，内容之多之全，首先声明，这是一个完全完整的集合全部重点内容，如果您难呢过坚持下来一个一个知识点去攻破，那恭喜你，集合的知识你差不多已经足够掌握了，妈妈再也...
javaSE-11-Collection集合1
weixin_36580930的博客
04-06 120
Collection集合 java.util.Collection是所有集合的顶级接口，集合与数组一样，可以保存一组元素，并且提供了操作元素的相关方法 Collection下面有多种实现类 两个常见的子接口 java.util.List；线性表，是可重复集合，并且有序的 java.util.Set；不可重复的集合，大部分实现类是无序的 这里可重复指：集合中的元素是否可重复 判定重复元素的标准是依靠元素自身equals比较的结果，为true就认为是重复元素 注：集合不
JavaSE专题-List集合.doc
06-03
【JavaSE专题-List集合】 Java集合框架是Java API的核心组件之一，主要用于存储和操作对象。List集合是其中的一个重要接口，它代表了一个有序的、允许元素重复的序列。List接口扩展了Collection接口，提供了更丰富...
JavaSE入门——集合Collection
明光
08-04 164
文章目录Collection Collection 在集合的继承体系中，collection可以说是最大的，它下面有list和set（子孙类），因此，collection中定义的方法规定是list和set都有的。 集合中只能存储单个元素，且只能保存引用数据类型的数据，保存 ...
JavaSE专题-Set集合.doc
06-03
JavaSE专题-Set集合 Set集合是JavaSE中的一种重要数据结构，主要包括HashSet、TreeSet和LinkedHashSet三个子类。下面我们将对Set集合的原理、特点、使用场景等进行详细的探索和分析。 HashSet HashSet是Set集合中...
3.5.1_2 Maven - pom.xml 添加maven-assembly-plugin(官方标准打包插件)
GroupiesM的博客
06-05 8508
Maven打包操作步骤
3.1_21 JavaSE入门 P20 【正则】Pattern模式类、Matcher匹配器、元字符、分组捕获、反向引用
GroupiesM的博客
09-22 5950
JavaSE入门 P20 【正则】Pattern模式类、Matcher匹配器、元字符、分组捕获、反向引用 1.入门 2.底层实现 3.基本语法 4.元字符使用案例 5.Pattern模式类 6.Matcher匹配器 7.PatternSyntaxException异常类 8.应用案例 9.常用正则
3.1_2 JavaSE入门 P1 【Java基础】Java语言概述、JDK编译
GroupiesM的博客
01-26 4376
JavaSE入门 P1 【Java基础】Java语言概述
3.1_9 JavaSE入门 P8 【面向对象】关键字(final,static)，抽象类，接口，包
GroupiesM的博客
03-29 4156
JavaSE入门 P8 【面向对象】关键字(final,static)，抽象类，接口.... 1.final和static关键字 2.抽象类 3.接口 4.包 5.课后练习
3.1_11 JavaSE入门 P10 【常用API】数组排序和Arrays工具类、包装类、Date
GroupiesM的博客
04-19 4114
JavaSE入门 P10 【常用API】数组排序和Arrays工具类、包装类、Date 1.数组排序和Arrays工具类 2.包装类 3.Date、SimpleDateFormat类 4.课后练习 5.Date格式校验Utils
3.1_15 JavaSE入门 P14 【多线程】同步、匿名内部类、死锁、生命周期
GroupiesM的博客
05-18 4095
JavaSE入门 P14 【进阶】多线程、同步、匿名内部类、死锁、生命周期 1.概述 2.多线程实现（模拟卖票） 3.多线程安全问题&解决方案 4.匿名内部类 5.同步 6.死锁，多线程生命周期 7.面试题
3.1_14 JavaSE入门 P13 【其他】异常，File，IO，字节(符)流，字节(符)缓冲流，转换流
GroupiesM的博客
05-10 3974
JavaSE入门 P13 【其他】异常，File，IO，字节(符)流，字节(符)缓冲流，转换流 1.异常 2.File类 3.IO流 4.NIO（new IO） 5.IO流练习
3.1_3 JavaSE入门 P2 【Java基础】运算符、键盘录入、流程语句【顺序结构、选择结构】
GroupiesM的博客
01-27 3881
JavaSE入门 P2 【Java基础】运算符、键盘录入、流程语句【顺序结构、选择结构】
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值