java2_day03java集合

Java集合

目录

  1. java集合框架概述

  2. Collection接口方法

  3. Iterator迭代器接口

  4. Collection子接口一:List

  5. Collection子接口二:Set

  6. Map接口

  7. Collections工具类

1 java集合框架概述

  • 一 方面,面向对象语言对事物的体现都是以对象的形式,为了方便对多个对象的操作,就要对对象进行存储。另一方面,使用Array存储对象方面具有一些弊端,而Java集合就像一种容器,可以动态地把多个对象的引用放入容器中。

1.1 集合与数组

  1. 集合与数组存储数据概述:

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

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

  1. 数组存储的特点:

  • 一旦初始化以后,其长度就确定了。

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

比如: String[] arr; int[] arr1; Object[] arr2;

  1. 数组存储的弊端:

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

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

  • 获取数组中实际元素的个数的需求,数组没有现成的属性或方法可用

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

  1. 集合存储的特点:

  • 解决数组存储数据方面的弊端。

  1. 集合的使用场景

image-20220409203232392

1.2 java集合

  • java集合可分为Collection和Map两种体系

  • collection接口:单列数据,定义了存取一组对象的方法的集合。(目前只关注List和set)

    • List接口:存储有序的、可重复的数据。 -->“动态”数组

      • ArrayList、LinkedList、Vector

    • set接口:存储无序的、不可重复的数据 -->高中讲的“集合”

      • HashSet、LinkedHashSet、TreeSet

  • Map接口:双列数据,保存具有映射关系(key - value)对的集合 -->高中函数: y = f(x),多个key可以对应相同的值。

    • HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

image-20220409204941219

2 Collection接口方法

  • 此程序包含1. add 2. size 3. addAll 4. clear 5. isEmpty 共5种方法的测试

 package com.xue.java2;
 
 import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Date;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/9
  * Time: 19:50
  * Description: 集合框架的概述
  */
 public class CollectionTest0 {
     @Test
     public void test1(){
         Collection coll = new ArrayList();
         //1. add(object e): 将元素添加到集合coll中
         coll.add("AA");
         coll.add("BB");
         coll.add(123);  //自动装箱
         coll.add(new Date());
 
         //2. size(): 获取添加的元素的个数
         System.out.println(coll.size());  //4
 
         //3. addAll()
         Collection coll1 = new ArrayList();
         coll1.add(456);
         coll1.add("CC");
         coll.addAll(coll1);
         System.out.println(coll.size());  //6
         System.out.println(coll);  //[AA, BB, 123, Sat Apr 09 21:41:49 CST 2022, 456, CC]
 
         //4. clear(): 清空集合元素
         //coll.clear();   这会清空当前集合的数据
 
         //5. isEmpty():判断当前集合是否为空
         System.out.println(coll.isEmpty());  //false
 
    }
 }

此程序包含1. contains 2. containsAll 3. remove 4. removeAll 5. retainAll 6. equals 7. hashcode 8. toArray对集合、数组的转换,共8种方法的测试。还有一种遍历方法将在下一节进行讲解。

 package com.xue.java2;
 
 import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.zip.CheckedOutputStream;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/9
  * Time: 16:40
  * Description: Collection接口中声明的方法的测试
  * 向Collection接口的实现类的对象中添加数据obj时,要求obj所在类要重写equals();
  */
 public class CollectionTest {
     @Test
     public void test1(){
         Collection coll = new ArrayList();
         coll.add(123);
         coll.add(456);
         coll.add(new String("Tom"));
         coll.add(false);
         //Person p = new Person("jerry", 53);
         //coll.add(p);
         coll.add(new Person("jerry", 53));
 
         //1. contains(Object obj): 判断集合中是否包含obj
         //我们在判断时会调用obj对象所在类的equals()。
         boolean contains = coll.contains(123);
         System.out.println(contains);  //true
         System.out.println(coll.contains(new String("Tom")));  //true
         //调的是equals进行判断的,而不是==,这里String进行了重写,所以进行的是内容比较。
         //System.out.println(coll.contains(p));   //true
         System.out.println(coll.contains(new Person("jerry", 53))); //可以通过debug查看执行过程
         //因为这里对Person类的equals进行了重写,所以比较的也是内容,所以也为true。
         // 具体过程为执行equals方法,从123开始,然后456,一个个和new Person("jerry", 53)进行比较
         //如果不进行重写,里边使用的是==,就需要地址也相同。
 
         //2. containsAll(collection coll1): 判断形参coll1中所有元素是否都在当前集合中。
         System.out.println("===========================");
         Collection coll1 = Arrays.asList(123, 456);
         System.out.println(coll.containsAll(coll1));  //true
    }
 
     @Test
     public void test2(){
         //3. remove(object obj): 从当前集合中删除obj元素
         Collection coll = new ArrayList();
         coll.add(123);
         coll.add(456);
         coll.add(new Person("jerry", 20));
         coll.add(new String("Tom"));
         coll.add(false);
 
         boolean remove = coll.remove(123);
         System.out.println(remove);  //true,代表删除成功
         System.out.println(coll);  //[456, Person{name='jerry', age=20}, Tom, false]
 
         //4. removeAll(Collection coll1): 差集:从当前集合中移除coll1中所有的元素
         Collection coll1 = Arrays.asList(123, 456);
         coll.removeAll(coll1);
         System.out.println(coll);  //[Person{name='jerry', age=20}, Tom, false]
 
    }
 
     @Test
     public void test3(){
         Collection coll = new ArrayList();
         coll.add(123);
         coll.add(456);
         coll.add(new Person("jerry", 20));
         coll.add(new String("Tom"));
         coll.add(false);
 
         //5. retainAll(Collection coll1): 交集:获取当前集合和coll1集合的交集,并返回给当前集合
 //       Collection coll1 = Arrays.asList(123, 456, 789);
 //       coll.retainAll(coll1); //求交集,给coll
 //       System.out.println(coll); //[123, 456]
 
         //6. equals(object obj): 要想返回true,需要当前集合和形参集合的元素都相同,顺序也要一致。
         Collection coll2 = new ArrayList();
         coll2.add(123);
         coll2.add(456);
         coll2.add(new Person("jerry", 20));
         coll2.add(new String("Tom"));
         coll2.add(false);
 
         System.out.println(coll.equals(coll2));  //true,但是是有序的,如果顺序不对就是false
    }
 
     @Test
     public void test4(){
         Collection coll = new ArrayList();
         coll.add(123);
         coll.add(456);
         coll.add(new Person("jerry", 20));
         coll.add(new String("Tom"));
         coll.add(false);
 
         //7. hashcode():返回当前对象的哈希值(可以理解为一个身份码)
         System.out.println(coll.hashCode());  //-1265134228
 
         //8.集合 -->数组: toArray()
         Object[] arr = coll.toArray();
         for (int i = 0; i < arr.length; i++) {
             System.out.println(arr[i]);
        }
 
         //拓展: 数组-->集合
         List<String> list = Arrays.asList(new String[]{"AA", "BB", "NN"});
         System.out.println(list);  //[AA, BB, NN]
 
         List<Integer> arr1 = Arrays.asList(123, 456);
         System.out.println(arr1);  //[123, 456]
 
         //9. interator(): 返回Interator接口的实例,用于遍历集合元素。放在InteratorTest.java中测试
 
 
 
    }
 
 }
  • 上述程序新建了一个Person类,需要重写equals方法。

 package com.xue.java2;
 
 import java.util.Objects;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/9
  * Time: 17:01
  * Description:
  */
 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;
    }
 
     @Override
     public String toString() {
         return "Person{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 '}';
    }
 
     @Override  //重写equals方法
     public boolean equals(Object o) {
         System.out.println("Person equals()...");  //用来确定是否调用了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);
    }
 
     @Override
     public int hashCode() {
         return Objects.hash(name, age);
    }
 }

