Java 常见数据结构

数据结构

package Data;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;
import java.util.Stack;


/**
 * Java 数据结构
 */
public class JavaDataStr {

	public static void main(String[] args) {
		/**
		 * 数组 Arrays 固定大小，类型相同，效率高
		 */
		int[] arrays = new int[5];	
		System.out.println(arrays[0]);
		
		/**
		 * 列表 Lists 
		 * 	//ArrayList 动态数组，可变大小
		 * 	//LinkedList 双向链表，元素间通过指针链接
		 */
		List<String> list = new ArrayList<>();
		list.add("like");
		List<Integer> list2 = new LinkedList<>();
		list2.add(85);
		System.out.println(list+" * "+list2);
		
		
		/**
		 * 集合 Set  存储补充都的元素
		 * 	HashSet--->>>无序集合 基于 HashMap实现
		 * 	TreeSet--->>>有序集合，不允许重复元素
		 */
		Set<String> hash = new HashSet<>();
		hash.add("isSet");
//		Set<Integer> tree = new TreeSet<>();
		System.out.println(hash);
		
		
		/**
		 * 映射 Maps  ---》》键值对
		 */
		Map<String, Integer> hashMap = new HashMap<>();
		hashMap.put("liming ", 01);
		System.out.println(hashMap);
		
		
		/**
		 * 栈 Stack
		 * 	--->>>后进先出
		 */
		Stack<Integer> stack = new Stack<>();
		stack.add(99);
		stack.add(88);
		System.out.println(stack);
		
		/**
		 * 队列 Queue --->>> 先进先出原色
		 * 	常见实现 LinkedList  PriorityQueue ArrayDeque
		 */
		Queue<String> queue = new LinkedList<>();
		queue.add("linked");
		System.out.println(queue);
		
		
		/**
		 * 堆 Heap  优先队列的基础，可以实现最大堆和最小堆
		 */
		PriorityQueue<Integer> minHeap = new PriorityQueue<>();
		PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
		
		
		/**
		 * 树 Trees
		 * 		 提供了 TreeNode 类型，可以用于构建二叉树等数据结构
		 */
		class TreeNode{
			int val;
			TreeNode left;
			TreeNode right;
			TreeNode(int x){
				val = x;
			}
		}
		
		
		
		

	}

}

集合的遍历

Map集合遍历

import java.util.HashMap;
import java.util.*;
import java.util.Map;

/**
 * 集合遍历
 */
public class MapTest {

	public static void main(String[] args) {
		
		// Map集合遍历
		Map<Integer, String> map = new HashMap<>();
		map.put(20025, "pony");
		map.put(20008, "Jackie");
		map.put(20006, "Sephirex");
		map.put(20015, "George");
		map.put(20028, "Karl_Marx");
		
		//第一种：二次取值
		System.out.println("①：通过 Map.keySet遍历key和value");
		for(Integer key : map.keySet()) {
			System.out.println("key="+key+ " value="+map.get(key));
		}
		
		//第二种：
		System.out.println("②：通过Map.entrySet使用iterator遍历key和value");
		Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
		while(it.hasNext()) {
			Map.Entry<Integer, String> entry = it.next();
			System.out.println("key:"+entry.getKey()+" value:"+entry.getValue());
		}
		
		
		//第三种：容量大的时候使用
		System.out.println("③：通过Map.entrySet遍历key和value");
		for(Map.Entry<Integer, String> entry : map.entrySet()) {
			System.out.println("key::"+entry.getKey() + "; value::"+entry.getValue());
		}
		
		//第四种：
		System.out.println("④：通过Map.values()遍历所有的value,但不能遍历key");
		for(String v : map.values()) {
			System.out.println("values_is : "+v);
		}
		
		
		
	}
	
}

LinkedList 集合遍历

import java.util.*;

public class linkedListTest {

	public static  void main(String[] args) {
		//linkedList集合
		LinkedList<String> list = new LinkedList<String>();
		list.add("Jeff_Bezos");
		list.add("Bernard_Arnault");
		list.add("Warren_Buffett");
		list.add("Bill_Gates");
		list.add("Mukesh_Ambani");
		list.add("Elon_Musk");
		list.add("Steve_Ballmer");
		list.add("Larry_Ellison");
		System.out.println(list);
		
		//使用 addFirst()在头部添加元素
		list.addFirst("Michael_Bloomberg");
		// 使用 addLast()在尾部添加元素
		list.addLast("Carlos_Slim_Helu");
		System.out.println(list);
		
		//移除列表头部元素
		list.removeFirst();
		// 移除列表尾部元素
		list.removeLast();
		System.out.println(list);
		
		
		//获取列表开头&&结尾元素
		String first = list.getFirst();
		String end = list.getLast();
		System.out.println(first + ";" + end);
		
		
		//使用 for 配合size()方法来迭代列表中的元素
		for(int size=list.size() , i=0;i<size;i++) {
			System.out.println(list.get(i));
		}
		System.out.println("--分-割-符--");
		//使用 for-each 迭代元素
		for(String i:list) {
			System.out.println(i);
		}
		
		

	}

}

