集合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。

import java.util.*;

class LinkedListDemo  
{
    public static void main(String[] args) 
    {
        LinkedList link=new LinkedList();

        link.addFirst("java01");
        link.addFirst("java02");
        link.addFirst("java03");
        link.addFirst("java04");
        

        sop(link.getLast());
        sop("size:"+link.size());

        sop(link.removeLast());
        sop("size:"+link.size());

        //用自己的方法取出元素
        while(!link.isEmpty())
        {
            sop(link.removeFirst());
        }
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

 

09 LinkedList练习

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

import java.util.*;
class myStack
{
    private LinkedList link;
    public myStack()
    {
        link=new LinkedList();
    }

    public void myAdd(Object obj)
    {
        link.addFirst(obj);
    }
    public Object myGet()
    {
        return link.removeFirst();
    }
    public boolean isNull()
    {
        return link.isEmpty();
    }
}
class  LinkedListTest
{
    public static void main(String[] args) 
    {
        myStack s=new myStack();
        s.myAdd("java01");
        s.myAdd("java02");
        s.myAdd("java03");
        s.myAdd("java04");

        while(!s.isNull())
        {
            System.out.println(s.myGet());
        }

        
    }
}

 

队列：先进先出

import java.util.*;
class myQueue
{
    private LinkedList link;
    public myQueue()
    {
        link=new LinkedList();
    }

    public void myAdd(Object obj)
    {
        link.addFirst(obj);
    }
    public Object myGet()
    {
        return link.removeLast();
    }
    public boolean isNull()
    {
        return link.isEmpty();
    }
}
class  LinkedListTest
{
    public static void main(String[] args) 
    {
        myQueue q=new myQueue();
        q.myAdd("java01");
        q.myAdd("java02");
        q.myAdd("java03");
        q.myAdd("java04");

        while(!q.isNull())
        {
            System.out.println(q.myGet());
        }

        
    }
}

 

 

10 ArrayList练习

去掉ArrayList中的重复元素

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

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

//去掉ArrayList中的重复元素
import java.util.*;
class ArrayListTest 
{
    public static ArrayList singleElement(ArrayList al)
    {
        ArrayList newAl=new ArrayList();
        Iterator it=al.iterator();
        while(it.hasNext())
        {
            Object obj=it.next();
            if(!newAl.contains(obj))
         {
                newAl.add(obj);

         }
        }
        /*
        注意，循环中只能调用一次next，就用hasNext判断一次，
        否则，会出现错误。
        while(it.hasNext())
        {
            sop(it.next()+"......"+it.next());
        }
        */
        return newAl;
        
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        ArrayList al=new ArrayList();
        al.add("java01");
        al.add("java03");
        al.add("java01");
        al.add("java03");
        al.add("java01");
        al.add("java02");
        sop(al);


        sop(singleElement(al));
        
    }
}

 

 

11 ArrayList练习2

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

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

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

import java.util.*;
class  Person
{
    private String name;
    private int age;
    public Person(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public String getName()
    {return name;}
    public int getAge()
    {return age;}
    //重写父类的equals方法
    public boolean equals(Object obj)
    {
        if(! (obj instanceof Person))
            return false;
        Person p=(Person)obj;
        System.out.println(this.name+"..."+p.name);//输出语句，显示equals的调用过程
        //此语句中调用的是String 中的equals方法
        return this.name.equals(p.name) && this.age==p.age;
        
            
    }
}


class ArrayListTest2
{
    public static void sop(Object obj)
 {
    System.out.println(obj);
 }
    public static ArrayList singleElement(ArrayList al)
    {
        ArrayList newAl=new ArrayList();
        Iterator it=al.iterator();
        while(it.hasNext())
        {
            Object obj=it.next();
            //contains底层调用的是对象的equals方法
            //但是原equals方法比较的是对象的地址
            //并不知道，我们想要的比较方法
            //所以，要在Person类中重写父类的equals方法
            if(!newAl.contains(obj))
            {
                newAl.add(obj);
            }
        }
        return newAl;


    }
    public static void main(String[] args)
    {
        ArrayList al=new ArrayList();
        al.add(new Person("java01",12));//al.add(Object obj) //Object obj=new Person("java01"，12)
        al.add(new Person("java02",22));
        al.add(new Person("java01",32));
        al.add(new Person("java03",22));
        al.add(new Person("java02",22));

        //如果注释掉重写的equals方法，remove的调用结果就是false,即找不到要移除的对象
        //这说明remove底层调用的也是对象的equals方法。
        sop("remove:"+al.remove(new Person("java03",22)));

        al=singleElement(al);

        Iterator it=al.iterator();
        while(it.hasNext())
        {
            Person p=(Person)it.next();
            sop(p.getName()+"----"+p.getAge());

        }


    }
}

12 HashSet

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

import java.util.*;
class HashSetDemo 
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        //验证Set无序，不可重复的特点
        HashSet hs=new HashSet();
        hs.add("java01");
        hs.add("java01");
        //sop(hs.add("java01"));sop(hs.add("java01")); 第一个是true 第二个是false
        hs.add("java03");
        hs.add("java04");
        hs.add("java05");

        Iterator it=hs.iterator();
        
        while(it.hasNext())
        {
            sop(it.next());
        }

    }
}

13 HashSet存储自定义对象

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

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

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

/*
对象存入HashSet，先调用自己的hashCode方法计算哈希值，看哈希表中是否有和自己哈希值相同的元素
如果哈希值相同，再调用对象的equals方法来比较，
  如果结果仍然相同，就不会存入Hashset；
  如果不同就在哈希值相同的元素后，顺延一个位置存入。
*/
import java.util.*;
class  HashSetTest
{
    public static void main(String[] args) 
    {
        HashSet hs=new HashSet();
        hs.add(new Person("a1",11));
        hs.add(new Person("a2",12));
        hs.add(new Person("a2",12));
        hs.add(new Person("a1",13));
        hs.add(new Person("a3",11));

        Iterator it=hs.iterator();
        while(it.hasNext())
        {
            Person p=(Person)it.next();
            sop(p.getName()+"::"+p.getAge());
        }
        
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
class  Person
{
    private String name;
    private int age;
    public int hashCode()
    {
        //return 60;
        //为了避免再调用对象的equals方法进行比较，应该尽量使对象的hashCode值不同
        return name.hashCode()+age*39;

    }
    public Person(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public String getName()
    {return name;}
    public int getAge()
    {return age;}
    //重写父类的equals方法
    public boolean equals(Object obj)
    {
        if(! (obj instanceof Person))
            return false;
        Person p=(Person)obj;
        System.out.println(this.name+"...equals..."+p.name);//输出语句，显示equals的调用过程
        //此语句中调用的是String 中的equals方法
        return this.name.equals(p.name) && this.age==p.age;
        
            
    }
}

14 HashSet判断和删除的依据

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

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

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