3 Iterator迭代器接口

  • Iterator对象称为迭代器(设计模式的一种),主要用于遍历Collection集合中的元素

  • GOF给迭代器模式的定义为: 提供一种方法访问一个容器(container)对象中各个元素,而又不需暴漏该对象的内部细节。迭代器模式,就是为容器而生。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”

  • Collection接口继承了java.lang.Iterable接口,该接口有一个iterator()方法,那么所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象。

  • Iterator仅用于遍历集合,Iterator本身并不提供承装对象的能力。如果需要创建Iterator对象,则必须有一个被迭代的集合。

  • 集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前。(即下面测试程序的错误方式二)

3.1 方法测试

内部的方法: hasnext() 和 next()

 package com.xue.java2;
 
 import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/10
  * Time: 12:33
  * Description: 集合元素的遍历操作,使用迭代器Iterator接口
  * 内部的方法: hasnext() 和 next()
  */
 public class IteratorTest {
     @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);
 
         Iterator iterator = coll.iterator(); //实例化,创建对象
         // 方式一:
 //       System.out.println(iterator.next()); //123
 //       System.out.println(iterator.next()); //456
 //       System.out.println(iterator.next()); //Person{name='jerry', age=20}
 //       System.out.println(iterator.next()); //Tom
 //       System.out.println(iterator.next()); //false
         //System.out.println(iterator.next()); //越界了,只有五个元素
         
         //方式二:不推荐
 //       for (int i = 0; i < coll.size(); i++) {
 //           System.out.println(iterator.next());
 //       }
 
         //方式三: 推荐
         while (iterator.hasNext()){
             System.out.println(iterator.next());
        }
 
    }
 
 }

3.2 迭代器的执行原理

image-20220410130138539

  • 执行原理解释:(iterator只是用来遍历,并不是一个容器)

    • 先调用了一个iterator方法,返回了一个iterator对象《——(Iterator iterator = coll.iterator());

    • 此时指针指向空

    • 判断是否还有下一个元素,若为true

    • 执行next,即指针下移,将指针对应的元素返回,至此一次循环结束

    • 继续判断是否还有下一个元素

3.3 两种错误方式:

 @Test
     public void test2(){
         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()); //跳着输出了,执行一次next,指针就会下移
 //       }
 
         //错误方式二:
         while(coll.iterator().hasNext()){  //集合对象每次调用iterator()方法都得到一个全新的迭代器对象
             System.out.println(coll.iterator().next());  //指针一直指向123,一直循环为123
        }

3.4 remove方法

  • 内部定义了remove(),可以在遍历的时候,删除其中的元素,此方法不同于集合直接调用remove(),这是迭代器里的remove方法。

 //测试Iterator中的remove()方法
 @Test
 public void test3(){
     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.hasNext()){
         Object obj = iterator.next();  //调用next之前,不能remove,因为此时指针指向空的
         if("Tom".equals(obj)){
             iterator.remove();  //下一次next之前,不能两次调用remove,不然也会报错,因为第一次已经删掉了
        }
    }
     iterator = coll.iterator(); //删除完遍历,需要指针从头开始,集合调用对象即可实现此操作
     while (iterator.hasNext()){
         System.out.println(iterator.next());  //输出结果没有"Tom"了
    }
 }

3.5 使用foreach循环遍历集合元素

  • java5.0提供了foreach循环迭代访问Collection和数组

  • 遍历操作不许获取Collection或数组的长度,无需使用索引访问元素

  • 遍历集合的底层调用Iterator完成操作(可以debug查看)

  • foreach还可以用来遍历数组

image-20220410220208667

 package com.xue.java2;
 
 import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/10
  * Time: 22:04
  * Description:
  * java5.0提供了foreach循环迭代访问Collection和数组
  */
 public class ForTest {
     @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);
             //执行过程,取coll第一个元素给obj,一个个取
        }
    }
 
     @Test
     public void test2(){
         int[] arr = {1, 2, 3, 4, 5, 6};
         //for(数组元素的类型 局部变量 : 数组对象)
         for(int i : arr){
             System.out.println(i);
        }
    }
     
      @Test
     public void test3(){
         String[] arr = {"MM", "MM", "MM"};
         //方式一:普通for循环
 //       for (int i = 0; i < arr.length; i++) {
 //           arr[i] = "GG";
 //       }
 //       for (int i = 0; i < arr.length; i++) {
 //           System.out.println(arr[i]); //GG GG   GG
 //       }
         //方式一:增强for循环
         for(String s : arr){
             s = "GG";
        }
         for (int i = 0; i < arr.length; i++) {
             System.out.println(arr[i]);   //MM MM MM,改的是s
        }
 
    }
 }

4 Collection子接口

4.1 LIst接口概述

  • 鉴于Java中数组用来存储数据的局限性,我们通常使用List替代数组

  • List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引

  • List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。

