Java基础—Java集合

一、Java集合框架概述

1、集合、数组都是对多个数据进行存储操作的结构，简称Java容器。

说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储(.txt,.jpg,.avi,数据库中)。

2、数组在存储多个数据方面的特点：

> 一旦初始化以后，其长度就确定了。

> 数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。

比如：String[] arr、int[] arr1、Object[] arr2;

3、数组在存储多个数据方面的缺点：

> 一旦初始化以后，其长度就不可修改。

> 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。

> 获取数组中实现元素的个数的需求，数组没有现成的属性或方法可用。

> 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

4、集合框架

Collection接口：单列集合，用来存储一个一个的对象。

> List接口：存储有序的、可重复的数据。---> "动态"数组

List接口实现类：ArrayList、LinkedList、Vector

> Set接口：存储无序的、不可重复的数据。---> 高中的"集合"

Set接口实现类：HashSet、LinkedHashSet、TreeSet

Map接口：双列集合，用来存储一对(key - value)一对的数据。---> 类似于y=f(x)

Map接口实现类：HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

二、Collection接口方法

1、add(Object e)：将元素e添加到集合coll中。

2、size()：获取添加的元素的个数。

3、addAll(Collection coll1)：将coll1集合中的元素添加到当前的集合中。

4、clear()：清空集合元素。

5、isEmpty()：判断当前集合是否为空。

public class CollectionTest{@Testpublic void test(){Collection coll = new ArrayList();//多态的体现//add(Object e)：将元素e添加到集合coll中coll.add("AA");coll.add("BB");coll.add(123);//自动装箱coll.add(new Date());//size()：获取添加的元素的个数System.out.println(coll.size());//addAll(Collection coll1)：将coll1集合中的元素添加到当前的集合中Collection coll1 = new ArrayList();coll1.add(456);coll1.add("CC");coll.addAll(coll1);System.out.println(coll.size());System.out.println(coll);//clear()：清空集合元素coll.clear();//isEmpty()：判断当前集合是否为空System.out.println(coll.isEmpty());}}

6、contains(Object obj)：判断当前集合中是否包含obj，在判断时会调用obj对象所在类的equals()。

7、containsAll(Collection coll1)：判断形参coll1中的所有元素是否都存在于当前集合中。

@Test
public void test(){Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new Person("Jerry",20));coll.add(new String("Tom"));coll.add(false);//contains(Object obj)：判断当前集合中是否包含objboolean contains = coll.contains(123);System.out.println(contains);System.out.println(coll.contains(new String("Tom")));System.out.println(coll.contains(new Person("Jerry",20)));//自定义类需重写equals()//containsAll(Collection coll1)：判断形参coll1中的所有元素是否都存在于当前集合中Collection coll1 = Arrays.asList(123,4567);System.out.println(coll.containsAll(coll1));}

8、remove(Object obj)：从当前集合中移除obj元素。

9、removeAll(Collection coll1)：从当前集合中移除coll1中所有的元素（差集）。

@Test
public void test(){Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new Person("Jerry",20));coll.add(new String("Tom"));coll.add(false);//remove(Object obj)：从当前集合中移除obj元素coll.remove(1234);System.out.println(coll);coll.remove(new Person("Jerry",20));System.out.println(coll);//removeAll(Collection coll1)：从当前集合中移除coll1中所有的元素Collection coll1 = Arrays.asList(123,456);coll.removeAll(coll1);System.out.println(coll);}

10、retainAll(Collection coll1)：获取当前集合和coll1集合的交集，并返回给当前集合。

11、equals(Object obj)：要想返回true，需要当前集合和形参集合的元素都相同。

@Test
public void test(){Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new Person("Jerry",20));coll.add(new String("Tom"));coll.add(false);//retainAll(Collection coll1)：获取当前集合和coll1集合的交集，并返回给当前集合//Collection coll1 = Arrays.asList(123,456,789);//coll.retainAll(coll1);//System.out.println(coll);//equals(Object obj)：要想返回true，需要当前集合和形参集合的元素都相同Collection coll2 = new ArrayList();coll2.add(456);coll2.add(123);coll2.add(new Person("Jerry",20));coll2.add(new String("Tom"));col2l.add(false);System.out.println(coll.equals(coll1));}

12、hashCode()：返回当前对象的哈希值。

13、集合 ---> 数组：toArray()。

14、数组 ---> 集合：调用Arrays类的静态方法asList()。

@Test
public void test(){Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new Person("Jerry",20));coll.add(new String("Tom"));coll.add(false);//hashCode()：返回当前对象的哈希值System.out.println(coll.hashCode());//集合 ---> 数组：toArray()Object[] arr = coll.toArray();for(int i = 0;i < arr.length;i++){System.out.println(arr[i]);}//数组 ---> 集合：调用Arrays类的静态方法asList()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());//1List arr2 = Arrays.asList(new Integer[]{123, 456});System.out.println(arr2.size());//2}

15、iterator()：返回Iterator接口的实例，用于遍历集合元素。

注意点：

向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()。

三、Iterator迭代器接口

集合元素的遍历操作，使用迭代器Iterator接口。

1、内部的方法：hasNext() 和 next()

