人生苦短我学Java12异常处理/集合/ArrayList与LinkedList/队列/堆栈/链表广深

一、Exception异常

相对是一个小问题一般是代码逻辑问题会产生该异常。亦可捕获异常进行处理，常处理分为两种

非RuntimeException(编译时期异常)
RuntimeException(运行时期异常)

package com.ppl.exTry;
/*
com.ppl.com.ppl.exTry：学习项目
@user：广深-小龙
@date：2022/1/16 12:34
*/

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


public class TryCatch {
    public static void main(String[] args) throws MyException {

        // 万能抛异常
        try {
            String strTime = "2022-01-15 22:30:36";
            DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            LocalDateTime localDateTime = LocalDateTime.parse(strTime, pattern);
            System.out.println(localDateTime.format(pattern));
            System.out.println(5 / 0);
        } catch (Exception e) {
            System.err.println("格式错误 strTime error：" + e.getClass() + e.getMessage());
        }

        // 主动抛异常
        try {
            SimpleDateFormat f = new SimpleDateFormat("");
            f.parse("");
        } catch (Exception e) {
            throw new RuntimeException("主动抛出异常：error RuntimeException");
        }

        // 自定义异常
        ExTest.exTest(5);
    }
}

class MyException extends Exception {
    public MyException() {
    }

    public MyException(String err) {
        super(err);
    }
}

class ExTest {
    // 自定义异常
    public static void exTest(int num) throws MyException {
        if (num > 10) {
            System.out.println(num);
        } else {
            throw new MyException("自定义异常---错误！！！");
        }
    }
}

自定义异常类，继承Exception或者RuntimeException，写多个构造方法

二、Collection集合

1、什么是集合？集合就是个容器，用来装东西。比如数组容器、集合容器。

2、集合容器的特点？

1.集合容器的长度是可以变化的
2.集合容器只能存储引用数据类型
3.一个集合容器中可以存储不同引用数据类型的数据

3、集合容器和数组容器的区别？

1.集合容器的长度是可以变化的，数组容器一旦初始化长度就不能改变了
2.集合容器只能存储引用数据类型，数组容器既可以存储基本数据类型，也可以存储引用数据类型
3.一个集合容器中可以存储不同引用数据类型的数据，一个数组容器中只能存储同一种数据类型的数据

package com.ppl.object;
/*
com.ppl.object：学习项目
@user：广深-小龙
@date：2022/1/16 19:54
*/

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

public class Obj_Collection {
    public static void main(String[] args) {
        new MyCollection().ToArr();
    }
}


class MyCollection {
    public MyCollection() {
        // 创建集合容器
        Collection c = new ArrayList();
        // 添加元素
        c.add("字符串");
        c.add(123);
        c.add(true);
        System.out.println("c：" + c);
        // 添加集合
        Collection c1 = new ArrayList();
        c1.addAll(c);
        System.out.println("c1：" + c1);
        // 删除元素
        c1.remove(true);
        System.out.println("c1删除元素：" + c1);
        // 按照条件删除元素
        c1.removeIf(
                new Predicate() {
                    @Override
                    public boolean test(Object o) {
                        // 判断o(也就是每个元素)是否是Integer类型，true就删除该元素
                        return o instanceof Integer;
                    }
                });
        System.out.println("c1 removeIf：" + c1);
        // 清空集合
        c1.clear();
        System.out.println("c1 清空集合：" + c1);
        // 集合容器长度
        System.out.println(c.size());
        // 判断集合中是否包含指定元素，返回布尔值
        System.out.println("判断集合中是否包含指定元素：" + c.contains(true));
        // 判断集合是否为空，返回布尔值
        System.out.println(c1.isEmpty());
    }

    public void ToArr() {
        // 转为数组，for遍历
        System.out.print("for遍历：");
        Collection c = new ArrayList();
        c.add("a");
        c.add(123);
        c.add(true);
        Object[] obj = c.toArray();
        for (int i = 0; i < obj.length; i++) {
            System.out.print(obj[i] + " ");
        }
        System.out.println();

        // 迭代器遍历
        System.out.print("迭代器遍历：");
        Iterator it = c.iterator();
        while (it.hasNext()) {
            Object o = it.next();
            System.out.print(o + " ");
        }

        // 增强for循环
        System.out.println();
        System.out.print("增强for循环：");
        for (Object o : c) {
            System.out.print(o + " ");
        }
    }
}

三、List

1、List接口
List集合的特点？

1.有序的(存入的顺序和取出的顺序是一样的)
2.元素可以重复的
3.有索引的

2、常见的成员方法？

和上面的Collection是一样
void add(int index, Object element)：在指定的索引处添加元素
Object get(int index)：获取指定索引处的元素
Object remove(int index)：删除指定索引处的元素
Object set(int index, Object element)：修改指定索引处的元素，返回被修改的数据

package com.ppl.object;
/*
com.ppl.object：学习项目
@user：广深-小龙
@date：2022/1/16 17:21
*/

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

