黑马程序员02_集合框架

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

集合特点：

LIst的特点：有重复、有序的

Set的特点：无重复、按照一定的规则排序

Map的特点：按键值对存储、key唯一

集合的基本方法：

增删改查（各个集合方法名有锁不同，具体查API）

LIst的使用

ArrayLIst和LInkedList可以模拟堆栈和队列

用LinkedLIst模仿队列的代码：

import java.util.LinkedList;  

public class Test9 {  
    public static void main(String[] args) {  
        DuiLie duiLie =new DuiLie();  
        for(int i=0;i<10;i++)  
            duiLie.myAdd("jingtian"+i);  
        while(!duiLie.isNull())  
            System.out.println(duiLie.myGet());  
    }  

}  


class DuiLie  
{  
    private LinkedList<Object> linkedList=new LinkedList<Object>();  

    public DuiLie() {  
        super();  
    }  
      
    public void myAdd(Object object)  
    {  
        linkedList.addFirst(object);  
    }  
    public Object myGet()  
    {  
        return linkedList.removeLast();  
    }  
    public boolean isNull()  
    {  
        return linkedList.isEmpty();  
    }  
}  

用LinkedLIst模仿堆栈的代码：

    import java.util.LinkedList;  
      
    public class Test9 {  
        public static void main(String[] args) {  
            DuiZhan DuiZhan =new DuiZhan();  
            for(int i=0;i<10;i++)  
                DuiZhan.myAdd("jingtian"+i);  
            while(!DuiZhan.isNull())  
                System.out.println(DuiZhan.myGet());  
        }  
      
    }  
      
      
    class DuiZhan  
    {  
        private LinkedList<Object> linkedList=new LinkedList<Object>();  
      
        public DuiZhan() {  
            super();  
        }  
          
        public void myAdd(Object object)  
        {  
            linkedList.addFirst(object);  
        }  
        public Object myGet()  
        {  
            return linkedList.removeFirst();  
        }  
        public boolean isNull()  
        {  
            return linkedList.isEmpty();  
        }  
    }  

自己写一个集合实现迭代功能

package com.xiaozhi.threads;
import java.util.Iterator;  

public class Test {  

    public static void main(String[] args) {  
        MyCollection<Object> myCollection = new MyCollection<Object>();  
        for (int i = 0; i < 10; i++)  
            System.out.println("add-----" + i + "---------"+ myCollection.add(new String("jingtianxiaozhi" + i)));  
        Iterator<Object> iterator = myCollection.iterator();  
        while (iterator.hasNext()) {  
            System.out.println("next()--------------" + iterator.next());  
        }  
    }  
}  

class MyCollection<E> implements Iterable<E> {  
    Object object[] = new Object[100];  
    int count = 0;  
    int index = 0;  

    public boolean add(Object o) {  
        object[count] = o;  
        count++;  
        return true;  
    }  

    @Override  
    public Iterator<E> iterator() {  
        return new MyIterator();  
    }  

    private class MyIterator implements Iterator<E> {  

        public boolean hasNext() {  
            if (index < count)  
                return true;  
            return false;  
        }  

        public E next() {  
            index++;  
            return (E) object[index - 1];  
        }  

        @Override  
        public void remove() {  
            count--;  
            object[count] = new Object();  
        }  
    }  
}  

Set的介绍：

HashSet的数据结构是哈希表，按照哈希值得大小来排列。如果是自己写的对象，想按照自己的规则去除相同内容对象，放入HashSet中，可以重写hashCode（）和equals（）。

HashSet在调用add（）时会自动先调用hashCode（），如果哈希值相等，再调用equals（）方法。

HashSet先用hashcode方法比较哈希值，再使用equals方法比较内容！

ThreeSet的数据结构是二叉树，如果是自己写的对象，想按照自己的规则存放到TreeSet中，可以让存入的对象类实现Compatable接口，或者往TreeSet对象中传入比较器的方法，实现比较。

让Person覆盖hashCode（）方法和equals（）方法，装入hashSet中，去除重复

package com.xiaozhi.hashset;  

import java.util.HashSet;  


public class Test {  

    public static void main(String[] args) {  
        HashSet<Person>persons=new HashSet<Person>();  
        persons.add(new Person("jingtian1",21));  
        persons.add(new Person("jingtian2",22));  
        persons.add(new Person("jingtian3",23));  
        persons.add(new Person("jingtian4",24));  
        persons.add(new Person("jingtian2",22));  
        for(Person person:persons)  
            System.out.println(person.getName()+"--------------"+person.getAge());  
    }  
}  

class Person{  
    private String name;  
    private int age;  
    public Person(String name, int age) {  
        super();  
        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 int hashCode() {  
        return this.name.hashCode()+this.age;  
    }  
    
    @Override  
    public boolean equals(Object obj) {  
        Person person=(Person)obj;  
        return this.name.equals(person.getName()) && this.getAge()==person.getAge();  
    }  
      
}  

让Person实现Compatable接口，实现对象具备比较性

    package com.xiaozhi.mytreeset;  
      
    import java.util.TreeSet;  
      
