19_集合_第19天(List、Set)_讲义

今日内容介绍
1、List接口
2、Set接口
3、判断集合唯一性原理

非常重要的关系图

xmind下载地址

链接:https://pan.baidu.com/s/1kx0XabmT27pt4Ll9AqzVog 密码:bjgt

01List接口的特点

A:List接口的特点:

   a:它是一个元素存取有序的集合。
        例如,存元素的顺序是11、22、33。那么集合中,元素的存储就是按照11、22、33的顺序完成的)。
   b:它是一个带有索引的集合,通过索引就可以精确的操作集合中的元素(与数组的索引是一个道理)。

     c:集合中可以有重复的元素,通过元素的equals方法,来比较是否为重复的元素。

     d:List接口的常用子类有:
      ArrayList集合
      LinkedList集合

02List接口的特有方法

    A:List接口的特有方法(带索引的方法)
   a:增加元素方法
  ? add(Object e):向集合末尾处,添加指定的元素
  ? add(int index, Object e)   向集合指定索引处,添加指定的元素,原有元素依次后移

     /*
       *  add(int index, E)
       *  将元素插入到列表的指定索引上
       *  带有索引的操作,防止越界问题
       *  java.lang.IndexOutOfBoundsException
       *     ArrayIndexOutOfBoundsException
       *     StringIndexOutOfBoundsException
       */
      public static void function(){
        List<String> list = new ArrayList<String>();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");
        System.out.println(list);

        list.add(1, "itcast");
        System.out.println(list);
      }

   b:删除元素删除
  ? remove(Object e):将指定元素对象,从集合中删除,返回值为被删除的元素
  ? remove(int index):将指定索引处的元素,从集合中删除,返回值为被删除的元素
     /*
       *  E remove(int index)
       *  移除指定索引上的元素
       *  返回被删除之前的元素
       */
      public static void function_1(){
        List<Double> list = new ArrayList<Double>();
        list.add(1.1);
        list.add(1.2);
        list.add(1.3);
        list.add(1.4);

        Double d = list.remove(0);
        System.out.println(d);
        System.out.println(list);
      }
   c:替换元素方法
   set(int index, Object e):将指定索引处的元素,替换成指定的元素,返回值为替换前的元素
      /*
       *  E set(int index, E)
       *  修改指定索引上的元素
       *  返回被修改之前的元素
       */
      public static void function_2(){
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        Integer i = list.set(0, 5);
        System.out.println(i);
        System.out.println(list);
      }
    d:查询元素方法
    get(int index):获取指定索引处的元素,并返回该元素

03迭代器的并发修改异常

A:迭代器的并发修改异常

 /*
  *  迭代器的并发修改异常 java.util.ConcurrentModificationException
  *  就是在遍历的过程中,使用了集合方法修改了集合的长度,不允许的
  */
 public class ListDemo1 {
  public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    list.add("abc1");
    list.add("abc2");
    list.add("abc3");
    list.add("abc4");

    //对集合使用迭代器进行获取,获取时候判断集合中是否存在 "abc3"对象
    //如果有,添加一个元素 "ABC3"
    Iterator<String> it = list.iterator();
    while(it.hasNext()){
      String s = it.next();
      //对获取出的元素s,进行判断,是不是有"abc3"
      if(s.equals("abc3")){
        list.add("ABC3");
      }
      System.out.println(s);
    }
  }
 }

 运行上述代码发生了错误 java.util.ConcurrentModificationException这是什么原因呢?
   在迭代过程中,使用了集合的方法对元素进行操作。
   导致迭代器并不知道集合中的变化,容易引发数据的不确定性。

 并发修改异常解决办法:
    在迭代时,不要使用集合的方法操作元素。
    或者通过ListIterator迭代器操作元素是可以的,ListIterator的出现,解决了使用Iterator迭代过程中可能会发生的错误情况。

04数据的存储结构

A:数据的存储结构
 a:栈结构:后进先出/先进后出(手枪弹夹) FILO (first in last out)
 b:队列结构:先进先出/后进后出(银行排队) FIFO(first in first out)
 c:数组结构:
           查询快:通过索引快速找到元素
           增删慢:每次增删都需要开辟新的数组,将老数组中的元素拷贝到新数组中
                  开辟新数组耗费资源
 d:链表结构
           查询慢:每次都需要从链头或者链尾找起
           增删快:只需要修改元素记录的下个元素的地址值即可不需要移动大量元素

05ArrayList集合的自身特点