4.1.1 List接口框架

  • JDK API中List接口的实现类常用的有: ArrayList、 LinkedList和Vector。

  • List接口:存储有序的、可重复的数据。 -->“动态”数组,替换原有的数组

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

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

    • Vector: 作为List接口的古老实现类(jdk1.0就有了),线程安全,效率低; 底层使用Object[]存储

  • 面试题:ArrayList、LinkedList、Vector三者的异同?

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

    • 不同: 见上

4.1.2 ArrayList的源码分析

  • jdk7和8稍有不同

  1. jdk7情况下:

     *   ArrayList list = new ArrayList(); //底层创建了长度是10的Object[]数组elementData,查看底层源代码可知,当长度不够时,数组长度会右移一位,即×1.5;
     *   list.add(123); elementData[0] = new Integer(123);
     *   ...
     *   list.add(11); 如果此次添加导致底层elementData数组容量不够,则扩容。
     *   默认情况下,扩容为原来的容量的1.5倍,同时需要将原有数组中的数据复制到新的数组中。
     *   结论: 建议开发中使用带参的构造器:ArrayList list = new ArrayList(int capacity);提前大概确定需要的长度,避免频繁更改,影响工作效率。
  2. jdk 8中ArrayList的变化

 ArrayList list = new ArrayList();  //底层Object[]数组elementData初始化为{},并没有创建长度为10的数组。
 list.add(123); //第一次调用add()时,底层才创建了长度10的数组,并将数据123添加到elementData[0]。
 ...
     后续的添加和扩容操作与jdk7无异。
  1. 小结:

    • jdk7中的ArrayList的对象的创建类似于单例的饿汉式,而jdk8中的ArrayList对象的创建类似于单例的懒汉式,延迟了数组的创建,节省内存。

4.1.3 LinkedList的源码分析

 LinkedList list = new LinkedList(); //内部声明了Node类型的first和last属性,默认值为null
 list.add();  //将123封装到Node中,创建了Node对象
 其中,Node定义为:(双向链表)
     private static class Node<E> {
         E item;
         LinkedList.Node<E> next;
         LinkedList.Node<E> prev;
 
         Node(LinkedList.Node<E> prev, E element, LinkedList.Node<E> next) {
             this.item = element;
             this.next = next;
             this.prev = prev;
        }
    }

4.1.4 Vector的源码分析

  • jdk7和8中通过Vector()构造器创建对象时,底层都创建了长度为10的数组;

  • 在扩容方面,默认扩容为原来数组长度的2倍。

4.1.5 List接口常用方法

  • 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 lastlndexof(Object obj): 返回obj在当前集合中未次出现的位置

    • Object remove(int index): 移除指定index位置的元素,并返回此元素

    • Object set(int index, Object ele): 设置指定index位置的元素为ele

    • List subList(int fromlndex, int tolndex): 返回从fromIndex到tolndex位置的子集合

 package com.xue.java2;
 
 import org.junit.Test;
 
 import java.sql.SQLOutput;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/11
  * Time: 11:52
  * Description:
  * collection接口:单列数据,定义了存取一组对象的方法的集合。(目前只关注List和set)
  * -------------- List接口:存储有序的、可重复的数据。 -->“动态”数组,替换原有的数组
  *   - --------------------ArrayList: 作为List接口的主要实现类;线程不安全的,效率高; 底层使用Object[] elementData存储
  *   ---------------------LinkedList: 对于频繁的插入、删除操作,使用此类效率比ArrayList高; 底层使用双向链表存储
  *   ---------------------Vector: 作为List接口的古老实现类(jdk1.0就有了),线程安全,效率低; 底层使用Object[]存储
  * 5. list接口中的常用方法
  */
 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(456);
         System.out.println(list);  //[123, 456, AA, Person{name='Tom', age=12}, 456]
 
         //1. void add(int index, object ele); 在index位置插入ele元素
         list.add(1, "BB");
         System.out.println(list); //[123, BB, 456, AA, Person{name='Tom', age=12}, 456]
 
         //2. boolean addAll(int index, Collection eles): 从index位置开始将eles中的所有元素添加进来
         List list1 = Arrays.asList(1, 2, 3);
         list.addAll(list1);   //把每一个元素单独加进来,如果用add,就是加一个整体
         System.out.println(list.size()); //5+1+3 = 9
         System.out.println(list);  //[123, BB, 456, AA, Person{name='Tom', age=12}, 456, 1, 2, 3]
 
         //3. Object get(int index): 获取指定index位置的元素
         System.out.println(list.get(0));  //123
    }
 
     @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);
 
         //4. int indexOf(Object obj): 返回obj在集合中首次出现的位置
         System.out.println(list.indexOf(456));  //1,没有则返回-1
 
         //5. int lastlndexof(Object obj): 返回obj在当前集合中未次出现的位置
         System.out.println(list.lastIndexOf(456));  //4
 
         //6. Object remove(int index): 移除指定index位置的元素,并返回此元素
         Object obj = list.remove(1);
         System.out.println(obj);  //456
         System.out.println(list);  //[123, AA, Person{name='Tom', age=12}, 456]
 
         //7. Object set(int index, Object ele): 设置指定index位置的元素为ele
         list.set(1, "CC");
         System.out.println(list);  //[123, CC, Person{name='Tom', age=12}, 456]
 
         //8. List subList(int fromlndex, int tolndex): 返回从fromIndex到tolndex位置的子集合(左闭右开)
         List list1 = list.subList(2, 4);
         System.out.println(list1); //[Person{name='Tom', age=12}, 456]
         System.out.println(list);  //[123, CC, Person{name='Tom', age=12}, 456], list本身不会改变
 
    }
 }

总结: 常用方法

增:add(Object obj)

删:remove(int index) / remove(Object obj),后面的从集合继承的

改:set(int index, Object ele)

查:get(int index)

插:add((int index, Object ele))

长度:size()

遍历:1. Iterator迭代器方式 2. 增强for循环 3.普通for循环

 @Test
 public void test3(){
     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++) {q
         System.out.println(list.get(i));
    }
 
 
 }

