java常用集合 方法测试代码

package com.Test.Demo.JiHeTest;

import com.sun.org.apache.xalan.internal.xsltc.cmdline.Compile;
import com.sun.org.apache.xpath.internal.objects.XObject;

import java.util.*;

public class JiHeTest01 {
    public static void main(String[] args) {
        System.out.println("============ Collection中元素均可以迭代============");
        //采用面向接口编程
        List<Integer> l1 = new ArrayList<>(); //List集合有序 可重复
        //此处我们改为LinkedList运行结果也是一样 对程序没有影响
        //List<Integer> l1=new LinkedList<>();
        l1.add(996);
        l1.add(123);
        l1.add(123);
        l1.add(12345);
        System.out.println("============List集合方法测试============");
        System.out.println("============List集合中元素可重复 有序============");
        //List集合有下标
        for (Integer i : l1) {  //集合直接用foreach遍历输出
            System.out.println(i);
        }
        System.out.println("List 集合元素数量为:" + l1.size());
        l1.remove(new Integer(123));        //删除指定元素
        System.out.println("List 集合元素数量为:" + l1.size());
        for (int i = 0; i < l1.size(); i++) {           //利用size获取List集合元素数量
            System.out.println(l1.get(i));      //利用get方法获取指定下标的元素
        }
        Iterator<Integer> inte = l1.iterator();  //利用iterator方法返回一个迭代器
        while (inte.hasNext()) {              //利用迭代器中的hasNest方法判断集合中是否还有元素
            Integer t = inte.next();          //利用迭代器中的next方法获取集合中下一个元素
            System.out.println(t);
        }
        //while循环也可以改为for循环的写法
       /* for(Iterator inte1=l1.iterator();inte1.hasNext();){
            System.out.println(inte1.next());
        }*/
        System.out.println(l1.contains(123)); //利用contains方法判断集合中是否含有指定元素
        System.out.println(l1.isEmpty());  //判断集合是否为空
        Object[] l1Array = l1.toArray(); //将集合转变为对象数组
        for (Object t : l1Array) {  //foreach输出集合中的元素
            int t1 = (int) t;
            System.out.println(t1);
        }
        /*for(int i=0;i<l1Array.length;i++){
            System.out.println(l1Array[i]);
        }*/
        System.out.println();

        System.out.println("============Set集合方法测试============");
        System.out.println("============Set集合元素不可重复 无序============");
        System.out.println("============HasgSet集合测试============");
        //HachSet底层是HashMap 此类允许使用null元素 在HashSet中，元素都存到HashMap键值对的Key上面，而Value时有一个统一的值private static final Object PRESENT = new Object();，
        //因为HachSet中的元素不允许重复 所以我们自定义的类必须重写hashCode 和equals方法
        /*Set<Integer> set1=new HashSet<>(); //说明Integer重写了hashCode 和equals方法
        set1.add(new Integer(1));
        set1.add(new Integer(3));
        set1.add(new Integer(3));
        set1.add(new Integer(0));
        Iterator<Integer> inteSet=set1.iterator();
        while(inteSet.hasNext()){
            System.out.println(inteSet.next());
        }*/
        Set<Dog> set1 = new HashSet<>();
        Dog dog1 = new Dog(5, "www");
        Dog dog2 = new Dog(6, "lll");
        Dog dog3 = new Dog(9, "qqq");
        Dog dog4 = new Dog(5, "www");
        set1.add(dog1);
        set1.add(dog2);
        set1.add(dog3);
        set1.add(dog4);
        Iterator<Dog> inteSet = set1.iterator();
        while (inteSet.hasNext()) {
            System.out.println(inteSet.next());
        }
        //再次强调：特别是向 HashSet或 HashMap 中加入数据时必须同时覆盖 equals和 hashCode 方 法，应该养成一种习惯覆盖 equals的同时最好同时覆盖 hashCode
        //两个对象 equals 相等，那么它的hashcode 相等 两个对象 equals 不相等，那么它的 hashcode 并不要求它不相等，但一般建议不相等      hashcode 相等不代表两个对象相等（采用 equals 比较）
        System.out.println("============TreeSet集合方法测试============");
        System.out.println("============TreeSet可以对Set 集合进行排序，默认自然排序（即升序），但也可以做客户化的排序============");
        Set<Integer> te1=new TreeSet<>();
        te1.add(1);
        te1.add(0);
        te1.add(-1);
        te1.add(0);
       /* for(Integer i:te1){
            System.out.println(i);
        }*/
        //放到 TreeSet 中的元素会进行排序，那么必须实现 Comparable 接口，而 我们假如自定义的类没有实现，就会出现了错误。
        // 如：基本类型的包装类和 String 他们都是可以排序的，他们都实现 Comparable 接口
        for(Iterator<Integer> treeIter =te1.iterator();treeIter.hasNext();){
            System.out.println(treeIter.next());
        }
        //我们在Dog类中实现了Comparable接口 在类中覆写了compareTo方法 在将对象放到TreeSet中时 按照年龄排序
        Set<Dog> set2=new TreeSet<>();
        Dog dog11 = new Dog(5, "www");
        Dog dog22 = new Dog(6, "lll");
        Dog dog33 = new Dog(9, "qqq");
        Dog dog44 = new Dog(5, "www");
        set2.add(dog11);
        set2.add(dog22);
        set2.add(dog33);
        set2.add(dog44);
        Iterator tree1=set2.iterator();
        while(tree1.hasNext()){
            System.out.println(tree1.next());
        }
        System.out.println();
        //我们还可以实现Comparator接口完成排序
        Cat cat1=new Cat(2,"mmm");
        Cat cat2=new Cat(3,"kkk");
        Cat cat3=new Cat(2,"iii");
        Cat cat4=new Cat(5,"mmm");
        Comparator catComparator=new CatComparator();
        Set<Cat> catSet=new TreeSet<>(catComparator);
       /* Set<Cat> catSet=new TreeSet<>(new Comparator<Cat>() { //也可以不实现Comparator接口 直接采用匿名内部类的形式new接口
            @Override
            public int compare(Cat o1, Cat o2) {
                return o2.getAge()-o1.getAge();
            }
        });*/
        catSet.add(cat1);
        catSet.add(cat2);
        catSet.add(cat3);
        catSet.add(cat4);
        Iterator<Cat> catIterator=catSet.iterator();
        while(catIterator.hasNext()){
            System.out.println(catIterator.next());
        }
        //Comparator 和 Comparable 的区别？
        // Comparable 是默认的比较接口，Comparable 和需要比较的对象紧密结合到一起了 一个类实现了Camparable 接口则表明这个类的对象之间是可以相互比较的，这个类对象组成 的集合就可以直接使用sort 方法排序
        // Comparator 可以分离比较规则，所以它更具灵活性
        System.out.println();

        System.out.println("================Map集合测试==============");
        System.out.println("==============HashMap集合测试============");
        //Map 中可以放置键值对，也就是每一个元素都包含键对象和值对象 。key部 分的元素“无序不可重复”。所以key 部分等同可以看做Set集合。Map中 key起决定性作用。
        // key部分特点：无序不 可重复，但是存储的 元素可以按照元素大 小顺序自动排列。
        // Map 实现较常用的为 HashMap，HashMap对键对象的存取和 HashSet 一样，仍然采用的是哈希算法，所以如果使用自定类作为Map的键对象，必须复写equals 和 hashCode 方法。
        Map<Integer,String > map=new HashMap<>();
        map.put(111,"老王");
        map.put(122,"老刘");
        map.put(133,"老杜");
        map.put(111,"老付"); //Key值相同 value值覆盖
        Set<Map.Entry<Integer,String>> six=map.entrySet();//遍历Map集合方法1
        Iterator<Map.Entry<Integer,String >> entryIterator=six.iterator();
        while(entryIterator.hasNext()){
            Map.Entry<Integer,String> t=entryIterator.next();
            System.out.println("编号:"+t.getKey()+"  姓名:"+t.getValue());
        }
        /*Set<Integer> ttt=map.keySet();  //遍历Map集合方法2
        Iterator<Integer> ttt1= ttt.iterator();
        while(ttt1.hasNext()){
            Integer in=ttt1.next();
            System.out.println("编号:"+in+"  姓名:"+map.get(in));
        }*/
        //以上包装类和string均已经实现了复写equals 和 hashCode 方法。 所以在加入TreeMap时可以得到正确答案
        //以下为测试复写equals和hashCode方法的自定义类型
        Dog dog111 = new Dog(8, "lll");
        Dog dog222 = new Dog(6, "www");
        Dog dog333 = new Dog(9, "qqq");
        Dog dog444 = new Dog(6, "www");
        Map<Dog,String> map1=new HashMap<>();
        map1.put(dog111,"dasdasdad");
        map1.put(dog222,"adasdasdad");
        map1.put(dog333,"daasddasdad");
        map1.put(dog444,"dasdasdad");
        for(Iterator<Map.Entry<Dog,String >> tt=map1.entrySet().iterator();tt.hasNext();){
            Dog t=tt.next().getKey();
           System.out.println(t+" "+map1.get(t));
        }
        System.out.println("==============TreeMap集合测试============");
        //TreeMap 可以对 Map 中的 key 进行排序，如果 map 中的 key 采用的是自定类那么需要实现 Comaprable 或 Comparator 接口完成排序
        //同TreeSet 我就不写了。。。累了
        System.out.println();

        System.out.println("================Collections 工具类常用方法=============");
        List<Integer> list1=new ArrayList<>();
        list1.add(1);
        list1.add(99);
        list1.add(-1);
        list1.add(0);
        list1.add(-1);
        Collections.sort(list1); //对集合元素进行排序
        for(Iterator t=list1.iterator();t.hasNext();){
            System.out.println(t.next());
        }
        System.out.println();
        Collections.reverse(list1);//翻转集合元素
        for(Iterator t=list1.iterator();t.hasNext();){
            System.out.println(t.next());
        }
        System.out.println();
        Set set = new HashSet(); //不能直接对Set排序
        set.add(10);
        set.add(1);
        set.add(4);
        set.add(9);
        List list2=new ArrayList(set);//利用ArrayList的含参构造方法
        Collections.sort(list2);
        for(Iterator t=list2.iterator();t.hasNext();){
            System.out.println(t.next());
        }
        System.out.println();
        System.out.println(Collections.binarySearch(list2,9));
    }
}
class Cat{
    private int age;
    private String name;
    public Cat(int age,String name){
        this.age=age;
        this.name=name;
    }
    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
class CatComparator implements Comparator{
    public int compare(Object a,Object b){
        if((a instanceof Cat)&&(b instanceof Cat)){
            Cat a1=(Cat) a;
            Cat b1=(Cat) b;
            return b1.getAge()-a1.getAge();
        }
        else{
            throw new IllegalArgumentException("非法参数，o=" );
        }
    }
}
class Dog implements Comparable {
    private int age;
    private String name;
    public Dog(int age,String name){
        this.age=age;
        this.name=name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Dog dog = (Dog) o;
        return age == dog.age &&
                Objects.equals(name, dog.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(age, name);
    }

    @Override
    public String toString() {
        return "Dog{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }



    @Override
    public int compareTo(Object o) {
        if(o instanceof Dog)
        {
            Dog t=(Dog )o;
           //return (this.age-t.age);//升序
            return (t.age-this.age); //降序
        }
        else{
            throw new IllegalArgumentException("非法参数，o=" + o);
        }
    }
}

运行结果:
============ Collection中元素均可以迭代============
============List集合方法测试============
============List集合中元素可重复 有序============
996
123
123
12345
List 集合元素数量为:4
List 集合元素数量为:3
996
123
12345
996
123
12345
true
false
996
123
12345

============Set集合方法测试============
============Set集合元素不可重复 无序============
============HasgSet集合测试============
Dog{age=5, name='www'}
Dog{age=6, name='lll'}
Dog{age=9, name='qqq'}
============TreeSet集合方法测试============
============TreeSet可以对Set 集合进行排序，默认自然排序（即升序），但也可以做客户化的排序============
-1
0
1
Dog{age=9, name='qqq'}
Dog{age=6, name='lll'}
Dog{age=5, name='www'}

Cat{age=5, name='mmm'}
Cat{age=3, name='kkk'}
Cat{age=2, name='mmm'}

================Map集合测试==============
==============HashMap集合测试============
编号:133  姓名:老杜
编号:122  姓名:老刘
编号:111  姓名:老付
Dog{age=6, name='www'} dasdasdad
Dog{age=8, name='lll'} dasdasdad
Dog{age=9, name='qqq'} daasddasdad
==============TreeMap集合测试============

================Collections 工具类常用方法=============
-1
-1
0
1
99

99
1
0
-1
-1

1
4
9
10

2

Process finished with exit code 0