DAY09_Api(3)&Collection单列集合-List&数据结构-队列和栈、数组和链表

最新推荐文章于 2024-07-21 22:27:18 发布

_-Mr-sun

最新推荐文章于 2024-07-21 22:27:18 发布

阅读量34

点赞数

分类专栏： 2.JavaSE进阶文章标签： java

本文链接：https://blog.csdn.net/m0_57075290/article/details/129276136

版权

2.JavaSE进阶专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1 时间日期类

1.1 Date类

计算机中时间原点
- 1970年1月1日 00:00:00
时间换算单位
- 1秒 = 1000毫秒
Date类概述
- Date代表了一个特定的时间，精确到毫秒
Date类构造方法

方法名	说明
public Date()	分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
public Date(long date)	分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

import java.util.Date;

public class DateDemo1 {
    public static void main(String[] args) {
        //public Date()		创建一个Date对象，表示默认时间
        //public Date(long date)	创建一个Date对象，表示指定时间

        //那么这个时间就表示电脑中的当前时间。
        Date date1 = new Date();
        System.out.println(date1);

        //从计算机的时间原点开始，过了指定毫秒的那个时间。
        Date date2 = new Date(0L);
        System.out.println(date2);//Thu Jan 01 08:00:00 CST 1970
        //从时间原点开始，过了0毫秒。
        //因为我们是在中国，我们是在东八区需要+8小时。

        //1970年1月1日 上午的9点
        Date date3 = new Date(3600L * 1000);
        System.out.println(date3);
    }
}

1.2 Date类常用方法

方法名	说明
public long getTime()	获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
public void setTime(long time)	设置时间，给的是毫秒值

import java.util.Date;

public class DateDemo2 {
    public static void main(String[] args) {
        // public long getTime()			获取时间对象的毫秒值
        //public void setTime(long time)		设置时间，传递毫秒值

        method1();
        method2();
    }

    private static void method2() {
        Date date2 = new Date();
        date2.setTime(0L);
        System.out.println(date2);
    }

    private static void method1() {
        //把当前时间封装成一个date对象
        Date date1 = new Date();
        //获取这个date对象的毫秒值 --- 获取当前时间的毫秒值
        long time = date1.getTime();
        System.out.println(time);

        long time2 = System.currentTimeMillis();
        System.out.println(time2);
    }
}

1.3 SimpleDateFormat类

SimpleDateFormat类概述
- SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。
SimpleDateFormat类构造方法

方法名	说明
public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat使用给定的模式和默认的日期格式

SimpleDateFormat类的常用方法
- 格式化(从Date到String)
  - public final String format(Date date)：将日期格式化成日期/时间字符串
- 解析(从String到Date)
  - public Date parse(String source)：从给定字符串的开始解析文本以生成日期

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

public class DateDemo3 {
    public static void main(String[] args) {
        //当前时间的Date对象
        Date date = new Date();

        //创建了一个日期格式。
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日");
        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd");

        String result1 = sdf1.format(date);
        String result2 = sdf2.format(date);
        String result3 = sdf3.format(date);
        System.out.println(result1);
        System.out.println(result2);
        System.out.println(result3);
    }
}

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

public class DateDemo4 {
    public static void main(String[] args) throws ParseException {
        String s = "2048-01-01";
        //SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = sdf.parse(s);
        System.out.println(date);
    }
}

1.4 案例1 时间日期类练习

需求
秒杀开始时间是2020年11月11日 00:00:00,结束时间是2020年11月11日 00:10:00,用户小贾下单时间是2020年11月11日 00:03:47,用户小皮下单时间是2020年11月11日 00:10:11,判断用户有没有成功参与秒杀活动
实现步骤

判断下单时间是否在开始到结束的范围内
把字符串形式的时间变成毫秒值

import java.text.ParseException;
import java.text.SimpleDateFormat;

