1. 数据结构
数据结构是底层组织和贮存数据的一种形式，是指数据之间以什么形式排列的。
1.1 栈
特色：先进后出，后进先出
相似枪的子弹夹，压在弹夹底部的子弹会最初才发射。进出都在栈首
1.2 队列
特色：先进先出，后进后出
相似水管，先流进去的水会被首先流进去。进数据为队首，出队为队尾。
1.3 数组
通过索引查找数据
数组因为有索引，所以查问比拟快，删除和插入效率较低
1.4 链表
链表相似角色游戏的剧情一样，上一个工作实现了就会指向下一个。上面是链表的构造：
残缺的链表示意图：
向列表中插入数据：
较为简单的双向链表，岂但保留下一个数据的地址还保留了上一个数据的地址：
特色：
- 链表存储地址是不间断的，因为有存下一个数据的地址。
- 链表查问比较慢，每次都要从头开始。
- 链表的增删比拟快，批改地址指向即可。
1.5 二叉树
字面意思就是分为两个叉的树，事实上就是相似这样的构造 。一个节点，而后上面分出两个子节点，两个子节点在各自分出两个子节点，以此类推。
结构图：
特点：
- 只有一个根节点，每个节点最多只有两个子节点
- 领有雷同父节点的为兄弟节点
- 节点的度，每个父节点最大度为2，最小为0
- 叶子节点的高度为1，父节点为2以此类推到根节点
- 根节点为第一层
1.5.1 二叉树存储和疾速查找
依照节点右边小于等于父节点左边大于父节点的规定来存储程序，便于查找和排序。上面创立一个二叉树，每个叶子包含上节点，左节点，右节点和数据。
// 二叉树的示例public class Leaf { private int data; private Leaf top; private Leaf left; private Leaf right; public Leaf() { } public Leaf(int data) { this.data = data; } // get and set}public class LeafTest { public static void main(String[] args) { Leaf superLeaf = null; int[] x = {56, 86, 8, 95, 45, 34, 19, 20}; for (int i = 0; i < x.length; i++) { if (i == 0) { superLeaf = new Leaf(x[i]); } else { addLeaf(superLeaf, x[i]); } } System.out.println(superLeaf); } public static void addLeaf(Leaf leaf, int data) { if (leaf != null) { int superData = leaf.getData(); if (data <= superData) { if (leaf.getLeft() == null) { leaf.setLeft(new Leaf(data)); } else { addLeaf(leaf.getLeft(), data); } } else { if (leaf.getRight() == null) { leaf.setRight(new Leaf(data)); } else { addLeaf(leaf.getRight(), data); } } } }}// 查问二叉树public class LeafSearch { public static int x = -1; public static void main(String[] args) { int[] array = {56, 86, 8, 95, 45, 34, 19, 20}; Leaf leaf = LeafTest.getLeaf(array); searchIndex(leaf, 8); System.out.println(x); } private static void searchIndex(Leaf leaf, int i) { if (leaf != null) { int data = leaf.getData(); if (data == i) { x = leaf.getIndex(); } else if (data < i) { searchIndex(leaf.getRight(), i); } else if (data > i) { searchIndex(leaf.getLeft(), i); } } else { x = -1; } }}以上是个简略的示例，理论二叉树只是比拟广，齐全二叉树，满二叉树，均衡二叉树和红黑树等等。当前将具体开个系列解说。
2. 泛型
是从JDK1.5之后引入的个性，能够在编译阶段进行类型束缚，并进行查看。泛型只反对援用类型，汇合体系所有的接口和实现类都反对泛型。
泛型能够放在类、办法和接口上。
2.1 放在类上
// 格局,T只是泛型标识符，能够是任意示意，常见：T,K,V,E修饰符 class 类名<T>{}// 示例public class MyArrayList<T> { private ArrayList list = new ArrayList(); public void add(T t) { list.add(t); } public void remove(T t) { list.remove(t); }}public class Demo { public static void main(String[] args) { MyArrayList<String> myArrayList = new MyArrayList<>(); myArrayList.add("一"); myArrayList.add("二"); }}2.2 泛型办法
泛型办法用在办法上，便于通用办法的创立。泛型用在办法上，这样就能够接管任何类型，办法便具备通用型。
// 格局修饰符 <泛型> 返回类型 办法名(形参列表){}public class MyFunction { public static <T> void print(T t) { System.out.println(t); }}public static void functionTest() { MyFunction.print("你好！"); MyFunction.print(3.14);}2.3 泛型接口
// 格局修饰符 interface 接口类名称<泛型变量>{}public interface MyInterface<E> { void println(E e);}public class MyInterfaceImpl<E> implements MyInterface<E> { @Override public void println(E e) { System.out.println(e); }}public static void interfaceTest() { MyInterfaceImpl<String> myInterface = new MyInterfaceImpl<>(); // 此时只能传递String类型 myInterface.println("haha"); MyInterfaceImpl<Integer> myInterface1 = new MyInterfaceImpl<>(); // 此时只能传递Integer类型 myInterface1.println(11);}2.4 泛型通配符（？）
泛型通配符?，?能够通配任何类型，在应用时有以下两种状况：
- \<? extends 类型\>：?通配符的上线，泛型只能是类型或类型的子类
- \<? super 类型\>：?通配符的上限，泛型只能是类型，或其余类
// 示例public class GenericImpl<E> { public void getSize(Collection<? extends E> collection) { System.out.println(collection.size()); }}public static void test() { GenericImpl<Object> generic = new GenericImpl<>(); List<Object> list = new ArrayList<>(); list.add(1); list.add(2); list.add(3); generic.getSize(list);}3. 可变参
可变参次要用在形参中，能够接管多个参数，它实质是数组。可变参数传递参数比拟灵便
，能够不传，一个，多个或数组。应用次要有以下特色：
- 一个形参列表只能有一个形参
- 可变参只能够放在形参列表最初面
// 格局类型... 参数名称private static void paramTest(String... strings) { for (int i = 0; i < strings.length; i++) { System.out.println(strings[i]); }}paramTest();paramTest("asas");paramTest("sa", "as");String[] x = {"1", "2"};paramTest(x);本章完结，用于集体学习和小白入门，大佬勿喷！心愿大家多多点赞珍藏撑持撑持！
源码 【GitHub】 【码云】