滴水穿石-06集合

集合:长度可变,存储对象为引用类型

 

 

 1: 接口 Collection<E>

 

 

学习集合的流程大致是:首先学习构造方法,然后看一些主要功能:增.删.判.获.长.其他.

a:增加功能(add()　　addAll())

package d6;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionTest {

    public static void main(String[] args) {
        Collection c = new ArrayList();//a:注意导包//b:new 子类对象
        c.add("Hello");
        c.add("world");
        ////测试add方法
        System.out.println(c.toString());
        //------[Hello, world]--------//
        
        Collection c2 = new ArrayList(); 
        c2.add("java");
        c2.add("javaSE");        
        c2.addAll(c);
        ////测试addAll方法
        System.out.println(c2.toString());
        //-------[java, javaSE, Hello, world]-------//
    }

}

 b:删除功能(remove()　　removeAll()　　clear())

public static void main(String[] args) {
        Collection c = new ArrayList();// a:注意导包//b:new 子类对象
        c.add("Hello");
        c.add("world");
        c.add("!");

        System.out.println(c.toString());
        // ------[Hello, world, !]--------//
        //// 测试remove方法
        c.remove("Hello");
        System.out.println(c.toString());
        // ------[world, !]--------//

        Collection c2 = new ArrayList();
        c2.add("java");
        c2.add("javaSE");
        c2.add("Hello");
        c2.add("world");
        c2.add("!");
        //// 测试removeAll方法
        System.out.println(c2.toString());
        // -------[java, javaSE, Hello, world, !]-------//
        c2.removeAll(c);
        System.out.println(c2.toString());
        // -------[java, javaSE, Hello]-------//

        //// 测试clear方法
        c2.clear();
        System.out.println(c2.toString());
        // -------[]-------//
    }

 c:判断功能(contains()　　containsAll()　　isEmpty())

package d6;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionContains1 {
    public static void main(String[] args) {
        Collection c = new ArrayList();// a:注意导包//b:new 子类对象
        //// 测试isEmpty方法
        System.out.println(c.isEmpty());
        // ------true--------//
        c.add("Hello");
        //// 测试isEmpty方法
        System.out.println(c.isEmpty());
        // ------false--------//
        c.add("world");
        c.add("!");

        System.out.println(c.toString());
        // ------[Hello, world, !]--------//
        //// 测试contains方法
        System.out.println(c.contains("Hello"));
        // ------true--------//
        System.out.println(c.contains("Hlo"));
        // ------false--------//

        Collection c2 = new ArrayList();
        c2.add("java");
        c2.add("javaSE");
        c2.add("Hello");
        //// 测试contains方法 注意:包含所有元素才返回true
        System.out.println(c2.contains(c));
        // -------false-------//

    }
}

 d:获取功能(iterator())

package d6;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class collectionIterator1 {

    public static void main(String[] args) {
         //01 创建集合对象
         Collection c = new ArrayList();// a:注意导包//b:new 子类对象
         //02 创建添加对象 并添加到 集合对象
         String a ="Hello";
         String b ="world";
         c.add(a);
         c.add(b);
         //03 根据集合对象调用iterator对象
         Iterator i = c.iterator(); //a注意导包
         //04 循环遍历iterator对象
         while (i.hasNext()) {
             System.out.println(i.next());
        }
         //-------Hello-------//
         //-------world-------//
    }

}

 e:长度功能(size())

package d6;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionSize1 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("java");
        c.add("javaSE");
        c.add("Hello");
        //// 测试size方法  
        
        System.out.println(c.size());
        // -------3-------//
    }
    
}

 f:交集功能(retainAll()) 注意与ContrainAll()不同,如果此 collection 由于调用而发生更改，就返回true.为什么叫retain(保留)呢?因为交集后原来的集合发生了变化,变成了交集后的值

package d6;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionRetainAll1 {
     public static void main(String[] args) {
         Collection c = new ArrayList();// a:注意导包//b:new 子类对象
            
            c.add("Hello");        
            c.add("world");
            c.add("!");
            System.out.println(c.toString());
            // ------[Hello, world, !]--------//    

            Collection c2 = new ArrayList();
            c2.add("java");
            c2.add("javaSE");
            c2.add("Hello");
            
            //// 测试retainAll方法  注意与ContrainAll不同,只要集合的值发生改变,就返回true
            System.out.println(c2.retainAll(c));
            // -------true-------//
            System.out.println(c2.toString());// 注意此时c2的值
            // -------[Hello]-------// 

            Collection c3 = new ArrayList();
            //// 测试retainAll方法 注意:与空集合求交集返回true
            System.out.println(c2.retainAll(c3)); //
            // -------true-------//
            System.out.println(c2.toString());// 注意此时c2的值,没有交集也是空
            // -------[]-------//
            
            c2.add("java");
            c2.add("javaSE");
            c2.add("Hello");
                        
            c3.add("java11");
            System.out.println(c2.retainAll(c3));
            // -------true-------//
            System.out.println(c2.toString());// 注意此时c2的值,
            // -------[]-------//
    }
}

  g:转化功能

package d6;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionChange1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Collection c = new ArrayList();// a:注意导包//b:new 子类对象

        c.add("Hello");
        c.add("world");
        c.add("!");
        
        Object [] a =  c.toArray();
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i].toString());
        }
        //-----Helloworld!-------//
        
    }

}

 z:练习:遍历学生集合

package pojo;

public class Student {
    public Student () {}
    public Student (String name ,int age) {
        this.name=name;
        this.age=age;
    }
    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;
    }
    @Override
    public String toString() {
        return "Student [姓名=" + name + ", 年龄=" + age + "]";
    }
}

package d6;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import pojo.Student;

public class CollectionIterator2 {

    public static void main(String[] args) {
        //01 创建集合对象
        Collection c = new ArrayList();
        //02 创建学生对象 并添加到集合中
        Student s3 = new Student("张三",13);
        Student s4 = new Student("李四",14);
        Student s5 = new Student("王五",15);
        Student s6 = new Student("赵六",16);
        c.add(s3);
        c.add(s4);
        c.add(s5);
        c.add(s6);
        //03 根据集合对象创建iterator对象
        Iterator  it = c.iterator();
        //04 遍历iterator对象
        while (it.hasNext()) {
         System.out.println(it.next().toString());
        }
         System.out.println("-------方法二--------");
        //03-02 转化成数组
        Object [] sa = c.toArray();
        //04-02 遍历数组
        for (int i = 0; i < sa.length; i++) {
            System.out.println(sa[i].toString());
        }
        
        //--------Student [姓名=张三, 年龄=13]------------//
        //--------Student [姓名=李四, 年龄=14]------------//
        //--------Student [姓名=王五, 年龄=15]------------//
        //--------Student [姓名=赵六, 年龄=16]------------//
        //---------------方法二--------------------//
        //--------Student [姓名=张三, 年龄=13]------------//
        //--------Student [姓名=李四, 年龄=14]------------//
        //--------Student [姓名=王五, 年龄=15]------------//
        //--------Student [姓名=赵六, 年龄=16]------------//
            
        
    }

}

1.1 List:有序;索引;可重复;

 

a:增加功能(add()　　addAll())  可以在列表的指定位置插入指定元素

package d6;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ListAdd1 {

    public static void main(String[] args) {
        List c = new ArrayList();//a:注意导包//b:new 子类对象
        c.add("Hello");
        c.add("!");
        c.add(1,"world");
        ////测试add方法
        System.out.println(c.toString());
        //------[Hello, world, !]--------//
        
        List c2 = new ArrayList(); 
        c2.add("java");
        c2.add("javaSE");        
        c2.addAll(1,c);
        ////测试addAll方法
        System.out.println(c2.toString());
        //-------[java, Hello, world, !, javaSE]-------//
    }


}

b:删除功能(remove()) 根据索引删除元素,并返回被删除元素