public class DateDemo5 {
    public static void main(String[] args) throws ParseException {
        //开始时间：2020年11月11日 0:0:0
        //结束时间：2020年11月11日 0:10:0

        //小贾2020年11月11日 0:03:47
        //小皮2020年11月11日 0:10:11

        //1.判断两位同学的下单时间是否在范围之内就可以了。
        //2.要把每一个时间都换算成毫秒值。

        String start = "2020年11月11日 0:0:0";
        String end = "2020年11月11日 0:10:0";

        String jia = "2020年11月11日 0:03:47";
        String pi = "2020年11月11日 0:10:11";

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        long startTime = sdf.parse(start).getTime();
        long endTime = sdf.parse(end).getTime();

        System.out.println(startTime);
        System.out.println(endTime);

        long jiaTime = sdf.parse(jia).getTime();
        long piTime = sdf.parse(pi).getTime();

        if (jiaTime >= startTime && jiaTime <= endTime) {
            System.out.println("小贾同学参加上了秒杀活动");
        } else {
            System.out.println("小贾同学没有参加上秒杀活动");
        }

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

        if (piTime >= startTime && piTime <= endTime) {
            System.out.println("小皮同学参加上了秒杀活动");
        } else {
            System.out.println("小皮同学没有参加上秒杀活动");
        }
    }
}

1.5 扩展——JDK8新增日期类

从Java 8开始，java.time包提供了新的日期和时间API，主要涉及的类型有如下：

新增的API严格区分了时刻、本地日期、本地时间，并且，对日期和时间进行运算更加方便。
其次，新API的类型几乎全部是不变类型（和String的使用类似），可以放心使用不必担心被修改。

1.5.1 日期、时间、日期时间对象介绍

他们分别表示日期，时间，日期时间对象，他们的类的实例是不可变的对象。
他们三者构建对象和API都是通用的

1.5.2 构建对象的方式如下

方法: Xxxx now()静态方法，根据当前时间创建对象
方法: Xxxx of(…)静态方法，指定日期/时间创建对象

案例1 根据当前时间创建对象

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class Demo1 {
    public static void main(String[] args) {
        //只有日期
        LocalDate date = LocalDate.now();
        //只有时间
        LocalTime time = LocalTime.now();
        //日期和时间
        LocalDateTime dateTime = LocalDateTime.now();
        System.out.println(date);//2023-03-12
        System.out.println(time);//21:18:46.198
        System.out.println(dateTime);//2023-03-12T21:18:46.198
    }
}

案例2 根据指定日期创建对象

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class Demo2 {
    public static void main(String[] args) {
        //指定时间创建对象
        //指定年月日
        LocalDate date = LocalDate.of(2019, 6, 9);
        //指定时分秒纳秒
        LocalTime time = LocalTime.of(12, 34, 53, 5);
        //指定年月日时分秒
        LocalDateTime dateTime = LocalDateTime.of(2019, 6, 29, 12, 23, 51, 1);
        System.out.println(date);//2019-06-09
        System.out.println(time);//12:34:53.000000005
        System.out.println(dateTime);//2019-06-29T12:23:51.000000001
    }
}

案例3 LocalDate单独获取年、月、日、星期

import java.time.LocalDate;

public class Demo3 {
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        // 获取年
        System.out.println(date.getYear()); // 2023
        // 获取月
        System.out.println(date.getMonth()); // MARCH
        // 获取1月当中第几天
        System.out.println(date.getDayOfMonth()); // 12
        // 获取1年当中第几天
        System.out.println(date.getDayOfYear()); // 71
        // 获取1星期中第几天
        System.out.println(date.getDayOfWeek()); // SUNDAY
    }
}

案例4 LocalTime获取小时、分钟、秒钟、纳秒

import java.time.LocalTime;

public class Demo4 {
    public static void main(String[] args) {
        LocalTime time = LocalTime.now();
        // 获取小时
        System.out.println(time.getHour());//21
        // 获取分钟
        System.out.println(time.getMinute());//26
        // 获取秒钟
        System.out.println(time.getSecond());//11
        // 获取纳秒
        System.out.println(time.getNano());//462000000
    }
}

案例5 LocalDateTime可以单独获取年月日, 还可以获取时分秒

LocalDateTime相当于包含LocalDate和LocalTime, 因此LocalDateTime对象可以转换为LocalDate和LocalTime对象

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class Demo5 {
    public static void main(String[] args) {
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt); // 2023-03-12T21:27:44.046

        // 转为日期对象
        LocalDate ld = ldt.toLocalDate();
        // 转为时间对象
        LocalTime lt = ldt.toLocalTime();
        System.out.println(ld); // 2023-03-12
        System.out.println(lt); // 21:27:44.046
    }
}

1.5.3 修改日期时间相关方法

