标签：Java springboot arraylist 元素 sites key println out 分布式
new Person(“Xiao”, “Hong”, 25),
new Person(“Bob”, “Smith”, 20)
);
boolean exist = list.contains(new Person(“Bob”, “Smith”, 20));
System.out.println(exist ? “测试成功!” : “测试失败!”);
}
}
class Person {
String firstName;
String lastName;
int age;
public Person(String firstName, String lastName, int age) {
this.firstName = firstName;
this.lastName = lastName;
this.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 age == person.age && Objects.equals(firstName, person.firstName) && Objects.equals(lastName, person.lastName);
}
@Override
public int hashCode() {
return Objects.hash(firstName, lastName, age);
}
}
在集合类中，List是最基础的一种集合：它是一种有序列表。
List的行为和数组几乎完全相同：List内部按照放入元素的先后顺序存放，每个元素都可以通过索引确定自己的位置，List的索引和数组一样，从0开始。
ArrayList
引用包：
import java.util.ArrayList;
创建方法：
ArrayList arrayList = new ArrayList();
示例代码：
import java.util.ArrayList;
import java.util.Comparator;
public class RunoobTest {
public static void main(String[] args) {
ArrayList sites = new ArrayList();
//添加元素
sites.add(“Google”);
sites.add(“Runoob”);
sites.add(“Taobao”);
sites.add(“Weibo”);
System.out.println(sites);
//访问元素
System.out.println(sites.get(1)); // 访问第二个元素
//修改元素
sites.set(2, “Wiki”); // 第一个参数为索引位置，第二个为要修改的值
System.out.println(sites);
//删除元素
sites.remove(3); // 删除第四个元素
System.out.println(sites);
//获取List长度
System.out.println(sites.size());
//循环输出元素
for (int i = 0; i < sites.size(); i++) {
System.out.println(sites.get(i));
}
for (String i : sites) {
System.out.println(i);
}
//List排序
sites.sort(Comparator.naturalOrder());
System.out.println("排序后: " + sites);
}
}
List转Array：
import java.util.List;
public class HelloWord {
public static void main(String[] args) {
List list = List.of(“apple”, “pear”, “banana”);
//第1种方法
Object[] array = list.toArray();
for (Object s : array) {
System.out.println(s);
}
//第2种方法，指定类型
String[] stringArray1 = list.toArray(new String[3]);
for (String n : stringArray1) {
System.out.println(n);
}
//第2种方法改进版
String[] stringArray2= list.toArray(new String[list.size()]);
for (String n : stringArray2) {
System.out.println(n);
}
//第3种方法
String[] stringArray3 = list.toArray(String[]::new);
for (String n : stringArray3) {
System.out.println(n);
}
}
}
Array变List
import java.util.List;
public class HelloWord {
public static void main(String[] args) {
//Array变为List就简单多了，通过List.of(T…)方法
List list = List.of(12, 34, 56);
System.out.println(list);
//我们调用List.of()，它返回的是一个只读List,如下代码会报错
list.add(999); // UnsupportedOperationException
}
}
常用API：
| 方法 | 描述 |
| — | — |
| add() | 将元素插入到指定位置的 arraylist 中 |
| addAll() | 添加集合中的所有元素到 arraylist 中 |
| clear() | 删除 arraylist 中的所有元素 |
| clone() | 复制一份 arraylist |
| contains() | 判断元素是否在 arraylist |
| get() | 通过索引值获取 arraylist 中的元素 |
| indexOf() | 返回 arraylist 中元素的索引值 |
| removeAll() | 删除存在于指定集合中的 arraylist 里的所有元素 |
| remove() | 删除 arraylist 里的单个元素 |
| size() | 返回 arraylist 里元素数量 |
| isEmpty() | 判断 arraylist 是否为空 |
| subList() | 截取部分 arraylist 的元素 |
| set() | 替换 arraylist 中指定索引的元素 |
| sort() | 对 arraylist 元素进行排序 |
| toArray() | 将 arraylist 转换为数组 |
| toString() | 将 arraylist 转换为字符串 |
| ensureCapacity() | 设置指定容量大小的 arraylist |
| lastIndexOf() | 返回指定元素在 arraylist 中最后一次出现的位置 |
| retainAll() | 保留 arraylist 中在指定集合中也存在的那些元素 |
| containsAll() | 查看 arraylist 是否包含指定集合中的所有元素 |
| trimToSize() | 将 arraylist 中的容量调整为数组中的元素个数 |
| removeRange() | 删除 arraylist 中指定索引之间存在的元素 |
| replaceAll() | 将给定的操作内容替换掉数组中每一个元素 |
| removeIf() | 删除所有满足特定条件的 arraylist 元素 |
| forEach() | 遍历 arraylist 中每一个元素并执行特定操作 |
小结：
-
ArrayList必须要连续空间，查询快、增删慢
-
频繁访问列表中的某一个元素时使用ArrayList。
-
只需要在列表末尾进行添加和删除元素操作时使用ArrayList。
LinkedList
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。链表可分为单向链表和双向链表。
一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。
一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。
以下情况使用 LinkedList :
-
你需要通过循环迭代来访问列表中的某些元素。
-
需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。
LinkedList 继承了 AbstractSequentialList 类。
LinkedList 实现了 Queue 接口，可作为队列使用。
LinkedList 实现了 List 接口，可进行列表的相关操作。
LinkedList 实现了 Deque 接口，可作为队列使用。
LinkedList 实现了 Cloneable 接口，可实现克隆。
LinkedList 实现了 java.io.Serializable 接口，即可支持序列化，能通过序列化去传输
引用包：import java.util.LinkedList;
创建方法：
LinkedList list = new LinkedList(); // 普通创建方法
或者
LinkedList list = new LinkedList(Collection<? extends E> c); // 使用集合创建链表
示例代码：
import java.util.LinkedList;
public class HelloWord {
public static void main(String[] args) {
LinkedList sites = new LinkedList();
sites.add(“Google”);
sites.add(“Runoob”);
sites.add(“Taobao”);
sites.add(“Weibo”);
// 使用 addFirst() 在头部添加元素
sites.addFirst(“Baidu”);
// 使用 addLast() 在尾部添加元素
sites.addLast(“Alibaba”);
for (int size = sites.size(), i = 0; i < size; i++) {
System.out.println(sites.get(i));
}
// 使用 removeFirst() 移除头部元素
sites.removeFirst();
// 使用 removeLast() 移除尾部元素
sites.removeLast();
for (String i : sites) {
System.out.println(i);
}
// 使用 getFirst() 获取头部元素
System.out.println(sites.getFirst());
// 使用 getLast() 获取尾部元素
System.out.println(sites.getLast());
}
}
常用方法：传送门
小结：
-
API
-
首尾添加
-
首尾获取
-
首尾移除
-
（双向）链表结构：
-
每一个元素都分为上一个，下一个，当前元素
-
每次增加元素，只新增一个对象，极大提高了集合元素变化的性能
-
对元素的访问性能不高，因为其本质是没有游标的，要访问某个元素都是从首尾开始迭代
如果我们只需要存储不重复的key，并不需要存储映射的value，那么就可以使用Set。
特点：
-
无序、无下标、元素不可重复
-
Set实现了Collection接口中定义的方法。
Set用于存储不重复(唯一)的元素集合，它主要提供以下几个方法：
-
将元素添加进Set：boolean
add(E e) -
将元素从Set删除：boolean
remove(Object e) -
判断是否包含元素：boolean
contains(Object e)
Set实际上相当于只存储key、不存储value的Map。我们经常用Set用于去除重复元素。
Set接口并不保证有序，而SortedSet接口则保证元素是有序的：
-
HashSet是无序的，因为它实现了Set接口，并没有实现SortedSet接口； -
TreeSet是有序的，因为它实现了SortedSet接口。
HashSet
没有真正意义上的set集合，他使用的是HashMap的key。
方法：
-
新建集合
HashSet<String> hashSet = new HashSet<String>(); -
添加元素
hashSet.add( ); -
删除元素
hashSet.remove( ); -
遍历操作
增强for for(type type : hashSet)
迭代器 Iterator<String> it = hashSet.iterator( );
- 判断
hashSet.contains( );，hashSet.isEmpty();
TreeSet
特点：
-
基于排列顺序实现元素不重复
-
实现
SortedSet接口，对集合元素自动排序 -
元素对象的类型必须实现
Comparable接口，指定排序规则 -
通过
CompareTo方法确定是否为重复元素 -
使用TreeSet和使用TreeMap的要求一样，添加的元素必须正确实现
Comparable接口，如果没有实现Comparable接口，那么创建TreeSet时必须传入一个Comparator对象。
方法：
-
创建集合 TreeSet treeSet = new TreeSet<>()
-
添加元素 treeSet.add();
-
删除元素 treeSet.remove();
-
遍历 1. 增强for 2. 迭代器
-
判断 treeSet.contains();
使用：要求：元素必须实现Comparable接口，compareTo()方法的返回值为0，认为是重复元素
// 重写compareTo
@override
public int compareTo(Person o){
int n1 = this.getName().compareTo(o.getName()); //后面的compareTo方法为String带的方法
int n2 = this.getAge()-o.getAge();
return n1 == 0 ? n2 : n1;
}
或者 传入一个Comparator对象
// 重写compare 创建集合时就制定比较规则
TreeSet treeSet = new TreeSet<>(new Comparator){
@override
public int compare(Person o1,Person o2){
int n1 = o1.getName().compareTo(o2.getName());
int n2 = o1.getAge()-o2.getAge();
return n1 == 0 ? n2 : n1;
}
}
特点：存储一对数据（Key-Value）【键值对】，无序、无下标、键不可重复，值可重复
HashMap
方法：
-
V
put(K key,V value)：将对象存入到集合中，关联键值。key重复则覆盖原值 -
Object
get(Object key)：根据键获取对应的值 -
keySet()：返回所有key -
values()：返回包含所有值的Collection集合 -
Set<Map.Entry<K,V>>
entrySet()：键值匹配的Set集合 -
boolean
containsKey(K key)：判断key是否存在
示例代码：
import java.util.HashMap;
import java.util.Map;
public class HelloWord {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();//需要指定key和value的类型
// 1. 添加元素
map.put(“cn”, “中国”);
map.put(“uk”, “英国”);
map.put(“cn”, “zhongguo”); // 会替换第一个
// 2.
《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》
【docs.qq.com/doc/DSmxTbFJ1cmN1R2dB】 完整内容开源分享
删除
map.remove(“uk”); //用key删除
// 3. 遍历
// 3.1 使用KeySet()
for(String key : map.keySet()){
System.out.println(key + “—” + map.get(key));
}
// 3.2 使用entrySet()
for(Map.Entry<String, String> entry : map.entrySet()){
System.out.println(entry.getKey() + “—” + entry.getValue());
}
//判断
System.out.println(map.containsKey(“cn”));
System.out.println(map.containsValue(“泰国”));
}
}
备注：Java这块的Map和C#中的Dictionary不太一样，如果key已经存在了再添加同名的key不会报错。
重复放入key-value并不会有任何问题，但是一个key只能关联一个value。在上面的代码中，一开始我们把key对象"apple"映射到Integer对象123，然后再次调用put()方法把"apple"映射到789，这时，原来关联的value对象123就被“冲掉”了。实际上，put()方法的签名是V put(K key, V value)，如果放入的key已经存在，put()方法会返回被删除的旧的value，否则，返回null。
要正确使用HashMap，作为key的类必须正确覆写equals()和hashCode()方法；
一个类如果覆写了equals()，就必须覆写hashCode()，并且覆写规则是：
-
equals()返回true，则hashCode()返回值必须相等；
-
如果equals()返回false，则hashCode()返回值尽量不要相等。
-
实现hashCode()方法可以通过Objects.hashCode()辅助方法实现。
EnumMap
如果作为key的对象是enum类型，那么，还可以使用Java集合库提供的一种EnumMap，它在内部以一个非常紧凑的数组存储value，并且根据enum类型的key直接定位到内部数组的索引，并不需要计算hashCode()，不但效率最高，而且没有额外的空间浪费。
示例代码：
import java.time.DayOfWeek;
import java.util.EnumMap;
import java.util.Map;
public class AAA {
public static void main(String[] args) {
Map<DayOfWeek, String> map = new EnumMap<>(DayOfWeek.class);
map.put(DayOfWeek.MONDAY, “星期一”);
map.put(DayOfWeek.TUESDAY, “星期二”);
map.put(DayOfWeek.WEDNESDAY, “星期三”);
map.put(DayOfWeek.THURSDAY, “星期四”);
map.put(DayOfWeek.FRIDAY, “星期五”);
map.put(DayOfWeek.SATURDAY, “星期六”);
map.put(DayOfWeek.SUNDAY, “星期日”);
System.out.println(map);
System.out.println(map.get(DayOfWeek.MONDAY));
}
}
小结：
-
如果
Map的key是enum类型，推荐使用EnumMap，既保证速度，也不浪费空间。 -
使用
EnumMap的时候，根据面向抽象编程的原则，应持有Map接口。
TreeMap
SortedMap在遍历时严格按照Key的顺序遍历，最常用的实现类是TreeMap；
-
作为SortedMap的Key必须实现
Comparable接口，或者传入Comparator； -
要严格按照
compare()规范实现比较逻辑，否则，TreeMap将不能正常工作。
示例代码：
import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;
public class AAA {
public static void main(String[] args) {
Map<Student, Integer> map = new TreeMap<>(new Comparator() {
public int compare(Student p1, Student p2) {
if (p1.score == p2.score) {
return 0;
}
return p1.score > p2.score ? -1 : 1;
}
});
标签：Java,springboot,arraylist,元素,sites,key,println,out,分布式 来源： https://blog.csdn.net/m0_64867152/article/details/122104111
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。