package d6;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ListRemove1 {
    public static void main(String[] args) {
        List c = new ArrayList();// a:注意导包//b:new 子类对象
        c.add("Hello");
        c.add("world");
        c.add("!");

        System.out.println("原来的集合是: " +c.toString());
        // ------原来的集合是: [Hello, world, !]--------//
        //// 测试remove方法
        System.out.println("被删除的元素是: " +c.remove(1));
        // ------被删除的元素是: world--------//
        System.out.println("删除后的结果是: " +c.toString());
        // ------删除后的结果是: [Hello, !]--------//
        

        List c2 = new ArrayList();
        c2.add("java");        
        c2.add("Hello");
        c2.add("world");
        c2.add("!");
        c2.add("javaSE");
        //// 测试removeAll方法
        System.out.println("原来的集合是: " +c2.toString());
        // -------原来的集合是: [java, Hello, world, !, javaSE]-------//
        System.out.println("被删除的元素是: "+c2.removeAll(c)); //注意这里返回true
        //--------被删除的元素是: true------------//
        System.out.println("删除后的结果是: "+c2.toString());
        // -------删除后的结果是: [java, world, javaSE]-------//

         
    }

}

c:修改功能(set())

package d6;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ListSet1 {

    public static void main(String[] args) {
        List c = new ArrayList();//a:注意导包//b:new 子类对象
        c.add("Hello");
        c.add("!");
        c.add(1,"world");
        ////测试set方法
        c.set(2,"!!!");
        System.out.println(c.toString());
        //------[Hello, world, !!!]--------//
        
         
    }


}

d:获取功能(get())

package d6;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ListGet1 {

    public static void main(String[] args) {
        List c = new ArrayList();//a:注意导包//b:new 子类对象
        c.add("Hello");
        c.add("!");
        c.add(1,"world");
        ////测试get方法        
        System.out.println(c.get(2));
        //------!--------//
        System.out.println(c.get(5));
        //------java.lang.IndexOutOfBoundsException:--------//
         
    }


}

e:查找功能(indexOf())

package d6;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class ListIndexOf1 {

    public static void main(String[] args) {
        List c = new ArrayList();//a:注意导包//b:new 子类对象
        c.add("Hello");
        c.add("!");
        c.add(1,"world");
        ////测试set方法
        System.out.println(c.indexOf("!!!"));
        //-------1--------//   注意这里是-1
        System.out.println(c.indexOf("!"
                + ""));
        //------2--------//
         
    }


}

f:遍历功能(listIterator()) 

package d6;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class ListSet1 {

    public static void main(String[] args) {
         //01 创建集合对象
         List c = new ArrayList();// a:注意导包//b:new 子类对象
         //02 创建添加对象 并添加到 集合对象
         String a ="Hello";
         String b ="world";
         c.add(a);
         c.add(b);
         //03 根据集合对象调用iterator对象
         ListIterator i = c.listIterator(); //a注意导包
         //04 循环遍历iterator对象
         while (i.hasNext()) {
             System.out.println(i.next());
        }
         //-------Hello-------//
         //-------world-------//
         //向前遍历
         while (i.hasPrevious()) {
             System.out.println(i.previous());
        }
         //-------world-------//
         //-------Hello-------//         
         for (int h=0;h<c.size();h++) {
             System.out.println(c.get(h));
        }
         //-------Hello-------//
         //-------world-------//
    }
}

1.1.1 ArrayList

特点:底层结构是数组,查询快,增删慢,线程不安全,效率高

练习:添加时去除重复元素(注意:Contains()底层是equals方法,所以要在Student类中,重写equals方法)

package pojo;

public class Student {
    public Student () {}
    public Student (String name ,int age) {
        this.name=name;
        this.age=age;
    }
    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;
    }
    @Override
    public String toString() {
        return "Student [姓名=" + name + ", 年龄=" + age + "]";
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
}

package d6;

import java.util.ArrayList;
import java.util.Collection;

import pojo.Student;

public class ArrayListAdd2 {

    public static void main(String[] args) {

        ArrayList c = new ArrayList();// a:注意导包//b:new 子类对象

        // 02 创建学生对象 并添加到集合中
        Student s3 = new Student("张三", 13);
        Student s4 = new Student("李四", 14);
        Student s5 = new Student("王五", 15);
        Student s55 = new Student("王五", 15);
        Student s6 = new Student("赵六", 16);
        if (!c.contains(s3)) {
            c.add(s3);
        }
        if (!c.contains(s4)) {
            c.add(s4);
        }
        if (!c.contains(s5)) {
            c.add(s5);
        }
        if (!c.contains(s55)) {
            c.add(s55);
        }
        if (!c.contains(s6)) {
            c.add(s6);
        }
        
        //// 测试add方法
        System.out.println(c.toString());
        // ------[Student [姓名=张三, 年龄=13], Student [姓名=李四, 年龄=14],
        //Student [姓名=王五, 年龄=15], Student [姓名=赵六, 年龄=16]]--------//

    }

}

练习2:foreach 与集合的嵌套

package d6;

import java.util.ArrayList;
import java.util.Collection;

import pojo.Student;

public class ArrayListContainsArrayList {

    public static void main(String[] args) {

        ArrayList<ArrayList<Student>> c = new ArrayList<ArrayList<Student>>();// a:注意导包//b:new 子类对象

        ArrayList<Student> s = new ArrayList<Student>();        
        ArrayList<Student> s1 = new ArrayList<Student>();        
        ArrayList<Student> s2 = new ArrayList<Student>();
        // 02 创建学生对象 并添加到集合中
        Student s3 = new Student("张三", 13);
        Student s4 = new Student("李四", 14);
        
        Student s5 = new Student("王五", 25);
        Student s6 = new Student("赵六", 26);
        
        Student s7 = new Student("孙七", 77);
        
        s.add(s3);        s.add(s4);
        
        s1.add(s5);        s1.add(s6);
        
        s2.add(s7);
        
        c.add(s);    c.add(s1);    c.add(s2);
        //// 测试foreach嵌套
        for (ArrayList<Student> list : c) {
            for (Student student : list) {
                System.out.println(student.toString());
            }
        }
        //-------Student [姓名=张三, 年龄=13]----------//
        //-------Student [姓名=李四, 年龄=14]----------//
        //-------Student [姓名=王五, 年龄=25]----------//
        //-------Student [姓名=赵六, 年龄=26]----------//
        //-------Student [姓名=孙七, 年龄=77]----------//

    }

}

1.1.2 Vector

特点:底层结构是数组,查询快,增删慢,线程安全,效率低

a:增加功能(addElement();被add()替代)

package d6;

import java.util.Vector;

public class VectorAdd1 {

    public static void main(String[] args) {
        Vector c = new Vector();//a:注意导包//b:new 子类对象
        c.add("Hello");
        c.add("world");
        c.addElement("!!");
        ////测试addElement方法
        System.out.println(c.toString());
        //------[Hello, world, !!]--------// 
    } 
}

b:获取功能(elementAt();被get()替代)

package d6;

import java.util.Vector;

public class VectorGet1 {

    public static void main(String[] args) {
        Vector c = new Vector();//a:注意导包//b:new 子类对象
        c.add("Hello");
        c.add("world");
        c.addElement("!!");
        ////测试get方法
        System.out.println(c.get(1));
        //------world--------// 
        ////测试elementAt方法
        System.out.println(c.elementAt(1));
        //------world--------// 
    } 
}

c:遍历功能(Enumeration elements();被Iterator iterator()替代)

package d6;

import java.util.Enumeration;
import java.util.Vector;

public class VectorEnumeration1 {

    public static void main(String[] args) {
        Vector c = new Vector();//a:注意导包//b:new 子类对象
        c.add("Hello");
        c.add("world");
        c.addElement("!!");
        ////测试addElement方法
        System.out.println(c.toString());
        //------[Hello, world, !!]--------// 
        
        Enumeration e = c.elements();
        while (e.hasMoreElements()) {
            System.out.println(e.nextElement());
        } 
        //------Hello--------// 
        //------world--------// 
        //------!!--------// 
    } 
}

1.1.3 LinkedList

特点:底层结构是链表,查询慢,增删快,线程不安全,效率高

a:增加功能(addFirst();addLast())

package d6;

import java.util.LinkedList;

public class LinkedListAdd1 {

    public static void main(String[] args) {
        LinkedList c = new LinkedList();//a:注意导包//b:new 子类对象
        c.add("world");
        c.addFirst("Hello");
        c.addLast("!!!");
        ////测试addFirst和addLast方法
        System.out.println(c.toString());
        //------[Hello, world]--------// 
    }


}

b:获取功能(getFirst();getLast())

package d6;

import java.util.LinkedList;

public class LinkedListGet1 {