    /* 
     * 让Person实现Compatable借口，实现对象具备比较性 
     */  
    public class MyTreeSet {  
        public static void main(String[] args) {  
            TreeSet<Person>persons=new TreeSet<Person>();  
            persons.add(new Person("jingtian01",21));  
            persons.add(new Person("jingtian02",19));  
            persons.add(new Person("jingtian03",22));  
            persons.add(new Person("jingtian04",24));  
            persons.add(new Person("jingtian01",21));  
            for(Person person:persons)  
            {  
                System.out.println(person.getName()+"--------------"+person.getAge());  
            }  
        }  
    }  
      
      
    class Person implements Comparable  
    {  
        private String name;  
        private int age;  
        public Person(String name, int age) {  
            super();  
            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 int compareTo(Object o) {  
            Person person=(Person)o;  
            if(this.age>person.getAge())  
                return 1;  
            else if(this.age==person.getAge())  
            {  
                return this.name.compareTo(person.getName());  
            }  
            return -1;  
        }  
    }  

往TreeSet对象中传入比较器的方法，实现比较。

package com.xiaozhi.mytreeset2;  

import java.util.Comparator;  
import java.util.TreeSet;  

public class MyComparator {  

    /** 
     * 用Comparator比较器传参实现TreeSet具备比较性 
     */  
    public static void main(String[] args) {  
        TreeSet<Person>persons=new TreeSet<Person>(new MyCompatator());  
        persons.add(new Person("jingtian01",21));  
        persons.add(new Person("jingtian02",19));  
        persons.add(new Person("jingtian03",22));  
        persons.add(new Person("jingtian04",24));  
        persons.add(new Person("jingtian01",21));  
        for(Person person:persons)  
        {  
            System.out.println(person.getName()+"--------------"+person.getAge());  
        }  

    }  

}  

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

class MyCompatator implements Comparator  
{  

    @Override  
    public int compare(Object o1, Object o2) {  
        Person p1=(Person)o1;  
        Person p2=(Person)o2;  
        return p1.getName().compareTo(p2.getName());  
    }  
      
}  

Map的两种迭代方式：

一种是使用Map.Entry，一种是使用keySet()方法。

    import java.util.HashMap;  
    import java.util.Iterator;  
    import java.util.Map;  
    import java.util.Set;  
    import java.util.Map.Entry;  
      
      
    public class Test2 {  
      
        public static void main(String[] args) {  
            HashMap<Person,String>hashMap=new HashMap<Person,String>();  
            hashMap.put(new Person("jingtianxiaozhi1",21),"beijing");  
            hashMap.put(new Person("jingtianxiaozhi3",23),"qingdao");  
            hashMap.put(new Person("jingtianxiaozhi2",22),"jinan");  
            hashMap.put(new Person("jingtianxiaozhi4",24),"nanjing");  
            Set<Map.Entry<Person, String>> entry=hashMap.entrySet();  
            Iterator<Map.Entry<Person,String>>iterator=entry.iterator();  
            while(iterator.hasNext())  
            {  
                System.out.println(iterator.next().getKey().getName());  
            }  
        }  
    }  
    class Person{  
        private String name;  
        private int age;  
          
        public Person(String name, int age) {  
            super();  
            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;  
        }  
          
    }  

Collections和Arrays的使用

Collections工具类有给集合加锁的方法，让集合更具有安全性。

Arrays工具类有将对象数组转化成List的方法，但是只能进行一些普通的操作比如contain（）和indexOf（）等等，不能进行增删改查操作。

泛型：

泛型一共有三种用法，一种是泛型类，一种是泛型方法，还有泛型的高级限定

泛型类

    /* 
     * 泛型类 
     */  
    public class Test2 {  
        public static void main(String[] args) {  
            Demo<String> demo = new Demo<String>();  
            demo.setName("泛型类");  
        }  
    }  
      
    class Demo<T> {  
        public <T> void setName(T t) {  
            System.out.println(t);  
        }  
    }  

泛型方法

    /* 
     * 泛型方法 
     */  
    public class Test3 {  
      
        public static void main(String[] args) {  
            Type type=new Type();  
            type.print(new String("泛型方法"));  
            type.show(new Integer(100));  
        }  
    }  
      
    class Type{  
        public <W>void print(W w){  
            System.out.println(w);  
        }  
        public <Q>void show(Q q){  
            System.out.println(q);  
        }  
    }  

泛型的高级限定

    import java.util.ArrayList;  
    import java.util.Iterator;  
    /* 
     * 泛型的高级限定 
     */  
    public abstract class Test {  
        public static void main(String[] args) {  
            ArrayList<Person>persons=new ArrayList<Person>();  
            persons.add(new Person("person1"));  
            persons.add(new Person("person2"));  
            persons.add(new Person("person3"));  
            persons.add(new Person("person4"));  
            ArrayList<Student>students=new ArrayList<Student>();  
            students.add(new Student("student1"));  
            students.add(new Student("student2"));  
            students.add(new Student("student3"));  
            students.add(new Student("student4"));  
            method(persons);  
            method(students);  
        }  
        public static void method(ArrayList<? extends Person> a){  
            Iterator<? extends Person>iterator=a.iterator();  
            while(iterator.hasNext())  
            {  
                System.out.println(iterator.next().getName());  
            }  
        }  
    }  
    class Person  
    {  
        private String name;  
      
        public Person(String name) {  
            super();  
            this.name = name;  
        }  
      
        public String getName() {  
            return name;  
        }  
      
        public void setName(String name) {  
            this.name = name;  
        }  
          
    }  
      
    class Student extends Person{  
          
        public Student(String name) {  
            super(name);  
        }  
    }  

泛型的优点：

避免了一部分强转，节约了时间。

最后附上一张集合家族图

---------------------- ASP.Net+Unity开发、 .Net培训、期待与您交流！ ----------------------