A:ArrayList集合的自身特点

 底层采用的是数组结构
 ArrayList al=new ArrayList();//创建了一个长度为0的Object类型数组
 al.add("abc");//底层会创建一个长度为10的Object数组 Object[] obj=new Object[10]
               //obj[0]="abc"
              //如果添加的元素的超过10个,底层会开辟一个1.5*10的长度的新数组
              //把原数组中的元素拷贝到新数组,再把最后一个元素添加到新数组中
   原数组:
     a b c d e f g h k l
   添加m:
     a b c d e f g h k l m null null null null

06LinkedList集合的自身特点

A:LinkedList集合的自身特点

 底层采用链表结构,每次查询都要从链头或链尾找起,查询相对数组较慢
 但是删除直接修改元素记录的地址值即可,不要大量移动元素

 LinkedList的索引决定是从链头开始找还是从链尾开始找
 如果该元素小于元素长度一半,从链头开始找起,如果大于元素长度的一半,则从链尾找起

07LinkedList特有方法

*A:LinkedList特有方法:获取,添加,删除

   /*
 *  LinkedList 链表集合的特有功能
 *    自身特点: 链表底层实现,查询慢,增删快
 *
 *  子类的特有功能,不能多态调用
 */
public class LinkedListDemo {
  public static void main(String[] args) {
    function_3();
  }

  /*
   *  E removeFirst() 移除并返回链表的开头
   *  E removeLast() 移除并返回链表的结尾
   */
  public static void function_3(){
    LinkedList<String> link = new LinkedList<String>();
    link.add("1");
    link.add("2");
    link.add("3");
    link.add("4");

    String first = link.removeFirst();
    String last = link.removeLast();
    System.out.println(first);
    System.out.println(last);

    System.out.println(link);
  }

  /*
   * E getFirst() 获取链表的开头
   * E getLast() 获取链表的结尾
   */
  public static void function_2(){
    LinkedList<String> link = new LinkedList<String>();
    link.add("1");
    link.add("2");
    link.add("3");
    link.add("4");

    if(!link.isEmpty()){
      String first = link.getFirst();
      String last = link.getLast();
      System.out.println(first);
      System.out.println(last);
    }
  }

  public static void function_1(){
    LinkedList<String> link = new LinkedList<String>();
    link.addLast("a");
    link.addLast("b");
    link.addLast("c");
    link.addLast("d");

    link.addFirst("1");
    link.addFirst("2");
    link.addFirst("3");
    System.out.println(link);
  }

  /*
   *  addFirst(E) 添加到链表的开头
   *  addLast(E) 添加到链表的结尾
   */
  public static void function(){
    LinkedList<String> link = new LinkedList<String>();

    link.addLast("heima");

    link.add("abc");
    link.add("bcd");

    link.addFirst("itcast");
    System.out.println(link);

  }
}

08Vector类的特点

*A:Vector类的特点

   Vector集合数据存储的结构是数组结构,为JDK中最早提供的集合,它是线程同步的
   Vector中提供了一个独特的取出方式,就是枚举Enumeration,它其实就是早期的迭代器。
   此接口Enumeration的功能与 Iterator 接口的功能是类似的。
   Vector集合已被ArrayList替代。枚举Enumeration已被迭代器Iterator替代。

09Set接口的特点

A:Set接口的特点
a:它是个不包含重复元素的集合。
b:Set集合取出元素的方式可以采用:迭代器、增强for。
c:Set集合有多个子类,这里我们介绍其中的HashSet、LinkedHashSet这两个集合。

10Set集合存储和迭代

A:Set集合存储和迭代

  /*
   *  Set接口,特点不重复元素,没索引
   *
   *  Set接口的实现类,HashSet (哈希表)
   *  特点: 无序集合,存储和取出的顺序不同,没有索引,不存储重复元素
   *  代码的编写上,和ArrayList完全一致
   */
  public class HashSetDemo {
    public static void main(String[] args) {
      Set<String> set = new HashSet<String>();
      set.add("cn");
      set.add("heima");
      set.add("java");
      set.add("java");
      set.add("itcast");

      Iterator<String> it = set.iterator();
      while(it.hasNext()){
        System.out.println(it.next());
      }
      System.out.println("==============");

      for(String s : set){
        System.out.println(s);
      }
    }
  }

11哈希表的数据结构


A:哈希表的数据结构:(参见图解)

    加载因子:表中填入的记录数/哈希表的长度
    例如:
    加载因子是0.75 代表:
      数组中的16个位置,其中存入16*0.75=12个元素

    如果在存入第十三个(>12)元素,导致存储链子过长,会降低哈希表的性能,
    那么此时会扩充哈希表(在哈希),底层会开辟一个长度为原长度2倍的数组,把老元素拷贝到新
    数组中,再把新元素添加数组中

    当存入元素数量>哈希表长度*加载因子,就要扩容,因此加载因子决定扩容时机