面试题:考察remove

 package com.xue.exer;
 
 import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/12
  * Time: 10:37
  * Description: 面试题:考察remove
  */
 public class ListExer {
     @Test
     public void testListRemove(){
         ArrayList list = new ArrayList();
         list.add(1);
         list.add(2);
         list.add(3);
         updateList(list);
         System.out.println(list);  //[1, 2]
 
    }
 
     private static void updateList(List list){
         list.remove(2);  //删掉的是索引2
         //list.remove(new Integer(2)); //删掉的是数字2
    }
 }

4.2 Set接口概述

Set接口的框架:

  • collection接口:单列数据,定义了存取一组对象的方法的集合。(目前只关注List和set)

    • set接口:存储无序的、不可重复的数据 -->高中讲的“集合”

      • HashSet: 作为Set接口的主要实现类,线程不安全的;可以存储null值;

      • LinkedHashSet: 作为HashSet的子类; 遍历其内部数据时,可以按照添加的顺序遍历

      • TreeSet: 可以按照添加对象的指定属性进行排序。

  • Set集合不允许包含相同的元素,如果试把两个相同的元素加入同一个Set集合中,则添加操作失败

  • Set判断两个对象是否相同不是使用==运算符,而是根据equals()方法。

  • Set接口中没有定义新的方法,使用的都是Collection中声明过的方法。

  • HashSet底层用的是数组+链表的结构。

4.2.1 HashSet

 package com.xue.java3;
 
 import com.xue.java2.Person;
 import org.junit.Test;
 
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/12
  * Time: 10:48
  * Description:
  */
 public class SetTest {
     /*
     一、 set接口:存储无序的、不可重复的数据
     1. 无序性:不等于随机性. 存储的数据在底层数组中并非按照数组索引的顺序添加,而是根据数据的哈希值决定的
 
     2. 不可重复性:保证添加的元素按照equals()判断时,不能返回true,即:相同的元素只能添加一个。
     
     二、 添加元素的过程:以HashSet为例
     我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法,计算元素a的哈希值
     此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即为:索引位置),判断
     数组此位置上是否已经有元素:
         如果此位置上没有其他元素,则元素a添加成功。   -->情况1
         如果此位置上有其他元素(或以链表形式存在的多个元素),则比较元素a与b的hash值:
             如果hash值不相同,则元素a添加成功。       -->情况2
             如果hash值相同,进而需要调用元素a所在类的equals()方法:
                 equals()返回true,元素a添加失败
                 equals()返回false,元素a添加成功。   -->情况3
     对于添加成功的情况2和3而言:元素a与已经存在指定索引位置上数据以链表的形式存储。
     jdk7: 元素a放到数组中,指向原来的元素
     jdk8: 原来的元素在数组中,指向元素a
     总结: 七上八下
      */
     @Test
     public void test1(){
         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());
             //输出结果与书写顺序无关,同时只输出123一次,但是user会多次输出,因为没用重写方法(需要包含hashcode)。
 
        }
 
 
    }
 }

image-20220412223227659

Eclipse/IDEA工具里hashCode()的重写.

以Eclipse/IDEA为例,在自定义类中可以调用工具自动重写equals和hashCode。问题: 为什么用Eclipse/IDEA复写hashSode方法,有31这个数字?

  • 选择系数的时候要选择尽量大的 系数。因为如果计算出来的hash地址越大,所谓的“冲突”就越少,查找起来效率也会提高。(诚少冲突)

  • 并且31只占用5bits, 相乘造成数据溢出的概率较小。

  • 31可以由i*31==(i<<5)-1来表示,现在很多虚拟机里面都有做相关优化。 (提高算法效率)

  • 31是一个素数,素数作用就是如果我用一个数字来乘以这个素数,那么最终出来的结果只能被素数本身和被乘数还有1来整除! (减少冲突)

要求:

  1. 向Set(主要指:HashSet和LinkedHashSet)中添加数据,其所在的类一定要重写hashCode()和equals()方法

  2. 重写的hashCode()和equals()方法一定要有相同的特性,即相等的对象必须具有相等的散列码。

重写hashCode()方法的基本原则

  1. 在程序运行时,同一个对象多次调用hashCode()方法应该返回相同的值

  2. 当两个对象的equals方法比较返回true时,这两个对象的hashCode()方法的返回值也应相等

  3. 对象中用作equals()方法比较的Field,都应该用来计算hashCode值。

4.2.2 LinkedHashSet

 /*LinkedHashSet的使用
 LinkedHashSet作为HashSet的子类,在添加数据的同时,每个数据还维护了两个引用,记录此数据的前后一个数据。
 优点:
      1. 对于频繁的遍历操作,LinkedHashSet效率高于HashSet
  */
 @Test
 public void test2(){
     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());
         //也是无序存放的,但是遍历的时候是按照顺序出来的
    }

4.2.3 TreeSet

 package com.xue.java3;
 
 import org.junit.Test;
 
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.TreeSet;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/13 21:19
  * Description:
  */
 public class TreeSetTest {
 
     /*
     1. 向TreeSet中添加的数据,要求是相同类的对象
     2. 两种排序方式: 自然排序和定制排序
     3. TreeSet自然排序中,比较两个对象是否相同的标准为: compareTo()返回0,不再是equals了
     4. TreeSet定制排序中,比较两个对象是否相同的标准为: compare()返回0,不再是equals了
      */
     @Test
     public void test1(){
         TreeSet set = new TreeSet();
         //set.add(new User("ss",12)); //定义文件名为TreeSet,重名了,不能调用add方法了
         //失败: 不能添加不同类的对象
 //       set.add(123);
 //       set.add(456);
 //       set.add("AA");
 //       set.add(new User("ss",12));
 
         //举例1: 数字类型
 //       set.add(123);
 //       set.add(-34);
 //       set.add(0);
 //       set.add(1546);
 //       System.out.println(set); //输出数组
 
         //举例2: String类型
         //举例3: 自定义类,需要重写Comparable才能输出,采用自然排序
         set.add(new User("Tom", 12));
         set.add(new User("Jerry", 122));
         set.add(new User("Tack", 33));
         set.add(new User("Jim", 54));
         set.add(new User("Jim", 67));  //重写方法中return,进行判断,才能加进去
 
         Iterator iterator = set.iterator();
         while(iterator.hasNext()){
             System.out.println(iterator.next());  //遍历
        }
    }
 
     @Test
     public void test2(){
         //定制排序
         Comparator com = new Comparator(){
             //按照年龄从小到大
             @Override
             public 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);
         //写上了参数com就按照定制排序,否则按照自然排序。
         //定制排序有两个参数哦o1和o2,自然排序只有一个o
         set.add(new User("Tom", 12));
         set.add(new User("Jerry", 122));
         set.add(new User("Tack", 33));
         set.add(new User("Jim", 54));
         set.add(new User("Jim", 67));  //重写方法中return,进行判断,才能加进去
 
         Iterator iterator = set.iterator();
         while(iterator.hasNext()){
             System.out.println(iterator.next());  //遍历
        }
 
    }
 
 }