    public static void main(String[] args) {
        LinkedList c = new LinkedList();//a:注意导包//b:new 子类对象
        c.add("Hello");
        c.add("!");
        c.add(1,"world");
        ////测试get方法        
        System.out.println(c.getFirst());
        //------!--------//
        System.out.println(c.getLast());
        //--------------//
         
    }


}

c:删除功能(removeFirst();removeLast() )

package d6;

import java.util.LinkedList;

public class ListRemove1 {
    public static void main(String[] args) {
        LinkedList c = new LinkedList();// a:注意导包//b:new 子类对象
        c.add("Hello");
        c.add("world");
        c.add("!");

        System.out.println("原来的集合是: " +c.toString());
        // ------原来的集合是: [Hello, world, !]--------//
        //// 测试remove方法
        System.out.println("被删除的元素是: " +c.removeFirst());
        // ------被删除的元素是: Hello--------//
        System.out.println("被删除的元素是: " +c.removeLast());
        // ------被删除的元素是: ! ---------//
        System.out.println("删除后的结果是: " +c.toString());
        // ------删除后的结果是: [world]--------// 
         
    }

}

练习:用LinkedList模拟栈数据结构集合并测试 .(栈:先进后出)

package dao.impl;

import java.util.LinkedList;

public class MyStack {
    private LinkedList link;

    public MyStack() {
        link = new LinkedList();
    }

    public void add(Object obj) {
        link.addFirst(obj);
    }

    public Object get() {
        return link.removeFirst();
    }
    
    public boolean isEmpty() {
        return link.isEmpty();
    }
}

package d6;

import dao.impl.MyStack;

public class LinkedList_Test1 {
    public static void main(String[] args) {
        MyStack m = new MyStack();
        m.add("1");
        m.add("2");
        m.add("3");
        m.add("4");
        
        while(!m.isEmpty()) {
            System.out.println(m.get());
        }
        
        //--------4---------//
        //--------3---------//
        //--------2---------//
        //--------1---------//
    }
}

 

1.2 Set:无序;唯一;

package d6;

 
import java.util.HashSet; 
import java.util.Set;

public class SetAdd1 {

    public static void main(String[] args) {
        Set<String> c = new HashSet<String>();//a:注意导包//b:new 子类对象
        c.add("Hello");
        c.add("!");
        c.add("world");
        c.add("!");
        c.add("world");
        
        ////测试Set属性,无序和唯一
        System.out.println(c.toString());
        //------[!, world, Hello]--------// 
    }


}

1.2.1 HashSet

特点:底层是哈希表.

唯一性粗浅理解:通过hashCode获取到hash值进行比较,如果相同进一步比较地址值或者equal();如果地址值或者equal()相同,则表示相同,不在进行添加操作

 练习:

package pojo;

public class Student {
    public Student () {}
    public Student (String name ,int age) {
        this.name=name;
        this.age=age;
    }
    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;
    }
    @Override
    public String toString() {
        return "Student [姓名=" + name + ", 年龄=" + age + "]";
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
}

package d6;

import java.util.ArrayList;
import java.util.HashSet;

import pojo.Student;

public class HashSetTest {

    public static void main(String[] args) {

        HashSet<Student> c = new HashSet<Student>();// a:注意导包//b:new 子类对象

        // 02 创建学生对象 并添加到集合中 ,注意需要重写Student中的hashCode和equal方法
        Student s3 = new Student("张三", 13);
        Student s4 = new Student("李四", 14);
        Student s5 = new Student("王五", 15);
        Student s55 = new Student("王五", 15);
        Student s6 = new Student("赵六", 16);

        c.add(s3);
        c.add(s4);
        c.add(s5);
        c.add(s55);
        c.add(s6);

        //// 测试add方法 ,注意HashSet是无序的
        System.out.println(c.toString());
        // ------[Student [姓名=王五, 年龄=15], Student [姓名=张三, 年龄=13], 
        //Student [姓名=赵六, 年龄=16], Student [姓名=李四, 年龄=14]]--------//

    }

}

1.2.1.1 LinkedHashSet:(有序;)

特点:底层是哈希表(保证唯一)+链表(保证有序)组成

package pojo;

public class Student {
    public Student () {}
    public Student (String name ,int age) {
        this.name=name;
        this.age=age;
    }
    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;
    }
    @Override
    public String toString() {
        return "Student [姓名=" + name + ", 年龄=" + age + "]";
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
}

package d6;

import java.util.LinkedHashSet;

import pojo.Student;

public class LinkedHashSetTest {

    public static void main(String[] args) {

        LinkedHashSet<Student> c = new LinkedHashSet<Student>();// a:注意导包//b:new 子类对象

        // 02 创建学生对象 并添加到集合中 ,注意需要重写Student中的hashCode和equal方法
        Student s3 = new Student("张三", 13);
        Student s4 = new Student("李四", 14);
        Student s5 = new Student("王五", 15);
        Student s55 = new Student("王五", 15);
        Student s6 = new Student("赵六", 16);

        c.add(s3);
        c.add(s4);
        c.add(s5);
        c.add(s55);
        c.add(s6);

        //// 测试add方法 ,注意LinkedHashSet是有序的
        System.out.println(c.toString());
        // ------[Student [[Student [姓名=张三, 年龄=13], Student [姓名=李四, 年龄=14], 
        //Student [姓名=王五, 年龄=15], Student [姓名=赵六, 年龄=16]]--------//

    }

}

1.2.2 TreeSet

特点:底层是红黑二叉树

a:自然排序

package d6;

import java.util.ListIterator;
import java.util.TreeSet;

public class TreeSet1 {

    public static void main(String[] args) {
         //01 创建集合对象
        TreeSet<Integer>  c= new TreeSet<Integer>();// a:注意导包//b:new 子类对象
         //02 创建添加对象 并添加到 集合对象         
         c.add(10);
         c.add(50);
         c.add(90);
         c.add(77);
         c.add(15);
         c.add(32);
         c.add(10);
         c.add(50); 
         System.out.println(c.toString());
         //-------[10, 15, 32, 50, 77, 90]-------//
         
    }
}

练习:根据学生的年龄排序

注意点:1如要实现自然排序,需要实现Comparable接口;2:除了考虑到年龄排序的主要条件,还要考虑是否为同一学生的次要条件,避免年龄相同的两个学生被过滤掉

package pojo;

public class Student implements Comparable<Student>{
    public Student () {}
    public Student (String name ,int age) {
        this.name=name;
        this.age=age;
    }
    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;
    }
    @Override
    public String toString() {
        return "Student [姓名=" + name + ", 年龄=" + age + "]";
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public int compareTo(Student o) {
        int num = this.getAge()-o.getAge();
        int num2=num==0?this.getName().compareTo(o.getName()):num;
        return num2;
    }
}

package d6;

import java.util.TreeSet;

import pojo.Student;

public class TreeSet2 {

    //根据学生的年龄排序
    //注意点:1如要实现自然排序,需要实现接口;
    //2:除了考虑到年龄排序的主要条件,还要考虑是否为同一学生的次要条件,避免年龄相同的两个学生被过滤掉
    public static void main(String[] args) {
        // 01 创建集合对象
        TreeSet<Student> c = new TreeSet<Student>();// a:注意导包//b:new 子类对象         
        // 02 创建学生对象 并添加到集合中
        Student s3 = new Student("张三", 13);
        Student s6 = new Student("赵六", 16);
        Student s4 = new Student("李四", 14);
        Student s5 = new Student("王五", 15);
        Student s55 = new Student("王小五", 15);
        Student s555 = new Student("王五", 15);
        
        c.add(s3);
        c.add(s6);
        c.add(s4);
        c.add(s5);
        c.add(s55);
        c.add(s555);
        System.out.println(c.toString());
        // -------[Student [姓名=张三, 年龄=13], Student [姓名=李四, 年龄=14],
        //Student [姓名=王五, 年龄=15], Student [姓名=王小五, 年龄=15], 
        //Student [姓名=赵六, 年龄=16]]-------//

    }
}

b:比较器排序

注意点:让集合的构造方法接收一个比较器接口的子类对象Comparator

练习:按照学生的语文成绩和数学成绩之和进行升序排序

package pojo;

public class Score {
    @Override
    public String toString() {
        return "Score [姓名=" + name + ", 语文=" + chinese + ", 数学=" + maths + ", 总成绩="+sum()+"]";
    }

