java基础学习笔记第11天

最新推荐文章于 2024-09-10 10:21:38 发布

Daniel_zbc1024

最新推荐文章于 2024-09-10 10:21:38 发布

阅读量90

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_38067916/article/details/107576837

版权

第11天集合

第1章集合的概述和Collection集合
第2章 List集合
第3章数据结构和ArrayList集合的相关案例

第1章集合的概述和Collection集合

1.1 集合的概述

集合是一个容器,是用来存储和获取数据的.

1.1.1 为什么会出现集合类

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

1.1.2 集合类体系结构图

在这里插入图片描述

1.2 Collection集合

1.2.1 创建Collection集合对象并添加元素

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

1.2.1.1 案例代码一:

package day11;

import java.util.ArrayList;
import java.util.Collection;
/*
* Collection:是单列集合的顶层接口。
 * Collection 表示一组对象，这些对象也称为 collection 的元素。
 * 一些 collection 允许有重复的元素，而另一些则不允许。
 * 一些 collection 是有序的，而另一些则是无序的。
 * JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。
 * 
 * 创建Collection集合的对象，我们采用的是多态的方式，使用的是具体的ArrayList类。
 * 因为这个类是最常用的集合类。
 * ArrayList() 
 * 
 * Collection<E>：
 * 		<E>:是一种特殊的数据类型，泛型。这里我们会使用就可以了。
 * 		如何使用呢?
 * 			在出现E的地方用引用数据类型替换即可。
 * 			举例：Collection<String>,Collection<Student>
 */
public class CollectionDemo {
	public static void main(String[] args) {
		//创建Collection集合对象
		//JDK7的新特性，看懂就可以
		//Collection<String> c = new ArrayList<>(); //多态的方式
		Collection<String> c = new ArrayList<String>(); //多态的方式
		
		//boolean add(E e):添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		
		//输出集合对象
		System.out.println(c);
		//输出了集合中的元素按照指定格式拼接的内容，说明ArrayList重写了toString()方法
	}
}

1.2.2 Collection集合的成员方法

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

1.2.2.1 案例代码二:

package day11;

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

/*
*
*   boolean add(E e):添加元素
*   boolean remove(Object o):从集合中移除元素
*   void clear():清空集合中的元素
*   boolean contains(Object o):判断集合中是否存在指定的元素
*   boolean isEmpty():判断集合是否为空
*   int size():集合的长度，也就是集合中元素的个数
*
* */
public class CollectionTest01 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<String>();

       //boolean add(E e):添加元素
        //System.out.println("add:" + c.add("hello"));
        //System.out.println("add:" + c.add("world"));
        //通过查看源码，我们都知道ArrayList方法返回值永远是true
        c.add("hello");
        c.add("world");
        c.add("java");

        //boolean remove(Object o):从集合中移除元素
        //System.out.println("remove:" + c.remove("world"));
        //System.out.println("remove:" + c.remove("lol"));

        //void clear():清空集合中的元素
        //c.clear();


        // boolean contains(Object o):判断集合中是否存在指定的元素
        //System.out.println("contains:" + c.contains("java"));

        //  boolean isEmpty():判断集合是否为空
        //System.out.println("isEmpty():" + c.isEmpty());

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

        //输出元素
        System.out.println(c);
    }
}

1.2.3 Collection集合的遍历

Collection集合的遍历
Iterator iterator():返回在此 collection 的元素上进行迭代的迭代器。
通过集合对象调用iterator()方法得到迭代器对象。
Iterator:
E next():返回迭代的下一个元素。
boolean hasNext():如果仍有元素可以迭代，则返回 true。

1.2.3.1 案例代码三:

package day11;

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

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


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


        //Iterator<E> iterator()
        Iterator<String> it = c.iterator(); //返回的是迭代器实现类接口的对象
        System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());
        //NoSuchElementException
        //System.out.println(it.next());


    }
}

1.2.4 集合使用步骤图解

在这里插入图片描述

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

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

集合的使用步骤：
A:创建集合对象
B:创建元素对象
C:把元素添加到集合
D:遍历集合

1.2.5.1 案例代码四:

package day11;

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

/*
*
*
* Collection集合存储自定义对象并遍历
* 提示：自定义一个学生类，给出成员变量name和age。
* 遍历集合的时候，在控制台输出学生对象的成员变量值。
*
*
* 集合的使用步骤：
*        1.创建集合对象
*        2.创建元素对象
*        3.把元素添加到集合
*        4.遍历集合
*
*
*
* */
public class CollectionTest03 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<Student> c = new ArrayList<Student>();

        //创建元素对象
        Student s1 = new Student("zbc",23);
        Student s2 = new Student("daniel",23);
        Student s3 = new Student("jack",18);

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

        //遍历集合
        Iterator<Student> it = c.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName() + "---" + s.getAge());
        }

    }
}