LocalDateTime 综合了 LocalDate 和 LocalTime 里面的方法。这些方法返回的是一个新的实例引用，因为LocalDateTime 、LocalDate 、LocalTime 都是不可变的。

方法名	说明
plusDays, plusWeeks, plusMonths, plusYears	向当前 LocalDate 对象添加几天、几周、几个月、几年
minusDays, minusWeeks, minusMonths, minusYears	从当前 LocalDate 对象减去几天、几周、几个月、几年
withDayOfMonth, withDayOfYear, withMonth, withYear	将月份天数、年份天数、月份、年份修改为指定的值并返回新的LocalDate 对象
isBefore, isAfter	比较两个 LocalDate

案例1 向当前LocalDate对象添加几天、几周、几个月、几年

import java.time.LocalDate;

public class Demo6 {
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        // 当前日期
        System.out.println(date); // 2023-03-12
        // 当前日期添加两天
        System.out.println(date.plusDays(2)); // 2023-03-14
        // 当前日期添加2月
        System.out.println(date.plusMonths(2)); // 2023-05-12
        // 当前时间添加10年
        System.out.println(date.plusYears(10)); // 2033-03-12
    }
}

案例2 向当前LocalTime对象添加几时, 几分, 几秒, 几纳秒

import java.time.LocalTime;

public class Demo6 {
    public static void main(String[] args) {
        LocalTime time = LocalTime.now();
        // 当前时间
        System.out.println(time);//  21:32:09.056
        // 当前时间加2小时
        System.out.println(time.plusHours(2)); // 23:32:09.056
        // 当前时间加10分钟
        System.out.println(time.plusMinutes(10)); // 21:42:09.056
        // 当前时间加30秒
        System.out.println(time.plusSeconds(30)); // 21:32:39.056
        // 当前时间加100纳秒
        System.out.println(time.plusNanos(100)); // 21:32:09.056000100
    }
}

案例3 从当前 LocalDate 对象减去几天、几周、几个月、几年

import java.time.LocalDate;

public class Demo7 {
    public static void main(String[] args) {
        LocalDate date = LocalDate.now();
        // 当前日期
        System.out.println(date); // 2023-03-12
        // 当前日期减少两天
        System.out.println(date.minusDays(2)); // 2023-03-10
        // 当前日期减少2月
        System.out.println(date.minusMonths(2)); // 2023-01-12
        // 当前时间减少10年
        System.out.println(date.minusYears(10)); // 2013-03-12
    }
}

案例4 从当前 LocalTime 对象减去几小时、几分钟、几秒钟、几纳秒

import java.time.LocalTime;

public class Demo7 {
    public static void main(String[] args) {
        LocalTime time = LocalTime.now();
        // 当前时间
        System.out.println(time);// 21:34:27.446
        // 当前时间减去2小时
        System.out.println(time.minusHours(2)); // 19:34:27.446
        // 当前时间减去10分钟
        System.out.println(time.minusMinutes(10)); // 21:24:27.446
        // 当前时间减去30秒
        System.out.println(time.minusSeconds(30)); // 21:33:57.446
        // 当前时间减去100纳秒
        System.out.println(time.minusNanos(100)); // 21:34:27.445999900
    }
}

1.5.4 isBefore, isAfter比较两个时间的方法

import java.time.LocalDate;

public class Demo8 {
    public static void main(String[] args) {
        // 定义一个时间
        LocalDate oldDate = LocalDate.of(2019, 6, 29);
        // 获取当前时间
        LocalDate nowDate = LocalDate.now();
        // 比较时间
        System.out.println(nowDate.isBefore(oldDate)); // false
        System.out.println(nowDate.isAfter(oldDate)); // true
    }
}

1.5.5 Instant时间戳

Instant类由一个静态的工厂方法now()可以返回当前时间戳。

import java.time.Instant;
import java.time.ZoneId;

public class Demo9 {
    public static void main(String[] args) {
        // 获取国际时间戳对象
        Instant instant = Instant.now();
        System.out.println(instant); // 2023-03-12T13:38:40.801Z
        // 获取中国当前的时间对象
        System.out.println(instant.atZone(ZoneId.systemDefault())); // 2023-03-12T21:38:40.801+08:00[Asia/Shanghai]
    }
}

时间戳是包含日期和时间的，与java.util.Date很类似，事实上Instant就是类似JDK8 以前的Date。
Instant和Date这两个类可以进行转换。