    private String name;
    private Integer chinese;
    private Integer maths;
    
    public Score(String name,int chinese,int maths) {
        this.name= name;
        this.chinese = chinese;
        this.maths=maths;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getChinese() {
        return chinese;
    }

    public void setChinese(Integer chinese) {
        this.chinese = chinese;
    }

    public Integer getMaths() {
        return maths;
    }

    public void setMaths(Integer maths) {
        this.maths = maths;
    }
    
    public int sum() {
        return this.chinese+this.maths;        
    }
}

package dao.impl;

import java.util.Comparator;

import pojo.Score;

public class ScoreCompare implements Comparator<Score> {

    @Override
    public int compare(Score o1, Score o2) {
         //主要条件
        int num = o1.sum()-o2.sum();
        int num2=num==0?o1.getName().compareTo(o2.getName()):num;
        return num2;
    }

     
}

package d6;

import java.util.TreeSet;

import dao.impl.ScoreCompare;
import pojo.Score;
 
public class TreeSet3 {

    //根据学生的总成绩排序
    //注意点:1如要实现比较器排序,需要实现创建一个比较;
    //2:除了考虑到年龄排序的主要条件,还要次要条件
    public static void main(String[] args) {
        // 01 创建集合对象
        TreeSet<Score> c = new TreeSet<Score>(new ScoreCompare());// a:注意导包//b:new 子类对象         
        // 02 创建学生对象 并添加到集合中
        Score s3 = new Score("张三", 13,99);
        Score s6 = new Score("赵六", 60,60);
        Score s4 = new Score("李四", 90,0);
        
        Score s5 = new Score("王五", 75,60);
        Score s55 = new Score("王小五", 59,30);
        Score s555 = new Score("王五", 100,98);
        
        c.add(s3);
        c.add(s6);
        c.add(s4);
        c.add(s5);
        c.add(s55);
        c.add(s555);
        System.out.println(c.toString());
        // -------[Score [姓名=王小五, 语文=59, 数学=30, 总成绩=89],
        //Score [姓名=李四, 语文=90, 数学=0, 总成绩=90], 
        //Score [姓名=张三, 语文=13, 数学=99, 总成绩=112], 
        //Score [姓名=赵六, 语文=60, 数学=60, 总成绩=120], 
        //Score [姓名=王五, 语文=75, 数学=60, 总成绩=135], 
        //Score [姓名=王五, 语文=100, 数学=98, 总成绩=198]]-------//

    }
}

ps:还可以通过匿名对象简化

package pojo;

public class Score {
    @Override
    public String toString() {
        return "Score [姓名=" + name + ", 语文=" + chinese + ", 数学=" + maths + ", 总成绩="+sum()+"]";
    }

    private String name;
    private Integer chinese;
    private Integer maths;
    
    public Score(String name,int chinese,int maths) {
        this.name= name;
        this.chinese = chinese;
        this.maths=maths;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getChinese() {
        return chinese;
    }

    public void setChinese(Integer chinese) {
        this.chinese = chinese;
    }

    public Integer getMaths() {
        return maths;
    }

    public void setMaths(Integer maths) {
        this.maths = maths;
    }
    
    public int sum() {
        return this.chinese+this.maths;        
    }
}

package d6;

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

import pojo.Score;
 
public class TreeSet4 {

    //根据学生的总成绩排序
    //注意点:1如要实现比较器排序,需要实现创建一个比较;
    //2:除了考虑到年龄排序的主要条件,还要次要条件
    public static void main(String[] args) {
        // 01 创建集合对象
        TreeSet<Score> c = new TreeSet<Score>( new Comparator<Score>(){
            public int compare(Score o1, Score o2) {
                 //主要条件
                int num = o1.sum()-o2.sum();
                int num2=num==0?o1.getName().compareTo(o2.getName()):num;
                return num2;
            }
        }); 
        // 02 创建学生对象 并添加到集合中
        Score s3 = new Score("张三", 13,99);
        Score s6 = new Score("赵六", 60,60);
        Score s4 = new Score("李四", 90,0);
        
        Score s5 = new Score("王五", 75,60);
        Score s55 = new Score("王小五", 59,30);
        Score s555 = new Score("王五", 100,98);
        
        c.add(s3);
        c.add(s6);
        c.add(s4);
        c.add(s5);
        c.add(s55);
        c.add(s555);
        System.out.println(c.toString());
        // -------[Score [姓名=王小五, 语文=59, 数学=30, 总成绩=89],
        //Score [姓名=李四, 语文=90, 数学=0, 总成绩=90], 
        //Score [姓名=张三, 语文=13, 数学=99, 总成绩=112], 
        //Score [姓名=赵六, 语文=60, 数学=60, 总成绩=120], 
        //Score [姓名=王五, 语文=75, 数学=60, 总成绩=135], 
        //Score [姓名=王五, 语文=100, 数学=98, 总成绩=198]]-------//

    }
}

2:数据结构

2.1 栈

2.2 队列

2.3 数组

2.4 链表

2.5 哈希表

2.6 红黑二叉树

 

 3 泛型

 

是一种把类型明确的工作推迟到创建对象或调用方法时才去明确的特殊的参数化类型.

参数化类型:把类型当做参数一样传递.此处的数据类型是引用类型

格式:<参数类型>

优点: a:把运行时的错误提前到了编译期间

　　  b:类型明确,避免了强制类型转换和黄色警告线.

3.1 将ArrayList创建对象用泛型改进

package d6;

import java.util.ArrayList;
import java.util.Iterator;
 
public class ArrayList_generic {

    public static void main(String[] args) {
        // 测试泛型
        ArrayList<String> c = new ArrayList<String>();// a:注意导包//b:new 子类对象
 
         c.add("Hello");
         c.add("World");
         c.add("!!!");
         
         Iterator<String> i = c.iterator();
         while (i.hasNext()) {            
             System.out.println(i.next());
        } 
        //-------Hello---------//
        //-------World---------//
        //-------!!!---------//

    }

}

3.2 泛型类:泛型可以像参数一样传递 

package dal;

public class ObjectTool<T> {
    private T obj;
    
    public void setObj(T obj) {
        this.obj = obj;            
    }
    
    public T getObj() {
        return this.obj;
    }
}

package d6;

import dal.ObjectTool;

public class ObjectTool_Test {

    public static void main(String[] args) {
        
        ObjectTool o = new ObjectTool();
        o.setObj("张三");
        System.out.println(o.getObj());
        //-------张三----------//
        o.setObj(111);
        System.out.println(o.getObj());
        //-------111----------//
        // 测试泛型类
        ObjectTool<String> o2 = new ObjectTool<String>();
        o2.setObj("张三");
        System.out.println(o2.getObj());
        //-------张三----------//         
    }

}

3.3 泛型方法

package dal;

public class ObjectTool2 {

    //泛型方法
    public <T> void show(T t) {
        System.out.println(t);
    }
}

package d6;

import dal.ObjectTool2;

public class ObjectTool_Test2 {

    public static void main(String[] args) { 
        
        ObjectTool2 o = new ObjectTool2();
        o.show("张三"); 
        //-------张三----------//
        o.show(111); 
        //-------111----------//
    }

}

 3.4 泛型接口

3.4.1 实现接口时可以确定类型

package dal;

public interface Inter <T>{
    public abstract void show(T t);
}

package dao.impl;

import dal.Inter;

public class Interimpl implements Inter<String>{

    @Override
    public void show(String t) {
        // 第一种方式实现接口的时候已经明确了类型
        System.out.println(t);
    }

}

package d6;

import dal.Inter;
import dao.impl.Interimpl;

public class InterImpl_test {

    public static void main(String[] args) {
        // 第一种方式实现接口的时候已经明确了类型
        Inter<String> i = new Interimpl();//定义接口类型,通过具体的子类来实现
        i.show("张三");
    }

}

3.4.2 实现接口时仍不能确定类型.较为常见

package dal;

public interface Inter <T>{
    public abstract void show(T t);
}

package dao.impl;

import dal.Inter;

public class Interimpl2<T> implements Inter<T>{

    @Override
    public void show(T t) {
        // 第一种方式实现接口的时候已经明确了类型
        System.out.println(t);
    }

}

package d6;

import dal.Inter;
import dao.impl.Interimpl2;

public class InterImpl_test2 {

