java中常见的的数据结构方法

最新推荐文章于 2024-07-03 19:13:37 发布

舟中渡人

最新推荐文章于 2024-07-03 19:13:37 发布

阅读量71

点赞数

文章标签： java 数据结构开发语言

本文链接：https://blog.csdn.net/weixin_51522567/article/details/133081738

版权

在Java中，常见的算法数据结构包括以下几种，每种数据结构都有对应的方法：

1. 数组（Array）：

- 获取元素：

arr[index]

- 修改元素：

arr[index] = value

- 获取长度：

arr.length

- 遍历元素：

for (int i = 0; i < arr.length; i++)

for(int num:arr)

- 查找元素：

Arrays.binarySearch(arr, key)

Arrays.toList.contains(value)

- 排序：Arrays.sort(arr)

int[] arr=new arr[];
arr[0]=1;
arr[1]=2;
int value=99;
//获取元素
int result=arr[0];
//修改元素
arr[0]=3;
//获取长度
int len=arr.lentgth;
//遍历元素
for(int i=0;i<arr.length;i++)
for(int num:arr)
//查找元素
//binarySearch(int[] obj,int value)需要先排序才能查找，查找是否存在该值，存在为1不存在为-1
Arrays.binarySearch(arr,key)
//转为List，使用list.contains(Object o)
Arrays.asList(arr).contains(value)
//排序
Array.sort(arr)

ArrayList(Collection<?> c)：构造方法，使用一个 Collection 对象来初始化 ArrayList。
List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c"));
ArrayList(int capacity)：构造方法，创建一个具有指定容量的 ArrayList。

List<String> list = new ArrayList<>(10);
add(int index, E element)：向指定位置插入一个元素。

List<String> list = new ArrayList<>();
list.add(0, "a"); // 在第一个位置插入元素 "a"
add(E element)：在列表末尾添加一个元素。

List<String> list = new ArrayList<>();
list.add("a"); // 在列表末尾添加元素 "a"
addAll(int index, Collection<? extends E> c)：将另一个 Collection 对象中的元素添加到指定位置。

List<String> list = new ArrayList<>();
list.addAll(0, Arrays.asList("b", "c")); // 在第一个位置插入元素 "b" 和 "c"

clear()：清空列表中的所有元素。
List<String> list = new ArrayList<>();
list.clear(); // 清空列表中的所有元素

clone()：返回一个与当前 ArrayList 对象完全相同的副本。
List<String> list = new ArrayList<>();
List<String> clone = list.clone(); // 返回一个与当前列表相同的副本

contains(Object o)：判断列表中是否包含指定元素。
List<String> list = new ArrayList<>();
list.add("a");
boolean contains = list.contains("a"); // 判断列表中是否包含元素 "a"
indexOf(Object o)：返回指定元素在列表中第一次出现的位置。如果列表中不包含该元素，则返回 -1。

List<String> list = new ArrayList<>();
list.add("a");
int index = list.indexOf("b"); // 返回元素 "b" 在列表中第一次出现的位置，如果不存在则返回 -1

2. 链表（LinkedList）：

- 插入元素：

add(value)：在链表末尾添加指定元素。

1. addFirst(value)：在链表头部添加指定元素。

2. addLast(value)：在链表末尾添加指定元素。

- 修改元素：

set(index,value)

- 删除元素：

1. E remove(value)：删除链表中第一次出现的指定元素。

2. E removeFirst()：删除链表的第一个元素。

3. E removeLast()：删除链表的最后一个元素。

- 获取长度：

list.size()

- 获取元素：

1. get(index)：获取链表中指定位置的元素。

2. getFirst()：获取链表的第一个元素。

3. getLast()：获取链表的最后一个元素。

- 遍历元素：

for (int i = 0; i < list.size(); i++)

- 查找元素：

list.contains(value)

