相关链接

  • Excel目录

目录

  • P11 【集合】单例 Collection集合
    • 1 集合的概述
      • 1.1 为什么会出现集合类
      • 1.2 集合类体系结构图
    • 2 Collection集合
      • 2.1 Collection集合入门
      • 2.2 Collection集合的成员方法
      • 2.3 Collection集合的遍历
      • 2.4 集合使用步骤图解
      • 2.5 Collection集合的练习存储自定义对象并遍历
    • 3 List集合
      • 3.1 List集合特点
      • 3.2 List集合的特有成员方法
      • 3.3 List集合的普通for循环遍历
      • 3.4 List集合练习
      • 3.5 List.ListIterator();
      • 3.6 List并发修改异常
      • 3.7 增强for循环
      • 3.8 增强for练习
    • 4 数据结构
      • 4.1 常见数据结构【栈】【队列】
      • 4.2 常见数据结构【数组】【链表】
    • 5 ArrayList案例
      • 5.1 ArrayList集合存储字符串
      • 5.2 ArrayList存储实体类
    • 6 Set集合特点和HashSet集合类
      • 6.1 Set集合的特点
      • 6.2 HashSet集合类
        • 6.2.1 HashSet元素唯一性原理
        • 6.2.2 HashSet集合存储实体类
        • 6.2.3 HashSet重写hashCode();equals();
    • 7 课后练习
      • 7.1 练习1 ArrayList
      • 7.2 练习2 ArrayList
      • 7.3 练习3 ArrayList
      • 7.4 练习4 ArrayList
      • 7.5 练习5 ArrayList

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方法的返回值永远都是truepublic boolean add(E e) {ensureCapacityInternal(size + 1);  // Increments modCount!!elementData[size++] = e;return true;}*/System.out.println("add:" + c.add("hello"));//add:trueSystem.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:trueSystem.out.println("remove:" + c.remove("haha"));//remove:false/* //3. void clear():清空集合中的元素public void clear() {modCount++;// clear to let GC do its workfor (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:trueSystem.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());//helloSystem.out.println(it1.next());//worldSystem.out.println(it1.next());//javaSystem.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();/*helloworldjava*/System.out.println(s);}/* 遍历方式二： try catch 获取NoSuchElementException异常 */System.out.println("===========方式二：try catch===============");Iterator<String> it3 = c1.iterator();iter:while (true) {try {/*helloworldjava遍历结束*/System.out.println(it3.next());} catch (NoSuchElementException e) {System.out.println("遍历结束");break iter;}}/* 遍历方式三： 增强for循环 c1.for根据提示自动生成*/System.out.println("===========方式三：增强for循环===============");for (String s : c1) {/*helloworldjava*/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();/*helloworldjava*/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));//helloSystem.out.println(list.get(1));//worldSystem.out.println(list.get(2));//javaSystem.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 学生类的姓名，年龄信息*/@Overridepublic 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.普通forSystem.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.增强forSystem.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();/*javaworldhello*/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.foriSystem.out.println("----a1.普通for : arr.fori-----");for (int i = 0; i < arr.length; i++) {/*12345*/System.out.println(arr[i]);}//a2.增强for : arr.forSystem.out.println("----a2.增强for : arr.for-----");for (int i : arr) {/*12345*/System.out.println(i);}//b.定义一个String类型的数组String[] strArr = {"hello", "world", "java"};//b1.增强for : strArr.forSystem.out.println("----b1.增强for : strArr.for-----");for (String s : strArr) {/*helloworldjava*/System.out.println(s);}//c.创建集合对象List<String> list = new ArrayList<String>();list.add("hello");list.add("world");list.add("java");//c1.增强for : list.forSystem.out.println("----c1.增强for : list.for-----");for (String s : list) {/*helloworldjava*/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;}@Overridepublic 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.forfor (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.iteratorSystem.out.println("a.迭代器 arr.iterator");Iterator<String> it = arr.iterator();while (it.hasNext()) {/*helloworldjava*/System.out.println(it.next());}//b.普通for arr.foriSystem.out.println("b.普通for arr.fori ");for (int i = 0; i < arr.size(); i++) {/*helloworldjava*/System.out.println(arr.get(i));}//c.增强forfor (String s : arr) {/*helloworldjava*/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;}@Overridepublic 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.iteratorSystem.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.普通forSystem.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.增强forSystem.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.forfor (String s : set) {/*worldjavahello*/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;}@Overridepublic 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;}@Overridepublic String toString() {return "{name='" + name + "'" + ", age=" + age + '}';}/*** @introduction 因为我们存储的元素所属的类没有重写hashCode()和equals()方法，所以保证不了元素的唯一性。*              而我想保证，怎么办呢?重写这两个方法就可以了。*              如何重写呢?自动生成就可以了。alt+insert* @param o* @return*/@Overridepublic 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*/@Overridepublic 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.forfor (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;}@Overridepublic 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.67for (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;}@Overridepublic 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.72it002---孙红雷---男---22---1.78it003---章子怡---女---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;}@Overridepublic 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

3.1_12 JavaSE入门 P11 【集合】单例 Collection集合相关推荐

  1. Kotlin入门(28)Application单例化

    Application是Android的又一大组件,在App运行过程中,有且仅有一个Application对象贯穿应用的整个生命周期,所以适合在Application中保存应用运行时的全局变量.而开展 ...

  2. Kotlin入门(18)利用单例对象获取时间

    前面介绍了,使用扩展函数可以很方便地扩充数组Array的处理功能,例如交换两个数组元素.求数组的最大元素等等.那么除了数组之外,日期和时间的相关操作,也是很常见的,比如获取当前日期,获取当前时间.获取 ...

  3. 集合框架一:Collection集合

    目录 概述 Colletion接口常用方法 List集合 常用方法 ArrayList实现类 1.底层实现原理 2.常用方法 3.add()方法的扩容问题 4.sort()方法 linkedList实 ...

  4. Java集合框架之Collection集合

    为什么80%的码农都做不了架构师?>>>    一.引言 Java集合框架和IO框架一样,看似很庞杂的体系框架,但是当你逐一深入每个集合的用法后,就能明显的看出他们之间的区别和联系. ...

  5. Java基础（18）集合概述、Collection集合、List集合

    1.集合 1. 集合的引入 需求:我有3个学生,请把这个3个学生的信息存储到数组中,并遍历数组,获取得到每一个学生信息. public class TestDemo01 {public static ...

  6. Android学习-Kotlin语言入门-变量、函数、语法糖、when、for-in、主构造函数、单例类、函数式API、集合遍历、隐式Intent、Activity生命周期、四种启动模式、标准函数

    探究java语言的运行机制 变量.函数.语法糖 when条件语句 for循环 主构造函数.次构造函数 数据类和单例类 集合的创建与遍历 集合的函数式API 创建菜单 隐式使用Intent Activi ...

  7. Spring如何解决单例循环依赖

    所谓的循环依赖是指,A 依赖 B,B 又依赖 A,它们之间形成了循环依赖.那么spring在自动注入的时候是如何解决这个问题的呢? 答案是:三级缓存,就是三个map,通过提早的暴露对象来解决这个问题. ...

  8. 集合 (一) ----- 集合的基本概念与Collection集合详解

    相关文章: <集合 (一) ----- 集合的基本概念与Collection集合详解> <集合 (二) ----- Map集合详解> 文章目录 集合的基本概念 一.集合的分类 ...

  9. Java中的Collection集合以及Collection集合实现类实例

    Collection集合 集合概述 集合的体系特点 Collection集合常用API Collection集合的遍历方式 方式一:迭代器 方式二:foreach/增强for循环 方式三:lambda ...

最新文章

  1. Web开发（一）·期末不挂之第六章·网页布局(浮动定位)
  2. 再说变体结构 - 回复 彬 的问题
  3. 双系统安装（win10系统+Ubuntu）
  4. Jenkins定时自动构建项目
  5. 机器学习之KNN 算法
  6. Spring中的@Autowired，@Qualifier和@Primary注解
  7. QQ自动登陆脚本生成器 v1.0
  8. handbrake下载太慢_handbrake使用教程
  9. linux常用的英文单词收集
  10. mapreduce 和hive 的区别
  11. C语言与或非应用案例,与或非(生活中与或非例子)
  12. Android模仿新浪微博（前言）
  13. 高德地图标识大全_连地震都查得一清二楚！高德地图新功能体验
  14. Latex标题页上标和脚注的处理方法 如何在latex文件中添加footnote
  15. Z490 AORUS PRO AX+i9-10850K黑苹果EFI引导文件
  16. Java面试题2019
  17. 哪个牌子的护眼台灯比较好？2022秋季最佳护眼灯推荐
  18. 做APP哪家公司好， APP软件开发的公司？
  19. 【JY】混凝土分析工具箱：CDP模型插件与滞回曲线数据
  20. 【架构整洁之道系列】（四）软件架构师与软件架构

热门文章

  1. 中文汉字占二个字节还是三个字节长度
  2. 淘淘商城第111讲——订单系统服务层和表现层工程搭建
  3. 自建Kubernetes的LoadBalancer类型服务方案-MetalLB
  4. 深入浅出React（四）：虚拟DOM Diff算法解析
  5. 服务器+固态硬盘安装Ubuntu16.04，重启黑屏（已解决）
  6. html5绘制 布局图,html5 div布局与table布局详解
  7. 收藏！！公司法人变更全流程及问题汇总
  8. 这32件小事儿，对考研上岸真的有帮助
  9. 提高js调试效率的一个快捷键ctr+g 快速定位代码行
  10. 谷歌有超清实时卫星地图吗?答案是没有