第2章 List集合

2.1 List集合的特点

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

2.1.1 案例代码五:

package day11;

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

/*
* List:有序的 collection（也称为序列）。
* 此接口的用户可以对列表中每个元素的插入位置进行精确地控制。
* 用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
* 与 set 不同，列表通常允许重复的元素。
*
* List集合的特点：
*		1.有序(存储和取出元素的顺序一致)
*		2.存储的元素可以重复
*
*
*
* */
public class ListTest {
    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();
            System.out.println(s);
        }

    }
}

2.2 List集合的特有成员方法

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

2.2.1 案例代码六:

package day11;

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

/*
* void add(int index,E element):在指定位置添加元素
* E remove(int index):删除指定位置的元素
* E get(int index):获取指定位置的元素
* E set(int index,E element):修改指定位置的元素
*
*
* */
public class ListTest01 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();

        //使用继承Collectiond添加类
        list.add("hello");
        list.add("world");
        list.add("java");

        //void add(int index,E element):在指定位置添加元素
        //list.add(1,"javase");
        //IndexOutOfBoundsException
        //list.add(9,"javaee");

        //E remove(int index):删除指定位置的元素
        //System.out.println("remove:" + list.remove(1));

        //E get(int index):获取指定位置的元素
        //System.out.println("get:" + list.get(2));

        //E set(int index,E element):修改指定位置的元素
        System.out.println("set:" + list.set(1,"javase"));

        //输出集合对象
        System.out.println(list);
    }
}

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

List集合的遍历：
A:迭代器
B:普通for循环

2.3.1 案例代码七:

package day11;

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

/*
* list集合的遍历
*      1.迭代器
*      2.普通for循环
*
*
*
* */
public class ListTest02 {
    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):获取指定位置的元素
        System.out.println(list.get(0));
        System.out.println(list.get(1));
        System.out.println(list.get(2));
        //IndexOutOfBoundsException
       // System.out.println(list.get(3));
        System.out.println("------------");

        //循环改进
        /*
        for(int x = 0;x<3;x++){
            System.out.println(list.get(x));
        }

         */
        //int size():集合的长度，就是集合元素的个数
        for(int x = 0;x<list.size();x++){
            String s = list.get(x);
            System.out.println(s);
        }
    }
}

2.4 List集合的练习存储自定义对象并遍历

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

2.4.1 案例代码八:

package day11;

public class Student {
    private String name;
    private int age;

    public Student(){}

    public Student(String name,int age){
        this.name = name;
        this.age = age;

    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

2.4.2 案例代码九:

package day11;

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

/*
*
*  List集合存储自定义对象并遍历
*  提示：自定义一个学生类，给出成员变量name和age。
*  遍历集合的时候，在控制台输出学生对象的成员变量值。
*  两种方式遍历
*		迭代器
*		普通for
*
* */
public class ListTest03 {
    public static void main(String[] args) {
        //创建集合对象
        List<Student> list = new ArrayList<Student>();

        //创建元素对象
        Student s1 = new Student("zbc",23);
        Student s2 = new Student("danile",19);
        Student s3 = new Student("jack",23);

        //添加
        list.add(s1);
        list.add(s2);
        list.add(s3);


        //迭代器
        Iterator<Student> it = list.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName() + "---" + s.getAge());
        }

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

        for(int x=0;x<list.size();x++){
            Student s = list.get(x);
            System.out.println(s.getName()+ "---" + s.getAge());
        }
    }

}

2.5 列表迭代器的特有功能

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

2.5.1 案例代码十:

package day11;

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

/*
* ListIterator:
*      ListIterator<E> listIterator():返回此列表元素的列表迭代器
*      public interface ListIterator<E>extends Iterator<E>
*
*   特有功能：
* 		E previous():返回列表中的前一个元素。
* 		boolean hasPrevious():如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
*       注意：ListIterator可以实现逆向遍历，但是要求先正向遍历，才能逆向遍历。
*
*
* */
public class ListIteratorTest {
    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();
        while(lit.hasNext()){
            String s = lit.next();
            System.out.println(s);
        }
        System.out.println("-------------");



    }
}

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

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

2.6.1 案例代码十一:

package day11;

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

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

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

        //我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素
        /*
        Iterator<String> it = list.listIterator();
        while(it.hasNext()){
            String s = it.next();
            if(s.equals("world")){
                list.add("javaee");
            }
        }

         */



        //迭代器遍历的时候，我可以通过迭代器修改集合中的元素