LinkedList<E> linkList=new LinkedList<E>();
LinkedList<Integer> linkList=new LinkedList<>();
//插入元素
linkList.add(1);
linkList.addFirst(2);
linkList.addLast(3);
//修改元素
linkList.set(0,4);
//删除元素
linkList.remove(1);
linkList.removeFirst();
linkList.removeLast();
//获取长度
int len=linkList.size();
//获取元素
Integer value=linkList.get(0);
Integer fistValue=linkList.getFirst();
Integer lastValue=linkList.getLast();
//遍历元素
for(int i=0;i<linkedList.size();i++)
for(int num:linkedList)
//查找元素
boolean flag=linkedList.contains(1;

3. 栈（Stack）：

- 入栈：

stack.push(value)

- 出栈：

stack.pop()

- 获取栈顶元素：

stack.peek()

- 判断栈是否为空：

stack.isEmpty()

stack.empty();

- 获取栈的大小：

stack.size()

Stack<Integer> stack=new Stack<>();
//入栈
stack.push(1);
//出栈
stack.pop();
//获得栈顶元素
Integer value=stack.peek();
//判断栈是否为空
boolean flag=stack.isEmpty();
boolean flag1=stack.empty();
//获得栈的大小
int len=stack.size();

//也可以用LinkedList来模拟栈

4. 队列（Queue）：

- 入队：

queue.offer(value)

queue.add(value)

offer(value)和add(value)的区别

返回值：offer(value)方法在将指定元素插入队列时，如果成功则返回true，如果队列已满则返回false。而add(value)方法在将指定元素插入队列时，如果成功则返回true，如果队列已满则抛出IllegalStateException异常。
异常处理：offer(value)方法在队列已满时返回false，而不会抛出异常。这种情况通常用于在有界队列中插入元素时，如果队列已满，可以根据返回值进行相应的处理。而add(value)方法在队列已满时会抛出IllegalStateException异常。

可以用ArrayBlockingQueue来验证

ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(3);
queue.add(1);
queue.add(2);
queue.add(3);

System.out.println("Before adding elements:");
System.out.println("Queue: " + queue);

// 使用add(value)方法添加元素，但队列已满
boolean isAdded1 = queue.add(4);
System.out.println("Element 4 added using add(value): " + isAdded1);

// 使用offer(value)方法添加元素，但队列已满
boolean isAdded2 = queue.offer(5);
System.out.println("Element 5 added using offer(value): " + isAdded2);

System.out.println("After adding elements:");
System.out.println("Queue: " + queue);

综上所述，offer(value)方法更适合在队列已满时返回特定值的场景，而add(value)方法更适合在队列已满时需要抛出异常的场景。一般来说，如果不确定队列是否已满，建议使用offer(value)方法，以避免异常的发生。

- 出队：

queue.poll()

- 获取队头元素：

queue.peek()

- 判断队列是否为空：

queue.isEmpty()

- 获取队列大小：

queue.size()

Queue<Integer> queue=new LinkedList<>();
//入队
queue.offer(1);
queue.add(2);
//出队
Integer value=queue.poll();
//获取队头元素
Integer topValue=queue.peek();
//判断队列是否为空
boolean flag=queue.isEmpty();
//获取队列大小
int size=queue.size();

5. 哈希表（HashMap）：

- 添加键值对：

map.put(key, value)

- 获取值：

map.get(key)

- 移除键值对：

map.remove(key)

- 判断键是否存在：

map.containsKey(key)

- 判断值是否存在：

map.containsValue(value)

- 获取键的集合：

map.keySet()

- 获取值的集合：

map.values()

Map<String,String> map=new HashMap<>();
//添加键值对
map.put("name","kevin");
//获取值
String name=map.get("name");
//移除键值对
String value=map.remove("name");
//判断键是否存在
boolean flag=map.containsKey("name");
//判断值是否存在
boolean flag1=map.containsValue("kevin");
//获取键的集合
Set<String> keySet=map.keySet();
//获取值的集合
Collection<String> values=map.values();