import java.time.Instant;
import java.util.Date;

public class Demo10 {
    public static void main(String[] args) {
        // 获取国际时间戳对象, 北京时间+8小时＝国际时间
        Instant instant = Instant.now();
        System.out.println(instant); // 2023-03-12T13:50:55.296Z

        // 将Instant转为Date对象
        Date date = Date.from(instant);
        System.out.println(date); // Sun Mar 12 21:50:55 CST 2023
        // Date也可以转回Instant
        Instant ins = date.toInstant();
        System.out.println(ins); // 2023-03-12T13:50:55.296Z
    }
}

1.5.6 DateTimeFormatter

在JDK8中，引入了一个全新的日期与时间格式器DateTimeFormatter。正反都能调用format方法来格式化时间。

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class Demo11 {
    public static void main(String[] args) {
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt); // 2023-03-12T21:54:50.195

        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // 正向格式化
        System.out.println(dtf.format(ldt)); // 2023-03-12 21:54:50
        // 反向格式化
        System.out.println(ldt.format(dtf)); // 2023-03-12 21:54:50
    }
}

解析字符串时间为日期对象, 解析完成后就可以调用日期的方法

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class Demo12 {
    public static void main(String[] args) {
        // 创建格式化器
        DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // 调用parse方法, 传入解析的时间和格式化器
        LocalDateTime ldt1 = LocalDateTime.parse("2011-11-11 11:11:11", dtf1);
        System.out.println(ldt1); // 2011-11-11T11:11:11
    }
}

2 Collection集合

2.1 数组和集合的区别

相同点
- 都是容器,可以存储多个数据
不同点
- 数组的长度是不可变的,集合的长度是可变的
- 数组可以存基本数据类型和引用数据类型
  - 集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

import java.util.ArrayList;
import java.util.Arrays;

public class MyCollectonDemo1 {
    public static void main(String[] args) {
        //数组可以存储基本数据类型也可以存储引用数据类型
        int[] arr1 = {1, 2, 3};
        String[] arr2 = {"a", "b", "c"};
        System.out.println(Arrays.toString(arr1));//[1, 2, 3]
        System.out.println(Arrays.toString(arr2));//[a, b, c]

        ArrayList<String> list1 = new ArrayList<>();
        list1.add("a");
        list1.add("b");
        list1.add("c");
        System.out.println(list1);//[a, b, c]

        //如果集合要存储基本数据类型,那么实际存储的是他们的包装类
        //ArrayList<int> list2 = new ArrayList<int>();
        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(1);
        list2.add(2);
        list2.add(3);
        System.out.println(list2);//[1, 2, 3]
    }
}

2.2 集合类体系结构

在这里插入图片描述

2.3 Collection 集合概述和使用

Collection集合概述
- 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素
- JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现
创建Collection集合的对象
- 多态的方式
- 具体的实现类ArrayList

Collection集合常用方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
boolean removeIf(Object o)	根据条件进行移除
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

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

public class MyCollectonDemo2 {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<>();
        //boolean add(E e)		添加元素
        collection.add("aaa");
        collection.add("bbb");
        collection.add("ccc");
        collection.add("dddd");
        System.out.println("----------boolean add(E e) 添加元素");
        System.out.println(collection);//[aaa, bbb, ccc, dddd]

