LinkedList, Set 和 Map

本文主要是介绍LinkedList, Set 和 Map，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1，LinkedList

1.1 LinkedList 介绍

  底层数据存储结构为双向链表
  链表头：
      class LinkedList<E> {
        Node<E> first;
        Node<E> last;
        int size（）；
}

  Node 是 LinkedList 内部类！！！
节点 Node<E>
	class Node<E> {
		Node<E> previous; // 引用 指向前一个节点 Node 引用
		E e;
		Node<E> next; // 引用  指向后一个节点 Node 引用
	}

1.2 图例分析 LinkedList

1.3 重要方法演示

import java.util.LinkedList;

/*
 * LinkedList<E> 方法演示
 * 
 * addFirst(E e); 添加元素到头节点之前
 * addLast(E e); 添加元素到尾节点之后
 * E getFirst(); 获取头节点元素
 * E getLast(); 获取尾节点元素
 * E removeFirst(); 删除头节点元素，返回值是头节点元素数据内容
 * E removeLast(); 删除尾节点元素，返回值是尾节点元素数据内容
 */
public class Demo1 {
	public static void main(String[] args) {
		LinkedList<String> list1 = new LinkedList<String>();

		list1.add("胡辣汤");
		list1.add("小米粥");
		list1.add("豆腐脑");
		list1.add("两掺");
		
		System.out.println(list1);
		
		list1.addLast("牛肉包子");
		list1.addFirst("牛肉肉盒");
		
		System.out.println(list1); 
		
		System.out.println(list1.getFirst());
		System.out.println(list1.getLast());
		
		System.out.println(list1.removeFirst());
		System.out.println(list1.removeLast());
		
		System.out.println(list1);
	}
}

2. Set

2.1 Set 集合概述

    特征：
      无序 数据存储顺序和添加顺序不一致。
      不可重复 要求元素存储不允许出现相同元素，如果添加相同元素， add 方法返回值为false
    Set 集合没有特征方法，使用的方法都是 Collection 方法
    class HasgSet<E>
    class TreeSet<E>

public class Demo1 {
	public static void main(String[] args) {
		HashSet<Integer> set = new HashSet<Integer>();
		
		/*
		 * 无序 ： 数据存储顺序和添加顺序不一致。
		 */
		set.add(2);
		set.add(6);
		set.add(1);
		set.add(4);
		set.add(5);
		set.add(3);
		
		System.out.println(set);
		
		HashSet<String> set2 = new HashSet<String>();
		
		set2.add("羊肉汤");
		set2.add("烩面");
		set2.add("牛肉面");
		set2.add("葱油拌面");
		set2.add("炒拉条");
		/*
		 * 不可重复，要求元素存储不允许出现相同元素，如果添加相同元素，add方法返回值为 false
		 */
		System.out.println(set2.add("油泼面"));
		System.out.println(set2.add("油泼面"));
		
		System.out.println(set2);
	}
}

2.2 HashSet 存储流程概述分析

底层数据存储结构为 哈希表结构 ==> 简单来看就是一个 Excel 表格。
HashSet 存储数据主要有两个过程
	1. 通过添加元素的 hashCode 方法获取添加元素的 哈希值，通过 哈希运算 计算当前元素应该在哈希表中对应单元格位置
	2. 如果对应单元格存在其他元素，需要通过调用 equals 方法判断两个元素是否同一个元素，如果是同一个元素，后者无法添加，如果不一致，可以存储。

import java.util.HashSet;

public class Demo2 {
	public static void main(String[] args) {
		HashSet<Person> set = new HashSet<Person>();

		/*
		 * 执行添加方法，都会自动调用添加元素的 hashCode 方法
		 */
		set.add(new Person(1, "张三", 26));
		set.add(new Person(2, "李四", 26));
		set.add(new Person(3, "王五", 96));
		set.add(new Person(4, "赵六", 86));
		set.add(new Person(5, "周八", 76));
		set.add(new Person(6, "六一", 66));
		/*
		 * 第二次添加 new Person(6, "六一", 66)
		 * 在当前 Set 集合中有相同元素，添加失败。
		 * 1. 添加元素过程中，调用hashCode方法，计算对应单元格位置，发现对应单元格有之前添加的元素
		 * 2. 调用添加元素的 equals 方法，和之前元素比较，如果比较结果为同一个元素，根据 Set 集合规则
		 * 无法存在相同元素，添加失败
		 */
		set.add(new Person(6, "六一", 66));
		Person p1 = new Person(6, "六一", 66);
		Person p2 = new Person(6, "六一![](https://www.www.weizhi.cc/i/l/?n=22&i=blog/2880577/202205/2880577-20220523224313951-273182229.png)
", 66);
		System.out.println(p1.hashCode());
		System.out.println(p2.hashCode());

		System.out.println(set);
		System.out.println(set.size());
	}
}

2.3 TreeSet 结构分析和存储数据要求

/*
 * 自定义类遵从 Comparable 接口，增强为一个可比较类！！！
 * 采用的遵从方式是【妻管严模式】在遵从接口的过程中，直接明确当前泛型约束
 * 数据类型为 SingleDog 类型，当前类为 SingleDog 所需进行比较的类型
 * 也是对应 SingleDog 类型，非其他类型。
 */
public class SingleDog implements Comparable<SingleDog> {
	private int id;
	private String name;
	private int age;

	public SingleDog() {
	}

	public SingleDog(int id, String name, int age) {
		this.id = id;
		this.name = name;
		this.age = age;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "SingleDog [id=" + id + ", name=" + name + ", age=" + age + "]";
	}

