1. 数组 (Array)
一组连续的内存空间,用于存储相同类型的数据。
1.创建数组
int[] myArray = new int[5];
2.Arrays.toString()
用于将数组转换为字符串,可以快速的输出数组的内容
int[] arr = {1, 2, 3};
System.out.println(Arrays.toString(arr));
3.Arrays.sort()
给数组排序,默认是升序的
int[] arr = {5, 2, 3, 1, 4};
Arrays.sort(arr);
4.Arrays.equals()
比较数组内容是否相等,如果相等返回true,否则返回false
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
boolean isEqual = Arrays.equals(arr1, arr2);
5.Arrays.copyOf()
复制指定数组,当中的第一个参数是复制的原数组,第二个参数是复制的长度
int[] arr1 = {1, 2, 3};
int[] arr2 = Arrays.copyOf(arr1, 5);
6.Arrays.copyOfRange()
是上个方法的改进版,上面这个方法只能从下标为0的地方开始完成对数组的复制,但是这个方法里可以指定起始位置和结束位置
int[] arr1 = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] arr2 = new int[5];
arr2 = Arrays.copyOfRange(arr1,3,5);
2. 链表(Linked List)
由节点组成的数据结构,每个节点包含数据和指向下一个节点的指针
1.创建链表
public class Node {
int data;
Node next;
public Node(int data) {
this.data = data;
this.next = null;
}
}
public class Main {
public static void main(String[] args) {
// 创建头节点
Node head = new Node(0);
// 创建其他节点
Node node1 = new Node(10);
head.next = node1;
Node node2 = new Node(20);
node1.next = node2;
Node node3 = new Node(30);
node2.next = node3;
// 遍历链表并打印节点数据
Node current = head.next;
while (current != null) {
System.out.print(current.data + " ");
current = current.next;
}
}
}
2. addFirst
头插
public void addFirst(int value) {
Node node = new Node(value);
node.next = head;
head = node;
}
3.addLast
尾插
public void addLast(int value) {
Node node = new Node(value);
// 链表为空的情况
if (head == null) {
head = node;
return;
}
Node cur = head;
// 找到最后一个结点的位置
while (cur.next != null) {
cur = cur.next;
}
cur.next = node;
}
4.addIndex
在任意位置插入
public void checkIndex(int index) {
if (index < 0 || index > size()) {
// size()方法获取链表长度,遍历链表即可,比较简单,不多赘述
throw new LinkListIndexOutOfException("这个位置不合法");
// 异常处理
}
}
5.contains
public boolean contain(int key) {
Node cur = head;
while (cur != null) {
if (cur.value == key) {
return true;
}
cur = cur.next;
}
return false;
}
6. remove
public void remove(int key) {
// 如果链表为空
if (head == null) {
return;
}
// 如果头结点就是key
if (head.value == key) {
head = head.next;
return;
}
// 首先要找到key的前一个结点
Node prevKey = findPrevKey(key);
if (prevKey == null) {
return;
}
// 重新链接
Node del = prevKey.next;
prevKey.next = del.next;
}
删除第一次出现关键字为key的结点 判定是否包含某个元素
3. 栈(Stack)
一种后进先出(LIFO)的数据结构,只能在栈顶进行插入和删除操作。
1.创建栈
Stack<Character> stack = new Stack<Character>();
2.push
是指将一个元素压入栈中。在栈数据结构中,新元素被压入栈的顶部,成为新的栈顶元素。 例如,如果要将整数 5 压入栈中,可以使用
stack.push(5)
3.pop
是指从栈中移除并返回栈顶元素,可以将栈顶元素移除,并返回该元素的值
stack.pop()
4.peek
是查看栈顶元素。在栈数据结构中,栈顶元素是最后一个被压入栈的元素,也是第一个被弹出栈的元素。可以获取栈顶元素的值,但不会将其从栈中弹出。
stack.peek()
4. 队列(Queue)
一种先进先出(FIFO)的数据结构,只能在队列的一端进行插入操作,另一端进行删除操作
1.创建队列
Queue<String> queue = new LinkedList<>()
2.方法
add(E element):将指定元素添加到队列末尾,如果队列满了则抛出异常。
offer(E element):将指定元素添加到队列末尾,如果队列满了则返回false
remove():移除并返回队列头部元素,如果队列为空则抛出异常。
po11():移除并返回队列头部元素,如果队列为空则返回 nu11。
element():返回队列头部元素,但不移除它,如果队列为空则抛出异常
peek():返回队列头部元素,但不移除它,如果队列为空则返回nul1。
5. 哈希表(HashMap)
利用哈希函数将键映射到值的数据结构,用于快速查找和插入数据。
1.创建哈希表
Map<Character, Character> hashmap = new HashMap<Character, Character>();
2.方法
添加键值对:使用put(key, value)方法将键值对添加到HashMap中。
获取值:使用get(key)方法获取指定键对应的值。
删除键值对:使用remove(key)方法从HashMap中删除指定的键值对。
判断键是否存在:使用containsKey(key)方法检查HashMap中是否包含指定的键。
判断值是否存在:使用containsValue(value)方法检查HashMap中是否包含指定的值。
获取键集合:使用keySet()方法获取HashMap中所有键的集合。
获取值集合:使用values()方法获取HashMap中所有值的集合。
获取键值对集合:使用entrySet()方法获取HashMap中所有键值对的集合。
获取HashMap大小:使用size()方法获取HashMap中键值对的数量
6. 列表(List)
List是集合体系中较为重要的接口,它具有单列存储的特点,即一次只能添加一个元素
1.创建列表
List<Integer> vals = new ArrayList<Integer>();
2.方法
添加元素:add()
获取元素:get()
删除元素:remove()
清空列表:clear()
判断列表是否为空:isEmpty()
获取列表大小:size()
替换元素:set()
查找元素位置:indexOf()
判断是否包含某元素:contains()
获取子列表:subList()
迭代列表元素:使用迭代器或for-each循环
7. Set
1.创建set
Set<Integer> set=new HashSet<Integer>();
2.方法
添加元素: 使用add(element)方法将新元素添加到Set中。 删除元素: 使用remove(element)方法从Set中删除指定的元素。 使用clear()方法清空Set中的所有元素。 包含元素: 使用contains(element)方法检查Set中是否包含指定的元素。 遍历元素: 使用for-each循环或迭代器来遍历Set中的所有元素。 大小操作: 使用size()方法获取Set中元素的数量