12字符串对象的哈希值

  A:字符串对象的哈希值
  /*
   *  对象的哈希值,普通的十进制整数
   *  父类Object,方法 public int hashCode() 计算结果int整数
   */
  public class HashDemo {
    public static void main(String[] args) {
      Person p = new Person();
      int i = p.hashCode();
      System.out.println(i);

      String s1 = new String("abc");
      String s2 = new String("abc");
      System.out.println(s1.hashCode());
      System.out.println(s2.hashCode());

      /*System.out.println("重地".hashCode());
      System.out.println("通话".hashCode());*/
    }
  }

  //String类重写hashCode()方法
  //字符串都会存储在底层的value数组中{'a','b','c'}
  public int hashCode() {
          int h = hash;//hash初值为0
          if (h == 0 && value.length > 0) {
              char val[] = value;

              for (int i = 0; i < value.length; i++) {
                  h = 31 * h + val[i];
              }
              hash = h;
          }
          return h;
      }

13哈希表的存储过程


A:哈希表的存储过程

 public static void main(String[] args) {
    HashSet<String> set = new HashSet<String>();
    set.add(new String("abc"));
    set.add(new String("abc"));
    set.add(new String("bbc"));
    set.add(new String("bbc"));
    System.out.println(set);
}

存取原理:

每存入一个新的元素都要走以下三步:

1.首先调用本类的hashCode()方法算出哈希值

2.在容器中找是否与新元素哈希值相同的老元素,
  如果没有直接存入
  如果有转到第三步

3.新元素会与该索引位置下的老元素利用equals方法一一对比
  一旦新元素.equals(老元素)返回true,停止对比,说明重复,不再存入
  如果与该索引位置下的老元素都通过equals方法对比返回false,说明没有重复,存入

14哈希表的存储自定义对象

A:哈希表的存储自定义对象

 /*
  *  HashSet集合的自身特点:
  *    底层数据结构,哈希表
  *    存储,取出都比较快
  *    线程不安全,运行速度快
  */
 public class HashSetDemo1 {
  public static void main(String[] args) {

    //将Person对象中的姓名,年龄,相同数据,看作同一个对象
    //判断对象是否重复,依赖对象自己的方法 hashCode,equals
    HashSet<Person> setPerson = new HashSet<Person>();
    setPerson.add(new Person("a",11));
    setPerson.add(new Person("b",10));
    setPerson.add(new Person("b",10));
    setPerson.add(new Person("c",25));
    setPerson.add(new Person("d",19));
    setPerson.add(new Person("e",17));//每个对象的地址值都不同,调用Obejct类的hashCode方法返回不同哈希值,直接存入
    System.out.println(setPerson);
  }
 }

public class Person {
  private String name;
  private int 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;
  }
  public Person(String name, int age) {
    super();
    this.name = name;
    this.age = age;
  }
  public Person(){}

  public String toString(){
    return name+".."+age;
  }

 }

15自定义对象重写hashCode和equals

 A:自定义对象重写hashCode和equals
  /*
      *  HashSet集合的自身特点:
      *    底层数据结构,哈希表
      *    存储,取出都比较快
      *    线程不安全,运行速度快
      */
     public class HashSetDemo1 {
      public static void main(String[] args) {

        //将Person对象中的姓名,年龄,相同数据,看作同一个对象
        //判断对象是否重复,依赖对象自己的方法 hashCode,equals
        HashSet<Person> setPerson = new HashSet<Person>();
        setPerson.add(new Person("a",11));
        setPerson.add(new Person("b",10));
        setPerson.add(new Person("b",10));
        setPerson.add(new Person("c",25));
        setPerson.add(new Person("d",19));
        setPerson.add(new Person("e",17));
        System.out.println(setPerson);
      }
     }

    public class Person {
      private String name;
      private int age;

      /*
       *  没有做重写父类,每次运行结果都是不同整数
       *  如果子类重写父类的方法,哈希值,自定义的
       *  存储到HashSet集合的依据
       *
       *  尽可能让不同的属性值产生不同的哈希值,这样就不用再调用equals方法去比较属性
       *
       */
      public int hashCode(){
        return name.hashCode()+age*55;
      }
      //方法equals重写父类,保证和父类相同
      //public boolean equals(Object obj){}
      public boolean equals(Object obj){
        if(this == obj)
          return true;
        if(obj == null)
          return false;
        if(obj instanceof Person){
          Person p = (Person)obj;
          return name.equals(p.name) && age==p.age;
        }
        return false;
      }

      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 Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
      }
      public Person(){}

      public String toString(){
        return name+".."+age;
      }

     }