	/*
	 * 遵从 Comparable<T> 接口要求实现的方法
	 * 返回值为 int 类型
	 * 		返回值为 0 两者一致 ==> 利用到 TreeSet(底层数据存储为二叉树的 Set 集合) 无法添加后者元素
	 * 		返回值为 正/负数 存在大小比较关系。
	 */
	@Override
	public int compareTo(SingleDog o) {
		System.out.println("遵从 Comparable 接口实现 compareTo 方法");
		/*
		 * age 调用方法对象对应的 age 成员变量
		 * o.age 是参数对象对应的 age 成员变量
		 * 调用方法对象和参数对象不重要！！！完全由 TreeSet(底层数据存储为二叉树的 Set 集合) 自行决定！！！
		 */
		return o.age - age;
	}

}

import java.util.Comparator;

/**
 * 自定义比较器类，遵从 Comparator 接口，同时泛型直接约束确定为 SingleDog类型
 * 当前自定义比较器是处理比较 SingleDog 类型的
 * @author Anonymous
 *
 */
public class MyComparator implements Comparator<SingleDog> {

	/*
	 * 返回值为 int 类型
	 * 		返回值为 0 两者一致 ==> 利用到 TreeSet(底层数据存储为二叉树的 Set 集合) 无法添加后者元素
	 * 		返回值为 正/负数 存在大小比较关系。
	 */
	@Override
	public int compare(SingleDog o1, SingleDog o2) {
		System.out.println("自定义比较器遵从 Comparator 接口，实现 compare 方法");
		return o1.getAge() - o2.getAge();
	}
}

3. Map

3.1 Map 双边队列

键值对 Key = Value
针对于 键值对模型
	Key 是在整个数据中唯一的
	value 是对应key 且允许 value 重复

Java 中利用 interface Map<K, V> 用于对应键值对模型数据，而且在开发中大量使用。
	K key V Value 
	Map 结构使用两个泛型，一个 K 约束 键 V 约束 值

Map整体Java体系
interface Map<K, V>
--| class HashMap<K, V> 
	底层数据存储方式为 哈希表结构的 Map 双边队列，对于整个数据而言 Key 唯一，采用 Key 对应数据哈希值决定当前【键值对】在哈希表中的存储位置。

--| class TreeMap<K, V>	
	底层数据存储结构为 平衡二叉树结构，也是根据对应整个Map 唯一的 Key ，要求Key有比较顺序或者提供对应的比较方式。Comparator 接口 Comparable 接口

3.2 Map 双边队列涉及到的方法

增
	put(K k, V v);
		根据实例化 Map 双边队列对象约束的键值对泛型类型，添加对应的键值对
	putAll(Map<? extends K, ? extends V> map);
		添加参数 Map 双边队列到当前 Map 中，要求参数Map数据存储类型和调用方法 Map 存储数据类型一致或者其子
		类
删
	V remove(Object key);
		根据指定 Key 删除对应的键值对对象，返回值是对应的 Value 数据
改	
	put(K k, V v);
		如果当前 Map 双边队列中有对应 Key ，使用当前参数 value 替换原 Map 存储 value
查
	int size();
		Map双边队列中有效键值对个数
	boolean isEmpty();
		判断当前 Map 双边队列是否为空
	boolean containsKey(Object key);
		判断当前 Map 双边队列中，是否有指定 Key 存在
	boolean containsValue(Object value);
		判断当前 Map 双边队列中，是否有指定 Value 存在
    Collection<V> values();
    	返回整个 Map 双边队列所有 Value 对应的 Collection<V>
    Set<K> keySet();
		返回整个 Map 双边队列所有 Key 对应的 Set<K> 集合

3.3 重点方法 entrySet 方法

Map<K, V> ==> K, V ==> Entry对象
Set<Map.Entry<K, V>> entrySet();
	通过 Map 双边队列对象，获取当前 Map 双边队列的所有键值对(Entry类型) Set 集合。

Entry 是 Map 内部类	
	对应当前 Map 双边队列的 键值对对象(Key=Value) ==> Entry
	Entry 在整个 Map 双边队列中不可重复，可以通过 entrySet方法 获取得到整个 Map 双边队列的所有键值对对象 Entry 对应的 Set 集合
	class Entry<K, V> {
		K k;
		V v;
		
		public K getKey() {
			return k;
		}
		
		public V getValue() {
			return v;
		}
	}
例如:
	Map<String, Integer> map ==> {"宫保鸡丁":15, "老干妈":10};
	Set<Entry<String, Integer>> set = map.entrySet();
	set<Entry> ===> {
		Entry<String, Integer> => {K:"宫保鸡丁", V:15},
		Entry<String, Integer> => {K:"老干妈", V:10}
	}

/*
 * EntrySet 方法
 */
public class Demo2 {
	public static void main(String[] args) {
		HashMap<String, Integer> map1 = new HashMap<String, Integer>();

		map1.put("宫保鸡丁", 15);
		map1.put("羊肉烩面", 12);
		map1.put("班记油泼面", 15);
		map1.put("羊肉泡馍", 20);
		map1.put("黄焖鸡米饭", 16);
		map1.put("驴肉火烧", 8);
		
		Set<Entry<String, Integer>> entrySet = map1.entrySet();
		
		for (Entry<String, Integer> entry : entrySet) {
			System.out.print(entry.getKey() + ":");
			System.out.println(entry.getValue());
		}
	}
}

这篇关于LinkedList, Set 和 Map的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！