共计 3556 个字符,预计需要花费 9 分钟才能阅读完成。
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】【码云】