    @Testpublic void test(){Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new Person("Jerry",20));coll.add(new String("Tom"));coll.add(false);Iterator iterator = coll.iterator();//方式一：不推荐for(int i = 0;i < coll.size();i++){System.out.println(iterator.next());}//方式二：推荐//hasNext()：判断是否还有下一个元素while(iterator.hasNext()){//next()：①指针下移 ②将下移以后集合位置上的元素返回System.out.println(iterator.next());}}

2、集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。

    @Testpublic void test(){Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new Person("Jerry",20));coll.add(new String("Tom"));coll.add(false);//错误方式一：
//        Iterator iterator = coll.iterator();
//        while((iterator.next()) != null){
//            System.out.println(iterator.next());//间隔输出，并且会报IllegalStateException
//        }//错误方式二：//集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。while (coll.iterator().hasNext()){System.out.println(coll.iterator().next());//重复输出第一个元素，进入死循环}}

3、内部定义了remove()，可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()。

    //如果还未调用next()或在上一次调用next方法之后已经调用了 remove 方法，//再调用remove都会报IllegalStateException。@Testpublic void test(){Collection coll = new ArrayList();coll.add(123);coll.add(456);coll.add(new Person("Jerry",20));coll.add(new String("Tom"));coll.add(false);//删除集合中"Tom"Iterator iterator = coll.iterator();//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());}}

public 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;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic boolean equals(Object o) {System.out.println("Person equals()....");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);}@Overridepublic int hashCode() {return Objects.hash(name, age);}
}

补充：foreach循环，用于遍历集合、数组 ---> jdk5.0新增

for(集合元素的类型局部变量 : 集合对象){} ---> 内部仍然调用了迭代器

for(数组元素的类型局部变量 : 数组对象){} ---> 内部仍然调用了迭代器

    @Testpublic 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);}}

    @Testpublic void test(){int[] arr = new int[]{1,2,3,4,5,6};//for(数组元素的类型 局部变量:数组对象){}for(int i:arr){System.out.println(i);}}

四、Collection子接口一：List

1、List接口框架

Collection接口：单列集合，用来存储一个一个的对象。

> List接口：存储有序的、可重复的数据。---> "动态"数组，替换原有的数组。

ArrayList：作为List接口的主要实现类；线程不安全，效率高；底层使用Object[] elementData存储

LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储

Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储

2、ArrayList的源码分析

①jdk 7的情况下：

ArrayList list = new ArrayList(); //底层创建了长度是10的Object[]数组elementData

list.add(123); //elementData[0] = new Integer(123);

...

list.add(11); //如果此次的添加导致底层elementData数组容量不够，则扩容

默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。

结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity);

②jdk 8中ArrayList的变化：

ArrayList list = new ArrayList(); //底层Object[] elementData初始化为{},并没有创建长度为10的数组