public class Obj_List {
    public static void main(String[] args) {
        // 创建集合
        List list = new ArrayList();
        // 添加元素
        list.add("a");
        list.add(123);
        list.add(true);
        System.out.println(list);
        // 查询index的值
        System.out.println("查询index的值:" + list.get(0));
        // 修改元素
        list.set(0, "被修改了");
        System.out.println("修改元素:" + list);
        // index删除元素
        list.remove(1);
        System.out.println("index删除元素:" + list);

        // 遍历方式一：iterator迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
        System.out.println();
        // 遍历方式二：转数组遍历
        Object[] obj = list.toArray();
        for (int i = 0; i < obj.length; i++) {
            System.out.print(obj[i] + " ");
        }
        System.out.println();
        // 遍历方式三：obj
        for (Object o : list) {
            System.out.print(o + " ");
        }
        System.out.println();
        // 遍历方式四：利用list的get进行普通for
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
    }
}

四、实现类：ArrayList与LinkedList

重点掌握这两个实现类。

1、ArrayList集合的特点？成员方法和List一样

1.有序的(存入的顺序和取出的顺序是一样的)
2.元素可以重复的
3.有索引的

package com.ppl.object;
/*
com.ppl.object：学习项目
@user：广深-小龙
@date：2022/1/16 21:42
*/

import java.util.ArrayList;

public class Obj_ArrayList {
    public static void main(String[] args) {
        // 创建集合
        ArrayList arr = new ArrayList();
        // 添加元素
        arr.add("a");
        arr.add(123);
        arr.add(false);
        // 其它方法、遍历和List是差不多的
    }
}

重写排序

class MyCollect implements Comparable<MyCollect> {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }


    public int getAge() {
        return age;
    }

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

    @Override
    public int compareTo(MyCollect o) {
        // 倒序
        int i = o.age - this.age;
        return i == 0 ? o.name.compareTo(this.name):i;
    }
    public static void main(String[] args) {
        ArrayList<String> a = new ArrayList<>();
        a.add("aaa");
        a.add("aa");
        a.add("b");
        a.add("bbb");
        a.add("bbc");

        // 未自定义排序前
        System.out.println(a);

        // 自定义排序,重写比较器，长度从小到大
        Collections.sort(a, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        });
        System.out.println(a);

        // 自定义类的排序，需要重写 compareTo
        ArrayList<MyCollect> b = new ArrayList<>();
        System.out.println("排序前：" + b);
        b.add(new MyCollect("ppl", 12));
        b.add(new MyCollect("aa", 12));
        b.add(new MyCollect("bb", 15));
        b.add(new MyCollect("gsxl", 12));
        b.add(new MyCollect("ppl", 13));
        b.add(new MyCollect("ppl", 14));
        Collections.sort(b);
        for (MyCollect t : b) {
            System.out.println(t.getName() + " " + t.getAge());
        }
    }
}

2、LinkedList实现类

LinkedList集合的特点？

1.有序的(存入的顺序和取出的顺序是一样的)
2.元素可以重复的
3.有索引的

常见的成员方法？

和List一样的
public void addFirst(Object e):将元素添加到第一个位置
public void addLast(Object e)：将元素添加到最后一个位置
public Object getFirst()：获取第一个位置的元素
public Object getLast()：获取最后一个位置的元素
public Object removeFirst()：删除第一个位置的元素
public Object removeLast()：删除最后一个位置的元素

package com.ppl.object;
/*
com.ppl.object：学习项目
@user：广深-小龙
@date：2022/1/16 21:42
*/

import java.util.LinkedList;

public class Obj_ArrayList {
    public static void main(String[] args) {
        new Obj_ArrayList().linkedList();
    }


    public void linkedList() {
        // linkedList与ArrayList差不多一致，linkedList有头和尾的元素操作
        LinkedList list = new LinkedList();
        list.add("asd");
        System.out.println("linkedList初始值：" + list);
        // 添加首位元素
        list.addFirst("首位");
        // 添加末尾元素
        list.addLast("末尾");
        System.out.println("首末添加元素后:" + list);
        // 获取首位元素
        System.out.println("获取首位元素:" + list.getFirst());
        // 获取末尾元素
        System.out.println("获取末尾元素:" + list.getLast());
        // 删除首位元素
        list.removeFirst();
        // 删除末尾元素
        list.removeLast();
        System.out.println("最后：" + list);
    }
}

五、队列

队列：

特点：先进先出，后进后出

六、栈

特点：先进后出，后进先出

七、数组数据结构

ArrayList 底层使用的是数组结构

查询快，增删慢。

增删可以发现是调用了复制数组，此方法：System.arraycopy

八、链表数据结构

LinkedList

特点：查询快，增删慢。

欢迎来大家QQ交流群一起学习：482713805，博主微信+：gogsxl

相关阅读:
Java Generics and Collections-2.2
Java Generics and Collections-2.1
Java Generics and Collections-8.1
oracle 倒库后insert id冲突的问题
 第十章基本数据结构练习 10.4-4
第十章基本数据结构练习 10.4-2
第十章基本数据结构练习 10.4-3
第九章中位数和顺序统计量 9.2 期望为线性时间的选择算法
 Log4j2的基本使用
 JSF页面中的JS取得受管bean的数据（受管bean发送数据到页面）
原文地址：https://www.cnblogs.com/gsxl/p/15810679.html

人生苦短我学Java12异常处理/集合/ArrayList与LinkedList/队列/堆栈/链表 广深