HashSet 集合遍历

import java.util.HashSet;

public class HashSetTest {

	public static void main(String[] args) {
		//HashSet 无序，不允许重复，允许null
		
		HashSet<String> sits = new HashSet<String>();
		sits.add("Thomas_Alva_Edison");
		sits.add("Cristóbal_Colón");
		sits.add("Martin_Luther");
		sits.add("Galileo_di_Vincenzo_Bonaulti_de_Galilei");
		sits.add("Leonardo_da_Vinci");
		sits.add("Darwin");
		sits.add("Fernando_de_Magallanes");
		sits.add("Isaac_Newton");
		sits.add("Isaac_Newton"); //重复的元素不会被添加
		System.out.println(sits);
		
		
		//判断元素是否存在
		boolean iscontains = sits.contains("Isaac_Newton");
		//计算大小
		int size = sits.size();
		System.out.println(iscontains + ";"+ size);
		
		//for-each迭代集合元素
		for(String i : sits) {
			System.out.println(i);
		}
		
		//删除元素
		sits.remove("Darwin");
		System.out.println(sits);
		//删除所有元素
		sits.clear();
		System.out.println(sits);
		

	}

}

HashMap 集合遍历

import java.util.HashMap;

public class HashMapTest {

	public static void main(String[] args) {
		//HashMap 无序散列表，内容（key-value），最多一条null
		
		HashMap<Integer,String> map = new HashMap<>();
		map.put(1001, "zhangsan");
		map.put(1086, "lisi");
		map.put(1023, "wangwu");
		map.put(1025, "zhaoliu");
		map.put(1099, "sunqi");
		map.put(1011, "zhouba");
		map.put(1056, "wujiu");
		map.put(1026, "zhengshi");
		System.out.println(map);
		
		//通过 key 获取 value
		String name = map.get(1023);
		System.out.println(name);
		
		//计算大小
		int size = map.size();
		System.out.println(size);
		
/*		
		
		//删除元素
		String del = map.remove(1086);
		//删除所有
		map.clear();
		System.out.println(del +";"+ map);
*/
		
		//for-each遍历 map 集合
		//key-value
		for(Integer i : map.keySet()) {
			System.out.println(i+":"+map.get(i));
		}
		
		//value值
		for(String v : map.values()) {
			System.out.println(v);
		}
		

	}

}

Iterator 遍历集合（ArrayList）

import java.util.ArrayList;
import java.util.Iterator;

public class IteratorTest {

	public static void main(String[] args) {
		// Iterator（迭代器），用于访问遍历集合； 用于迭代 ArrayList 和 HashList等集合
		/**
		 * next() - 返回迭代器的下一个元素，并将迭代器的指针移到下一个位置。
			hasNext() - 用于判断集合中是否还有下一个元素可以访问。
			remove() - 从集合中删除迭代器最后访问的元素（可选操作）。
		 */
		
		ArrayList<String> list = new ArrayList<>();
		list.add("The_Russian_Federation");
		list.add("The_Dominion_of_Canada");
		list.add("The_United_States_of_America");
		list.add("The_Federative_Republic_of_Brazil");
		list.add("The_Commonwealth_of_Australia");
		list.add("The_Republic_of_India");
		
		//获取迭代器
//		Iterator it = list.iterator();
		Iterator<String> it = list.iterator();
		
		//输出第一个元素
//		Object fir = it.next();
//		System.out.println(fir);
		
		//循环遍历元素
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
		
		
		//删除元素
		ArrayList<Integer> num = new ArrayList<>();
		num.add(12);
		num.add(10);
		num.add(58);
		num.add(6);
		num.add(9);
		num.add(23);
		Iterator<Integer> itnum = num.iterator();
		while(itnum.hasNext()) {
			Integer i = (Integer) itnum.next();
			if(i<10) {
				itnum.remove();
			}
		}
		System.out.println(num);
		
		
		
	}

}