list.add(123); //第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到elementData[0]

...

list.add(11); //如果此次的添加导致底层elementData数组容量不够，则扩容

默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。

结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity);

③小结：

jdk 7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk 8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

3、LinkedList的源码分析

LinkedList list = new LinkedList(); //内部声明了Node类型的first和last属性，默认值为null

list.add(123); //将123封装到Node中，创建了Node对象

其中，Node定义为：体现了LinkedList的双向链表的说法

private static class Node<E>{

E item;

Node<E> next;

Node<E> prev;

Node(Node<E> prev,E element,Node<E> next){

this.item = element;

this.next = next;

this.prev = prev;

}

}

4、Vector的源码分析

jdk 7和jdk 8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。在扩容方面，默认扩容为原来的数组长度的2倍。

注意点：ArrayList、LinkedList、Vector三者的异同？

同：三个类都实现了List接口，存储数据的特点相同：存储有序的、可重复的数据。

不同：见上。

5、List接口中的常用方法

void add(int index,Object ele)：在index位置插入ele元素

boolean addAll(int index,Collection eles)：从index位置开始将eles中的所有元素添加进来

Object get(int index)：获取指定index位置的元素

@Test
public void test(){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);System.out.println(list.size());//Object get(int index)：获取指定index位置的元素System.out.println(list.get(0));}

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位置的子集合