    public static void main(String[] args) {
        // 第一种方式实现接口的时候已经明确了类型
        Inter<String> i = new Interimpl2<String>();
        i.show("张三2");
        //------张三2----------//
    }

}

 3.5 泛型通配符

package d6;

import java.util.ArrayList;
import java.util.Collection;

public class InterImpl_test3 {

    public static void main(String[] args) {
        Collection c = new ArrayList();
        // 01 写定了<Object>
        Collection<Object> c2 = new ArrayList<Object>();
        // Collection<Object> c2 = new ArrayList<Animal>(); ×
        // 02 ?通配符
        Collection<?> c3 = new ArrayList<Object>();
        Collection<?> c4 = new ArrayList<Animal>();
        Collection<?> c5 = new ArrayList<Dog>();
        // 03 ? extends T
        // Collection<? extends Animal> c6 = new ArrayList<Object>(); ×
        Collection<? extends Animal> c7 = new ArrayList<Animal>();
        Collection<? extends Animal> c8 = new ArrayList<Dog>();

        // 03 ? supper T
        Collection<? super Animal> c9 = new ArrayList<Object>(); 
        Collection<? super Animal> c10 = new ArrayList<Animal>();
        //Collection<? super Animal> c11 = new ArrayList<Dog>();    ×

    }

}

class Animal {
}

class Dog extends Animal {
}

 4.0 Map集合

 

键值对 。不能包含重复的键；每个键最多只能映射到一个值。

常用功能

a:增加功能(put()　　putAll())

特点：如果key值不存在，则新增，返回值为null； 如果key值存在，则更新，返回值为被更新的Value

package d6;

import java.util.HashMap;
import java.util.Map;

public class MapAdd1 {

    public static void main(String[] args) {
        Map<String, String> m = new HashMap<String, String>();

        String r = m.put("张三", "1");
        System.out.println(r);
        // -------null-------//
        String r2 =m.put("张三", "001");
        System.out.println(r2);
        // -------null-------//
        m.put("李四", "002");
        m.put("王五", "003");
        //// 测试put方法
        System.out.println(m.toString());
        // -------{李四=002, 张三=001, 王五=003}-------//
        
        /*
         * put方法
         * 1格式：V put(K key, V value)
         * 特点：如果key值不存在，则新增，返回值为null；
         *         如果key值存在，则更新，返回值为，被更新的Value
         * */
    }

}

package d6;

import java.util.HashMap;
import java.util.Map;

public class MapPutAll1 {

    public static void main(String[] args) {
        Map<String, String> m = new HashMap<String, String>();

        m.put("张三", "1");        
        m.put("张三", "001");         
        
        m.put("王五", "003");
        //// 测试put方法
        System.out.println(m.toString());
        // -------{张三=001, 王五=003}-------//
        
        
        Map<String, String> m1 = new HashMap<String, String>();
         
        m1.put("张三", "001");
        m1.put("李四", "002");
        m1.put("王五", "005");
        System.out.println(m1.toString());
        // -------{李四=002, 张三=001, 王五=005}-------//
        
        //// 测试put方法
        m.putAll(m1);
        System.out.println(m.toString());
        // -------{李四=002, 张三=001, 王五=005}-------//
        
        
        /*
         * putAll方法
         * 1格式：void putAll(Map<? extends K,? extends V> m)
         * 特点：如果key值不存在，则新增， 
         *         如果key值存在，则更新，则更新Value
         * */
    }

}

  b:删除功能(remove()　clear())

package d6;

import java.util.HashMap;
import java.util.Map;

public class MapRemove1 {

    public static void main(String[] args) {
        Map<String, String> m = new HashMap<String, String>();

        m.put("张三", "001");
        m.put("李四", "002");
        m.put("王五", "003");
        System.out.println(m.toString());
        // -------{李四=002, 张三=001, 王五=003}-------//
        //// 测试remove方法
        String r = m.remove("zhagnsan");
        System.out.println(r);
        // -------null-------//
        String r1 = m.remove("张三");
        System.out.println(r1);
        // -------001-------//
        System.out.println(m.toString());
        // -------{李四=002, 王五=003}-------//
        
        /*
         * remove方法 1
         * 格式：V remove(Object key)
         * 特点：如果映射關係不存在，返回值为null；
         * 如果映射關係存在，则移除映射關係，返回值为被移除的Value
         */
    }

}

package d6;

import java.util.HashMap;
import java.util.Map;

public class MapClear1 {

    public static void main(String[] args) {
        Map<String, String> m = new HashMap<String, String>();

        m.put("张三", "001");
        m.put("李四", "002");
        m.put("王五", "003");
        System.out.println(m.toString());
        // -------{李四=002, 张三=001, 王五=003}-------//
        m.clear();
         
        System.out.println(m.toString());
        // -------{}-------//
        
        /*
         * clear方法 1
         * 格式：void clear()
         * 特点：從集合中移除所有的映射關係
         */
    }

}

  c:判断功能(containsKey()　　containsValue()　　isEmpty())

package d6;

import java.util.HashMap;
import java.util.Map;

public class MapContains {

    public static void main(String[] args) {
        Map<String, String> m = new HashMap<String, String>();

        m.put("张三", "001");
        m.put("李四", "002");
        m.put("王五", "001");

        System.out.println(m.toString());
        // -------{李四=002, 张三=001, 王五=001}-------//

        // 测试containsKey方法
        System.out.println(m.containsKey("张三"));
        // -----true---------//
        System.out.println(m.containsKey("张三三"));
        // -----false--------//

        // 测试containsValue方法
        System.out.println(m.containsValue("001"));
        // -----true---------//
        System.out.println(m.containsValue("003"));
        // -----false---------//

        /*
         * put方法 
         * 1格式：boolean containsKey(Object key);
         *          boolean containsValue(Object value)
         * 特点：存在true，不存在false
         */
    }

}

package d6;

import java.util.HashMap;
import java.util.Map;

public class MapIsEmpty1 {

    public static void main(String[] args) {
        Map<String, String> m = new HashMap<String, String>();

        System.out.println(m.isEmpty());
        // -------true-------//
         
        m.put("张三", "001"); 
        m.put("王五", "003");
        System.out.println(m.isEmpty());
        // -------false-------// 
     
        m.clear();
        System.out.println(m.isEmpty());
        // -------true-------//
        
        
        /*
         * isEmpty方法
         * 1格式：boolean isEmpty()
         * 特点： 
         * */
    }

}

 d:长度功能(size())

package d6;

import java.util.HashMap;
import java.util.Map;

public class MapSize1 {

    public static void main(String[] args) {
        Map<String, String> m = new HashMap<String, String>();

        System.out.println(m.size());
        // -------0-------//
         
        m.put("张三", "001"); 
        m.put("王五", "003");
        System.out.println(m.size());
        // -------2-------// 
     
        m.clear();
        System.out.println(m.size());
        // -------0-------//
        
        
        /*
         * size方法
         * 1格式：int size()
         * 特点： 
         * */
    }

}

e:获取功能(get()　　keySet()　　values()　　entrySet())

get():　　　  根据键获取值

keySet();　　获取所有键

values();　　获取所有值

entrySet();　 获取所有Map对象

package d6;

import java.util.HashMap;
import java.util.Map;

public class MapGet1 {

