Collections是一个操作Set、Lit和Map等集合的工具类
Collections中提供了一系列静态的方法对集合元素进行排序、査询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
String 常用方法
字符串操作
-
int length()：返回字符串的长度：return value.length -
char charAt(int index)： 返回某索引处的字符return value[index] -
boolean isEmpty()：判断是否是空字符串：return value.length == 0 -
String toLowerCase()：使用默认语言环境，将 String 中的所字符转换为小写 -
String toUpperCase()：使用默认语言环境，将 String 中的所字符转换为大写 -
String trim()：返回字符串的副本，忽略前导空白和尾部空白 -
boolean equals(Object obj)：比较字符串的内容是否相同 -
boolean equalsIgnoreCase(String anotherString)：与equals()方法类似，忽略大小写 -
String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用+ -
int compareTo(String anotherString)：比较两个字符串的大小 -
String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex 开始截取到最后的一个子字符串。 -
String substring(int beginIndex, int endIndex)：返回一个新字符串，它是此字符串从 beginIndex 开始截取到 endIndex (不包含)的一个子字符串。
Java之集合
集合与数组
1. 集合与数组存储数据概述：
集合，数组都是对多个数据进行存储操作的结构 ，简称Java容器 。 集合和数组都是对内存层面的存储不是持久化的存储
2. 数组存储的特点：
数组创建的时候长度就已经确定了。数组定义好了以后类型也就确定了 ，我们只能操作指定类型的数据了
3. 数组存储的弊端：
数组一旦创建就无法修改长度了
数组提供的方法非常有限，对于删除，添加，插入数据等操作非常不方便 ，同时效率不高
获取数组中实际元素的个数的需求，数组没有现成的方法可用
数组存储数据的特点 ： 有序 ，可重复。对于无序不可重复的需求，不能满足
4. 集合存储的优点：
解决了数组存储数据的方面弊端
5. 集合的分类
Java集合可以分为Collection和Map两种体系
|---Collection接口单列集合
|---List 元素有序 可重复
|---ArrayList 作为List接口的主要实现类，线程不安全，效率高，底层采用Object[] elementData数组存储
|---LinkedList 对于频繁插入删除操作使用此类比ArrayList效率高底层采用双向链表存储
|---Vector 作为List的古老实现类，线程安全，效率低 底层采用Object[]数组存储
|---set 元素无序 不可重复
|---HashSet 作为Set接口的主要实现类线程不安全 可以存null值
|---LinkdeHashSet：作为HashSet的子类，遍历其内部数据时，可以按照添加顺序遍历，对于频繁的遍历操作，LinkedHashSet效率高于HashSet
|---TreeSet 可以按照添加对象的指定属性，进行排序
|---Map集合接口 双列数组存储Key_value对的数据
|---HashMap 作为Map接口的主要实现类线程不安全 效率高 存储null的key和value
|--LinkedHashMap 保证在遍历map元素的时可以按照添加的顺序实现遍历
|---TreeMap 保证照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序和定制排序底层使用红黑树
|---Hashtable 作为古老的实现类 效率低 不能存储null的key和value
|---properties 常用来处理配置文件，key value都是String类型
Collection接口
Collertion接口是List和set接口的父接口，该接口里定义的方法即可用于操作Set集合也可用于List集合
JDK不提供此接口的任何直接实现，而是提供更具体的子接口实现 在JDK5.0之前，Java集合会丢失容器中所有对象的数据类型，吧所有对象都当初Object类型处理；从JDK5.0增加了泛型以后，Java集合就可以记住容器对象的数据类型。
2. Collection接口常用方法：
- 添加
- add(object obj)
- addAll(Collection coll)
- 获取有效元素个数
- int size()
- 是否为集合
- boolean isEmpty() 4.是否包含元素
-
- boolean contains(Object obj) 是通过元素的equals方法来判断是否是同一个元素
-
- boolean containsAll（Collection c） 也是调用元素的equals方法来比较的，用两个两个元素逐一比较
5.清空集合
- void clear() 6.删除
- boolean remove(Object obj)通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素
- boolean removeAll(Collection coll) 删除当前集合的差集 7.取两个集合的合集
- boolean retainAll(Colleation coll)把交集的结果存在当前集合中 8.集合是否相等
- boolean equals(Object obj)
- 转换成对象数组
- Object[] toArray() 10.遍历
- 迭代器遍历
@Test
public void test1() {
Collection collection = new ArrayList();
//1.add(Object e):将元素添加到集合中
collection.add("ZZ");
collection.add("AA");
collection.add("BB");
collection.add(123);
collection.add(new Date());
//2.size():获取添加元素的个数
System.out.println(collection.size());//5
//3.addAll(Collection coll1):将coll1集合中的元素添加到当前集合中
Collection collection1 = new ArrayList();
collection1.add("CC");
collection1.add(213);
collection.addAll(collection1);
System.out.println(collection.size());//9
//调用collection1中的toString()方法输出
System.out.println(collection);//[ZZ, AA, BB, 123, Tue Apr 28 09:22:34 CST 2020, 213, 213]
//4.clear():清空集合元素
collection1.clear();
System.out.println(collection1.size());//0
System.out.println(collection1);//[]
//5.isEmpty():判断当前集合是否为空
System.out.println(collection1.isEmpty());//true
}
@Test
public void test2() {
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Tom", 23));
coll.add(new Person("Jarry", 34));
coll.add(false);
//6.contains(Object obj):判断当前集合中是否包含obj
//判断时需要调用obj对象所在类的equals()方法
System.out.println(coll.contains(123));//true
System.out.println(coll.contains(new Person("Tom", 23)));//true
System.out.println(coll.contains(new Person("Jarry", 23)));//false
//7.containsAll(Collection coll1):判断形参coll1中的元素是否都存在当前集合中
Collection coll1 = Arrays.asList(123, 4566);
System.out.println(coll.containsAll(coll1));//flase
//8.remove(Object obj):从当前集合中移除obj元素
coll.remove(123);
System.out.println(coll);//[456, Person{name='Tom', age=23}, Person{name='Jarry', age=34}, false]
//9.removeAll(Collection coll1):差集：从当前集合中和coll1中所有的元素
Collection coll2 = Arrays.asList(123, 456, false);
coll.removeAll(coll2);
System.out.println(coll);//[Person{name='Tom', age=23}, Person{name='Jarry', age=34}]
}
@Test
public void test3() {
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Tom", 23));
coll.add(new Person("Jarry", 34));
coll.add(false);
//10.retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合
Collection coll1 = Arrays.asList(123, 345, 456);
boolean b = coll.retainAll(coll1);
System.out.println(b);//true
System.out.println(coll);//[123, 456]
//11.equals(Object obj):返回true需要当前集合和形参集合的元素相同
Collection coll2 = new ArrayList();
coll2.add(123);
coll2.add(456);
System.out.println(coll.equals(coll2));//true
//12.hashCode():返回当前对象的哈希值
System.out.println(coll.hashCode());//5230
//13.集合--->数组:toArray()
Object[] array = coll.toArray();
for (Object obj : array) {
System.out.println(obj);
}
//14.数组--->集合:调用Arrays类的静态方法asList()
List<int[]> ints = Arrays.asList(new int[]{123, 345});
System.out.println(ints.size());//1
List<String> strings = Arrays.asList("AA", "BB", "CC");
System.out.println(strings);//[AA, BB, CC]
//15.iteratoriterator():返回Iterator接口的实例，用于遍历集合元素。
}
3. Collection集合与数组间的转换
//集合 --->数组：toArray()
Object[] arr = coll.toArray();
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}
//拓展：数组 --->集合:调用Arrays类的静态方法asList(T ... t)
List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
System.out.println(list);
List arr1 = Arrays.asList(new int[]{123, 456});
System.out.println(arr1.size());//1
List arr2 = Arrays.asList(new Integer[]{123, 456});
System.out.println(arr2.size());//2
使用 Collection 集合存储对象，要求对象所属的类满足：
向 Collection 接口的实现类的对象中添加数据 obj 时，要求 obj 所在类要重写
equals()。
4. 单列集合框架结构（图示）
Iterator接口与foreach循环
1. 遍历Collection的两种方式：
使用迭代器Itertor遍历
foreach循环遍历
java.utils包下定义的迭代器接口：Iterator
说明：
Itertor对象称为迭代器，主要用于遍历Collection集合，GOF给迭代器模型的定义为：提供一种方法访问一种容器对象的各个元素，而又不需要暴露该对象的内部细节。迭代器模式就是为容器而生
作用：
遍历集合Collectiton元素
如何获取实例：
集合对象.itertor()返回一个迭代器实例
遍历的代码实现：
Iterator iterator = coll.iterator();
//hasNext():判断是否还下一个元素
while(iterator.hasNext()){
//next():①指针下移 ②将下移以后集合位置上的元素返回
System.out.println(iterator.next());
}
图示说明：
2.6 iterator中remove()方法的使用：
测试Itertor中的remove（）
如果还未调用next或在上一次调用了next方法之后调用了remove方法，再调用remove都会报IllegalstateException
内部定义了remove，可以在遍历的时候，删除集合中的元素，此方法不同于集合直接调用remove
代码示例：
@Test
public void test3(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add("Tom"
);
coll.add(false);
//删除集合中"Tom"
Iterator iterator = coll.iterator();
while (iterator.hasNext()){
// iterator.remove();
Object obj = iterator.next();
if("Tom".equals(obj)){
iterator.remove();
// iterator.remove();
}
}
//将指针重新放到头部，遍历集合
iterator = coll.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
foreach 遍历集合举例：
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new Person("Jerry",20));
coll.add(new String("Tom"));
coll.add(false);
//for(集合元素的类型 局部变量 : 集合对象)
for(Object obj : coll){
System.out.println(obj);
}
}
foreach 遍历数组举例：
@Test
public void test2(){
int[] arr = new int[]{1,2,3,4,5,6};
//for(数组元素的类型 局部变量 : 数组对象)
for(int i : arr){
System.out.println(i);
}
}
Collection子接口：List接口
1. 存储的数据特点：
存储序有序的、可重复的数据。
2.常用方法
List除了从collection集合继承的方法外，list集合里添加了一些根据索引来操作集合元素的方法
- void add(int index , Object ele) 在指定位置插入元素
- boolean addAll(int index , Collection coll) 从指定位置插入coll的所有元素
- Object get（int index）获取指定位置的元素
- int IndexOf(Object obj) 返回obj在当前集合中第一次出现的位置
- int lastIndex(Object obj) 返回obj在当前集合中最后一次出现的位置
- Object set(int Index , Object ele) 设置指定index位置的元素为ele
- Object remove(int index)移除指定位置的元素，并返回此元素
- List subList(int from , int to) 返回从from到to的子集合 总结：
- 插入 add(int index , Object obj)
- 删 remove (int index)
- 改 set (int Index , Object obj)
- 查 get (int Index)
- 增 add(Object obj)
- 长度 size（）
- 遍历 ： 1.迭代器遍历 2.foreach循环遍历 3.普通循环
代码示例：
@Test
public void test2(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add(new Person("Tom",12));
list.add(456);
//int indexOf(Object obj):返回obj在集合中首次出现的位置。如果不存在，返回-1.
int index = list.indexOf(4567);
System.out.println(index);
//int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。如果不存在，返回-1.
System.out.println(list.lastIndexOf(456));
//Object remove(int index):移除指定index位置的元素，并返回此元素
Object obj = list.remove(0);
System.out.println(obj);
System.out.println(list);
//Object set(int index, Object ele):设置指定index位置的元素为ele
list.set(1,"CC");
System.out.println(list);
//List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
List subList = list.subList(2, 4);
System.out.println(subList);
System.out.println(list);
}
@Test
public void test1(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add(new Person("Tom",12));
list.add(456);
System.out.println(list);
//void add(int index, Object ele):在index位置插入ele元素
list.add(1,"BB");
System.out.println(list);
//boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
List list1 = Arrays.asList(1, 2, 3);
list.addAll(list1);
// list.add(list1);
System.out.println(list.size());//9
//Object get(int index):获取指定index位置的元素
System.out.println(list.get(0));
}
Map集合
双列集合 存储key-value对的数据
- HashMap 作为map的主要实现类 线程不安全 效率高 可以存储null 底层是 数组+链表+红黑树实现
- LinkedHashMap 保证在遍历map元素时，可以按照添加的顺序遍历 原因在原有的hashmap底层基础上添加了一对指针。指向前一个和后一个元素，对于频繁的遍历操作此类高于HashMap
- Hashtable 作为map的古老实现类 线程安全 效率低 不能存储null
- Properties 常用来处理配置文件 ，key-verlue都是String类型
- TreeMap 按照添加的key-value 进行排序实现排序遍历 底层属于红黑树
Map key-value 理解
1.key不能重复 value能重复
2.所有key用set存储 value用collection存储
3.一个key-value组成了一个entry对象
4.entry是无序的不可重复的，使用set存储所有的entry
HashMap的底层原理
HashMap map = new HashMap();
在实例化以后底层创建了长度为16的一维数组entry[] table
map.put（key1 ，value1）；
首先计算key1所在的hashCode（）计算kay1哈希值 ，此哈希值经过某种算法以后得到entry数组中的存放位置 如果此位置的数据为空则添加成功
如果不为空（意味着此位置上存在一个或多个数据（以链表形式存在）），比较key1和已经存在的一个或多个数据的哈希值：
如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key-value添加成功
如果key1的哈希值和某个已经存在的数据的哈希值相同，继续比较，调用key1所在类的equals方法，
比较：
如果equals返回false：此时key1添加成功
如果equals放回true ：此时value替换valuew
jdk8 相较于jdk7在底层实现方面的不同
1.new HashMap 底层没有创建长度为16的数组
2.jdk8 底层的数组是Node[] 不是entry
3.首次调用put的时候创建长度为16的数组
4.jdk7的底层结构只有数组加链表 jdk8中底层结构数组加链表加红黑树 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8且当前数组的长度>64 此时此索引位置上的所有数据改为使用红黑树存储
LinkedHashMap
-
LinkedHashMap底层使用的结构与HashMap相同，因为LinkedHashMap继承于HashMap.
-
区别就在于：LinkedHashMap内部提供了Entry，替换HashMap中的Node.
-
与Linkedhash Set类似，LinkedHashMap可以维护Map的迭代顺序：迭代顺序与Key-value对的插入顺序一致
总结 ： 常用方法
添加 put（object key）
修改 put（object key）
删除 remove（object key）
查询 get（object key ）
长度 size
遍历 entrySet() value（） keySet（）
```public class Dome01 {
Map map = new LinkedHashMap<>();
/**
添加 删除 修改操作
put（object key , object value）添加单个 putAll（） 添加多个
remove（object key） 删除 移除指定 key value 返回value
clear() 清空当前map集合
*/
@Test
public void dome(){
//添加
map.put("11" , "11");
map.put("22" , "账号1");
map.put("33" , "账号1");
map.put(11 , 11);
//修改（替换原有的key）
map.put("11" , "账号1");
System.out.println(map);
//添加多个
Map m = new HashMap<>();
m.put(99,99);
m.put("99","字符99");
map.putAll(m);
System.out.println(map);
//删除
map.remove(11);
System.out.println(map);
//清空集合
map.clear();
System.out.println(map);
}
/**
元素查询操作
get（object key ） 获取指定key对应的value
containsKey（object key) 查询是否包含指定key
containsValue （object value） 查询是否包含指定value
size（） 返回集合中key-value的个数
isempty（） 判断是否为空
equals（object obj） 判读当前map和参数对象obj是否相等
*/
@Test
public void dome1(){
map.put("11" , "11");
map.put("22" , "账号1");
map.put("33" , "账号1");
map.put(11 , 11);
//get
System.out.println(map.get(11));
//containsKey
System.out.println(map.containsKey("22"));
//containsValue
System.out.println(map.containsValue("11"));
}
/**
元视图的操作方法
keySet（） 返回所以key构成的set集合
value（） 返回所有的value
entrySet() 返回所有的key-value
*/
@Test
public void dome2(){
map.put("11" , "11");
map.put("22" , "账号1");
map.put("33" , "账号1");
map.put(11 , 11);
Set set = map.keySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//遍历所有的value
Collection values = map.values();
for (Object obj : values){
System.out.println(obj);
}
//遍历所以的key-value
//entrySet
//方式一
Set set1 = map.entrySet();
Iterator iterator1 = set1.iterator();
while (iterator1.hasNext()){
System.out.println(iterator1.next());
}
//方式二
Set set2 = map.keySet();
Iterator iterator2 = set2.iterator();
while (iterator2.hasNext()){
Object next = iterator2.next();
Object o = map.get(next);
System.out.println(next +"===" + o);
}
}
}
TreeMap
-
TreeMap存储Key-Value对时，需要根据key-value对进行排序。TreeMap可以保证所有的 Key-Value对处于有序状态。
-
TreeSet底层使用红黑树结构存储数据
-
TreeMap的Key的排序:
- 自然排序： TreeMap的所有的Key必须实现Comparable接口，而且所有的Key应该是同一个类的对象，否则将会抛出ClasssCastEXception()
- 定制排序：创建 TreeMap时，传入一个 Comparator对象，该对象负责对TreeMap中的所有key进行排序。此时不需要Map的Key实现Comparable接口
-
TreeMap判断两个key相等的标准：两个key通过 compareTo()方法或者compare()方法返回0.
Properties
- 用来处理配置文件的 key_value都是String类型
- 存取数据时，建议使用 `setProperty(String key,String value)` 方法和 `getProperty(String key)` 方法
Collections工具类
Collections中提供了一系列静态的方法对集合元素进行排序、査询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
1.排序操作
-
reverse(List)：反转 List 中元素的顺序 -
shuffle(List)：对 List 集合元素进行随机排序 -
sort(List)：根据元素的自然顺序对指定 List 集合元素升序排序 -
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序 -
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换 -
Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素 -
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素 -
Object min(Collection) -
Object min(Collection，Comparator) -
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数 -
void copy(List dest,List src)：将src中的内容复制到dest中 -
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所旧值
作者：RealPluto
链接：juejin.cn/post/696133…
来源：稀土掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
@Test
public void CollectionsDome(){
List list = new ArrayList();
list.add(11);
list.add(914);
list.add(451);
list.add(381);
list.add(51);
list.add(121314);
System.out.println(list);
// 反转
// Collections.reverse(list);
// 随机排序
// Collections.shuffle(list);
// 排序
// Collections.sort(list);
// 交换位置
// Collections.swap(list ,2 , 5);
// 返回最大元素
// Comparable max = Collections.max(list);
// System.out.println(max);
// 返回最小元素
// Comparable min = Collections.min(list);
// System.out.println(min);
// 返回集合中指定元素出现的次数
// int frequency = Collections.frequency(list, 11);
// System.out.println(frequency);
// 将一个集合的内容复制到另一个集合中
// List list1 = Arrays.asList(new Object[list.size()]);
// Collections.copy(list1,list);
// System.out.println(list1);
System.out.println(list);
}
}
