Java学习:基础(集合List、常见数据结构、泛型深入)

集合概述

• 集合存储对象的一种容器
• 集合大小、类型不固定，可以动态变化
• 集合支持泛型，可以在编译阶段约束只能操作某种数据类型

Collection

• Collection单列集合，每个元素只能包含一个值，有两个体系(List、Set)
• List系列集合：元素有序、可重复、有索引
• Set系列集合：元素无需、不重复、无索引

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

public class ArrayDemo1 {
    public static void main(String[] args) {
        // 初始化集合
        Collection<String> list = new ArrayList<>();
        // 添加元素
        list.add("java");
        list.add("html");
        list.add("c++");
        list.add("go");

        // 判断集合是否为空
        System.out.println(list.isEmpty());

        // 获取集合的大小
        System.out.println(list.size());

        // 判断集合种某个元素是否选择
        System.out.println(list.contains("java"));

        // 删除某个元素，多个默认删除第一个
        System.out.println(list.remove("c++"));

        // 集合转数组
        Object[] arr = list.toArray();
        System.out.println(Arrays.toString(arr));

        // 清空集合
        list.clear();
    }
}

• 集合遍历

1）迭代器遍历，（如需删除数据，集合删除会出并发修改异常，需用迭代器自己删）

2）增强for遍历，（如需删除数据，会出并发修改异常，无法解决）

3）Lambda表达式遍历，（如需删除数据，会出并发修改异常，无法解决）

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

public class ArrayDemo3 {
    public static void main(String[] args) {
        // 初始化集合
        Collection<String> list = new ArrayList<>();
        // 添加元素
        list.add("java");
        list.add("html");
        list.add("c++");
        list.add("go");

        // 迭代器遍历集合
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String rs = it.next();
            System.out.println(rs);
        }

        // 增强for遍历
        for (String els : list) {
            System.out.println(els);
        }

        // lambda表达式遍历
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        // 简化1
        list.forEach(s-> {
            System.out.println(s);
        });
        // 简化2
        list.forEach(s-> System.out.println(s));
        // 简化3
        list.forEach(System.out::println);

    }
}

常见数据结构

• 栈， 先进后出，后进先出
• 队列，先进先出，后进后出
• 数组，内存中一块连续的空间
• 链表，内存中不连续的空间，每个节点包含值和下一个元素的地址
• 二叉树

① 只有一个根节点，且每个子节点最多有两个直接子节点

② 节点度，节点拥有子树的个数，二叉树的度最大为2，最小为0，叶子节点的度为0，也叫终端节点

③ 高度，叶子节点的高度为1，它的父节点为2，依次类推

• 二叉查找树

① 左子树上的节点值都小于根节点的值

② 右子树上的节点值都大于根节点的值

③ 节点值都是排好序的

• 平衡二叉树

① 满足二叉树条件时，同时降低高度

② 任意节点左右两棵子树的高度差不能超过1，都是平衡二叉树

③ 保持平衡基本策略，左旋或右旋，左左（以根节点右拉）、左右（以不平衡节点左拉再以根节点右拉）、右右（以根节点左拉）、右左（以不平衡节点右拉再以根节点左拉）

• 红黑树

① 每一个节点可以是红或黑，通过红黑规则进行平衡

② 根节点必须是黑色

③ 一个节点没有子节点或父节点，则该节点的指针属性为nil，这些nil视为叶节点，叶节点是黑色

④ 某一个节点是红色，它的子节点必须是黑色，不能出现两个红色节点相连的情况

⑤ 某一节点，到其后代叶子节点的简单路径上，均含有相同数量的黑色节点

泛型深入

• 统一数据类型
• 自定义泛型类

/**
 * 定义泛型类
 * @param <E>
 */
public class MyArrayList<E> {
    public void add(E e) {

    }

    public void remove(E e) {

    }
}


class Test {
    public static void main(String[] args) {
        MyArrayList<String> list = new MyArrayList<>();
        list.add("java");
        list.add("html");

    }
}

• 自定义泛型方法，接收一切类型的参数，使方法更具有通用性

public class MyArrayFun {
    public static void main(String[] args) {
        String[] name = {"java", "c++", "html", "php", "golang", "python"};
        printArray(name);

        Integer[] age = {15, 20, 40, 90};
        printArray(age);

        Integer[] ages = getArray(age);

    }

    /**
     * 打印数据, 定义泛型方法
     * @param arr
     * @param <T>
     */
    public static <T> void printArray(T[] arr) {
        if(arr == null) {
            System.out.println(arr);
        } else {
            StringBuilder sb = new StringBuilder("[");
            int len = arr.length;
            for (int i = 0; i < len; i++) {
                sb.append(arr[i]).append(i == len - 1 ? "" : ", ");
            }
            sb.append("]");
            System.out.println(sb);
        }
    }

    /**
     * 定义泛型方法
     * @param arr
     * @param <T>
     * @return
     */
    public static <T> T[] getArray(T[] arr) {
        return  arr;
    }
}

• 自定义泛型接口，让实现类现在当前功能需要操作的数据类型

/**
 * 定义泛型接口
 * @param <E>
 */
interface Data<E> {
    void add(E e);
    void update(E e);
}

class Teacher {

}

class TeacherData implements Data<Teacher> {
    @Override
    public void add(Teacher teacher) {

    }

    @Override
    public void update(Teacher teacher) {

    }
}

• 泛型通配符：?，在使用泛型的时候可以代表一切类型
• 泛型上限 ，? extends 必须继承其或子类
• 泛型下限 ，?super 必须继承其或父类

public class MyArrayInterface {

    public void go(ArrayList<? extends Teacher> teacher) {

    }
}

class Teacher {

}