欢迎大家来到IT世界,在知识的湖畔探索吧!
一、Java集合的整体介绍
- Java 集合类可以用于存储数量不等的多个对象,还可用于保存具有映射关系的
关联数组。很好地应对了数组array的弊端。 - 使用的场景:
①Android客户端 ②服务器 ③端数据库
二、Collection接口
Collection接口:单列数据,定义了存取一组对象的方法的集合。
Collection 接口是 List、Set 和 Queue 接口的父接口,该接口里定义的方法 既可用于操作 Set 集合,也可用于操作 List 和 Queue 集合。JDK不提供此接口的任何直接实现,而是提供更具体的子接口(如:Set和List) 实现。Java 集合会丢失容器中所有对象的数据类型,把所有对象都当成 Object 类型处理; 但可以增加泛型,来实现Java 集合记住容器中对象的数据类型。
1、Collection接口方法
方法 |
方法说明 |
add(Object obj) |
添加元素 |
addAll(Collection coll) |
添加整个集合 |
int size() |
获取有效元素的个数 |
void clear() |
清空集合 |
boolean isEmpty() |
是否是空集合 |
boolean contains(Object obj) |
是否包含某个元素,是通过元素的equals方法来判断是否是同一个对象 |
boolean containsAll(Collection c) |
是否包含某个元素, 也是调用元素的equals方法来拿两个集合的元素挨个比较。 |
boolean remove(Object obj) |
通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素 |
boolean removeAll(Collection coll) |
删除集合中所有的此元素(取当前集合的词集) |
boolean retainAll(Collection c) |
取两个集合中的交集(把交集的结果存在当前集合中,不影响c) |
boolean equals(Object obj) |
判断集合是否相等 |
Object[] toArray() |
转成对象数组 |
hashCode() |
获取集合对象的哈希值 |
iterator() |
返回迭代器对象,用于集合遍历 |
package Collection接口;
import org.junit.Test;
import java.util.*;
public class CollectionTest {
@Test
public void test1(){
Collection coll= new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Jerry"));
Person p = new Person("Tom",15);
coll.add(p);
coll.add(true);
// 1.contains(object obj):判断当前集合中是否包含obj
// 在判断时会调用obj对象所在类的equals()
boolean contains = coll.contains(123);
System.out.println(contains); //true
System.out.println(coll.contains(new String("Jerry"))); //true
System.out.println(coll.contains(new Person("Tom", 15))); //false ---> true 进行重写equals方法
System.out.println(coll.contains(p)); //true
//2.containsAll(Collection coll1) : 判断形参coll1中的所有元素是否都存在于当前集合中
Collection coll1 = Arrays.asList(123,456);
System.out.println(coll.containsAll(coll1)); //true
}
@Test
public void test2(){
//3.remove(Object obj):
Collection coll= new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Jerry"));
Person p = new Person("Tom",15);
coll.add(p);
coll.add(false);
coll.remove(1234);
System.out.println(coll); //[123, 456, Jerry, Collection接口.For_Iterator.Person{name='Tom', age=15}, false]
coll.remove(new Person("Tom",15));
System.out.println(coll); //[123, 456, Jerry, false]
//4.removeAll(Collection coll1):从当前的集合中移除从从coll1中的所有元素
Collection coll1 = Arrays.asList(123,456);
coll.removeAll(coll1);
System.out.println(coll); //[Jerry, false]
}
@Test
public void test3(){
Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Jerry"));
Person p = new Person("Tom",15);
coll.add(p);
coll.add(false);
/* // 5.retainAll(Collection coll): 交集 :获取当前集合和从coll1集合的交集,并返回给当前集合 Collection coll1 = Arrays.asList(123,456,789); coll.retainAll(coll1); System.out.println(coll); //[123, 456]*/
//6.equals(Object obj) :
Collection coll1 = new ArrayList(); //Array是有序的,如果add的顺序不同,依然输出false
coll1.add(123);
coll1.add(456);
coll1.add(new String("Jerry"));
coll1.add(new Person("Tom",15));
coll1.add(false);
System.out.println(coll.equals(coll1)); //true
}
@Test
public void test4(){
Collection coll= new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Jerry"));
Person p = new Person("Tom",15);
coll.add(p);
coll.add(false);
// 7.hasCode() : 返回当前对象的哈希值
System.out.println(hashCode());
//8.集合 --> 数组 :toArray()
Object[] arr = coll.toArray();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
//拓展 :数组 --> 集合 【注意asList要用包装类,否则将视为一个元素】
List<String> strings = Arrays.asList(new String[]{ "AA", "BB", "CC", "DD"});
System.out.println(strings); //[AA, BB, CC, DD]
List ints = Arrays.asList(new int[]{ 12, 34, 56});
System.out.println(ints.size()); // 1
List ints1 = Arrays.asList(new Integer[]{ 12, 34, 56});
System.out.println(ints1.size()); // 3
// 9.iterator(): 返回Iterator()接口的实例,用于遍历集合元素。放在IteratorTest.java 中测试
}
}
class Person{
private String name;
private int age;
public Person(){
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
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 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(name, person.name);
}
@Override
public String toString() {
return "Collection接口.For_Iterator.Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
欢迎大家来到IT世界,在知识的湖畔探索吧!
2、Collection子接口一:List
List:元素有序,可重复的集合。
鉴于Java中数组用来存储数据的局限性,我们通常使用List替代数组
List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引。
List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
- JDK API中List接口的实现类常用的有:ArrayList、LinkedList和Vector。
List接口的主要方法:
【除了从Collection集合继承的方法外,List 集合里添加了一些根据索引来操作集合元素的方法】
方法 |
方法说明 |
void add(int index, Object ele) |
在index位置插入ele元素 |
boolean addAll(int index, Collection eles) |
从index位置开始将eles中的所有元素添加进来 |
Object get(int index) |
获取指定index位置的元素 |
int indexOf(Object obj) |
返回obj在集合中首次出现的位置 |
int lastIndexOf(Object obj) |
返回obj在当前集合中末次出现的位置 |
Object remove(int index) |
移除指定index位置的元素,并返回此元素 |
Object set(int index, Object ele) |
设置指定index位置的元素为ele |
List subList(int fromIndex, int toIndex) |
返回从fromIndex到toIndex位置的子集合 |
①ArrayList ⭐
作为List 接口的主要实现类;线程不安全,效率高
ArrayList 类是一个可以动态修改的数组,与普通数组的区别就是它是没有固定大小的限制,我们可以添加或删除元素。ArrayList 继承了 AbstractList ,并实现了 List 接口。
ArrayList 是一个数组队列,提供了相关的添加、删除、修改、遍历等功能。
欢迎大家来到IT世界,在知识的湖畔探索吧!package List接口;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/** * 常用方法总结: * 增:add(Object obj) * 删:remove(int index) / remove(Object obj * 改:set(int index,Object ele) * 查:get(int index,Object ele) * 插:add(int index,Object obj) * 长度:size() */
public class ListTest {
@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(false);
System.out.println(list); //[123, 456, AA, For_Iterator.Person{name='Tom', age=12}, false]
//1. void add (int index, Object ele) : 在index位置插入ele元素
list.add(1,"BB");
System.out.println(list); //[123, BB, 456, AA, For_Iterator.Person{name='Tom', age=12}, false]
List list1 = Arrays.asList(1,2,3);
//list.addAll(list1); //[123, BB, 456, AA, For_Iterator.Person{name='Tom', age=12}, false, 1, 2, 3]
list.add(list1); //[123, BB, 456, AA, For_Iterator.Person{name='Tom', age=12}, false, [1, 2, 3]]
System.out.println(list);
//2.Object get(int index) : 获取指定index位置的元素
System.out.println(list.get(2)); // 456
}
@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(false);
//3.int index(Object obj) : 返回obj在集合中首次出现的位置
int index = list.indexOf(123);
System.out.println(index); // 0
//4.int lastIndexOf(Object obj) : 返回obj在集合中末次出现的位置
int lastIndexOf = list.lastIndexOf(456);
System.out.println(lastIndexOf); // 1
//5.Object remove(int index) : 移除指定index位置的元素,并返回此元素
Object obj = list.remove(0);
System.out.println(obj); // 123
System.out.println(list); // [456, AA, For_Iterator.Person{name='Tom', age=12}, false]
//6.Object set(int index,Object ele) : 设置指定index位置的元素ele
list.set(0,123);
System.out.println(list); //[123, AA, For_Iterator.Person{name='Tom', age=12}, false]
//7.list subList(int formIndex,int toIndex) : 返回从fromIndex到toIndex位置的左闭右开区间
List subList = list.subList(2, 4);
System.out.println(subList); //[For_Iterator.Person{name='Tom', age=12}, false]
System.out.println(list); //[123, AA, For_Iterator.Person{name='Tom', age=12}, false]
}
}
②LinkedList
对于频繁的插入、删除操作、使用此类的效率比ArrayList高;底层使用的是双向列表存储
链表(Linkedlist)是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的地址。
链表可分为单向链表和双向链表。一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。
一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。
【使用方式与ArrayList基本相同,在此就不进行代码上的重复】
③Vector
作为List 接口古老实现类;线程安全,效率低;
面试题
ArrayList和LinkedList的异同?
二者都线程不安全,相对线程安全的Vector,执行效率高。
此外,ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。对于随机访问get和set,ArrayList优于LinkedList,因为LinkedList要移动指针。对于新增和删除操作add(特指插入)和remove,LinkedList比较占优势,因为ArrayList要移动数据。ArrayList和Vector的区别?
Vector和ArrayList几乎是完全相同的,唯一的区别在于Vector是同步类(synchronized),属于强同步类。因此开销就比ArrayList要大,访问要慢。正常情况下,大多数的Java程序员使用ArrayList而不是Vector,因为同步完全可以由程序员自己来控制。Vector每次扩容请求其大小的2倍空间,而ArrayList是1.5倍。Vector还有一个子类Stack。
3、Collection子接口二:Set
Set:元素无序,不可重复的集合。 储存无序的 ≠ 随机性,根据数据的hash值顺序进行添加
Set接口是Collection的子接口,set接口没有提供额外的方法。
Set集合不允许包含相同的元素,如果是把两个相同的元素加入同一个 Set 集合中,则添加操作失败。Set 判断两个对象是否相同不是使用 == 运算符,而是根据 equals() 方法。
①HashSet
作为Set接口的主要实现类 ;线程不安全 ,可以存储null值
LinkHashSet:作为HashSet的子类;遍历其内部数据时,可以按照添加的顺序遍历
import org.junit.Test;
import java.util.*;
public class SetTest {
/* Set接口 :1. 储存无序的 ≠ 随机性,根据数据的hash值顺序进行添加 2. 不可重复的数据 */
@Test
public void HashTest(){
Set set = new HashSet();
set.add(456);
set.add(123);
set.add(123);
set.add("AA");
set.add(new Person("Tom",12));
//set.add(new User("Tom",12));
set.add("cc");
set.add(false);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.print(iterator.next() + " ");
//AA cc Collection接口.For_Iterator.Person{name='Tom', age=12} false 456 123
}
}
@Test
public void LinkedHashTest(){
/* LinkedHashSet作为HashSet的子类,在添加数据的同时,每个数据还维护了两个引用,记录此数据前后两个数据。 优点 :对于频繁的遍历操作,LinkedHashSet的效率要高于HashSet */
Set set = new LinkedHashSet();
set.add(456);
set.add(123);
set.add(123);
set.add("AA");
set.add(new Person("Tom",12));
set.add("cc");
set.add(false);
Iterator iterator = set.iterator();
while(iterator.hasNext()) {
System.out.print(iterator.next() + " ");
//456 123 AA Collection接口.For_Iterator.Person{name='Tom', age=12} cc false
}
}
}
②SortedSet
TressSet:可以按照对象的指定属性,进行排序。
换言之:TreeSet可以按照程序员自己的意愿进行排序;排序方法分为自由排序,定制排序
欢迎大家来到IT世界,在知识的湖畔探索吧!import org.junit.Test;
import java.util.*;
public class SetTest {
@Test
public void treeSetTest2() {
/* 定制排序:(比较的标准为:compare()返回0) */
Comparator com = new Comparator() {
//按照年龄从大到小排序
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof User && o2 instanceof User){
User user1 = (User)o1;
User user2 = (User)o2;
return Integer.compare(user1.getAge(), user2.getAge());
}else {
throw new RuntimeException("输入的数据类型不匹配");
}
}
/* @Override public boolean equals(Object obj) { return false; }*/
};
TreeSet treeSet = new TreeSet(com);
treeSet.add(new User("jerry", 3));
treeSet.add(new User("Mike", 13));
treeSet.add(new User("Shar", 15));
treeSet.add(new User("Tom", 12));
treeSet.add(new User("Tww", 12));
Iterator iterator1 = treeSet.iterator();
while (iterator1.hasNext()) {
System.out.println(iterator1.next());
//User{name='jerry', age=3}
//User{name='Tom', age=12}
//User{name='Mike', age=13}
//User{name='Shar', age=15}
}
}
@Test
public void test3(){
/** * 【面试题:】 * 注意:重写equals和hashCode方法 */
HashSet set = new HashSet();
User u1 = new User("AA",1001);
User u2 = new User("BB",1002);
set.add(u1);
set.add(u2);
System.out.println(set); //[User{name='AA', age=1001}, User{name='BB', age=1002}]
u1.name = "CC";
set.remove(u1);
System.out.println(set); //[User{name='CC', age=1001}, User{name='BB', age=1002}]
set.add(new User("CC",1001));
System.out.println(set); //[User{name='CC', age=1001}, User{name='CC', age=1001}, User{name='BB', age=1002}]
set.add(new User("AA",1001));
System.out.println(set); //[User{name='CC', age=1001}, User{name='CC', age=1001}, User{name='AA', age=1001}, User{name='BB', age=1002}]
}
}
//建立一个实现Comparable的User类,用于上面Set的操作
class User implements Comparable {
String name;
int age;
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
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 "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//按照姓名从小到大排列
@Override
public int compareTo(Object o) {
if(o instanceof User){
User user = (User) o;
return this.name.compareTo(user.name);
}else {
throw new RuntimeException("输入的类型不匹配");
}
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
if (age != user.age) return false;
return name != null ? name.equals(user.name) : user.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
}
三、Iterator迭代器接口
1、Iterator遍历
Java Iterator(迭代器)不是一个集合,它是一种用于访问集合的方法,可用于迭代 ArrayList 和 HashSet 等集合。
Iterator 是 Java 迭代器最简单的实现,ListIterator 是 Collection API 中的接口, 它扩展了Iterator 接口。
Iterator 仅用于遍历集合,Iterator 本身并不提供承装对象的能力。如果需要创建Iterator 对象,则必须有一个被迭代的集合。集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前。
- 迭代器 iterator 的两个基本操作是 next 、hasNext 和 remove。
调用 iterator.next() 会返回迭代器的下一个元素,并且更新迭代器的状态。
调用 iterator.hasNext() 用于检测集合中是否还有元素。
调用 iterator.remove() 将迭代器返回的元素删除。
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorTest {
//迭代器Iterator接口,用于遍历Collection集合中的元素
//1.内部方法 hasNext() next()
//2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象
//3.内部定义了remove(),可以在遍历的时候,删除集合中的元素。【不同于集合调用remove()】
@Test
public void tes1(){
Collection coll= new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Jerry"));
Person p = new Person("Tom",15);
coll.add(p);
coll.add(false);
Iterator iterator = coll.iterator();
/* //方式一 : System.out.println(iterator.next()); //123 System.out.println(iterator.next()); //456 System.out.println(iterator.next()); //Jerry System.out.println(iterator.next()); //Collection接口.For_Iterator.Person{name='Tom', age=15} System.out.println(iterator.next()); //false System.out.println(iterator.next()); //超出集合的范围,报错NoSuchElementException*/
/* //方式二 : 不推荐 for (int i=0;i< coll.size();i++){ System.out.println(iterator.next()); } */
//方式三 :
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
//测试Iterator中的remove()
@Test
public void test2(){
Collection coll= new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Jerry"));
Person p = new Person("Tom",15);
coll.add(p);
coll.add(false);
//删除集合中的“Jerry"数组
Iterator iterator = coll.iterator();
while (iterator.hasNext()){
Object obj = iterator.next();
if ("Jerry".equals(obj)){
iterator.remove();
}
}
//遍历集合
iterator = coll.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next()); //此时输出没有了”Jerry“元素
}
}
//创建一个Person类,来作为集合的一个元素
class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
}
}
- 遍历的原理:
hasNext():判断是否还有下一个元素
next():指针下移;将下移以后集合位置上的元素返回
2、foreach:增强for循环
Java 5.0 提供了 foreach 循环迭代访问 Collection和数组。
遍历操作不需获取Collection或数组的长度,无需使用索引访问元素。遍历集合的底层调用Iterator完成操作。foreach还可以用来遍历数组。
package For_Iterator;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
public class ForTest {
//foreach循环,用于遍历集合、数组
@Test
public void test1(){
Collection coll= new ArrayList();
coll.add(123);
coll.add(456);
coll.add(new String("Jerry"));
Person p = new Person("Tom",15);
coll.add(p);
coll.add(false);
//for(集合元素的类型 局部变量 : 集合对象)
for (Object obj : coll){
System.out.println(obj);
}
}
@Test
public void test2(){
int[] arr = new int[]{ 1,2,3,4,5,6};
//for(数组元素的类型 局部变量 : 数组对象)
for (int i : arr){
System.out.println(i);
}
}
//练习
@Test
public void test3(){
String[] arr = new String[]{ "qq","wwe","wear"};
/* //方式一 : 普通for循环 for (int i = 0; i < arr.length; i++) { arr[i] = "GG"; } for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); // GG GG GG }*/
//方式二 : 增强for循环
for(String i : arr){
i = "GG";
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] +" "); // qq wwe wear
}
}
}
四、Map接口
Map接口:双列数据,保存具有映射关系“ key – value对 ”的集合。
Map与Collection是并列的存在;一个单列数据,一个双列数据。
- 常用方法
方法 |
方法说明 |
Object put(Object key,Object value) |
增:将指定key-value添加到(或修改)当前map对象中 |
Object remove(Object key) |
删:移除指定key的key-value对,并返回value |
void putAll(Map m) |
改:将m中的所有key-value对存放到当前map中 |
void clear() |
清空:清空当前map中的所有数据 |
Object get(Object key) |
查:获取指定key对应的value |
boolean containsKey(Object key) |
查:是否包含指定的key |
boolean containsValue(Object value) |
查:是否包含指定的Value |
boolean isEmpty() |
判断当前map是否为空 |
boolean equals(Object obj) |
判断当前map和参数对象obj是否相等 |
原始图操作的方法
方法 |
方法说明 |
Set keySet() |
返回所有key构成的Set集合 |
Collection values() |
返回所有value构成的Collection集合 |
Set entrySet() |
返回所有key-value对构成Set的集合 |
1、Hashtable
- 作为古老的实现类;线程安全,效率低;不能存储null的key和value
- Properties:常用来处理配置文件,key和value都是String类型
2、HashMap⭐
- 作为Map的主要实现类;线程不安全,效率高;能存储null的key和value
- LinkedHashMap:保证在遍历map元素时,可以按照添加的顺序实现遍历,效率要高于HashMap。
public class MapTest {
@Test
public void test1(){
Map map = new HashMap();
//添加
map.put("AA",123);
map.put(45,123);
map.put("BB",87);
//修改
map.put("AA",87);
System.out.println(map); // {AA=87, BB=87, 45=123}
Map map1 = new HashMap();
map1.put("CC",123);
map1.put("DD",234);
map.putAll(map1);
System.out.println(map); // {AA=87, BB=87, CC=123, DD=234, 45=123}
//删除
Object value = map.remove(45);
System.out.println(value); // 123
System.out.println(map); // {AA=87, BB=87, CC=123, DD=234}
//清空
map.clear();
System.out.println(map); // {}
System.out.println(map.size()); // 0
}
@Test
public void test2(){
Map map = new HashMap();
map.put("AA",123);
map.put(45,123);
map.put("BB",87);
map.put("AA",87);
Map map1 = new HashMap();
map1.put("aa",123);
map1.put("bb",345);
System.out.println(map.get("AA")); // 87
System.out.println(map.containsKey("CC")); //false
System.out.println(map.containsValue(123)); //true
System.out.println(map.isEmpty()); //false
System.out.println(map.size()); //3
System.out.println(map.equals(map1)); //false
}
@Test
public void test3(){
/** * 遍历 * 1.Set keySet():返回所有key构成的Set集合 * 2.Collection values():返回所有value构成的Collection集合 * 3.Set entrySet():返回所有key-value对构成Set的集合 */
Map map = new HashMap();
map.put("AA",123);
map.put(45,123);
map.put("BB",87);
map.put("AA",87);
//1.Set keySet():返回所有key构成的Set集合
Set set = map.keySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.print(iterator.next() + " "); //AA BB 45
}
//2.Collection values():返回所有value构成的Collection集合
Collection values = map.values();
for(Object obj: values){
System.out.print(obj + " "); // 87 87 123
}
//3.Set entrySet():返回所有key-value对构成Set的集合
Set set1 = map.entrySet();
System.out.println(set1); //[AA=87, BB=87, 45=123]
}
}
3、SortedMap
- TreeMap保证按照添加的key-value对进行排序,实现排序遍历,此时考虑key的自然排序或定制排序。
- 自然排序:TreeMap 的所有的 Key 必须实现 Comparable 接口,而且所有的 Key 应该是同一个类的对象,否则将会抛出 ClasssCastException。
- 定制排序:创建 TreeMap 时,传入一个 Comparator 对象,该对象负责对TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现Comparable 接口。
五、Collections工具类
- Collections : 操作Collection、Map的工具类
类名 |
类名解释 |
reverse(List) |
反转List中元素的顺序 |
shuffle(List) |
对List集合元素进行随机排序 |
sort(List) |
根据元素的自然模式对指定List 集合元素按升序排序 |
sort(list,Comparator) |
根据指定比较器Comparator产生的顺序对指定列表进行排序。 |
swap(List,int,int) |
将指定List集合中的 i 处元素和 j 处元素进行交换 |
Object max(Collection) |
根据元素的自然顺序,返回给定集合中的最大元素 |
Object max (Collection,Comparator) |
根据 Comparator 指定的顺序,返回给定集合中的最大元素 |
Object min(Collection) |
根据元素的自然顺序 返回给定 collection 的最小元素。 |
Object min (Collection,Comparator) |
根据指定比较器Comparator产生的顺序,返回给定 collection 的最小元素。 |
int frequency(Collection,Object) |
返回指定集合中指定元素的出现次数 |
void copy(List dest,List src) |
将src中的内容复制到dest中 |
boolean replaceAll(List list,Object oldVal,Object newVal) |
使用新值替换List对应旧值 |
import org.junit.Test;
import java.util.*;
/** * Collections工具类的使用演示 */
public class CollectionsTest {
@Test
public void test1(){
List list = new ArrayList();
list.add(123);
list.add(43);
list.add(-927);
list.add(0);
System.out.println(list); //[123, 43, -927, 0]
//reverse 反转
Collections.reverse(list);
System.out.println(list); //[0, -927, 43, 123]
//shuffle 随机
Collections.shuffle(list);
System.out.println(list); // [43, 123, 0, -927]
//sort 排序
Collections.sort(list);
System.out.println(list); //[-927, 0, 43, 123]
//swap 交换
Collections.swap(list,1,2);
System.out.println(list); // [-927, 43, 0, 123]
//Object max/min 最大值/最小值
Object max = Collections.max(list);
System.out.println(max); // 123
Object min = Collections.min(list);
System.out.println(min); // -927
//frequency 频率
int frequency = Collections.frequency(list,123);
int frequency1 = Collections.frequency(list,1);
System.out.println(frequency); // 1
System.out.println(frequency1); // 0
}
@Test
public void test2(){
//copy 复制
List list = new ArrayList();
list.add(123);
list.add(43);
list.add(-927);
list.add(0);
/* 错误写法:java.lang.IndexOutOfBoundsException: Source does not fit in dest List dest = new ArrayList(); Collections.copy(dest,list); System.out.println(dest); */
List dest = Arrays.asList(new Object[list.size()]);
System.out.println(dest.size()); // 4
Collections.copy(dest,list);
System.out.println(dest); //[123, 43, -927, 0]
//replace 替换
Collections.replaceAll(list,123,321);
System.out.println(list); // [321, 43, -927, 0]
}
}
带你了解Java高级编程—–集合_符工爱奇的博客-CSDN博客
免责声明:本站所有文章内容,图片,视频等均是来源于用户投稿和互联网及文摘转载整编而成,不代表本站观点,不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益,请在线联系站长,一经查实,本站将立刻删除。 本文来自网络,若有侵权,请联系删除,如若转载,请注明出处:https://itzsg.com/21891.html