16LinkedHashSet集合

  A:LinkedHashSet集合
    /*
     *   LinkedHashSet 基于链表的哈希表实现
     *   继承自HashSet
     *
     *   LinkedHashSet 自身特性,具有顺序,存储和取出的顺序相同的
     *   线程不安全的集合,运行速度块
     */
    public class LinkedHashSetDemo {

      public static void main(String[] args) {
        LinkedHashSet<Integer> link = new LinkedHashSet<Integer>();
        link.add(123);
        link.add(44);
        link.add(33);
        link.add(33);
        link.add(66);
        link.add(11);
        System.out.println(link);
      }
    }

17ArrayList,HashSet判断对象是否重复的原因

A:ArrayList,HashSet判断对象是否重复的原因

 a:ArrayList的contains方法原理:底层依赖于equals方法
   ArrayList的contains方法会使用调用方法时,
     传入的元素的equals方法依次与集合中的旧元素所比较,
     从而根据返回的布尔值判断是否有重复元素。
     此时,当ArrayList存放自定义类型时,由于自定义类型在未重写equals方法前,
     判断是否重复的依据是地址值,所以如果想根据内容判断是否为重复元素,需要重写元素的equals方法。

 b:HashSet的add()方法和contains方法()底层都依赖 hashCode()方法与equals方法()

  Set集合不能存放重复元素,其添加方法在添加时会判断是否有重复元素,有重复不添加,没重复则添加。
  HashSet集合由于是无序的,其判断唯一的依据是元素类型的hashCode与equals方法的返回结果。规则如下:
  先判断新元素与集合内已经有的旧元素的HashCode值
  ? 如果不同,说明是不同元素,添加到集合。
  ? 如果相同,再判断equals比较结果。返回true则相同元素;返回false则不同元素,添加到集合。
  所以,使用HashSet存储自定义类型,如果没有重写该类的hashCode与equals方法,则判断重复时,使用的是地址值,如果想通过内容比较元素是否相同,需要重写该元素类的hashcode与equals方法。

18hashCode和equals方法的面试题

 A:hashCode和equals的面试题
 /*
  *   两个对象  Person  p1 p2
  *   问题: 如果两个对象的哈希值相同 p1.hashCode()==p2.hashCode()
  *        两个对象的equals一定返回true吗  p1.equals(p2) 一定是true吗
  *        正确答案:不一定
  *
  *        如果两个对象的equals方法返回true,p1.equals(p2)==true
  *        两个对象的哈希值一定相同吗
  *        正确答案: 一定
  */
 在 Java 应用程序执行期间,
 1.如果根据 equals(Object) 方法,两个对象是相等的,那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。
 2.如果根据 equals(java.lang.Object) 方法,两个对象不相等,那么对这两个对象中的任一对象上调用 hashCode 方法不 要求一定生成不同的整数结果。 

    两个对象不同(对象属性值不同) equals返回false=====>两个对象调用hashCode()方法哈希值相同

    两个对象调用hashCode()方法哈希值不同=====>equals返回true

    两个对象不同(对象属性值不同) equals返回false=====>两个对象调用hashCode()方法哈希值不同

    两个对象调用hashCode()方法哈希值相同=====>equals返回true

   所以说两个对象哈希值无论相同还是不同,equals都可能返回true

作业测试

1、分析以下需求,并用代码实现:

(1)有如下代码:
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("f");
        list.add("b");
        list.add("c");
        list.add("a");
        list.add("d");

    }
    (2)利用HashSet对list集合去重(最终结果:list中没有重复元素)

2、:自己写出contains 方法

3、分析以下需求,并用代码实现: (1)编写一个泛形方法,实现指定位置数组元素的交换 (2)编写一个泛形方法,接收一个任意数组,并反转数组中的所有元素

4.将"goOd gooD stUdy dAy dAy up"

 每个单词的首字母转换成大写其余还是小写字母(不许直接输出good good study day day up 要用代码实现)

原文地址:https://www.cnblogs.com/wanghui1234/p/9558007.html

时间: 2024-10-29 18:19:27

19_集合_第19天(List、Set)_讲义的相关文章

基本_移动类型轮播效果_框架

一.基本元素: D:display window;用户浏览的窗口: S:scroll window;存放内容的大容器:通过移动来改变显示的内容: C:content;内容信息: B:button;按钮,多种样式,可选: 二.思路: 通过移动S 的位置,由于C位于S中,所有的C将会同时跟随S而移动. 在D中显示的内容将会被改变. 三.html结构: 1 <div class=”D”> 2 <div class=”S”> 3 <div class=”C”>content&l