        method1(collection);
        method2(collection);
        method3(collection);
        method4(collection);
        method5(collection);
        method6(collection);
    }

    private static void method1(Collection<String> collection) {
        //boolean remove(Object o)	    从集合中移除指定的元素
        //如果删除成功了,则返回true
        //如果删除失败了,则返回false
        boolean result1 = collection.remove("aaa");
        boolean result2 = collection.remove("bbb");
        System.out.println("----------boolean remove(Object o) 从集合中移除指定的元素");
        System.out.println(result1);//true
        System.out.println(result2);//true
        System.out.println(collection);//[ccc, dddd]
    }

    private static void method2(Collection<String> collection) {
        //boolean removeif(Object o)	根据条件进行删除
        //removeif底层会遍历集合,得到集合中的每一个元素
        //s依次表示集合中的每一个元素
        //就会把这每一个元素都到lambda表达式中去判断一下
        //如果返回的是true,则删除
        //如果返回的是false,则保留不删除.
        collection.removeIf(
                (String s) -> {
                    return s.length() == 3;
                }

        );
        System.out.println("----------boolean removeif(Object o) 根据条件进行删除");
        System.out.println(collection);//[dddd]
    }

    private static void method3(Collection<String> collection) {
        //void clear()			清空集合
        //就是将集合中所有的元素全部删除.
        collection.clear();
        System.out.println("----------void clear() 清空集合");
        System.out.println(collection);//[]
    }

    private static void method4(Collection<String> collection) {
        //boolean contains(Object o)	判断集合中是否存在指定的元素
        boolean result = collection.contains("a");
        System.out.println("----------boolean contains(Object o) 判断集合中是否存在指定的元素");
        System.out.println(result);
    }

    private static void method5(Collection<String> collection) {
        //boolean isEmpty()		判断集合是否为空
        collection.clear();
        boolean result = collection.isEmpty();
        System.out.println("----------boolean isEmpty() 判断集合是否为空");
        System.out.println(result);
    }

    private static void method6(Collection<String> collection) {
        //int size()		集合的长度，也就是集合中元素的个数
        int size = collection.size();
        System.out.println("----------int size() 集合的长度，也就是集合中元素的个数");
        System.out.println(size);
    }
}

2.4 Collection集合的遍历

迭代器介绍
- 迭代器,集合的专用遍历方式
- Iterator< E > iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到
- 该迭代器对象默认指向当前集合的0索引
Iterator中的常用方法
- boolean hasNext(): 判断当前位置是否有元素可以被取出
- E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

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

public class MyCollectonDemo3 {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        System.out.println(list);

        //1,获得迭代器的对象
        //迭代器对象一旦被创建出来,默认指向集合的0索引处
        Iterator<String> it = list.iterator();

        //利用迭代器里面的方法进行遍历
        //当前位置是否有元素可以被取出
        System.out.println(it.hasNext());//true

        //取出当前位置的元素  + 将迭代器往后移动一个索引的位置
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());//java.util.NoSuchElementException 没有这个元素异常
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

迭代器中删除的方法
- void remove(): 删除迭代器对象当前指向的元素

import java.util.ArrayList;

public class MyCollectonDemo4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            if ("b".equals(s)) {
                list.remove(i);
                i--;
            }
        }
        System.out.println(list);
    }
}

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

public class MyCollectonDemo5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            if ("b".equals(s)) {
                //指向谁,那么此时就删除谁.
                it.remove();
            }
        }
        System.out.println(list);
    }
}

2.5 增强for循环

增强for ：简化数组和Collection集合的遍历
- 它是JDK5之后出现的，其内部原理是一个Iterator迭代器
- 实现Iterable接口的类才可以使用迭代器和增强for
格式

for(元素数据类型变量名 : 数组或者Collection集合) {
//在此处使用变量即可，该变量就是元素
}

范例

ArrayList list = new ArrayList<>();
list.add(“aaa”);
…
for(String s : list) {
System.out.println(i);
}

import java.util.ArrayList;

public class MyCollectonDemo6 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");
        //1,数据类型一定是集合或者数组中元素的类型
        //2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
        //3,list就是要遍历的集合或者数组.
        for (String str : list) {
            System.out.println(str);
        }
    }
}

注意点:

import java.util.ArrayList;

public class MyCollectonDemo7 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");

        for(String str : list){
            str = "q";
            System.out.println(str);//输出四个q
        }

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

        for (String s : list) {
            System.out.println(s);//逐个输出abcd
        }

        System.out.println(list);//[a, b, c, d]
    }
}

2.6 三种循环的使用场景

如果需要操作索引，使用普通for循环
如果在遍历的过程中需要删除元素，请使用迭代器
如果仅仅想遍历，那么使用增强for

2.7 案例1 Collection集合存储学生对象并遍历

案例需求
- 创建一个Collection集合存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
思路
- 定义学生类
- 创建Collection集合对象
- 创建学生对象
- 把学生添加到集合
- 遍历集合(迭代器方式)

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

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

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

public class MyCollectonDemo8 {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();

        Student s1 = new Student("小皮同学", 23);
        Student s2 = new Student("小路同学", 31);
        Student s3 = new Student("小贾同学", 33);
        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);
        }
        System.out.println("-------------------------");
        //增强for
        for (Student student : list) {
            System.out.println(student);
        }
    }
}

3 List集合

3.1 List集合的概述和特点