    public static void main(String[] args) {
        Map<String, String> m = new HashMap<String, String>();

     
        m.put("張三", "001");         
        m.put("李四", "002");
        m.put("王五", "003");
        //// 测试get方法
        System.out.println(m.get("zhangsan"));
        // -------null-------//
        System.out.println(m.get("張三"));
        // -------001-------//
        
     
        /*
         * get方法
         * 1格式：V get(Object key)
         * 根據鍵找值  
         * 特点：如果key值不存在，则返回null ， 
         *         如果key值存在，則返回Value
         * */
    }

}

package d6;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapGet2 {

    public static void main(String[] args) {
        Map<String, String> m = new HashMap<String, String>();
        System.out.println(m.keySet()); // 獲取所有鍵
        // -------[]-------//
        System.out.println(m.values()); // 獲取所有值
        // -------[]-------//
        m.put("張三", "001");
        m.put("李四", "002");
        m.put("王五", "003");

        //// 测试keySet方法
        Set<String> ks = m.keySet();
        System.out.println(ks);
        // -------[李四, 王五, 張三]-------//

        //// 测试values方法
        Collection<String> vls = m.values();
        System.out.println(m.values());
        // -------[002, 003, 001]-------//

        /*
         * keySet方法 
         * 1格式：Set<K> keySet() 獲取所有鍵
         * 特点：如果key不存在，则返回"" ，
         * 如果jet存在，則返回Set集合
         */
        
        /*
         * values方法 
         * 1格式：Collection<V> values() 獲取所有值 
         * 特点：如果value值不存在，则返回"" ，
         * 如果value值存在，則返回Collection集合
         */
    }

}

package d6;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapGet3 {

    public static void main(String[] args) {
        Map<String, String> m = new HashMap<String, String>();
         
        System.out.println(m.entrySet()); // 獲取所有map對象
        // -------[]-------//
        m.put("張三", "001");
        m.put("李四", "002");
        m.put("王五", "003");

        //// 测试entrySet方法
        Set<Map.Entry<String, String>> es = m.entrySet();
        System.out.println(es);
        // -------[李四=002, 王五=003, 張三=001]-------//
 
        /*
         * entrySet方法 
         * 1格式：Set<Map.Entry<K,V>> entrySet() 獲取所有鍵值對對象
         * 特点：
         */
    }

}

  z:练习:遍历学生集合

先获取所有键，根据键找值；也可以直接获取到map对象进行遍历

package d6;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import pojo.Student;

public class MapTest1 {

    public static void main(String[] args) {
        Map<String, Student> m = new HashMap<String, Student>();
        Student s1 = new Student("张三", 13);
        Student s2 = new Student("李四", 14);
        Student s3 = new Student("王五", 15);

        m.put("001", s1);
        m.put("002", s2);
        m.put("003", s3);

        // 方法 1 獲取所有鍵，根據鍵獲取值
        Set<String> keys = m.keySet();
        for (String key : keys) {
            Student s = m.get(key);
            System.out.println(key + "------" + s);
        } 
        //-------001------Student [姓名=张三, 年龄=13]----------//
        //-------002------Student [姓名=李四, 年龄=14]----------//
        //-------003------Student [姓名=王五, 年龄=15]----------//
        
        // 方法2 獲取所有Map對象
        Set<Map.Entry<String, Student>> ents = m.entrySet();
        for (Map.Entry<String, Student> ent : ents) {
            String key = ent.getKey();
            Student st = ent.getValue();
            System.out.println(key + "------" + st);
        }         
        //------001------Student [姓名=张三, 年龄=13]-----------//
        //------002------Student [姓名=李四, 年龄=14]-----------//
        //------003------Student [姓名=王五, 年龄=15]-----------//
    }

}

4.1 HashMap：无序

底层是：哈希表

练习:<Studetn,sring>

package pojo;

public class Student implements Comparable<Student>{
    public Student () {}
    public Student (String name ,int age) {
        this.name=name;
        this.age=age;
    }
    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;
    }
    @Override
    public String toString() {
        return "Student [姓名=" + name + ", 年龄=" + age + "]";
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public int compareTo(Student o) {
        int num = this.getAge()-o.getAge();
        int num2=num==0?this.getName().compareTo(o.getName()):num;
        return num2;
    }
}

package d6;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import pojo.Student;

public class HashMapTest1 {

    public static void main(String[] args) {
        HashMap<Student,String> m = new HashMap<Student,String>() ;
        Student s1 = new Student("张三", 13);
        Student s2 = new Student("李四", 14);
        Student s3 = new Student("王五", 15);
        Student s4 = new Student("张三", 13);
        m.put( s1,"001");
        m.put( s2,"002");
        m.put( s3,"003");
        m.put( s4,"004");
 
        
        // 方法2 獲取所有Map對象
        Set<Map.Entry<Student,String>> ents = m.entrySet();
        for (Map.Entry<Student,String> ent : ents) {
            Student key = ent.getKey();
            String st = ent.getValue();
            System.out.println(key + "------" + st);
        }         
        //-----Student [姓名=王五, 年龄=15]------003-----------//
        //-----Student [姓名=张三, 年龄=13]------004-----------//
        //-----Student [姓名=李四, 年龄=14]------002-----------//
        
        //注意：若要實現Student的唯一需要重寫hashCode 和equals方法
    }

}

 4.1.1 LinkedHashMap 唯一；有序

底层是：哈希表 + 链表

package d6;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapTest1 {

    public static void main(String[] args) { 
        Map<String, String> m = new HashMap<String, String>(); 
         
        m.put("张三", "001");         
        m.put("李四", "002");
        m.put("王五", "003");
        System.out.println(m.toString()); 
        // -------{李四=002, 张三=001, 王五=003}-------//
        
        LinkedHashMap<String, String> lhm = new LinkedHashMap<String, String>();
        lhm.put("张三", "001");         
        lhm.put("李四", "002");
        lhm.put("王五", "003");
        System.out.println(lhm.toString());
        // -------{张三=001, 李四=002, 王五=003}-------//
        
        //通过对比说明其是有序的
    }

}

4.2 TreeMap 

底层是：红黑树

package d6;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

import pojo.Student;

public class TreeMapTest1 {

    public static void main(String[] args) { 
        TreeMap<Student, String> m = new TreeMap<Student, String>();  
     
        Student s1 = new Student("张三", 13);
        Student s2 = new Student("李四", 16);
        Student s3 = new Student("王五", 15);
        Student s4 = new Student("张三", 13);
        m.put( s1,"001");
        m.put( s2,"002");
        m.put( s3,"003");
        m.put( s4,"004");
 
        
        // 方法2 獲取所有Map對象
        Set<Map.Entry<Student,String>> ents = m.entrySet();
        for (Map.Entry<Student,String> ent : ents) {
            Student key = ent.getKey();
            String st = ent.getValue();
            System.out.println(key + "------" + st);
        }         
        //-----Student [姓名=张三, 年龄=13]------004----------//
        //-----Student [姓名=王五, 年龄=15]------003----------//
        //-----Student [姓名=李四, 年龄=16]------002----------//
        
     
        
        // Student中实现接口implements Comparable<Student>
    }

}