java画图程序_图片用字母画出来_源码发布_版本二

在上一个版本:java画图程序_图片用字母画出来_源码发布 基础上,增加了图片同比例缩放,使得大像素图片可以很好地显示画在Notepad++中. 项目结构: 运行效果1: 原图:http://images.cnblogs.com/cnblogs_com/hongten/356471/o_imagehandler_result1.png 运行效果2: 原图:http://images.cnblogs.com/cnblogs_com/hongten/356471/o_imagehandler_res

java画图程序_图片用字母画出来_源码发布

在之前写了一篇blog:java画图程序_图片用字母画出来 主要是把一些调试的截图发布出来,现在程序调试我认为可以了(当然,你如果还想调试的话,也可以下载源码自己调试). 就把源码发布出来. 项目结构: 资源文件: 原图:http://images.cnblogs.com/cnblogs_com/hongten/356471/o_imagehandler_resource.png 运行效果: 原图:http://images.cnblogs.com/cnblogs_com/hongten/356

python基础教程_学习笔记8:序列_练习与总结_1

序列_练习与总结 每次处理一个字符 任务: 用每次处理一个字符的方式处理字符串. 方案: 可以创建一个列表,列表的子项是字符串的字符.python实际上并没有一个特别的类型来对应"字符"并以此和字符串区分开来.可以调用内建的list,用字符串作为参数: thelist=list(thestring) 也可以不创建一个列表,直接用for语句完成对该字符串的循环遍历: for c in thestring: do_something_with(c) 或者使用列表推导中的for来遍历: re

『PyTorch』第四弹_通过LeNet初识pytorch神经网络_下

『PyTorch』第四弹_通过LeNet初识pytorch神经网络_上 # Author : Hellcat # Time : 2018/2/11 import torch as t import torch.nn as nn import torch.nn.functional as F class LeNet(nn.Module): def __init__(self): super(LeNet,self).__init__() self.conv1 = nn.Conv2d(3, 6, 5)

humlbe bundle如何绑定二次验证码_虚拟MFA_两步验证_谷歌身份验证器?

一般点账户名——设置——安全设置中开通虚拟MFA两步验证 具体步骤见链接 humlbe bundle如何绑定二次验证码_虚拟MFA_两步验证_谷歌身份验证器? 二次验证码小程序于谷歌身份验证器APP的优势(更多见官网) 1.无需下载app 2.验证码丢失后可找回 3.手机丢失后,可从其他手机登陆微信找回验证码,防止被别有用心的人找到利用.不像谷歌身份验证器,手机丢失后验证码跟随手机走,在没有网络的时候也依旧显示,对用户信息资产造成严重威胁. 二次验证码官网(点击查看) 原文地址:https://

基本数据类型-集合(set)_上周内容回顾(列表_元组_集合)

上周内容回顾 字符串数字列表元组字典 可变不可变:1.可变:列表,字典2.不可变: 字符串,数字,元组 访问顺序:1.直接访问:数字2.顺序访问:字符串,列表,元组3.映射: 字典 存放元素个数:容器类型:列表,元组,字典原子:数字,字符串 set集合是一个无序而且不重复的集合,有些类似于数学中的集合,也可以求交集,求并集等 集合特性:1.不同元素组成2.无序3.集合中元素必须是不可变类型 1 class set(object): 2 """ 3 set() -> ne

每天一个Linux命令(19)find命令_初识

Linux下find命令在目录结构中搜索文件,并执行指定的操作.     (1)用法: 用法: find pathname    -option      [-print | -exec | -ok]      find 路径名           选项参数    [-print | -exec | -ok]     (2)功能: 功能:用于在文件树种查找文件,并作出相应的处理.     (3)命令参数: 1) pathname: find命令所查找的目录路径.例如用.来表示当前目录,用/来表示

C++_系列自学课程_第_6_课_bitset集_《C++ Primer 第四版》

在C语言中要对一个整数的某一个位进行操作需要用到很多的技巧.这种情况在C++里面通过标准库提供的一个抽象数据类型 bitset得到了改善. 一.标准库bitset类型 1.bitset的作用 bitset可以看成bit的集合,可以单独的访问集合中的某一位,访问的结果可以作为逻辑的判断的条件.使用bitset的时候可以 不关心这些bit的存储方式,而通过bitset类型提供的一套接口进行操作. 和string和vector一样,要使用bitset类型,需要报备,如下所示: #include <bi