image-20220413220548693

User的自然排序方法重写

 //按照姓名从小到大
 @Override
 public 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("输入的类型不匹配");
    }
 }

5 集合复习及练习题

  1. 集合Collection中存储的如果是自定义类的对象,需要自定义类重写哪个方法? 为什么?

  • equals()方法。 调用contains() /remove()/retainsAll() ...可能要用到

  • List: equals()方法

  • Set: (HashSet、 LinkedHashSet为例): 重写equals()、hashCode()

(TreeSet 为例): 重写Comparable: compare To(Object obj)

重写Comparator: compare(Object o1, Object o2)

    • List一般用来装比较多的数据,

    • Set用的比较少,主要体现不重复的概念。像禁飞名单这种通过set效率比较高,直接计算hash值,通过equals方法。

  1. List接口:存储有序的、可重复的数据。 -->“动态”数组,替换原有的数组

    • ArrayList: 作为List接口的主要实现类;线程不安全的,效率高; 底层使用Object[] elementData存储;查找比较方便,直接定位到了。

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

    • Vector: 作为List接口的古老实现类(jdk1.0就有了),线程安全,效率低; 底层使用Object[]存储。

5.1 TreeSet练习题

 package com.xue.java4;
 
 import com.sun.source.tree.Tree;
 import org.junit.Test;
 
 import javax.print.DocFlavor;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.TreeSet;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/15 9:13
  * Description:
  * 创建该类的五个对象,并把这些对象放入TreeSet集合中(下一章:TreeSet需使用泛型来定义)
  * 分别按以下两种方式对集合中的元素进行排序,并遍历输出
  * 1) 使Employee实现Comparable接口,并按name排序
  * 2) 创建TreeSet时传入Comparator对象,按生日日期的先后顺序排序。
  */
 public class TreeSetTest<day> {
     //问题二: 按生日日期的先后排序
     @Test
     public void test2(){
         Comparator com = new Comparator() {
             @Override
             public int compare(Object o1, Object o2) {
                 if (o1 instanceof Employee && o2 instanceof Employee){
                     Employee ee1 = (Employee)o1;
                     Employee ee2 = (Employee)o2;
                     if(ee1.getBirthday().getYear() != ee2.getBirthday().getYear()){
                     return Integer.compare(ee1.getBirthday().getYear(), ee2.getBirthday().getYear());
                    }else if(ee1.getBirthday().getMonth() != ee2.getBirthday().getMonth()){
                         return Integer.compare(ee1.getBirthday().getMonth(), ee2.getBirthday().getMonth());
                    }else{
                         return Integer.compare(ee1.getBirthday().getDay(), ee2.getBirthday().getDay());
                    }
                }else{
                     throw new RuntimeException("滚");
                }
            }
        };
         TreeSet set = new TreeSet(com);  //也可以直接采用在这里new一个comparator的方法
         Employee e1 = new Employee("liudehua", 55, new MyDate(1965, 5, 4 ));
         //System.out.println(e1);
         Employee e2 = new Employee("liming", 51, new MyDate(1987, 5, 4 ));
         Employee e3 = new Employee("zhangxueyou", 43, new MyDate(1987, 6, 9 ));
         Employee e6 = new Employee("zhangxuelaing", 43, new MyDate(1987, 5, 10 ));
         Employee e4 = new Employee("guofucheng", 44, new MyDate(1954, 8, 12 ));
         Employee e5 = new Employee("laingchaowei", 21, new MyDate(1978, 12, 4 ));
 
         set.add(e1);
         set.add(e2);
         set.add(e3);
         set.add(e4);
         set.add(e5);
         set.add(e6);
 
         Iterator iterator = set.iterator();
         while(iterator.hasNext()){
             System.out.println(iterator.next());  //遍历
        }
    }
 
     //问题一: 根据姓名排序,使用自然排序
 
     @Test
     public void test1(){
         TreeSet set = new TreeSet();
         Employee e1 = new Employee("liudehua", 55, new MyDate(1965, 5, 4 ));
         //System.out.println(e1);
         Employee e2 = new Employee("liming", 51, new MyDate(1987, 5, 4 ));
         Employee e3 = new Employee("zhangxueyou", 43, new MyDate(1987, 5, 9 ));
         Employee e4 = new Employee("guofucheng", 44, new MyDate(1954, 8, 12 ));
         Employee e5 = new Employee("laingchaowei", 21, new MyDate(1978, 12, 4 ));
 
 //       MyDate myDate = new MyDate();
 //       System.out.println(myDate);
 
         set.add(e1);
         set.add(e2);
         set.add(e3);
         set.add(e4);
         set.add(e5);
 
         Iterator iterator = set.iterator();
         while(iterator.hasNext()){
             System.out.println(iterator.next());  //遍历
        }
 
    }
 
 }

MyDate类

 package com.xue.java4;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/14 20:52
  * Description: TreeSet课后习题
  * MyDate类包含:
  * private成员变量year, month, day; 并为每一个属性定义getter,setter放法
  *
  */
 public class MyDate {
     private int year;
     private int month;
     private int day;
 
     public MyDate() {
    }
 
     public MyDate(int year, int month, int day) {
         this.year = year;
         this.month = month;
         this.day = day;
    }
 
     public int getYear() {
         return year;
    }
 
     public void setYear(int year) {
         this.year = year;
    }
 
     public int getMonth() {
         return month;
    }
 
     public void setMonth(int month) {
         this.month = month;
    }
 
     public int getDay() {
         return day;
    }
 
     public void setDay(int day) {
         this.day = day;
    }
 
     @Override
     public String toString() {
         return "MyDate{" +
                 "year=" + year +
                 ", month=" + month +
                 ", day=" + day +
                 '}';
    }
 }