@Test
public void test(){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在集合中首次出现的位置。如果不存在，返回-1int index = list.indexOf(456);System.out.println(index);//int lastIndexOf(Object obj)：返回obj在当前集合中末次出现的位置。如果不存在，返回-1System.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位置的元素为elelist.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);}

总结：常用方法

增：add(Object obj)

删：remove(int index) / remove(Object obj)

改：set(int index,Object ele)

查：get(int index)

插：add(int index,Object ele)

长度：size()

遍历：①Iterator迭代器方式 ②增强for循环 ③普通的循环

@Test
public void test(){ArrayList list = new ArrayList();list.add(123);list.add(456);list.add("AA");//方式一：Iterator迭代器方式Iterator iterator = list.iterator();while(iterator.hasNext()){System.out.println(iterator.next());}System.out.println("***************");//方式二：增强for循环for(Object obj:list){System.out.println(obj);}System.out.println("***************");//方式三：普通for循环for(int i = 0;i < list.size();i++){System.out.println(list.get(i));}}

五、Collection子接口二：Set

1、Set接口的框架

Collection接口：单列集合，用来存储一个一个的对象。

> Set接口：存储无序的、不可重复的数据 ---> 高中的"集合"

HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值

> LinkedHashSet：作为HashSet的子类，遍历其内部数据时，可以按照添加的顺序遍历；

对于频繁的遍历操作，LinkedHashSet效率高于HashSet

TreeSet：可以按照添加对象的指定属性，进行排序

2、Set：存储无序的、不可重复的数据（以HashSet为例说明）

无序性：不等于随机性，存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。

不可重复性：保证添加的元素按照equals()判断时，不能返回true。即：相同的元素只能添加一个。

3、添加元素的过程（以HashSet为例）

我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断数组此位置上是否已经有元素：

> 如果此位置上没有其他元素，则元素a添加成功。---> 情况1

> 如果此位置上有其他元素b(或以链表形式存在的多个元素)，则比较元素a与元素b的哈希值：

> 如果哈希值不相同，则元素a添加成功。---> 情况2

> 如果哈希值相同，进而需要调用元素a所在类的equals()方法：

> equals()返回true，元素a添加失败。

> equals()返回false，则元素a添加成功。---> 情况3

对于添加成功的情况2和情况3而言：元素a与已经存在指定索引位置上数据以链表的方式存储。

jdk 7：元素a放到数组中，指向原来的元素。

jdk 8：原来的元素在数组中，指向元素a。

总结：七上八下

HashSet底层：数组+链表的结构。（前提：jdk 7）

    @Testpublic void test(){Set set = new HashSet();set.add(456);set.add(123);set.add(123);set.add("AA");set.add("CC");set.add(new User("Tom",12));set.add(new User("Tom",12));set.add(129);Iterator iterator = set.iterator();while(iterator.hasNext()){System.out.println(iterator.next());}}

public class User implements Comparable{private String name;private 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;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic boolean equals(Object o) {System.out.println("User equals()....");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;}@Overridepublic int hashCode() {int result = name != null ? name.hashCode() : 0;result = 31 * result + age;return result;}//按照姓名从大到小排列,年龄从小到大排列@Overridepublic int compareTo(Object o) {if(o instanceof User){User user = (User)o;
//            return -this.name.compareTo(user.name);int compare = -this.name.compareTo(user.name);if(compare != 0){//姓名不相同的情况，直接返回结果return compare;}else{ //姓名相同的情况，比较年龄return Integer.compare(this.age,user.age);}}else{throw new RuntimeException("输入的类型不匹配");}}
}

4、LinkedHashSet的使用

LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据的前一个数据和后一个数据。

优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet。

    @Testpublic void test(){Set set = new LinkedHashSet();set.add(456);set.add(123);set.add(123);set.add("AA");set.add("CC");set.add(new User("Tom",12));set.add(new User("Tom",12));set.add(129);Iterator iterator = set.iterator();while(iterator.hasNext()){System.out.println(iterator.next());}}

5、TreeSet的使用

①向TreeSet中添加的数据，要求是相同类的对象。

②两种排序方式：自然排序（实现Comparable接口）和定制排序（Comparator）

③自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals()返回true。

④定制排序中，比较两个对象是否相同的标准为：compare()返回0，不再是equals()。

    @Testpublic void test(){TreeSet set = new TreeSet();set.add(new User("Tom",12));set.add(new User("Jerry",32));set.add(new User("Jim",2));set.add(new User("Mike",65));set.add(new User("Jack",33));set.add(new User("Jack",56));Iterator iterator = set.iterator();while(iterator.hasNext()){System.out.println(iterator.next());}}

    @Testpublic void test(){Comparator com = new Comparator(){//按照年龄从小到大排列 ---> 定制排序@Overridepublic int compare(Object o1,Object o2){if(o1 instanceof User && o2 instanceof User){User u1 = (User)o1;User u2 = (User)o2;return Integer.compare(u1.getAge(),u2.getAge());}else{throw new RuntimeException("输入的数据类型不匹配");}}};TreeSet set = new TreeSet(com);//默认情况下调用重写的CompareTo()set.add(new User("Tom",12));set.add(new User("Jerry",32));set.add(new User("Jim",2));set.add(new User("Mike",65));set.add(new User("Mary",33));set.add(new User("Jack",33));set.add(new User("Jack",56));Iterator iterator = set.iterator();while(iterator.hasNext()){System.out.println(iterator.next());}}

注意点：

1、Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法。

2、向Set(主要指：HashSet、LinkedHashSet)中添加的数据，其所在的类一定要重写hashCode()和equals()。

3、重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码。

4、重写两个方法的小技巧：对象中用作equals()方法比较的Field，都应该用来计算hashCode值。

六、Map接口

1、Map的实现类结构

Map：双列数据，存储key-value对的数据 ---> 类似于高中的函数：y=f(x)

> HashMap：作为Map的主要实现类；线程不安全的，效率高；存储null的key和value

> LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序实现遍历。（原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行效率高于HashMap。）

> TreeMap：保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序；底层使用红黑树

> Hashtable：作为Map的古老实现类；线程安全的，效率低；不能存储null的key和value

> Properties：常用来处理配置文件；key和value都是String类型

注意点：HashMap的底层：

数组 + 链表（jdk 7及以前）

数组 + 链表 + 红黑树（jdk 8）

2、Map结构的理解

①Map中的key：无序的、不可重复的，使用Set存储所有的key ---> key所在的类要重写equals()和hashCode()（以HashMap为例）

②Map中的value：无序的、可重复的，使用Collection存储所有的value ---> value所在类要重写equals()

③一个键值对：key-value构成了一个Entry对象

④Map中的entry：无序的、不可重复的，使用Set存储所有的entry

3、HashMap的底层实现原理（以jdk 7为例说明）

HashMap map = new HashMap();

在实例化以后，底层创建了长度为16的一维数组Entry[] table。

...可能已经执行过多次put...

map.put(key1,value1);

首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置：

如果此位置上的数据为空，此时的key1-value1添加成功。---> 情况1

如果此位置上的数据不为空，意味着此位置上存在一个或多个数据(以链表形式存在)，比较key1和已经存在的一个或多个数据的哈希值：

> 如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。---> 情况2

> 如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)方法：

> 如果equals()返回false：此时key1-value1添加成功。---> 情况3

> 如果equals()返回true：使用value1替换value2。

补充：

①关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。

②在不断的添加过程中，会涉及到扩容问题，当超出临界值(且要存放的位置非空)时，扩容。

③默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来。

4、jdk 8相较于jdk 7在底层实现方面的不同

①HashMap map = new HashMap();//底层没有创建一个长度为16的数组

②jdk 8底层的数组是：Node[]，而非Entry[]

③首次调用put()方法时，底层创建长度为16的数组

④jdk 7底层结构只有：数组 + 链表；jdk 8中底层结构：数组 + 链表 + 红黑树

> 形成链表时，七上八下（jdk 7：新的元素指向旧的元素；jdk 8：旧的元素指向新的元素）。

> 当数组的某一个索引位置上的元素以链表形式存在的数据个数>8，且当前数组的长度>64时，此时此索引位置上的所有数据改为使用红黑树存储。

DEFAULT_INITIAL_CAPACITY：HashMap的默认容量，16

DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75

threshold：扩容的临界值，=容量*填充因子：16*0.75 => 12

TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树：8

MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量：64

5、LinkedHashMap的底层实现原理

源码：

static class Entry<K,V> extends HashMap.Node<K,V>{

Entry<K,V> before,after;//能够记录添加的元素的先后顺序

Entry(int hash,K key,V value,Node<K,V> next){

super(hash,key,value,next);

}

}

6、Map中定义的方法

①添加、删除、修改操作

Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中

void putAll(Map m)：将m中的所有key-value对存放到当前map中

Object remove(Object key)：移除指定key的key-value对，并返回value

void clear()：清空当前map中的所有数据

    @Testpublic void test(){Map map = new HashMap();//添加map.put("AA",123);map.put(45,123);map.put("BB",56);//修改map.put("AA",87);System.out.println(map);Map map1 = new Map();map1.put("CC",123);map1.put("DD",123);map.putAll(map1);System.out.println(map);//删除Object value = map.remove("CC");System.out.println(value);System.out.println(map);//清空map.clear();//与map=null操作不同System.out.println(map.size());//0System.out.println(map);//{}}

②元素查询的操作

Object get(Object key)：获取指定key对应的value

boolean containsKey(Object key)：是否包含指定的key

boolean containsValue(Object value)：是否包含指定的value

int size()：返回map中key-value对的个数

boolean isEmpty()：判断当前map是否为空

boolean equals(Object obj)：判断当前map和参数对象obj是否相等

    @Testpublic void test(){Map map = new Map();map.put("AA",123);map.put(45,123);map.put("BB",56);//Object get(Object key)System.out.println(map.get(45));//boolean containsKey(Object key)boolean isExist = map.containsKey("BB");System.out.println(isExist);isExist = map.containsValue(123);System.out.println(isExist);map.clear();System.out.println(map.isEmpty);}

③元视图操作方法

Set keySet()：返回所有key构成的Set集合

Collection values()：返回所有value构成的Collection集合

Set entrySet()：返回所有key-value对构成的Set集合

    @Testpublic void test5(){Map map = new HashMap();map.put("AA",123);map.put(45,1234);map.put("BB",56);//遍历所有的key集：keySet()Set set = map.keySet();Iterator iterator = set.iterator();while(iterator.hasNext()){System.out.println(iterator.next());}System.out.println();//遍历所有的value集：values()Collection values = map.values();for(Object obj:values){System.out.println(obj);}System.out.println();//遍历所有的key-value//方式一：entrySet()Set entrySet = map.entrySet();Iterator iterator1 = entrySet.iterator();while(iterator1.hasNext()){Object obj = iterator1.next();//entrySet集合中的元素都是entryMap.Entry entry = (Map.Entry)obj;System.out.println(entry.getKey() + "---->" + entry.getValue());}System.out.println();//方式二：Set keySet = map.keySet();//遍历所有的key集Iterator iterator2 = keySet.iterator();while(iterator2.hasNext()){Object key = iterator2.next();Object value = map.get(key);System.out.println(key + "====" + value);}}

总结：常用方法

添加：put(Object key,Object value)

删除：remove(Object key)

修改：put(Object key,Object value)

查询：get(Object key)

长度：size()

遍历：keySet() / values() / entrySet()

7、TreeMap的使用

向TreeMap中添加key-value，要求key必须是由同一个类创建的对象。原因：要按照key进行排序：自然排序、定制排序。

    //自然排序@Testpublic void test(){TreeMap map = new TreeMap();User u1 = new User("Tom",23);User u2 = new User("Jerry",32);User u3 = new User("Jack",20);User u4 = new User("Rose",18);map.put(u1,98);map.put(u2,89);map.put(u3,76);map.put(u4,100);Set entrySet = map.entrySet();Iterator iterator = entrySet.iterator();while(iterator.hasNext()){Object obj = iterator.next();Map.Entry entry = (Map.Entry)obj;System.out.println(entry.getKey() + "---->" + entry.getValue());}}

    //定制排序@Testpublic void test(){TreeMap map = new TreeMap(new Comparator(){@Overridepublic int compare(Object o1,Object o2){if(o1 instanceof User && o2 instanceof User){User u1 = (User)o1;User u2 = (User)o2;return Integer.compare(u1.getAge(),u2.getAge());}throw new RuntimeException("输入的类型不匹配！");}});User u1 = new User("Tom",23);User u2 = new User("Jerry",32);User u3 = new User("Jack",20);User u4 = new User("Rose",18);map.put(u1,98);map.put(u2,89);map.put(u3,76);map.put(u4,100);Set entrySet = map.entrySet();Iterator iterator = entrySet.iterator();while (iterator.hasNext()){Object obj = iterator.next();Map.Entry entry = (Map.Entry) obj;System.out.println(entry.getKey() + "---->" + entry.getValue());}}

8、Properties：常用来处理配置文件。key和value都是String类型。

public class PropertiesTest {FileInputStream fis = null;try {Properties pros = new Properties();fis = new FileInputStream("jdbc.properties");pros.load(fis);//加载流对应的文件String name = pros.getProperty("name");String password = pros.getProperty("password");System.out.println("name = " + name + ", password = " + password);} catch (IOException e) {e.printStackTrace();} finally {if(fis != null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}

七、Collections工具类：用来操作Collection、Map

reverse(List)：反转List中元素的顺序

shuffle(List)：对List集合元素进行随机排序

sort(List)：根据元素的自然排序对指定List集合元素按升序排序

sort(List,Comparator)：根据指定的Comparator产生的顺序对List集合元素进行排序

swap(List,int,int)：将指定list集合中的i处元素和j处元素进行交换

    @Testpublic void test(){List list = new ArrayList();list.add(123);list.add(43);list.add(765);list.add(765);list.add(765);list.add(-97);list.add(0);System.out.println(list);//Collections.reverse(list);//Collections.shuffle(list);//Collections.sort(list);//Collections.swap(list,1,2);int frequency = Collections.frequency(list,123);System.out.println(list);System.out.println(frequency);}

Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素

Object max(Collection,Comparator)：根据Comparator指定的顺序，返回给定集合中的最大元素

Object min(Collection)：根据元素的自然顺序，返回给定集合中的最小元素

Object min(Collection,Comparator)：根据Comparator指定的顺序，返回给定集合中的最小元素

int frequency(Collection,Object)：返回指定集合中指定元素的出现次数

void copy(List dest,List src)：将src中的内容复制到dest中

boolean replaceAll(List list,Object oldVal,Object newVal)：使用新值替换List对象的所有旧值

    @Testpublic void test2(){List list = new ArrayList();list.add(123);list.add(43);list.add(765);list.add(-97);list.add(0);//报异常：IndexOutOfBoundsException("Source does not fit in dest")//List dest = new ArrayList();//Collections.copy(dest,list);List dest = Arrays.asList(new Object[list.size]);System.out.println(dest.size());//list.sizeCollections.copy(dest,list);System.out.println(dest);}

注意点：

Collections类中提供了多个synchronizedXxx()方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题。

//返回的list1即为线程安全的List

List list1 = Collections.synchronizedList(list);

查看全文
如若内容造成侵权/违法违规/事实不符，请联系编程学习网邮箱：809451989@qq.com进行投诉反馈，一经查实，立即删除！

【计算机组成原理】指令流水与指令周期
一、CPU的功能 1、CPU由【运算器】和【控制器】构成这些指令还有执行的先后顺序 CPU必须具有控制程序的顺序执行（称指令控制）、产生完成每条指令的控制命令（称操作控制）、对各种操作加以时间上的控制（称时间控制&am…...
2024/4/15 7:04:42
初学JavaWeb，前端css要不要了解一下啊？一文学会JavaWeb中css的简单应用
文章目录一、设置CSS样式二、CSS代码语法三、CSS选择器一、设置CSS样式有三种设置方式。 1、在HTML标签内设置：仅对当前标签有效。 ①代码 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><title&g…...
2024/4/14 20:55:08
六.用场效应管设计D触发器(高电平触发)(上升沿触发)
这篇文章将用场效应管设计一个D触发器（全电路只用到PMOS和NMOS） 目录…...
2024/4/18 21:40:10
《华为机试》刷题之HJ3 明明的随机数
一、题目明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了 N 个 1 到 1000 之间的随机整数（ N≤1000 ），对于其中重复的数字，只保留一个，把其余相同的数去掉&…...
2024/4/20 17:51:08
2.7英文题面翻译
描述 A sequence consisting of one digit, the number 1 is initially written into a computer. At each successive time step, the computer simultaneously tranforms each digit 0 into the sequence 1 0 and each digit 1 into the sequence 0 1. So, after the first …...
2024/4/13 12:18:56
I-Nodal节点仪专用sps分拆
I-Nodal节点仪切割数据时，只能先切割线，再由线合并成炮，而施工sps均为完整sps，即一炮由多条测线构成，切割节点仪数据时，需要对sps数据进行按线拆分，为便于施工，写了本次小脚本。 im…...
2024/4/13 12:19:21
EasyClick Html UI 第十节 CSS选择器
EasyClick Html UI 第十节 CSS选择器 CSS 选择器 css 选择器是用来选择标签的，选出来以后给标签加样式。 CSS 选择器的种类标签选择器类选择器层级选择器(后代选择器)id选择器组选择器伪类选择器标签选择器根据标签来选择标签，以标签开头&#…...
2024/4/13 12:19:26
研究生文献阅读与整理
就当是一个记录吧，简单说一说师兄教给我的文献查询与阅读的方式。文献查询首选学校图书馆所购买的一些网站。对于我这个工科生来说，主要是ieee和sci这两个，其中sci最全但是ieee用的最多，，但是sci上有些文章无法下载&am…...
2024/4/13 12:19:16
基于内容的电影推荐：物品画像和用户画像
基于内容的电影推荐：物品画像(基于tf-idf)、用户画像及推荐结果 1. 基于内容的推荐算法基于内容的推荐算法非常直接，它以物品的内容描述信息为依据所做出的的推荐，本质上是基于对物品和用户自身的特征或属性的直接分析和计算。 2. 基于内…...
2024/4/17 12:54:31
Netty简介
Netty 是基于 Java NIO 的异步事件驱动的网络应用框架，使用 Netty 可以快速开发网络应用，Netty 提供了高层次的抽象来简化 TCP 和 UDP 服务器的编程，但是你仍然可以使用底层的 API。 Netty 的内部实现是很复杂的，但是 Netty 提供了…...
2024/4/18 4:59:22
批量向PDF文件添加中文水印...
可以通过设置批量PDF文件所在的路径及需要添加的水印名称可以实现批量添加PDF水印的效果。实现思路是这样的，通过在批量PDF文件路径下面生成一个带有水印的PDF模板。最后，将批量文件的每个PDF页面和水印模板进行合并完成批量添加水印的效果。【阅读全…...
2024/4/13 12:20:11
第四次网页前端培训
1.视频讲解：【优极限】 HTMLCSSJavaScriptjQuery前端必学教程，小白教学，前端基础全套完成版_哔哩哔哩_bilibili 1，css常用属性： 背景： background-color 属性定义了元素的背景颜色实例： h…...
2024/4/13 12:19:41
python中yield,greenlet,gevent实现协程
一.什么是协程： 协程是python中另外一种实现多任务的方式，只不过比线程更小，占用的执行资源（理解为需要的资源）也更少。为啥说他说一个执行单元？因为他自带cpu上下文，这样，在合适的额…...
2024/4/18 13:19:48
小程序云开发入门——关于云函数那些事（2）
上传视频到云存储 wx.chooseVideo(Object object) 1.选择要上传的视频 //上传视频，第一步选择要上传的视频chooseVideo(){wx.chooseVideo({camera:back,//后置或前置摄像头compressed: true,maxDuration: 60,//视频最长的秒数sourceType: [album,camera],//从相册选…...
2024/4/18 9:31:58
死磕ES-第一章
一句话介绍 Elasticsearch是实时的分布式搜索分析引擎，内部使用 Lucene 做索引与搜索。主要功能分布式搜索引擎大数据近实时分析引擎产品特性高性能易用易扩展 Lucene 是基于Java语言开发的类库具有高性能、易扩展的特点具有局限性只能基于Java语言开…...
2024/4/7 21:57:15
自动运镜项目
ipad21 人【人像居中】功能效果效果演示： https://9to5mac.com/2021/05/19/roundup-heres-how-the-2021-ipad-pro-center-stage-feature-really-works/ https://www.youtube.com/watch?vTzwtHRPGSkM 复现实现： 单帧具备的功能： 根据检测到…...
2024/4/16 3:42:31
什么是ad hoc
Ad hoc是一种多跳的、无中心的、自组织无线网络，又称为多跳网（MulTI-hop Network）、无基础设施网（Infrastructureless Network）或自组织网（Self-organizing Network）。整个网络没有固定的基础设…...
2024/4/20 14:58:58
IO面试题
笔试面试题： 1 文件IO和标准IO的区别文件IO是Linux系统调用（内核API），而标准IO是C语言库函数； 文件IO不带缓冲，标准IO带有缓冲文件IO操作的是文件描述符，标准IO操作的是流FILE 文件IO和标…...
2024/4/20 1:18:52
Java小农养成记第二十九天
day29 今日内容数据库连接池Spring JDBC ：JDBC Template 数据库连接池概念：其实就是一个容器（集合），存放数据库连接的容器当系统初始化好后，容器中会申请一些连接对象，当用户来访问数据库…...
2024/4/20 15:13:10
官方还有这个控件？Android优雅实现小红点效果，so easy~
作者：yechaoa 一、前言通常情况下，我们在做小红点效果的时候，会有两种选择： 自定义BadgeView，然后设置给目标View。 xml写一个View，然后设置shape。有的同学可能会想，能实现不就行了吗&am…...
2024/4/20 10:23:29

Java基础—Java集合

相关文章

最新文章