 练习：判断一个字符串中字符出现的次数

package d6;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class CharCount {

    public static void main(String[] args) {
        // 计算一个字符串中元素出现个此处并按顺序给出
        //“asdfsfdgj”   a(1);d(2);f(2);g(1);j(1);s(2)
        String str = "asdfsfdgj";
        //01 将字符串转化为数组
        char[] chsrs = str.toCharArray();
        //02 定义Map对象
        TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
        
        //03 循环遍历数组
        for (char c : chsrs) {
            //04 如果TreeMap中存在则+1;如果不存在就添加
            if (tm.get(c)!=null) {
                int value = tm.get(c) +1;
                tm.put(c, value);
            }else {                
                tm.put(c, 1);
            }            
        }
        //04  循环遍历Map
        StringBuilder sb = new StringBuilder();
        Set<Map.Entry<Character,Integer>> ets = tm.entrySet();
        for (Map.Entry<Character,Integer> et : ets) {
            sb.append(et.getKey()+"(");
            sb.append(et.getValue()+")");
            sb.append(";");
        }
        String result =sb.toString().substring(0,sb.toString().lastIndexOf(";"));
        System.out.println(result);
        
        //---------a(1);d(2);f(2);g(1);j(1);s(2)----------//
    }

}

5 集合的嵌套练习

5.1 HashMap<HashMap>

package d6;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import pojo.Student;

public class CollectionMapTest1 {
    public static void main(String[] args) {
        //创建对象---开始
        HashMap<String,HashMap<Integer,Student>> hh = new HashMap<String,HashMap<Integer,Student>>();
        
        HashMap<Integer,Student> hsAnYang = new HashMap<Integer,Student>();
        HashMap<Integer,Student> hsZhengZhou = new HashMap<Integer,Student>();
        
        Student s1 = new Student("张三", 13);
        Student s2 = new Student("李四", 14);
        Student s3 = new Student("王五", 15);
        Student s4 = new Student("赵六", 16);
        //创建对象---结束
        
        //添加对象---开始
        hsAnYang.put(2, s2);
        hsAnYang.put(1, s1);        
        hsZhengZhou.put(1, s3);
        hsZhengZhou.put(2, s4);
        
        hh.put("郑州", hsZhengZhou);
        hh.put("安阳", hsAnYang);        
        //添加对象---结束 
        
        //遍历对象---开始
        Set<String> hhKeys = hh.keySet();
        for (String hhKey : hhKeys) {
            HashMap<Integer,Student> hhValues = hh.get(hhKey);
            
            Set<Map.Entry<Integer,Student>> hsStudents = hhValues.entrySet();
            for (Map.Entry<Integer, Student> entry : hsStudents) {
                String studentNO = entry.getKey().toString();
                Student StudentInfo = entry.getValue();
                System.out.println("地区: "+hhKey+"|||||||"+"学号: "+studentNO+"--详细信息: "+StudentInfo);
            }
        }
        //遍历对象---结束
        
        /*         
            地区: 安阳|||||||学号: 1--详细信息: Student [姓名=张三, 年龄=13]
            地区: 安阳|||||||学号: 2--详细信息: Student [姓名=李四, 年龄=14]
            地区: 郑州|||||||学号: 1--详细信息: Student [姓名=王五, 年龄=15]
            地区: 郑州|||||||学号: 2--详细信息: Student [姓名=赵六, 年龄=16]
         * */
    }
}

5.2 HashMap<ArrayList>

package d6;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import pojo.Student;

public class CollectionMapTest2 {
    public static void main(String[] args) {
        //创建对象---开始
        HashMap<String,ArrayList<Student>> hh = new HashMap<String,ArrayList<Student>>();
        
        ArrayList<Student> hsAnYang = new ArrayList<Student>();
        ArrayList<Student> hsZhengZhou = new ArrayList<Student>();
        
        Student s1 = new Student("张三", 13);
        Student s2 = new Student("李四", 14);
        Student s3 = new Student("王五", 15);
        Student s4 = new Student("赵六", 16);
        //创建对象---结束
        
        //添加对象---开始
        hsAnYang.add(s2);
        hsAnYang.add(s1);        
        hsZhengZhou.add(s3);
        hsZhengZhou.add(s4);
                     
        hh.put("郑州", hsZhengZhou);
        hh.put("安阳", hsAnYang);        
        //添加对象---结束 
        
        //遍历对象---开始
        Set<String> hhKeys = hh.keySet();
        for (String hhKey : hhKeys) {
            ArrayList<Student> hhValues = hh.get(hhKey); 
            for (Student student : hhValues) {                 
                    System.out.println("地区: "+hhKey+"|||||||--详细信息: "+student);
            }
        }
        //遍历对象---结束
        
        /*         
地区: 安阳|||||||--详细信息: Student [姓名=李四, 年龄=14]
地区: 安阳|||||||--详细信息: Student [姓名=张三, 年龄=13]
地区: 郑州|||||||--详细信息: Student [姓名=王五, 年龄=15]
地区: 郑州|||||||--详细信息: Student [姓名=赵六, 年龄=16]

         * */
    }
}

 5.3 Array<ListHashMap>

package d6;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import pojo.Student;

public class CollectionMapTest3 {
    public static void main(String[] args) {
        //创建对象---开始
        ArrayList<HashMap<Integer,Student>> hh = new ArrayList<HashMap<Integer,Student>>();
        
        HashMap<Integer,Student> hsAnYang = new HashMap<Integer,Student>();
        HashMap<Integer,Student> hsZhengZhou = new HashMap<Integer,Student>();
        
        Student s1 = new Student("张三", 13);
        Student s2 = new Student("李四", 14);
        Student s3 = new Student("王五", 15);
        Student s4 = new Student("赵六", 16);
        //创建对象---结束
        
        //添加对象---开始
        hsAnYang.put(2, s2);
        hsAnYang.put(1, s1);        
        hsZhengZhou.put(1, s3);
        hsZhengZhou.put(2, s4);
        
        hh.add(hsZhengZhou);
        hh.add(hsAnYang);        
        //添加对象---结束 
        
        //遍历对象---开始         
        for (HashMap<Integer,Student> list : hh) {             
            Set<Map.Entry<Integer,Student>> hsStudents = list.entrySet();
            for (Map.Entry<Integer, Student> entry : hsStudents) {
                String studentNO = entry.getKey().toString();
                Student StudentInfo = entry.getValue();
                System.out.println("学号: "+studentNO+"--详细信息: "+StudentInfo);
            }
        }
        //遍历对象---结束
        
        /*         
学号: 1--详细信息: Student [姓名=王五, 年龄=15]
学号: 2--详细信息: Student [姓名=赵六, 年龄=16]
学号: 1--详细信息: Student [姓名=张三, 年龄=13]
学号: 2--详细信息: Student [姓名=李四, 年龄=14]
         * */
    }
}

 5.4 HashMap<HashMap<HashMap>>

package d6;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import pojo.Student;

public class CollectionMapTest4 {
    public static void main(String[] args) {
        // 创建对象---开始
        HashMap<String, HashMap<String, HashMap<Integer, Student>>> hhh = new HashMap<String, HashMap<String, HashMap<Integer, Student>>>();

        HashMap<String, HashMap<Integer, Student>> hh = new HashMap<String, HashMap<Integer, Student>>();
        HashMap<String, HashMap<Integer, Student>> hh2 = new HashMap<String, HashMap<Integer, Student>>();

        HashMap<Integer, Student> hsAnYang = new HashMap<Integer, Student>();
        HashMap<Integer, Student> hsZhengZhou = new HashMap<Integer, Student>();
        HashMap<Integer, Student> hsHanDan = new HashMap<Integer, Student>();
        HashMap<Integer, Student> hsShiJiaZhuang = new HashMap<Integer, Student>();
        
        Student s1 = new Student("张三", 13);
        Student s2 = new Student("李四", 14);
        Student s3 = new Student("王五", 15);
        Student s4 = new Student("赵六", 16);         
        Student s11 = new Student("张三三", 13);
        Student s22 = new Student("李四四", 14);
        Student s33 = new Student("王五五", 15);
        Student s44 = new Student("赵六六", 16);
        // 创建对象---结束

        // 添加对象---开始
        hsAnYang.put(2, s2);
        hsAnYang.put(1, s1);
        hsZhengZhou.put(1, s3);
        hsZhengZhou.put(2, s4);
        hsHanDan.put(2, s22);
        hsHanDan.put(1, s11);
        hsShiJiaZhuang.put(1, s33);
        hsShiJiaZhuang.put(2, s44);
        
        hh.put("郑州", hsZhengZhou);
        hh.put("安阳", hsAnYang); 
        hh2.put("石家庄", hsShiJiaZhuang);
        hh2.put("邯郸", hsHanDan); 
        
        hhh.put("河南", hh);
        hhh.put("河北", hh2);
        // 添加对象---结束

        // 遍历对象---开始
        Set<Map.Entry<String, HashMap<String, HashMap<Integer, Student>>>> hhhEntrys = hhh.entrySet();
        for (Map.Entry<String, HashMap<String, HashMap<Integer, Student>>> hhhEntry : hhhEntrys) {
             //System.out.println(hhhEntry);
             String hhKeys = hhhEntry.getKey();
             HashMap<String, HashMap<Integer, Student>> hhValues = hhhEntry.getValue();
             //System.out.println(hhValues);
             Set<Map.Entry<String, HashMap<Integer, Student>>> hhEntrys = hhValues.entrySet();
             for (Map.Entry<String, HashMap<Integer, Student>>  hhEntry : hhEntrys) {
                 String hKeys = hhEntry.getKey();
                 HashMap<Integer, Student> hValues = hhEntry.getValue();
                 Set<Map.Entry<Integer, Student>> hEntrys = hValues.entrySet();
                 for (Map.Entry<Integer, Student> hEntry : hEntrys) {
                     Integer sNO = hEntry.getKey();
                     Student sInfo = hEntry.getValue();
                     System.out.println("省: "+hhKeys+"--市: "+hKeys+"---学号: "+sNO+"---学生详细信息: "+sInfo);
                } 
            }
        }
        // 遍历对象---结束

        /*
省: 河南--市: 安阳---学号: 1---学生详细信息: Student [姓名=张三, 年龄=13]
省: 河南--市: 安阳---学号: 2---学生详细信息: Student [姓名=李四, 年龄=14]
省: 河南--市: 郑州---学号: 1---学生详细信息: Student [姓名=王五, 年龄=15]
省: 河南--市: 郑州---学号: 2---学生详细信息: Student [姓名=赵六, 年龄=16]
省: 河北--市: 邯郸---学号: 1---学生详细信息: Student [姓名=张三三, 年龄=13]
省: 河北--市: 邯郸---学号: 2---学生详细信息: Student [姓名=李四四, 年龄=14]
省: 河北--市: 石家庄---学号: 1---学生详细信息: Student [姓名=王五五, 年龄=15]
省: 河北--市: 石家庄---学号: 2---学生详细信息: Student [姓名=赵六六, 年龄=16]

         */
    }
}

