学Java的第十二天 | List集合 | 数据结构简介 | Set集合 | 泛型 | Map集合 | 斗地主案例 | Properties

1 List集合

1 概述
List是一个接口，是Collection的子类接口，所以要通过实现类来访问
List是一个有序集合，可以通过索引，来指定位置
List集合中允许出现重复的数

package List;

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

/**
 * @ClassName Test01$
 * @Description:
 * @Time 2021/3/2$ 22:18$
 * @Author-Email FONG_y@outlook.com
 */
public class Test01 {
   
    public static void main(String[] args) {
   
        List<String> list = new ArrayList<>();
        list.add("iphone");
        list.add("ipad");
        list.add("ipod");
        //List集合特有的添加元素方法
        list.add(1,"iMac");
        System.out.println(list);
    }
}

2 常用方法

方法名	说明
void add(int index , E e)	在指定索引位置添加元素
E remove(int index)	删除指定索引位置的元素 ，返回被删除的元素
E set(int index , E e)	修改指定索引位置的元素，返回被修改前的元素
E get(int index)	获取指定索引位置的元素

package List;

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

/**
 * @ClassName Test02$
 * @Description: List的常用方法
 * @Time 2021/3/2$ 22:24$
 * @Author-Email FONG_y@outlook.com
 */
public class Test02 {
   
    public static void main(String[] args) {
   
        List<String> list = new ArrayList<>();
        list.add("iPhone");
        list.add("iPad");
        list.add("iPod");

        list.add(1,"iMac");
        System.out.println(list);  //  [iPhone, iMac, iPad, iPod]

        System.out.println(list.remove(3));  //  iPod
        System.out.println(list.set(2,"iWatch"));  //  iPad
        System.out.println(list.get(1));  //  iMac

    }
}

3 遍历方式

package List;

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

/**
 * @ClassName Test03$
 * @Description: list集合的五种遍历方式
 * @Time 2021/3/2$ 22:42$
 * @Author-Email FONG_y@outlook.com
 */
public class Test03 {
   
    public static void main(String[] args) {
   
        List<String> list = new ArrayList<>();
        list.add("iPhone");
        list.add("iPad");
        list.add("iPod");

        list.add(1,"iMac");

        //第一种
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
   
            System.out.println(iterator.next());
        }

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

        //第二种
        for (String str : list) {
   
            System.out.println(str);
        }

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

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

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

        //第四种
        list.stream().forEach(System.out::println);

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

        //第五种
        list.forEach(System.out::println);
    }
}

4 并发性修改异常

package List;

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

/**
 * @ClassName Test04$
 * @Description:
 * @Time 2021/3/2$ 22:52$
 * @Author-Email FONG_y@outlook.com
 */
public class Test04 {
   
    public static void main(String[] args) {
   
        List<String> list = new ArrayList<>();
        list.add("iPhone");
        list.add("iPad");
        list.add("iPod");

        list.add(1,"iMac");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
   
            String next = iterator.next();
            if (next.equals("iPhone")){
   
                list.add("AirPods");
            }
        }
        System.out.println(list);
    }
}

以上的这个代码块出现了异常 也就是这里要讲的并发性异常ConcurrentModificationException

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
	at java.util.ArrayList$Itr.next(ArrayList.java:859)
	at List.Test04.main(Test04.java:24)

我们使用迭代器去遍历list集合的时候，我们说过这个并不是集合本身，而在遍历的时候，迭代器的内部会有一个获取迭代器对象时候生成的预期迭代元素的个数，当我们满足了if后面那个条件后，我们在list集合添加了元素，导致了预期遍历的元素个数与原始集合的元素个数对应错误，出现异常。

想要解决这个异常就是使用最普通的for循环遍历：

package List;

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

/**
 * @ClassName Test04$
 * @Description: 并发性修改异常
 * @Time 2021/3/2$ 22:52$
 * @Author-Email FONG_y@outlook.com
 */
public class Test04 {
   
    public static void main(String[] args) {
   
        List<String> list = new ArrayList<>();
        list.add("iPhone");
        list.add("iPad");
        list.add("iPod");

        list.add(1,"iMac");

        for (int i = 0; i < list.size(); i++) {
   
            if (list.get(i).equals("iPhone")){
   
                list.add("AirPods");
            }
        }
        System.out.println(list);
    }
}

5 ListIterator ==> List集合的专属迭代器
常用方法：

方法名	说明
E next()	返回下一个
boolean hasNext()	判断有没有下一个
E previous	返回上一个
boolean hasPrevious	判断有没有上一个
void add(E e)	添加元素