Employee类

 package com.xue.java4;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/14 21:31
  * Description:
  *
  *定义一个Employee类
  * 该类包含:private成员变量name, age, birthday,其中birthday为MyDate类的对象;
  * 并为每一个属性定义getter,setter方法;
  * 并重写toString方法输出name, age, birthday
  */
 public class Employee implements Comparable{
     private String name;
     private int age;
     private MyDate birthday;
 
     public Employee() {
    }
 
     public Employee(String name, int age, MyDate birthday) {
         this.name = name;
         this.age = age;
         this.birthday = birthday;
    }
 
     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;
    }
 
     public MyDate getBirthday() {
         return birthday;
    }
 
     public void setBirthday(MyDate birthday) {
         this.birthday = birthday;
    }
 
     @Override
     public String toString() {
         return "Employee{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 ", birthday=" + birthday +
                 '}';
    }
 
     @Override
     public int compareTo(Object o) {
         if(o instanceof Employee){
             Employee employee = (Employee)o;  //可能是父子关系,所以要强转以下
             int compare = this.name.compareTo(employee.name);
             if(compare != 0){
                 return(compare);
            }else{
                 return Integer.compare(this.age, employee.age);
            }
        }else{
             throw new RuntimeException("您输入类型错误");
        }
    }
 }

5.2 List内去除重复数字值

  • 在List内去除重复数字值,要求尽量简单

 package com.xue.java4;
 
 import org.junit.Test;
 
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/15 10:33
  * Description: 在List内去除重复数字值,要求尽量简单
  */
 public class CollectionTest {
 
     public static List duplicateList(List list) {
 
         HashSet set = new HashSet();  //用set处理不重复数据
         set.addAll(list);
         return new ArrayList(set);
    }
     @Test
     public void test1(){
         List list = new ArrayList();
         list.add(new Integer(1));
         list.add(new Integer(2));
         list.add(new Integer(2));
         list.add(new Integer(4));
         list.add(new Integer(4));
         
         List list2 = duplicateList(list);  //调用方法
         for (Object integer : list2) {  //增强for循环遍历
             System.out.println(integer);
        }
    }
 }

5.3 面试题

 @Test
 public void test2(){
     HashSet set =  new HashSet();
     Person p1 =new Person(1001, "AA");
     Person p2 =new Person(1002, "BB");
 
     set.add(p1);
     set.add(p2);
     System.out.println(set);
 
     p1.name = "CC";
     set.remove(p1);
     System.out.println(set);
 
     set.add(new Person(1001, "CC"));
     System.out.println(set);
 
     set.add(new Person(1001, "AA"));
     System.out.println(set);
     //Person类重写了hashCode()和equals()方法
 }

输出:

[Person{ID='1002', name='BB'}, Person{ID='1001', name='AA'}] [Person{ID='1002', name='BB'}, Person{ID='1001', name='CC'}] [Person{ID='1002', name='BB'}, Person{ID='1001', name='CC'}, Person{ID='1001', name='CC'}] [Person{ID='1002', name='BB'}, Person{ID='1001', name='CC'}, Person{ID='1001', name='CC'}, Person{ID='1001', name='AA'}]

image-20220420170733775

image-20220415111745575

6 Map接口

6.1 HashMap

  1. Map接口继承树

image-20220415113303686

 * Map接口: 双列数据,存储key-value对的数据  -->类似于高中的函数: y = f(x)
 *        |-----HashMap:作为Map的主要实现类; 线程不安全的,效率高;可以存储null的key和value
 *              |-----LinkedHashMap: 保证在遍历map元素时,可以按照添加的顺序实现遍历
 *              原因:在原有的HashMap底层结构基础上,添加了一对指针,指向前一个和后一个元素。
 *                    对于频繁的遍历操作,此类执行效率高于HashMap。
 *        |-----TreeMap: 保证按照添加的key-value对进行排序,实现排序遍历(按照key来排序)
 *                       此时考虑key的自然排序或者定制排序
 *                       底层使用红黑树
 *        |-----Hashtable: 作为古老的实现类; 线程安全的,效率低;不能存储null的key和value
 *              |----Properties: 常用来处理配置文件。key和value都是String类型。
 *
 * HashMap的底层: 数组+链表 (jdk7及之前)
 *            数组+链表+红黑树 (jdk8)
  1. Map结构的理解:

  • Map中的key:无序的、不可重复的,使用Set存储所有的key ---》 key所在的类要重写equals()和hashCode(),以HashMap为例。 如果是TreeMap就要自然排序和定制排序了。

  • Map中的value:无序的、可重复的,使用Collection存储所有的value ---》value所在类要重写equals()。

  • 一个键值对:key-value构成了一个Entry对象。

  • Map中的entry:无序的、不可重复的,使用Set存储所有的entry

image-20220415151541979

  1. HashMap的底层实现原理? 以jdk7为例说明

 HashMap map = new HashMap();  
 //在实例化之后,底层创建了长度是16的一维数组Entry[] table。
 //此时可能已经执行过多次put
 map.put(key1, value1);
 //首先,调用key1所在类的hashCode()计算key1哈希值,此哈希值经过某种算法计算以后,得到在Entry数组中的存放位置。
 //如果此位置上的数据为空,此时的key1-value1添加成功。 - - -》
 //如果此位置上数据不为空(意味着此位置上存在一个或多个数据(以链表形式存在),比较key1和已经存在的一个或多个数据的哈希值):
       //如果key1的哈希值与已经存在的数据的哈希值都不相同,此时的key1-value1添加成功。
       //如果key1的哈希值与已经存在的某一个数据(key2-value2)的哈希值相同,继续比较:调用key1所在类的equals()方法,比较;
           //如果equals()返回false:此时key1-value1添加成功。
           //如果equals()返回true:使用value1替换value2。
 //补充:关于情况2和情况3,此时key1-value1和原来的数据以链表的方式存储。
 //在不断的添加过程中,会涉及到扩容问题,当超出临界值(且要存放的位置非空)时,扩容;默认的扩容方式:扩容为原来容量的2倍,并将原有的数据复制过来。
  1. jdk8相较于jdk7在底层实现方面的不同

    • jdk8底层的数组是:Node[],而非Entry[]

    • new HashMap():底层没有创建一个长度为16的数组

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

    • jdk7底层结构只有:数组+链表;jdk8中底层结构:数组+链表+红黑树。

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

  2. HashMap源码中的重要常量

    • DEFAULT_ INITIAL_ CAPACITY : HashMap的默认容量,16

    • MAXIMUM_ CAPACITY : HashMap的最大支持容量, 2^30

    • DEFAULT_ LOAD_ FACTOR: HashMap的默认加载因子: 0.75

    • TREEIFY THRESHOLD: Bucket中链表长度大于该默认值,转化为红黑树 :8

    • UNTREEIFY_ THRESHOLD: Bucket中红黑树存储的Node小于该默认值,转化为链表

    • MIN_ TREEIFY_CAPACITY: 桶中的Node被树化时最小的hash表容量 : 64。( 当桶中Node的数量大到需要变红黑树时,若hash表容量小于MIN_ TREEIFY_ CAPACITY时,此时应执行resize扩容操作这个MIN TREEIFY_ CAPACITY的值至少是TREEIFY_ _THRESHOLD的4倍。)

    • table: 存储元素的数组,总是2的n次幂

    • entrySet: 存储具体元素的集

    • size: HashMap中 存储的键值对的数量

    • modCount: HashMap扩容和结构改变的次数。

    • threshold: 扩容的临界值,=容量*填充因子 = 16 * 0.75 = 12,提前扩容,以免出现链表太长。

    • loadFactor:填充因子