//        ListIterator<String> lit = list.listIterator();
//        while(lit.hasNext()){
//            String s = lit.next();
//            if(s.equals("world")){
//                lit.add("javaee");
//            }
//        }

        //集合遍历的时候，我可以通过集合对象修改集合中的元素
        for(int x=0;x<list.size();x++){
            String s = list.get(x);
            if(s.equals("world")){
                list.add("javase");
            }
        }

        System.out.println(list);
    }
}

2.7 增强for的概述和使用

增强for：是for循环的一种
格式：
for(元素的数据类型变量名 : 数组名或者Collection集合对象名) {
使用变量名即可，这个变量名代表的其实就是数组或者Collection集合中的元素
}
好处：简化了数组和Collection集合的遍历
弊端：目标不能为null。如何保证呢?在遍历前先对目标进行不为null的判断。

2.7.1 案例代码十二:

package day11;

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

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

        //普通for
        for(int x= 0 ;x<arr.length;x++){
            System.out.println(arr[x]);
        }
        System.out.println("--------------");
        for(int x:arr){
            System.out.println(x);
        }
        System.out.println("--------------");
        //定义一个String类型数组
       String [] strArray = {"hello","world","java"};
       //增强for
        for(String s: strArray){
            System.out.println(s);
        }
        System.out.println("---------------");
        //创建集合对象
        List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("java");
        //增强for
        for(String s :list){
            System.out.println(s);
        }

        System.out.println("--------------");
        //list = null; NullPointerException
        if(list != null){
        for(String s :list) {
            System.out.println(s);
        }
        }
    }
}

2.8 增强for的练习List集合存储自定义对象并遍历

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

2.8.1 案例代码十三:

package day11;

public class Student {
    private String name;
    private int age;

    public Student(){}

    public Student(String name,int age){
        this.name = name;
        this.age = age;

    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

2.8.2 案例代码十四:

package day11;

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

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


        //创建元素对象
        Student s1 = new Student("zbc",23);
        Student s2 = new Student("cheng",23);
        Student s3 = new Student("daniel",23)
        //把元素添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //遍历集合
        //增强for
        for(Student s:list){
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

第3章数据结构和ArrayList集合的相关案例

3.1 数据结构

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

3.1.1 常见数据结构之栈和队列

在这里插入图片描述

3.1.2 常见数据结构之数组和链表

在这里插入图片描述

3.2 ArrayList集合的相关案例

3.2.1 List集合子类特点及ArrayList集合存储字符串并遍历

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

ArrayList存储字符串并遍历：
A:迭代器
B:普通for
C:增强for

3.2.1.1 案例代码十五:

package day11;

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

/*
* ArrayList:底层数据结构数数组，查询快，增删慢
*
* LinkedList：底层数据结构是链表，查询慢，增删快
*
*ArrayList存储字符串并遍历
*         1.迭代器
*         2.普通for
*         3.增强for
* */
public class ArrayListTest {
    public static void main(String[] args) {
     //创建集合对象
        ArrayList<String> array = new ArrayList<String>();


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

        //迭代器
        Iterator<String> it = array.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("--------------");

        //普通for
        for(int x =0;x<array.size();x++){
            String s = array.get(x);
            System.out.println(s);
        }
        System.out.println("------------");
        //增强for
        for (String s:array){
            System.out.println(s);
        }
    }
}

3.2.2 ArrayList集合的练习存储自定义对象并遍历

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

LinkedList的使用和ArrayList的相似，所以LinkedList的练习需要大家自己做

3.2.2.1 案例代码十六:

package day11;

public class Student {
    private String name;
    private int age;

    public Student(){}

    public Student(String name,int age){
        this.name = name;
        this.age = age;

    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

3.2.2.2 案例代码十七:

package day11;

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

/*
*  ArrayList集合存储自定义对象并遍历
* 提示：自定义一个学生类，给出成员变量name和age。遍历集合的时候，在控制台输出学生对象的成员变量值。
* 三种方式遍历
*		迭代器
*		普通for
*		增强for
*
*
*/
public class ArrayListTest01 {
    public static void main(String[] args) {
      //创建集合对象
        ArrayList<Student> array = new ArrayList<Student>();

      //创建元素对象
        Student s1 = new Student("zbc",23);
        Student s2 = new Student("daniel",23);
        Student s3 = new Student("cheng",18);


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

        //迭代器
        Iterator<Student> it = array.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName() + "---" +s.getAge());
        }
        System.out.println("-------------");

        //普通for
        for(int x=0;x<array.size();x++){
            Student s = array.get(x);
            System.out.println(s.getName() + "---" + s.getAge());

        }
        System.out.println("--------------");
        //增强for
        for(Student s:array){
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}