 6 Collections

 

 6.1 常用方法

sort(); 根据元素的自然顺序 对指定列表按升序进行排序。当然也可以根据比较器进行排序

max() ; 返回最大值

min();  返回最小值

binarySearch(): 二分查找 ;如果存在返回索引值,如果不存在返回-(集合长度+1)

reverse();　集合反转

shuffle();　随机置换

package d6;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class CollectionsTest {

    public static void main(String[] args) {
        List c = new ArrayList();//a:注意导包//b:new 子类对象
        c.add(20);
        c.add(50);
        c.add(30);
        c.add(10);
        c.add(40);
        ////测试sort方法   默认自然排序
        Collections.sort(c);
        System.out.println(c.toString());
        //------[10, 20, 30, 40, 50]--------//
        System.out.println(Collections.max(c));
        //------50--------//
        System.out.println(Collections.min(c));
        //------10--------//
         
        System.out.println(Collections.binarySearch(c,30));
        //------2--------//
        System.out.println(Collections.binarySearch(c,300));
        //-------6--------//
        
        Collections.reverse(c); 
        System.out.println(c.toString());
        //------[50, 40, 30, 20, 10]--------//        
        
        Collections.shuffle(c);
        System.out.println(c.toString());
        //------[50, 20, 10, 40, 30]--------//
    }


}

 练习:斗地主

package d6;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class PlayTest {

    public static void main(String[] args) {
        //创建一个表,用于记录每张牌的大小
        HashMap<Integer,String> ruleMap = new HashMap<Integer,String>();
        //创建一个牌盒(牌盒里其实就是54个数值,通过规则与之对应)
        ArrayList<Integer> pokersList = new ArrayList();    
        for (int i = 0; i < 54; i++) {
            pokersList.add(i);
        }
        //创建花色数组
        String [] colorArray = {"♦","♣","♥","♠"};
        //创建点数数组
        String [] pointArray = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        
        //创建扑克牌并放入牌盒,同时将大小规则记录在ruleMap表中
        int index = 0;
        for (int i = 0; i < pointArray.length; i++) {
            for (String colorStr : colorArray) {
                String poker =  colorStr+pointArray[i] +" ";
                ruleMap.put(index, poker);
                index++;
            }
        }
        ruleMap.put(index, "小王");
        index++;
        ruleMap.put(index, "大王");
        
        //洗牌
        Collections.shuffle(pokersList);
        
        //创建玩家,发牌
        ArrayList<Integer> zhangSan = new ArrayList<Integer>();
        ArrayList<Integer> liSi = new ArrayList<Integer>();
        ArrayList<Integer> wangWu = new ArrayList<Integer>();
        ArrayList<Integer> diPai = new ArrayList<Integer>();
        
        for (int i = 0; i < pokersList.size(); i++) {
            if (i>=pokersList.size()-3) {
                diPai.add(pokersList.get(i));
            }else if (i%3==0) {
                zhangSan.add(pokersList.get(i));
            }else if (i%3==1) {
                liSi.add(pokersList.get(i));
            }else if (i%3==2) {
                wangWu.add(pokersList.get(i));
            }
        }
        
        //看牌:把每位玩家的TreeSet中的值通过规则表匹配排序输出
        lookPoker("张三",zhangSan,ruleMap);
        lookPoker("李四",liSi,ruleMap);
        lookPoker("王五",wangWu,ruleMap);
        lookPoker("底牌",diPai,ruleMap);
    }

    private static void lookPoker(String name, ArrayList<Integer> player,HashMap<Integer,String> ruleMap) {
        //拿到每位玩家的牌以后排序
        Collections.sort(player);
        //排完序后输出
        StringBuilder sb = new StringBuilder();
        for (Integer piont : player) {
            sb.append(ruleMap.get(piont));
        }
        System.out.println(name+": "+sb.toString());
    }
/*
张三: ♥3 ♠3 ♦4 ♣4 ♥4 ♣5 ♠7 ♥8 ♦9 ♠9 ♦10 ♣J ♥K ♥A ♠A ♣2 ♠2 
李四: ♦3 ♣3 ♠4 ♦5 ♥5 ♠5 ♣6 ♥6 ♦8 ♣8 ♣9 ♣10 ♥10 ♠J ♦Q ♥Q ♠K 
王五: ♦6 ♠6 ♦7 ♣7 ♥7 ♠8 ♥9 ♠10 ♦J ♥J ♣Q ♠Q ♣K ♦A ♦2 小王大王
底牌: ♦K ♣A ♥2 
 * */
}

1.0版在看牌排序的时候用的是Collections的sort()方法,也可以通过TreeSet完成自动排序

package d6;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class PlayTest2 {

    public static void main(String[] args) {
        //创建一个表,用于记录每张牌的大小
        HashMap<Integer,String> ruleMap = new HashMap<Integer,String>();
        //创建一个牌盒(牌盒里其实就是54个数值,通过规则与之对应)
        ArrayList<Integer> pokersList = new ArrayList();    
        for (int i = 0; i < 54; i++) {
            pokersList.add(i);
        }
        //创建花色数组
        String [] colorArray = {"♦","♣","♥","♠"};
        //创建点数数组
        String [] pointArray = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        
        //创建扑克牌并放入牌盒,同时将大小规则记录在ruleMap表中
        int index = 0;
        for (int i = 0; i < pointArray.length; i++) {
            for (String colorStr : colorArray) {
                String poker =  colorStr+pointArray[i] +" ";
                ruleMap.put(index, poker);
                index++;
            }
        }
        ruleMap.put(index, "小王");
        index++;
        ruleMap.put(index, "大王");
        
        //洗牌
        Collections.shuffle(pokersList);
        
        //创建玩家,发牌
        TreeSet<Integer> zhangSan = new TreeSet<Integer>();
        TreeSet<Integer> liSi = new TreeSet<Integer>();
        TreeSet<Integer> wangWu = new TreeSet<Integer>();
        TreeSet<Integer> diPai = new TreeSet<Integer>();
        
        for (int i = 0; i < pokersList.size(); i++) {
            if (i>=pokersList.size()-3) {
                diPai.add(pokersList.get(i));
            }else if (i%3==0) {
                zhangSan.add(pokersList.get(i));
            }else if (i%3==1) {
                liSi.add(pokersList.get(i));
            }else if (i%3==2) {
                wangWu.add(pokersList.get(i));
            }
        }
        
        //看牌:把每位玩家的TreeSet中的值通过规则表匹配排序输出
        lookPoker("张三",zhangSan,ruleMap);
        lookPoker("李四",liSi,ruleMap);
        lookPoker("王五",wangWu,ruleMap);
        lookPoker("底牌",diPai,ruleMap);
    }

    private static void lookPoker(String name, TreeSet<Integer> player,HashMap<Integer,String> ruleMap) {
          
        StringBuilder sb = new StringBuilder();
        for (Integer piont : player) {
            sb.append(ruleMap.get(piont));
        }
        System.out.println(name+": "+sb.toString());
    }
/*
张三: ♥3 ♠3 ♦4 ♦6 ♠6 ♦7 ♠9 ♣10 ♠10 ♣J ♥J ♠J ♦K ♦A ♦2 ♠2 小王
李四: ♣4 ♥4 ♣5 ♥5 ♠5 ♣6 ♥6 ♣7 ♦8 ♥8 ♠8 ♣9 ♦10 ♥10 ♠Q ♣K ♠A 
王五: ♣3 ♦5 ♥7 ♠7 ♣8 ♦9 ♥9 ♦J ♦Q ♣Q ♥Q ♥K ♠K ♣A ♥A ♣2 ♥2 
底牌: ♦3 ♠4 大王
 * */
}