6.2 LinkedHashMap

  1. LinkedHashMap底层实现原理(了解)

    • HashMap中的内部类: Node

    • LinkedHashMap中的内部类: Entry

6.3 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中的所有数据

  • 元素查询的操作:

    • 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是否相等

  • 元视图操作的方法:

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

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

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

 package com.xue.java4;
 
 import org.junit.Test;
 
 import java.sql.SQLOutput;
 import java.util.*;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/15 11:37
  * Description:
  * Map接口: 双列数据,存储key-value对的数据 -->类似于高中的函数: y = f(x)
  *       |-----HashMap:作为Map的主要实现类; 线程不安全的,效率高;可以存储null的key和value
  *             |-----LinkedHashMap: 保证在遍历map元素时,可以按照添加的顺序实现遍历
  *             原因:在原有的HashMap底层结构基础上,添加了一对指针,指向前一个和后一个元素。
  *                   对于频繁的遍历操作,此类执行效率高于HashMap。
  *       |-----TreeMap: 保证按照添加的key-value对进行排序,实现排序遍历(按照key来排序)。
  *                       此时考虑key的自然排序或者定制排序
  *                       底层使用红黑树
  *       |-----Hashtable: 作为古老的实现类; 线程安全的,效率低;不能存储null的key和value
  *             |----Properties: 常用来处理配置文件。key和value都是String类型。
  *
  * HashMap的底层: 数组+链表 (jdk7及之前)
  *                 数组+链表+红黑树 (jdk8)
  */
 public class MapTest {
     @Test
     public void test1(){
         Map map = new HashMap();
         //map = new Hashtable(); //Hashtable()报空指针异常
         map.put(null, null);
    }
 
     @Test  //增删改
     public void test2(){
         Map map = new HashMap();
         //添加
         map.put("AA", 123);
         map.put(45, 23);
         map.put("BB", 56);
         //修改
         map.put("AA", 87);
         System.out.println(map);  //{AA=87, BB=56, 45=23}
 
         //putAll
         Map map1 = new HashMap();
         map1.put("CC", 123);
         map1.put("DD", 123);
         map.putAll(map1);
 
         System.out.println(map);  //{AA=87, BB=56, CC=123, DD=123, 45=23}
 
         //remove(object key)
         Object value = map.remove("CC");
         System.out.println(value);   //123
         System.out.println(map);  //{AA=87, BB=56, DD=123, 45=23}
 
         //clear()
         map.clear();  //与 map = null(这是空指针的意思)不同
         System.out.println(map);  //{}
         System.out.println(map.size());  //0
    }
 
     @Test  //查询
     public void test3(){
         Map map = new HashMap();
         map.put("AA", 123);
         map.put(45, 123);
         map.put("BB", 56);
 
         //Object get(Object key)
         System.out.println(map.get(45));  //123
 
         //Object get(Object key)
         boolean isExist = map.containsKey("BB");
         System.out.println(isExist);  //TRUE
 
         isExist = map.containsValue(123);
         System.out.println(isExist);  //true
 
         map.clear();  //new的对象仍然存在,只是value都清空了
         System.out.println(map.isEmpty());  //true
    }
 
     @Test  //元视图操作
     public void test4(){
         Map map = new HashMap();
         map.put("AA", 123);
         map.put(45, 123);
         map.put("BB", 56);
 
         //遍历所有的key集: keySet()
         Set set = map.keySet();
         Iterator iterator = set.iterator();
         while(iterator.hasNext()){
             System.out.println(iterator.next());
        }  //AA BB 45
 
         //遍历所有的value集: values()
         Collection values = map.values();
         for(Object obj : values){
             System.out.println(obj);  //123 56 123
        }
 
         //遍历所有的key-value,
         // 方式一: entrySet();
         Set entrySet = map.entrySet();
         Iterator iterator1 = entrySet.iterator();
         while(iterator1.hasNext()){
 //           Object obj = iterator1.next();
 //           Map.Entry entry = (Map.Entry) obj; //强转
 //           System.out.println(entry.getKey()+ "--->" + entry.getValue());
             //iterator1.next()这里是object,不能调用其他方法,如果进行强转,就可以使用其他方法
             System.out.println(iterator1.next());  //AA=123 BB=56 45=123
        }
 
         //方式二:
         Set keySet = map.keySet();
         Iterator iterator2 = keySet.iterator();
         while(iterator2.hasNext()){
             Object key = iterator2.next();
             Object value = map.get(key);
             System.out.println(key + "=======" + value);
 
        }
 
    }
 
 }