package List;

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

/**
 * @ClassName Test05$
 * @Description: ListIterator
 * @Time 2021/3/2$ 23:10$
 * @Author-Email FONG_y@outlook.com
 */
public class Test05 {
   
    public static void main(String[] args) {
   
        List<String> list = new ArrayList<>();
        list.add("iPhone");
        list.add("iPad");
        list.add("iPod");

        list.add(1,"iMac");

        ListIterator<String> listIterator = list.listIterator();

        while (listIterator.hasNext()){
   
            System.out.println(listIterator.next());
        }

        while (listIterator.hasPrevious()){
   
            System.out.println(listIterator.previous());
        }

        while (listIterator.hasNext()){
   
            String next = listIterator.next();
            if (next.equals("iPhone")){
   
                listIterator.add("AirPods");
            }
        }

        System.out.println(list);
    }
}

6 List集合的特点
ArrayLIst:底层数据结构是数组，修改查询快，添加删除慢
LinkedList:底层数据结构是链表，修改查询慢，添加删除快
7 LinkedList
常用方法：

方法名	说明
public void addFirst(E e)	头添加
public void addLast(E e)	尾添加
public E getFirst()	获取头
public E getLast()	获取尾
public E removeFirst()	移除头 并返回头
public E removeLast()	移除尾 并返回尾

package List;

import java.util.LinkedList;

/**
 * @ClassName Test06$
 * @Description:  LinkedList
 * @Time 2021/3/4$ 8:07$
 * @Author-Email FONG_y@outlook.com
 */
public class Test06 {
   
    public static void main(String[] args) {
   
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("111");
        linkedList.add("222");
        linkedList.add("333");
        linkedList.add("444");

        linkedList.addFirst("AAA");
        linkedList.addLast("ZZZ");

        System.out.println(linkedList); //[AAA, 111, 222, 333, 444, ZZZ]

        System.out.println("============");
        System.out.println(linkedList.getFirst()); //AAA
        System.out.println(linkedList.getLast()); //ZZZ
        System.out.println(linkedList.removeFirst());//AAA
        System.out.println(linkedList.removeLast());//ZZZ

        System.out.println(linkedList);//[111, 222, 333, 444]
    }
}

2 数据结构简介

程序 = 数据结构 + 算法
时间优先 、 空间优先 - 需求
Java对空间基本没有什么需求 运行端通常是PC或者服务器
底层写的程序 如果在设备里运行不了，只能改
Java PC平台 或者 服务器平台 如果设备运行不了，程序员可以要求客户升级设备

1 栈模型

只有一个开口， 数据的流向是双向的，先进的后出，后进的先出

栈底元素：最先进入模型的元素
栈顶元素：最后进入模型的元素
进栈/压栈：数据进入栈模型的元素
出栈/弹栈：数据离开栈模型的元素

package datastructure;

import java.util.Scanner;

/**
 * @ClassName Test01$
 * @Description: 栈模型递归案例
 * @Time 2021/3/4$ 8:58$
 * @Author-Email FONG_y@outlook.com
 */
public class Test01 {
   
    public static void main(String[] args) {
   
        System.out.println("请输入你想求的累加和的数字：");
        System.out.println(mySum(new Scanner(System.in).nextInt()));
    }

    private static int mySum(int nextInt) {
   
        if (nextInt == 1){
   
            return 1;
        }

        // n 的累加和 就是 n + n-1 的累加和
        return nextInt + mySum(nextInt - 1);
    }
}

2 队列模型

队列模型就是一个走廊一样的，两端都有开口，先进先出，后进后出

package datastructure;

/**
 * @ClassName Test02$
 * @Description:  队列模型
 * @Time 2021/3/4$ 9:05$
 * @Author-Email FONG_y@outlook.com
 */
public class Test02 {
   
    public static void main(String[] args) {
   
        method01();
        method02();
        method03();
    }

    private static void method03() {
   
        System.out.println("Method03进入队列了");
        System.out.println("Method03离开队列了");
    }

    private static void method02() {
   
        System.out.println("Method02进入队列了");
        System.out.println("Method02离开队列了");
    }

    private static void method01() {
   
        System.out.println("Method01进入队列了");
        System.out.println("Method01离开队列了");
    }
}

3 数组模型

数组就是相同数据类型的集合 ，这种模型的特点是 ：查询和修改快，删除和添加慢

package datastructure;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @ClassName Test03$
 * @Description:  数组模型 添加元素 
 * @Time 2021/3/4$ 9:09$
 * @Author-Email FONG_y@outlook.com
 */