List集合的概述
- 有序集合,这里的有序指的是存取顺序
- 用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素
- 与Set集合不同,列表通常允许重复的元素
List集合的特点
- 有序：存取和取出的元素一致
- 有索引：可以通过索引操作元素
- 可重复：存储的元素可以重复

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

public class MyListDemo1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");

        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }

        System.out.println("---------------------");
        
        for (String s : list) {
            System.out.println(s);
        }
    }
}

3.2 List集合的特有方法

方法名	描述
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

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

public class MyListDemo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        method1(list);
        method2(list);
        method3(list);
        method4(list);
    }

    private static void method1(List<String> list) {
        //void add(int index,E element)	在此集合中的指定位置插入指定的元素
        //原来位置上的元素往后挪一个索引.
        list.add(0, "qqq");
        System.out.println("---------------void add(int index,E element) 在此集合中的指定位置插入指定的元素");
        System.out.println(list);//[qqq, aaa, bbb, ccc]
    }

    private static void method2(List<String> list) {
        //E remove(int index)		删除指定索引处的元素，返回被删除的元素
        //在List集合中有两个删除的方法
        //第一个 删除指定的元素,返回值表示当前元素是否删除成功
        //第二个 删除指定索引的元素,返回值表示实际删除的元素
        String s = list.remove(0);
        System.out.println("---------------E remove(int index) 删除指定索引处的元素，返回被删除的元素");
        System.out.println(s);//qqq
        System.out.println(list);//[aaa, bbb, ccc]
    }

    private static void method3(List<String> list) {
        //E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
        //被替换的那个元素,在集合中就不存在了.
        String result = list.set(0, "qqq");
        System.out.println("---------------E set(int index,E element) 修改指定索引处的元素，返回被修改的元素");
        System.out.println(result);//aaa
        System.out.println(list);//[qqq, bbb, ccc]
    }

    private static void method4(List<String> list) {
        //E get(int index)		返回指定索引处的元素
        String s = list.get(0);
        System.out.println("---------------E get(int index) 返回指定索引处的元素");
        System.out.println(s);//qqq
    }
}

4 数据结构

数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合。
通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。

4.1 数据结构之栈和队列

栈结构
队列结构

4.2 数据结构之数组和链表

数组结构
链表结构

5 List集合的实现类

5.1 List集合子类的特点

ArrayList集合
- 底层是数组结构实现，查询快、增删慢
LinkedList集合
- 底层是链表结构实现，查询慢、增删快

import java.util.Iterator;
import java.util.LinkedList;

public class MyLinkedListDemo3 {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

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

        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }

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

        for (String s : list) {
            System.out.println(s);
        }
    }
}

5.2 LinkedList集合的特有功能

方法名	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

在这里插入图片描述

import java.util.LinkedList;

public class MyLinkedListDemo4 {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        method1(list);
        method2(list);
        method3(list);
        method4(list);
    }

    private static void method1(LinkedList<String> list) {
        //public void addFirst(E e)	在该列表开头插入指定的元素
        list.addFirst("qqq");
        System.out.println("--------------public void addFirst(E e) 在该列表开头插入指定的元素");
        System.out.println(list);
    }

    private static void method2(LinkedList<String> list) {
        //public void addLast(E e)	将指定的元素追加到此列表的末尾
        list.addLast("www");
        System.out.println("--------------public void addLast(E e) 将指定的元素追加到此列表的末尾");
        System.out.println(list);
    }

    private static void method3(LinkedList<String> list) {
        //public E getFirst()		返回此列表中的第一个元素
        //public E getLast()		返回此列表中的最后一个元素
        String first = list.getFirst();
        String last = list.getLast();
        System.out.println("--------------public E getFirst() 返回此列表中的第一个元素");
        System.out.println(first);
        System.out.println("--------------public E getLast() 返回此列表中的最后一个元素");
        System.out.println(last);
    }

    private static void method4(LinkedList<String> list) {
        //public E removeFirst()		从此列表中删除并返回第一个元素
        //public E removeLast()		从此列表中删除并返回最后一个元素
        String first = list.removeFirst();
        System.out.println("--------------public E removeFirst() 从此列表中删除并返回第一个元素");
        System.out.println(first);
        String last = list.removeLast();
        System.out.println("--------------public E removeLast() 从此列表中删除并返回最后一个元素");
        System.out.println(last);
        System.out.println(list);
    }
}