6.4 TreeMap两种添加方式的使用

 package com.xue.java4;
 
 import org.junit.Test;
 
 import java.util.*;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/19 10:10
  * Description:
  */
 public class TreeMapTest {
     //向TreeMap中添加key-value,要求key必须是由同一个类型创建的对象
     //因为要按照key进行排序:自然排序、定制排序
 
     //自然排序
     @Test
     public void test1(){
         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()); //转换成entry类,可以进行排序
        }
    }
 
     @Test
     public void test2(){
         Map map = new TreeMap(new Comparator() {
             @Override
             public int compare(Object o1, Object o2) {
                 if(o1 instanceof User && o1 instanceof User){
                     User u1 = (User) o1;
                     User u2 = (User) o2;
                     return Integer.compare(u1.getAge(), u2.getAge());
                }else{
                     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()); //转换成entry类,可以进行排序
        }
    }
 
 }

6.5 Properties

  • Properties类是Hashtable的子类,该对象用于处理属性文件

  • 由于属性文件里的key、value都是字符串类型,所以Properties里的key和value都是字符串类型。

  • 存取数据时,建议使用setProperties(String key, String value)方法和getProperty(String key)方法

 Properties pros = new Properties();
 pros.load(new FileInputStream("jdbc.properties"));
 String user = pros.getProperty("user");
 System.out.println(user);
 package com.xue.java4;
 
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.util.Properties;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/19 11:13
  * Description:
  */
 public class PropertiesTest {
     public static void main(String[] args) throws Exception {
         //Properties类是Hashtable的子类,该对象用于**处理属性文件**; key和value都是字符串类型
         Properties pros = new Properties();
         FileInputStream fis = new FileInputStream("jdbc.properties");  //选中类,alt enter 抛出异常
         pros.load(fis);  //加载流对应的文件
         String name = pros.getProperty("name");
         String password = pros.getProperty("password");
 
         System.out.println("name = "+ name + ", password =" + password);
    }
 }

properties文件如下:

 name=Tom
 password=abc123

7 Collections工具类

  • Collections是一个操作Set、List 和Map等集合的工具类

  • Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作,还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

  • 排序操作: (均为static方法)

    • 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中

7.1 排序、查找、替换

 package com.xue.java5;
 
 import org.junit.Test;
 
 import java.util.*;
 
 /**
  * Created with IntelliJ IDEA.
  * User: xinxueqi
  * Date: 2022/4/20 10:49
  * Description:
  * Collections: 操作Collection、Map的工具类
  * 面试题:Collection和Collections的区别?
  */
 public class CollectionsTest {
     @Test
     public void test2(){
         List list = new ArrayList();
         list.add(123);
         list.add(43);
         list.add(765);
         list.add(-97);
         list.add(0);
 
 //       List dest = new ArrayList();
 //       System.out.println(dest.size()); //0
 //       dest.add(123);
 //       dest.add(123);
 //       dest.add(123);
 //       dest.add(123);
 //       dest.add(123);
         List dest = Arrays.asList(new Object[ list.size() ]);  //新建list的size大小的数据
         Collections.copy(dest, list);  //报错了,查看源码发现是size的问题,dest不能小,只能提前填充数据撑起来
 
         System.out.println(dest);
    }
 
     @Test
     public void test1(){
         ArrayList list = new ArrayList();
         list.add(123);
         list.add(43);
         list.add(765);
         list.add(-97);
         list.add(0);
 
         ArrayList list1 = new ArrayList();
         list1.add(123);
         list1.add(43);
         list1.add(765);
         list1.add(765);
         list1.add(765);
         list1.add(-97);
         list1.add(0);
         System.out.println(list);  //[123, 43, 765, -97, 0]
 
         //Collections.reverse(List) 反转
 //       Collections.reverse(list); //[0, -97, 765, 43, 123]
 
         //Collections.shuffle(List) 随机排序
 //       Collections.shuffle(list); //[43, 0, -97, 123, 765]
 
         //Collections.sort(List) 排序,升序
 //       Collections.sort(list); //[-97, 0, 43, 123, 765]
 
         //Collections.swap(List) 交换索引位置上的元素
 //       Collections.swap(list, 1 , 2); //[123, 765, 43, -97, 0]
         System.out.println(list);
 
         int frequency = Collections.frequency(list1, 765);  //3
         System.out.println(frequency);
    }
 }

7.2 同步控制

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

 /*
 Collections类中提供了多个synchronizedXXX()方法,
 该方法可使将**指定集合包装成线程同步**的集合,
 从而可以解决**多线程并发访问集合时的线程安全问题**。
  */
 //返回的list1即为线程安全的List
 List list1 = Collections.synchronizedList(list);

8 数据结构-java版

  • 涉及的内容包括:数据的逻辑关系、数据的存储结构、排序算法、查找(或搜索)等

  • 理解数据结构的作用:

    • 战场: 程序运行所需的软件、硬件环境

    • 敌人: 项目或模块的功能需求

    • 指挥官: 编写程序的程序员

    • 士兵和装备: 一行一行的代码

    • 战术和策略: 数据结构

  • 程序能否快速而高效地完成预定的任务,取决于是否选对了数据结构,而程序是否能清楚而正确地把问题解决,则取决于算法

9 面试题

  1. 负载因子值的大小,对HashMap有什么影响

    • 负载因子的大小决定了HashMap的数据密度。

    • 负载因子越大密度越大,发生碰撞的几率越高,数组中的链表越容易长,造成查询或插入时的比较次数增多,性能会下降。

    • 负载因子越小,就越容易触发扩容,数据密度也越小,意味着发生碰撞的几率越小,数组中的链表也就越短,查询和插入时比较的次数也越小,性能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能,建议初始化预设大一点的空间。

    • 按照其他语言的参考及研究经验,会考虑将负载因子设置为0.7~0.75,此时平均检索长度接近于常数。

  2. ArrayList和HashMap都是线程不安全的,如果程序要求线程安全,我们可以将ArrayList、HashMap转换为线程的。

    使用synchronizedList(List list) 和 synchronizedMap(Map map)。

知识补充

1 IDEA 快捷键设置

  • File-->Seetings-->keyMap-->run .... -->修改成Q了

  • 如果已知快捷键是什么,可以通过放大镜搜寻

2 双击shift,可以进行查询

3 compare和compaeTo

 Integer.compare(ee1.getBirthday().getDay(), ee2.getBirthday().getDay()); 
 //compare是两个数在括号里比较
  this.name.compareTo(employee.name);
 //compareTo是一个数调用比较方法,参数是另一个被比较的数
 
posted @   诺不克  阅读(21)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 没有源码,如何修改代码逻辑?
· PowerShell开发游戏 · 打蜜蜂
· 在鹅厂做java开发是什么体验
· WPF到Web的无缝过渡:英雄联盟客户端的OpenSilver迁移实战
点击右上角即可分享
微信分享提示