容器：LinkedList实现类，HashSet实现类，Map接口，HashMap实现类
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了容器：LinkedList实现类，HashSet实现类，Map接口，HashMap实现类，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8258字，纯文字阅读大概需要12分钟。
内容图文
容器
1. LinkedList实现类
LinkedList实现类的数据是有序可重复的，底层结构式双向链表。特点是增删效率较高，根据索引查询、遍历、修改效率低。
应用场景：在大量做增删，少量做查询的情况下适合使用LinkedList
LinkedList中新增了一些操作链表头尾的方法
常用方法：
import java.util.LinkedList;
public class LinkedListDemo01 {
public static void main(String[] args) {
LinkedList<String> link = new LinkedList<>();
link.add("haha");
link.add("hehe");
link.add("heihei");
link.add("xixi");
System.out.println(link);
//add(int index, E element) 将指定元素插入此列表中的指定位置
link.add(2,"lala");
System.out.println(link);
//addFirst(E e) 在此列表的开头插入指定的元素
//addLast(E e) 将指定的元素追加到此列表的末尾
link.addFirst("first");
link.addLast("last");
System.out.println(link);
//element() 检索但不删除此列表的头部（第一个元素）
System.out.println(link.element());
//get(int index) 返回此列表中指定位置的元素
System.out.println(link.get(3));
//poll() 检索并删除此列表的头部（第一个元素）
link.poll();
System.out.println(link);
//pollFirst() 检索并删除此列表的第一个元素，如果此列表为空，则返回 null
//pollLast() 检索并删除此列表的最后一个元素，如果此列表为空，则返回 null
link.pollFirst();
link.pollLast();
System.out.println(link);
//set(int index, E element) 用指定的元素替换此列表中指定位置的元素
link.set(2,"tihuan");
System.out.println(link);
}
}
2. 添加比较器
使用Arrays工具类给存储自定义类型数据的数组进行排序，使用Lambda表达式的方式定义外部比较器。代码如下：
//自定义User类，将数据存于User类型的数组，使用Arrays.sort()方法对这个数组做排序，要求按照用户编号降序排序/按照工资做升序排序
import java.util.Arrays;
import java.util.Comparator;
public class Demo02 {
public static void main(String[] args) {
User u1 = new User(101,"张三",3000);
User u2 = new User(103,"李四",2000);
User u3 = new User(102,"王五",4000);
User[] arr = {u1,u2,u3};
//定义内部比较器类
Comparator<User> com = new Comparator<User>() {
@Override
public int compare(User o1, User o2) {
return o2.getUid()-o1.getUid();
}
};
//转为Lambda表达式
com = (User o1, User o2)->{
return o2.getUid()-o1.getUid();
};
//使用Lambda表达式排序
Arrays.sort(arr,(User o1, User o2)->{
return o2.getUid()-o1.getUid();
});
//使用Lambda表达式排序
Arrays.sort(arr,(User o1, User o2)->{
return o1.getSal()-o2.getSal();
});
System.out.println(Arrays.toString(arr));
}
}
class User{
private int uid;
private String name;
private int sal;
public User() {
}
public User(int uid, String name, int sal) {
this.uid = uid;
this.name = name;
this.sal = sal;
}
public int getUid() {
return uid;
}
public void setUid(int uid) {
this.uid = uid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSal() {
return sal;
}
public void setSal(int sal) {
this.sal = sal;
}
@Override
public String toString() {
return "User{" +
"uid=" + uid +
", name='" + name + '\'' +
", sal=" + sal +
'}';
}
}
3. HashSet实现类
HashSet实现类的数据是无序，不可重复的。底层结构是哈希表（数组+链表+红黑树）。特点是做查询，增删效率较高。
HashSet与TreeSet之间进行选择时，如果想要数据存储的时候默认升序或者降序使用TreeSet，否则建议选择HashSet。
通过HashSet存储自定义引用数据类型的数据时如果要去重，需要在自定义引用类型中重写hashcode与equals方法，根据内容进行比较。
HashSet常用方法和遍历方式：
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class HashSetDemo03 {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("张三");
set.add("李四");
set.add("王五");
set.add("赵六");
set.add("哈哈");
System.out.println(set);
set.remove("哈哈");
System.out.println(set);
//遍历方式
//增强for
for (String s:set){
System.out.println(s);
}
//iterator迭代器
Iterator<String> it = set.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
}
使用HashSet实现去重问题：
import java.util.HashSet;
import java.util.Objects;
public class HashSetDemo04 {
public static void main(String[] args) {
Person p1 = new Person(101,"张三",20);
Person p2 = new Person(102,"李四",18);
Person p3 = new Person(103,"王五",21);
Person p4 = new Person(101,"张三",20);
HashSet<Person> hash = new HashSet<>();
hash.add(p1);
hash.add(p2);
hash.add(p3);
hash.add(p4);
System.out.println(hash);//[Person{id=102, name='李四', age=18}, Person{id=101, name='张三', age=20}, Person{id=103, name='王五', age=21}]
}
}
class Person{
private int id;
private String name;
private int age;
public Person() {
}
public Person(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 "Person{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return id == person.id &&
age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name, age);
}
}
4. Map接口
Map<K,V>接口存储键值对数据，每一个key对应一个value，key是唯一的无序的，value是无序可重复的。
常用方法和遍历方式：
import java.util.*;
public class MapDemo {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<>();
//put(K key, V value) 将指定的值与此映射中的指定键相关联
map.put(101,"张三");
map.put(104,"李四");
map.put(102,"王五");
map.put(103,"赵六");
System.out.println(map);
//get(Object key) 返回指定键映射到的值，如果此映射不包含键的映射
System.out.println(map.get(103));
//remove(Object key) 如果存在，则从该映射中移除键的映射
map.remove(103);
System.out.println(map);
//三种遍历方式
//1. Set<K> keySet() 返回此映射中包含的键的Set视图 可以遍历得到键值对
Set<Integer> set1 = map.keySet();
for (int a:set1){
System.out.println(a+"-->"+map.get(a));
}
//2. Collection<V> values() 返回此映射中包含的值的Collection视图 只能遍历得到value
Collection<String> col = map.values();
Iterator<String> it = col.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
//3. Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射的Set视图 可以遍历得到键值对
Set<Map.Entry<Integer,String>> set2 = map.entrySet();
for (Map.Entry<Integer,String> entrys:set2){
System.out.println(entrys.getKey()+"-->"+entrys.getValue());
}
}
}
5. HashMap实现类
与HashSet相同，HashMap的底层结构也为红黑树。HashMap存储的key如果为自定义引用数据类型，为了去重，key类型中要求重写hashcode与equals方法。
代码：
import java.util.HashMap;
import java.util.Objects;
public class HashMapDemo {
public static void main(String[] args) {
Student s1 = new Student(104,"张三",24);
Student s2 = new Student(102,"李四",25);
Student s3 = new Student(103,"王五",22);
Student s4 = new Student(101,"赵六",26);
//将自定义类作为key
HashMap<Student, String> hash = new HashMap<>();
hash.put(s1,"班长");
hash.put(s2,"副班长");
hash.put(s3,"组长");
hash.put(s4,"副组长");
System.out.println(hash);
}
}
//自定义类
class Studet{
private int id;
private String name;
private int age;
public Studet() {
}
public Studet(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 "Studet{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
//重写equals方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Studet studet = (Studet) o;
return id == studet.id &&
age == studet.age &&
Objects.equals(name, studet.name);
}
//重写hashCode方法
@Override
public int hashCode() {
return Objects.hash(id, name, age);
}
}
6. Hash表存储原理
Hash表中Node节点数组存储节点数据，节点包含key，value，hash，next。Hash表的存储原理：
- put(key,value)存储键值对类型的数据，根据key计算hash值，确定索引的位置
- 找到Node数组中的指定索引位置，判断当前位置中是否存在数据，没有则直接构建一个Node节点对象 new Node(key,value,hash,null)，放入数组。如果已经存在值，就比较每一个Node的key与我当前要存储的key是否相等，相等value值覆盖，不相等则继续判断，最后数据放入链表的最后
Hash表的初识容量为16，加载因子为0.75（扩容的临界点），最大容量为2^30，扩容后的新数组容量为原容量的2倍。
内容总结
以上是互联网集市为您收集整理的容器：LinkedList实现类，HashSet实现类，Map接口，HashMap实现类全部内容，希望文章能够帮你解决容器：LinkedList实现类，HashSet实现类，Map接口，HashMap实现类所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】