• 集合2--毕向东java基础教程视频学习笔记


    Day14

    08 LinkedList
    09 LinkedList练习
    10 ArrayList练习
    11 ArrayList练习2

    12 HashSet
    13 HashSet存储自定义对象
    14 HashSet判断和删除的依据

     

     08 LinkedList

    LinkedList特有的方法:
    addFirst() addLast()

    getFirst() getLast()
    获取元素,但不删除元素。如果集合中没有元素,会出现NoSuchElementException。

    removeFirst() removeLast()
    获取元素,并删除元素。如果集合中没有元素,会出现NoSuchElementException。

    在JDK1.6中出现了替代方法。
    offerFirst() offerLast()

    peekFirst() peekLast()
    获取元素,但不删除元素。如果集合中没有元素,会返回null.

    pollFirst() pollLast()
    获取元素,并删除元素。如果集合中没有元素,会返回null。

     1 import java.util.*;
     2 
     3 class LinkedListDemo  
     4 {
     5     public static void main(String[] args) 
     6     {
     7         LinkedList link=new LinkedList();
     8 
     9         link.addFirst("java01");
    10         link.addFirst("java02");
    11         link.addFirst("java03");
    12         link.addFirst("java04");
    13         
    14 
    15         sop(link.getLast());
    16         sop("size:"+link.size());
    17 
    18         sop(link.removeLast());
    19         sop("size:"+link.size());
    20 
    21         //用自己的方法取出元素
    22         while(!link.isEmpty())
    23         {
    24             sop(link.removeFirst());
    25         }
    26     }
    27     public static void sop(Object obj)
    28     {
    29         System.out.println(obj);
    30     }
    31 }
    View Code

     


    09 LinkedList练习

    使用LinkedList模拟堆栈或者队列的数据结构
    堆栈:先进后出

     1 import java.util.*;
     2 class myStack
     3 {
     4     private LinkedList link;
     5     public myStack()
     6     {
     7         link=new LinkedList();
     8     }
     9 
    10     public void myAdd(Object obj)
    11     {
    12         link.addFirst(obj);
    13     }
    14     public Object myGet()
    15     {
    16         return link.removeFirst();
    17     }
    18     public boolean isNull()
    19     {
    20         return link.isEmpty();
    21     }
    22 }
    23 class  LinkedListTest
    24 {
    25     public static void main(String[] args) 
    26     {
    27         myStack s=new myStack();
    28         s.myAdd("java01");
    29         s.myAdd("java02");
    30         s.myAdd("java03");
    31         s.myAdd("java04");
    32 
    33         while(!s.isNull())
    34         {
    35             System.out.println(s.myGet());
    36         }
    37 
    38         
    39     }
    40 }
    View Code

     

    队列:先进先出

     1 import java.util.*;
     2 class myQueue
     3 {
     4     private LinkedList link;
     5     public myQueue()
     6     {
     7         link=new LinkedList();
     8     }
     9 
    10     public void myAdd(Object obj)
    11     {
    12         link.addFirst(obj);
    13     }
    14     public Object myGet()
    15     {
    16         return link.removeLast();
    17     }
    18     public boolean isNull()
    19     {
    20         return link.isEmpty();
    21     }
    22 }
    23 class  LinkedListTest
    24 {
    25     public static void main(String[] args) 
    26     {
    27         myQueue q=new myQueue();
    28         q.myAdd("java01");
    29         q.myAdd("java02");
    30         q.myAdd("java03");
    31         q.myAdd("java04");
    32 
    33         while(!q.isNull())
    34         {
    35             System.out.println(q.myGet());
    36         }
    37 
    38         
    39     }
    40 }
    View Code

     

     

    10 ArrayList练习

    去掉ArrayList中的重复元素

    基本思想:拿一个新的容器,分别取出原ArrayList中的元素,每拿一个便检查新容器中有没有与之相同的元素。

    如果有,就把此元素丢掉,如果没有,就把此元素放到新容器中。遍历完成后,新容器中就是原ArrayList去掉重复元素后的结果了。

     1 //去掉ArrayList中的重复元素
     2 import java.util.*;
     3 class ArrayListTest 
     4 {
     5     public static ArrayList singleElement(ArrayList al)
     6     {
     7         ArrayList newAl=new ArrayList();
     8         Iterator it=al.iterator();
     9         while(it.hasNext())
    10         {
    11             Object obj=it.next();
    12             if(!newAl.contains(obj))
    13          {
    14                 newAl.add(obj);
    15 
    16          }
    17         }
    18         /*
    19         注意,循环中只能调用一次next,就用hasNext判断一次,
    20         否则,会出现错误。
    21         while(it.hasNext())
    22         {
    23             sop(it.next()+"......"+it.next());
    24         }
    25         */
    26         return newAl;
    27         
    28     }
    29     public static void sop(Object obj)
    30     {
    31         System.out.println(obj);
    32     }
    33     public static void main(String[] args) 
    34     {
    35         ArrayList al=new ArrayList();
    36         al.add("java01");
    37         al.add("java03");
    38         al.add("java01");
    39         al.add("java03");
    40         al.add("java01");
    41         al.add("java02");
    42         sop(al);
    43 
    44 
    45         sop(singleElement(al));
    46         
    47     }
    48 }
    View Code

     

     

    11 ArrayList练习2

    将自定义对象作为元素存到ArrayList集合中,并去除重复元素
    比如,存入人对象,同姓名同年龄,视为同一个人,为重复元素

    思路:
    1.对人描述,将数据封装进人对象。(姓名、年龄都相同的视为同一个人)
    2.定义容器,将人存入
    3.取出

    List集合判断元素是否相同,依据的是元素的equals方法。

     1 import java.util.*;
     2 class  Person
     3 {
     4     private String name;
     5     private int age;
     6     public Person(String name,int age)
     7     {
     8         this.name=name;
     9         this.age=age;
    10     }
    11     public String getName()
    12     {return name;}
    13     public int getAge()
    14     {return age;}
    15     //重写父类的equals方法
    16     public boolean equals(Object obj)
    17     {
    18         if(! (obj instanceof Person))
    19             return false;
    20         Person p=(Person)obj;
    21         System.out.println(this.name+"..."+p.name);//输出语句,显示equals的调用过程
    22         //此语句中调用的是String 中的equals方法
    23         return this.name.equals(p.name) && this.age==p.age;
    24         
    25             
    26     }
    27 }
    28 
    29 
    30 class ArrayListTest2
    31 {
    32     public static void sop(Object obj)
    33  {
    34     System.out.println(obj);
    35  }
    36     public static ArrayList singleElement(ArrayList al)
    37     {
    38         ArrayList newAl=new ArrayList();
    39         Iterator it=al.iterator();
    40         while(it.hasNext())
    41         {
    42             Object obj=it.next();
    43             //contains底层调用的是对象的equals方法
    44             //但是原equals方法比较的是对象的地址
    45             //并不知道,我们想要的比较方法
    46             //所以,要在Person类中重写父类的equals方法
    47             if(!newAl.contains(obj))
    48             {
    49                 newAl.add(obj);
    50             }
    51         }
    52         return newAl;
    53 
    54 
    55     }
    56     public static void main(String[] args)
    57     {
    58         ArrayList al=new ArrayList();
    59         al.add(new Person("java01",12));//al.add(Object obj) //Object obj=new Person("java01",12)
    60         al.add(new Person("java02",22));
    61         al.add(new Person("java01",32));
    62         al.add(new Person("java03",22));
    63         al.add(new Person("java02",22));
    64 
    65         //如果注释掉重写的equals方法,remove的调用结果就是false,即找不到要移除的对象
    66         //这说明remove底层调用的也是对象的equals方法。
    67         sop("remove:"+al.remove(new Person("java03",22)));
    68 
    69         al=singleElement(al);
    70 
    71         Iterator it=al.iterator();
    72         while(it.hasNext())
    73         {
    74             Person p=(Person)it.next();
    75             sop(p.getName()+"----"+p.getAge());
    76 
    77         }
    78 
    79 
    80     }
    81 }
    View Code

    12 HashSet

    |--Set:元素是无序的(存入和取出的顺序不一定一致),元素不可以重复。
    |--HashSet:底层的数据结构是哈希表
    |--TreeSet:
    Set集合的功能和Collection是一致的。

     1 import java.util.*;
     2 class HashSetDemo 
     3 {
     4     public static void sop(Object obj)
     5     {
     6         System.out.println(obj);
     7     }
     8     public static void main(String[] args) 
     9     {
    10         //验证Set无序,不可重复的特点
    11         HashSet hs=new HashSet();
    12         hs.add("java01");
    13         hs.add("java01");
    14         //sop(hs.add("java01"));sop(hs.add("java01")); 第一个是true 第二个是false
    15         hs.add("java03");
    16         hs.add("java04");
    17         hs.add("java05");
    18 
    19         Iterator it=hs.iterator();
    20         
    21         while(it.hasNext())
    22         {
    23             sop(it.next());
    24         }
    25 
    26     }
    27 }
    View Code


    13 HashSet存储自定义对象

    HashSet是如何保证唯一性的呢?
    是通过元素的两个方法,hashCode和equals
    如果元素的hashCode值相同,才会判断equals是否为true
    如果元素的hashCode不同,直接存入,不会调用equals。

     在项目中,描述一个类,并且需要把它的对象装入集合时,一般都需要复写该类的hashCode方法和equals方法。

    因为,原有的方法不能比较我们需要比较的内容。

     1 /*
     2 对象存入HashSet,先调用自己的hashCode方法计算哈希值,看哈希表中是否有和自己哈希值相同的元素
     3 如果哈希值相同,再调用对象的equals方法来比较,
     4   如果结果仍然相同,就不会存入Hashset;
     5   如果不同就在哈希值相同的元素后,顺延一个位置存入。
     6 */
     7 import java.util.*;
     8 class  HashSetTest
     9 {
    10     public static void main(String[] args) 
    11     {
    12         HashSet hs=new HashSet();
    13         hs.add(new Person("a1",11));
    14         hs.add(new Person("a2",12));
    15         hs.add(new Person("a2",12));
    16         hs.add(new Person("a1",13));
    17         hs.add(new Person("a3",11));
    18 
    19         Iterator it=hs.iterator();
    20         while(it.hasNext())
    21         {
    22             Person p=(Person)it.next();
    23             sop(p.getName()+"::"+p.getAge());
    24         }
    25         
    26     }
    27     public static void sop(Object obj)
    28     {
    29         System.out.println(obj);
    30     }
    31 }
    32 class  Person
    33 {
    34     private String name;
    35     private int age;
    36     public int hashCode()
    37     {
    38         //return 60;
    39         //为了避免再调用对象的equals方法进行比较,应该尽量使对象的hashCode值不同
    40         return name.hashCode()+age*39;
    41 
    42     }
    43     public Person(String name,int age)
    44     {
    45         this.name=name;
    46         this.age=age;
    47     }
    48     public String getName()
    49     {return name;}
    50     public int getAge()
    51     {return age;}
    52     //重写父类的equals方法
    53     public boolean equals(Object obj)
    54     {
    55         if(! (obj instanceof Person))
    56             return false;
    57         Person p=(Person)obj;
    58         System.out.println(this.name+"...equals..."+p.name);//输出语句,显示equals的调用过程
    59         //此语句中调用的是String 中的equals方法
    60         return this.name.equals(p.name) && this.age==p.age;
    61         
    62             
    63     }
    64 }
    View Code


    14 HashSet判断和删除的依据

    注意,对于hashSet判断元素是否存在(contains()方法)或者删除元素(remove()方法)依赖的方法是HashCode和equals方法。

    如果,hashCode值不同,直接可知道该元素不存在;

    如果相同,再用equals方法判断。

  • 相关阅读:
    python学习笔记(五)
    python学习笔记(七)
    python小游戏——猜数字2.0
    python学习笔记(六)
    python小游戏——猜数字2.0
    python学习笔记(五)
    python中的in运算符
    python学习笔记(七)
    jmeter(4)响应断言 json断言 beanshell断言
    jmeter(2)几种不同的contenttype方式
  • 原文地址:https://www.cnblogs.com/wsw-tcsygrwfqd/p/5186660.html
Copyright © 2020-2023  润新知